使用cocos2d-x + ffmpeg播放视频

1、未完成，待补充，完善后会上传完整代码（包含ffmpeg）.目标平台暂定ios，完善后会完美跨平台。

2、实用价值跟遇到的困难不成正比，研究价值更大。

3、我们需要一个通用的，可嵌入到游戏内部的视频播放控件。 现有的解决方案都是android和iOS各自实用系统控件进行封装。好处是实现简单，一般情况下稳定，并且解码效率高。 缺点是无法与游戏真正契合在一起，毕竟是作为只能悬浮在游戏之上，并且iOS下面的MPPlayer还有一些恶心的问题，比如视频方向和大小莫名其妙的改变了。 

      另外，一个通用的播放控件可以完美的跨平台。比如现在的wp8版本暂时还无法播放视频，而且可以想见，如果使用的是native c++的系统结构，那么一定没有系统视频控件。

------------------------------------正文-----------------------------------

1、首先我们要做的是下载ffmpeg的代码 (git clone git://source.ffmpeg.org/ffmpeg.git ffmpeg) ,在windows下编译ffmpeg是相当麻烦的一件事（原因是微软的vs死活不支持c99，而ffmpeg死活要用c99），这个最后再研究。iOS下面最简单，所以先研究iOS平台。 另外要注意，使用越新版本的ffmpeg，出问题的可能性越大。所以直接clone上面的地址不见得是一件正确的事情，直接下载一个稳定版本最好。

2、下载最新的gas-preprocessor并拷贝到/usr/bin目录下，这个是unix下用来预处理汇编文件的脚本，mac下没有，需要到libav的网站去下载（http://git.libav.org/?p=gas-preprocessor.git），如果版本与ffmpeg不一致的话，可能会在编译汇编文件的时候出现编译错误

unknown register alias 'TCOS_D0_HEAD'

      ps：小说明一下libav，这个是ffmpeg的一个fork分支，起因是领导者对如何维护ffmpeg项目的分歧。代码非常相似，并且ffmpeg会经常从libav merge代码。不过无所谓一个要优于另外一个，否则就不会依然存在两个项目了。

3、在命令行下面切换到ffmpeg代码目录，运行configure

编译armv7版本的静态库

 ./configure --prefix=armv7 --disable-ffmpeg --disable-ffplay --disable-ffprobe --disable-ffserver --enable-avresample --enable-cross-compile --sysroot="/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk" --target-os=darwin --cc="/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/gcc" --extra-cflags="-arch armv7 -mfpu=neon -miphoneos-version-min=5.1" --extra-ldflags="-arch armv7 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS6.1.sdk -miphoneos-version-min=4.3" --arch=arm --cpu=cortex-a9 --enable-pic

待执行完毕后，运行 make; make install，如果权限不做就加上sudo。

注意几个参数，--prefix指定了make install的时候拷贝头文件和静态库的目标路径。  --sysroot指定了SDK版本，这个基本上一个xcode只有一个，要指定对，否则无法运行gcc。 --arch  --cpu 指定了当前cpu架构。  另外一些参数决定了要编译的内容。如果全部编译的话静态库有100+mb，很多编码器和解码器我们是用不到的，可以直接干掉。

同理，如果我们想要在模拟器下运行的话，还需要i386版本的静态库。

 ./configure --prefix=i386 --disable-ffmpeg --disable-ffplay --disable-ffprobe --disable-ffserver --enable-avresample --enable-cross-compile --sysroot="/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator6.1.sdk" --target-os=darwin --cc="/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/usr/bin/gcc" --extra-cflags="-arch i386" --extra-ldflags="-arch i386 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator6.1.sdk" --arch=i386 --cpu=i386 --enable-pic --disable-asm

4、当生成完毕两个版本的静态库后，我们需要使用lipo来合并两个版本，制作一个通用库。

 lipo -output universal/lib/libavcodec.a  -create -arch armv7 armv7/lib/libavcodec.a -arch i386 i386/lib/libavcodec.a
 lipo -output universal/lib/libavdevice.a  -create -arch armv7 armv7/lib/libavdevice.a -arch i386 i386/lib/libavdevice.a
 lipo -output universal/lib/libavfilter.a  -create -arch armv7 armv7/lib/libavfilter.a -arch i386 i386/lib/libavfilter.a
 lipo -output universal/lib/libavformat.a  -create -arch armv7 armv7/lib/libavformat.a -arch i386 i386/lib/libavformat.a
 lipo -output universal/lib/libavresample.a  -create -arch armv7 armv7/lib/libavresample.a -arch i386 i386/lib/libavresample.a
 lipo -output universal/lib/libavutil.a  -create -arch armv7 armv7/lib/libavutil.a -arch i386 i386/lib/libavutil.a
 lipo -output universal/lib/libswresample.a  -create -arch armv7 armv7/lib/libswresample.a -arch i386 i386/lib/libswresample.a
 lipo -output universal/lib/libswscale.a  -create -arch armv7 armv7/lib/libswscale.a -arch i386 i386/lib/libswscale.a

如果熟悉shell脚本的话，可以把上面的这些操作写成一个shell脚本，这样就方便很多了。 这里直接贴出这些步骤，一个图方便，二是明了我们真正需要操作什么。

5、生成通用静态库后，就可以直接把这些库加入到xcode项目中，设置好头文件依赖。 这里需要注意的是，包含ffmpeg头文件时需要用extern "C" {} 来括起来，否则就是一大堆链接错误

6、写一个CCVideoLayer来用cocos2d-x播放视频

       头文件

 #pragma once
 #include "cocos2d.h"

 #ifdef __APPLE__
 #include
 namespace std {
     namespace tr1 {}
     using namespace tr1;
     using tr1::function;
 }
 //using namespace std::tr1;
 #else
 #include
 #endif

 struct AVFormatContext;
 struct AVCodecContext;
 struct AVFrame;
 struct AVPicture;
 struct SwsContext;

 NS_CC_BEGIN

 class CCVideoLayer : public CCSprite
 {
 public:
     static CCVideoLayer* create(const char* path, int width, int height);
     CCVideoLayer();
     virtual ~CCVideoLayer();

     bool init(const char* path, int width, int height);
     void play(void);
     void stop(void);
     void pause(void);
     void seek(double sec);
     void draw(void);
     void update(float dt);

     virtual bool ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent);
     virtual void ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent);
     virtual void ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent);
     virtual void ccTouchCancelled(CCTouch *pTouch, CCEvent *pEvent);

     void setEnableTouchEnd(bool enable);                        // 是否可以点击关闭视频
     void setVideoEndCallback(std::function<void()> func);       // 关闭视频回调
 private:
     unsigned int m_width;
     unsigned int m_height;

     AVFormatContext *pFormatCtx;
     AVCodecContext *pCodecCtx;
     AVFrame *pFrame;
     AVPicture* picture;
     int videoStream;                // 视频流
     int audioStream;                // 音频流
     SwsContext *img_convert_ctx;

     std::string m_filePath;
     double m_frameRate;             // 帧率
     double m_elapsed;               // 用于帧率控制

     bool m_enableTouchEnd;
     std::function<void()> m_videoEndCallback;
 };


 NS_CC_END

实现文件

 //
 //  CCVideoLayer.cpp
 //  libquickcocos2dx
 //
 //  Created by langresser on 13-11-7.
 //  Copyright (c) 2013年 qeeplay.com. All rights reserved.
 //

 #include "CCVideoLayer.h"
 #include "SimpleAudioEngine.h"

 #define kEnableFFMPEG 0

 #if kEnableFFMPEG
 extern "C" {
 #include "libavformat/avformat.h"
 #include "libswscale/swscale.h"
 }
 #endif

 using namespace CocosDenshion;

 NS_CC_BEGIN
 CCVideoLayer* CCVideoLayer::create(const char* path, int width, int height)
 {
     CCVideoLayer* video = new CCVideoLayer();
     if (video) {
         video->init(path, width, height);
     }
     return video;
 }

 CCVideoLayer::CCVideoLayer()
 {
 #if kEnableFFMPEG
     pFormatCtx = NULL;
     pCodecCtx = NULL;
     pFrame = NULL;
     picture = NULL;
     img_convert_ctx = NULL;
 #endif

     m_frameRate = 1 / 30.0;
     m_elapsed = 0;
     m_enableTouchEnd = false;
 }

 CCVideoLayer::~CCVideoLayer()
 {
 #if kEnableFFMPEG
     sws_freeContext(img_convert_ctx);

     // Free RGB picture
     avpicture_free(picture);
     delete picture;

     // Free the YUV frame
     av_free(pFrame);

     // Close the codec
     if (pCodecCtx) avcodec_close(pCodecCtx);

     if (pFormatCtx) {
         avformat_close_input(&pFormatCtx);
     }
 #endif
 }

 bool CCVideoLayer::init(const char* path, int width, int height)
 {
 #if kEnableFFMPEG
     AVCodec         *pCodec;
     m_width = width;
     m_height = height;

     // Register all formats and codecs
     av_register_all();

     m_filePath = CCFileUtils::sharedFileUtils()->fullPathForFilename(path);
     if(avformat_open_input(&pFormatCtx, m_filePath.c_str(), NULL, NULL) != 0) {
          return false;
     }

     // 获取流信息
     if(avformat_find_stream_info(pFormatCtx, NULL) < 0) {
         return false;
     }

     // 查找视频流和音频流，由于不是做播放器，只取第一个流就可以了。视频格式为游戏服务
     videoStream = -1;
     audioStream = -1;
     for(int i=0; inb_streams; i++) {
         //if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO)
         if(videoStream == -1 && pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
             videoStream=i;
         }

         if (audioStream == -1 && pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
             audioStream = i;
         }

         if (videoStream != -1 && audioStream != -1) {
             break;
         }
     }

     //  没有视频流，无法播放
     if(videoStream == -1) {
          return false;
     }

     // Get a pointer to the codec context for the video stream
     pCodecCtx=pFormatCtx->streams[videoStream]->codec;

     // 获取视频帧率
     AVRational rational = pFormatCtx->streams[videoStream]->r_frame_rate;
     m_frameRate = 1.0 * rational.den / rational.num;

     m_frameRate = 1.0 / 31;

     // Find the decoder for the video stream
     pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
     if(pCodec==NULL) {
         return false;
     }

     if(avcodec_open2(pCodecCtx, pCodec, NULL)) {
         return false;
     }

     // Allocate video frame
     pFrame=avcodec_alloc_frame();

     // scale
     sws_freeContext(img_convert_ctx);

     // 用于渲染的一帧图片数据。注意其中的data是一个指针数组，我们取视频流用于渲染(一般是第0个流)
     picture = new AVPicture;
     avpicture_alloc(picture, PIX_FMT_RGB24, m_width, m_height);

     // 用于缩放视频到实际需求大小
     static int sws_flags =  SWS_FAST_BILINEAR;
     img_convert_ctx = sws_getContext(pCodecCtx->width,
                                      pCodecCtx->height,
                                      pCodecCtx->pix_fmt,
                                      m_width,
                                      m_height,
                                      PIX_FMT_RGB24,
                                      sws_flags, NULL, NULL, NULL);

     // 渲染的纹理
     CCTexture2D *texture = new CCTexture2D();
     texture->initWithData(picture->data[videoStream], picture->linesize[videoStream]*m_height, kCCTexture2DPixelFormat_RGB888, m_width, m_height, CCSize(m_width, m_height));
     initWithTexture(texture);

     this->setContentSize(CCSize(m_width, m_height));


     SimpleAudioEngine::sharedEngine()->preloadBackgroundMusic(m_filePath.c_str());
 #endif
     return true;
 }

 void CCVideoLayer::play()
 {
     std::string path = m_filePath.substr(0, m_filePath.rfind('.')) + ".m4a";
     SimpleAudioEngine::sharedEngine()->playBackgroundMusic(path.c_str());
     m_elapsed = 0;
     seek(0);

     this->schedule(schedule_selector(CCVideoLayer::update), m_frameRate);
 }

 void CCVideoLayer::stop(void)
 {
     this->unscheduleAllSelectors();
     SimpleAudioEngine::sharedEngine()->stopBackgroundMusic();
 }

 void CCVideoLayer::pause(void)
 {
     SimpleAudioEngine::sharedEngine()->pauseBackgroundMusic();
 }

 void CCVideoLayer::seek(double sec)
 {
 #if kEnableFFMPEG
     AVRational timeBase = pFormatCtx->streams[videoStream]->time_base;
     int64_t targetFrame = (int64_t)((double)timeBase.den / timeBase.num * sec);
     avformat_seek_file(pFormatCtx, videoStream, targetFrame, targetFrame, targetFrame, AVSEEK_FLAG_FRAME);
     avcodec_flush_buffers(pCodecCtx);
 #endif
 }

 void CCVideoLayer::update(float dt)
 {
 #if kEnableFFMPEG
     m_elapsed += dt;
 //    if (m_elapsed < m_frameRate) {
 //        return;
 //    }

     m_elapsed = 0;
     AVPacket packet;
     int frameFinished=0;

     while(!frameFinished && av_read_frame(pFormatCtx, &packet)>=0) {
         // Is this a packet from the video stream?
         if(packet.stream_index==videoStream) {
             // Decode video frame
             avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
         }

         // Free the packet that was allocated by av_read_frame
         av_free_packet(&packet);
     }

     sws_scale (img_convert_ctx, pFrame->data, pFrame->linesize,
                0, pCodecCtx->height,
                picture->data, picture->linesize);

     if (frameFinished == 0) {
         this->stop();
         if (m_videoEndCallback) {
             m_videoEndCallback();
         }

         this->removeFromParentAndCleanup(true);
     }
 #endif
 }

 void CCVideoLayer::draw(void)
 {
 #if kEnableFFMPEG
     CC_PROFILER_START_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");

     CCAssert(!m_pobBatchNode, "If CCSprite is being rendered by CCSpriteBatchNode, CCSprite#draw SHOULD NOT be called");

     CC_NODE_DRAW_SETUP();

     ccGLBlendFunc( m_sBlendFunc.src, m_sBlendFunc.dst );

     if (m_pobTexture != NULL)
     {
         ccGLBindTexture2D( m_pobTexture->getName() );
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_width, m_height, 0, GL_RGB, GL_UNSIGNED_BYTE,picture->data[videoStream]);
         //glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_width, m_height, GL_RGB, GL_UNSIGNED_BYTE,picture->data[videoStream]);
     }
     else
     {
         ccGLBindTexture2D(0);
     }

     //
     // Attributes
     //

     ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );

 #define kQuadSize sizeof(m_sQuad.bl)
     long offset = (long)&m_sQuad;

     // vertex
     int diff = offsetof( ccV3F_C4B_T2F, vertices);
     glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff));

     // texCoods
     diff = offsetof( ccV3F_C4B_T2F, texCoords);
     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));

     // color
     diff = offsetof( ccV3F_C4B_T2F, colors);
     glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));

     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

     CHECK_GL_ERROR_DEBUG();

     CC_INCREMENT_GL_DRAWS(1);

     CC_PROFILER_STOP_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");
 #endif
 }

 bool CCVideoLayer::ccTouchBegan(CCTouch *pTouch, CCEvent *pEvent)
 {
     return true;
 }

 void CCVideoLayer::ccTouchMoved(CCTouch *pTouch, CCEvent *pEvent)
 {
 }

 void CCVideoLayer::ccTouchEnded(CCTouch *pTouch, CCEvent *pEvent)
 {
     if (m_enableTouchEnd) {
         this->stop();

         if (m_videoEndCallback) {
             m_videoEndCallback();
         }

         this->removeFromParentAndCleanup(true);
     }
 }

 void CCVideoLayer::ccTouchCancelled(CCTouch *pTouch, CCEvent *pEvent)
 {
 }

 void CCVideoLayer::setEnableTouchEnd(bool enable)
 {
     m_enableTouchEnd = enable;
     if (enable) {
         setEventMode(kEventModeNormal);
     }
 }

 void CCVideoLayer::setVideoEndCallback(std::function<void(void)> func)
 {
     m_videoEndCallback = func;
 }


 NS_CC_END

相关说明：

      上面的这个CCVideoLayer只是初步实现了视频播放功能（ios下测试完毕），后续还有很多要完善的地方。不过最近新的项目要开启了，估计短时间内不会继续研究这个了。

       值得完善的地方：

       1、使用glSubTexImage来提交纹理更新，而不是使用glTexImage提交纹理，这个有助于效率提升（具体情况待测试）

       2、基本的帧率控制在update函数里面

       3、没有实现声音播放。声音解码和播放需要再研究一下。（我希望fmodex可以实现buffer声音的播放，要不然每个平台实现一套声音播放引擎太麻烦了）

       4、个人对这个还是比较满意的，可以向CCSprite一样随意的蹂躏，也可以直接放在lua里面作为一个对象来处理。不用担心一些系统控件的实现细节。效率也可以接受。