程序博客网 > mac mini 2014 换内存

WebRTC VideoEngine超详细教程（二）——集成OPENH264编解码器

来源：互联网 发布：mac mini 2014 换内存 编辑：程序博客网 时间：2024/05/02 06:45

WebRTC原生支持VP8和VP9，但也可以自行集成H264编解码器，比较常见的是OPENH264和X264（X264自身只有编码功能，如果要加入解码功能，可以再结合ffmpeg），总体来说，集成H264编解码器的流程和直接使用它们的库的流程类似，但是要先将相应功能依照WebRTC中对编解码器的封装形式重新封装，然后再通过注册外部编解码器的方法在主流程中使用它们。

下面先看一下WebRTC对编解码器的封装形式是怎么样的，定义在webrtc\modules\video_coding\codecs\interface\video_codec_interface.h中，如下

VideoEncoder

[cpp] view plaincopy
  1. class EncodedImageCallback  
  2. {  
  3. public:  
  4.     virtual ~EncodedImageCallback() {};  
  5.   
  6.     // Callback function which is called when an image has been encoded.  
  7.     //  
  8.     // Input:  
  9.     //          - encodedImage         : The encoded image  
  10.     //  
  11.     // Return value                    : > 0,   signals to the caller that one or more future frames  
  12.     //                                          should be dropped to keep bit rate or frame rate.  
  13.     //                                   = 0,   if OK.  
  14.     //                                   < 0,   on error.  
  15.     virtual int32_t  
  16.     Encoded(EncodedImage& encodedImage,  
  17.             const CodecSpecificInfo* codecSpecificInfo = NULL,  
  18.             const RTPFragmentationHeader* fragmentation = NULL) = 0;  
  19. };  
  20.   
  21. class VideoEncoder  
  22. {  
  23. public:  
  24.     virtual ~VideoEncoder() {};  
  25.   
  26.     // Initialize the encoder with the information from the VideoCodec.  
  27.     //  
  28.     // Input:  
  29.     //          - codecSettings     : Codec settings  
  30.     //          - numberOfCores     : Number of cores available for the encoder  
  31.     //          - maxPayloadSize    : The maximum size each payload is allowed  
  32.     //                                to have. Usually MTU - overhead.  
  33.     //  
  34.     // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  35.     virtual int32_t InitEncode(const VideoCodec* codecSettings, int32_t numberOfCores, uint32_t maxPayloadSize) = 0;  
  36.   
  37.     // Encode an I420 image (as a part of a video stream). The encoded image  
  38.     // will be returned to the user through the encode complete callback.  
  39.     //  
  40.     // Input:  
  41.     //          - inputImage        : Image to be encoded  
  42.     //          - codecSpecificInfo : Pointer to codec specific data  
  43.     //          - frame_types        : The frame type to encode  
  44.     //  
  45.     // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK, < 0  
  46.     //                                otherwise.  
  47.     virtual int32_t Encode(  
  48.         const I420VideoFrame& inputImage,  
  49.         const CodecSpecificInfo* codecSpecificInfo,  
  50.         const std::vector<VideoFrameType>* frame_types) = 0;  
  51.   
  52.     // Register an encode complete callback object.  
  53.     //  
  54.     // Input:  
  55.     //          - callback         : Callback object which handles encoded images.  
  56.     //  
  57.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  58.     virtual int32_t RegisterEncodeCompleteCallback(EncodedImageCallback* callback) = 0;  
  59.   
  60.     // Free encoder memory.  
  61.     //  
  62.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  63.     virtual int32_t Release() = 0;  
  64.   
  65.     // Inform the encoder about the packet loss and round trip time on the  
  66.     // network used to decide the best pattern and signaling.  
  67.     //  
  68.     //          - packetLoss       : Fraction lost (loss rate in percent =  
  69.     //                               100 * packetLoss / 255)  
  70.     //          - rtt              : Round-trip time in milliseconds  
  71.     //  
  72.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  73.     virtual int32_t SetChannelParameters(uint32_t packetLoss, int rtt) = 0;  
  74.   
  75.     // Inform the encoder about the new target bit rate.  
  76.     //  
  77.     //          - newBitRate       : New target bit rate  
  78.     //          - frameRate        : The target frame rate  
  79.     //  
  80.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  81.     virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) = 0;  
  82.   
  83.     // Use this function to enable or disable periodic key frames. Can be useful for codecs  
  84.     // which have other ways of stopping error propagation.  
  85.     //  
  86.     //          - enable           : Enable or disable periodic key frames  
  87.     //  
  88.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  89.     virtual int32_t SetPeriodicKeyFrames(bool enable) { return WEBRTC_VIDEO_CODEC_ERROR; }  
  90.   
  91.     // Codec configuration data to send out-of-band, i.e. in SIP call setup  
  92.     //  
  93.     //          - buffer           : Buffer pointer to where the configuration data  
  94.     //                               should be stored  
  95.     //          - size             : The size of the buffer in bytes  
  96.     //  
  97.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  98.     virtual int32_t CodecConfigParameters(uint8_t* /*buffer*/, int32_t /*size*/) { return WEBRTC_VIDEO_CODEC_ERROR; }  
  99. };  
VideoDecoder

[cpp] view plaincopy
  1. class DecodedImageCallback  
  2. {  
  3. public:  
  4.     virtual ~DecodedImageCallback() {};  
  5.   
  6.     // Callback function which is called when an image has been decoded.  
  7.     //  
  8.     // Input:  
  9.     //          - decodedImage         : The decoded image.  
  10.     //  
  11.     // Return value                    : 0 if OK, < 0 otherwise.  
  12.     virtual int32_t Decoded(I420VideoFrame& decodedImage) = 0;  
  13.   
  14.     virtual int32_t ReceivedDecodedReferenceFrame(const uint64_t pictureId) {return -1;}  
  15.   
  16.     virtual int32_t ReceivedDecodedFrame(const uint64_t pictureId) {return -1;}  
  17. };  
  18.   
  19. class VideoDecoder  
  20. {  
  21. public:  
  22.     virtual ~VideoDecoder() {};  
  23.   
  24.     // Initialize the decoder with the information from the VideoCodec.  
  25.     //  
  26.     // Input:  
  27.     //          - inst              : Codec settings  
  28.     //          - numberOfCores     : Number of cores available for the decoder  
  29.     //  
  30.     // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  31.     virtual int32_t InitDecode(const VideoCodec* codecSettings, int32_t numberOfCores) = 0;  
  32.   
  33.     // Decode encoded image (as a part of a video stream). The decoded image  
  34.     // will be returned to the user through the decode complete callback.  
  35.     //  
  36.     // Input:  
  37.     //          - inputImage        : Encoded image to be decoded  
  38.     //          - missingFrames     : True if one or more frames have been lost  
  39.     //                                since the previous decode call.  
  40.     //          - fragmentation     : Specifies where the encoded frame can be  
  41.     //                                split into separate fragments. The meaning  
  42.     //                                of fragment is codec specific, but often  
  43.     //                                means that each fragment is decodable by  
  44.     //                                itself.  
  45.     //          - codecSpecificInfo : Pointer to codec specific data  
  46.     //          - renderTimeMs      : System time to render in milliseconds. Only  
  47.     //                                used by decoders with internal rendering.  
  48.     //  
  49.     // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  50.     virtual int32_t  
  51.     Decode(const EncodedImage& inputImage,  
  52.            bool missingFrames,  
  53.            const RTPFragmentationHeader* fragmentation,  
  54.            const CodecSpecificInfo* codecSpecificInfo = NULL,  
  55.            int64_t renderTimeMs = -1) = 0;  
  56.   
  57.     // Register an decode complete callback object.  
  58.     //  
  59.     // Input:  
  60.     //          - callback         : Callback object which handles decoded images.  
  61.     //  
  62.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  63.     virtual int32_t RegisterDecodeCompleteCallback(DecodedImageCallback* callback) = 0;  
  64.   
  65.     // Free decoder memory.  
  66.     //  
  67.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  68.     virtual int32_t Release() = 0;  
  69.   
  70.     // Reset decoder state and prepare for a new call.  
  71.     //  
  72.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  73.     virtual int32_t Reset() = 0;  
  74.   
  75.     // Codec configuration data sent out-of-band, i.e. in SIP call setup  
  76.     //  
  77.     // Input/Output:  
  78.     //          - buffer           : Buffer pointer to the configuration data  
  79.     //          - size             : The size of the configuration data in  
  80.     //                               bytes  
  81.     //  
  82.     // Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.  
  83.     virtual int32_t SetCodecConfigParameters(const uint8_t* /*buffer*/, int32_t /*size*/) { return WEBRTC_VIDEO_CODEC_ERROR; }  
  84.   
  85.     // Create a copy of the codec and its internal state.  
  86.     //  
  87.     // Return value                : A copy of the instance if OK, NULL otherwise.  
  88.     virtual VideoDecoder* Copy() { return NULL; }  
  89. };  


具体到WebRTC原生支持的VP8编解码器，可以参见webrtc\modules\video_coding\codecs\vp8\vp8_impl.h和vp8_impl.cc两个文件，其中定义的VP8EncoderImpl和VP8DecoderImpl这两个类分别继承自VideoEncoder和VideoDecoder类，并且加入了一些私有的成员变量和函数。这也就意味着，我们在试图集成H264编解码器时，也应该有H264EncoderImpl和H264DecoderImpl这样的两个类。

本文先以OPENH264为例做详细说明
首先当然要通过OPENH264项目编译出welsenc.lib和welsdec.lib两个库，再把codec_api.h、codec_app_def.h、codec_def.h、codec_ver.h四个头文件以及welsdec.dll welsenc.dll welsvp.dll三个动态库加入到工程目录下，并且在项目属性中进行相应设置。

编码功能的重新封装

先说编码部分，定义H264EncoderImpl类如下，关键在于加入OPENH264编码功能核心类ISVCEncoder* encoder_;

[cpp] view plaincopy
  1. class H264EncoderImpl : public VideoEncoder{  
  2.  public:  
  3.   H264EncoderImpl();  
  4.   
  5.   ~H264EncoderImpl();  
  6.   
  7.   int Release();  
  8.   
  9.   int InitEncode(const VideoCodec* codec_settings,  
  10.                          int number_of_cores,  
  11.                          size_t max_payload_size);  
  12.   
  13.   int Encode(const I420VideoFrame& input_image,  
  14.                      const CodecSpecificInfo* codec_specific_info,  
  15.                      const std::vector<VideoFrameType>* frame_types);  
  16.   
  17.   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback);  
  18.   
  19.   int SetChannelParameters(uint32_t packet_loss, int rtt);  
  20.   
  21.   int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate);  
  22.   
  23.  private:  
  24.   // Update frame size for codec.  
  25.   int UpdateCodecFrameSize(const I420VideoFrame& input_image);  
  26.   
  27.   EncodedImage encoded_image_;  
  28.   EncodedImageCallback* encoded_complete_callback_;  
  29.   VideoCodec codec_;  
  30.   bool inited_;  
  31.   
  32. //openh264编码功能类  
  33.   ISVCEncoder* encoder_;  
  34.   
  35. };  // end of H264Encoder class  

然后再来看一下每个方法的具体实现，基本可以参照如下的OPENH264基本编码流程

[cpp] view plaincopy
  1. //setup encoder  
  2. int rv = WelsCreateSVCEncoder (&encoder_);  
  3. //initilize with basic parameter  
  4. SEncParamBase param;  
  5. memset (&param, 0, sizeof (SEncParamBase));  
  6. param.iUsageType = usageType;  
  7. param.fMaxFrameRate = frameRate;  
  8. param.iPicWidth = width;  
  9. param.iPicHeight = height;  
  10. param.iTargetBitrate = 5000000;  
  11. encoder_->Initialize (&param);  
  12. //set option, set option during encoding process  
  13. encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &g_LevelSetting);  
  14. int videoFormat = videoFormatI420;  
  15. encoder_->SetOption (ENCODER_OPTION_DATAFORMAT, &videoFormat);  
  16. //encode and store ouput bistream  
  17. int frameSize = width * height * 3 / 2;  
  18. BufferedData buf;  
  19. buf.SetLength (frameSize);  
  20. ASSERT_TRUE (buf.Length() == (size_t)frameSize);  
  21. SFrameBSInfo info;  
  22. memset (&info, 0, sizeof (SFrameBSInfo));  
  23. SSourcePicture pic;  
  24. memset (&pic, 0, sizeof (SsourcePicture));  
  25. pic.iPicWidth = width;  
  26. pic.iPicHeight = height;  
  27. pic.iColorFormat = videoFormatI420;  
  28. pic.iStride[0] = pic.iPicWidth;  
  29. pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;  
  30. pic.pData[0] = buf.data();  
  31. pic.pData[1] = pic.pData[0] + width * height;  
  32. pic.pData[2] = pic.pData[1] + (width * height >> 2);  
  33. for(int num = 0;num<total_num;num++) {  
  34.    //prepare input data  
  35.    rv = encoder_->EncodeFrame (&pic, &info);  
  36.    ASSERT_TRUE (rv == cmResultSuccess);  
  37.    if (info.eFrameType != videoFrameTypeSkip && cbk != NULL) {  
  38.     //output bitstream  
  39.    }  
  40. }  
  41. //teardown encoder  
  42. if (encoder_) {  
  43.     encoder_->Uninitialize();  
  44.     WelsDestroySVCEncoder (encoder_);  
  45. }  

H264EncoderImpl()方法实现如下
[cpp] view plaincopy
  1. H264EncoderImpl::H264EncoderImpl()  
  2.     : encoded_image_(),  
  3.       encoded_complete_callback_(NULL),  
  4.       inited_(false),  
  5.       encoder_(NULL)  
  6. {  
  7.   memset(&codec_, 0, sizeof(codec_));  
  8. }  

Release()方法实现如下，这里调用了OPENH264的WelsDestroySVCEncoder方法
[cpp] view plaincopy
  1. int H264EncoderImpl::Release() {  
  2.   if (encoded_image_._buffer != NULL) {  
  3.     delete [] encoded_image_._buffer;  
  4.     encoded_image_._buffer = NULL;  
  5.   }  
  6.   if (encoder_ != NULL) {  
  7.     encoder_->Uninitialize();  
  8.     WelsDestroySVCEncoder(encoder_);  
  9.     encoder_ = NULL;  
  10.   }  
  11.   inited_ = false;  
  12.   return WEBRTC_VIDEO_CODEC_OK;  
  13. }  

InitEncode()方法实现如下，基本上就是OPENH264编码器的创建WelsCreateSVCEncoder与初始化encoder_->Initialize以及参数设置SEncParamBase的流程
[cpp] view plaincopy
  1. int H264EncoderImpl::InitEncode(const VideoCodec* inst,  
  2.                                int number_of_cores,  
  3.                                size_t max_payload_size) {  
  4.   if (inst == NULL) {  
  5.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  6.   }  
  7.   if (inst->maxFramerate < 1) {  
  8.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  9.   }  
  10.   // allow zero to represent an unspecified maxBitRate  
  11.   if (inst->maxBitrate > 0 && inst->startBitrate > inst->maxBitrate) {  
  12.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  13.   }  
  14.   if (inst->width < 1 || inst->height < 1) {  
  15.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  16.   }  
  17.   if (number_of_cores < 1) {  
  18.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  19.   }  
  20.   
  21.   int ret_val= Release();  
  22.   if (ret_val < 0) {  
  23.     return ret_val;  
  24.   }  
  25.   
  26.   if (encoder_ == NULL) {  
  27.     ret_val = WelsCreateSVCEncoder(&encoder_);  
  28.   
  29.     if (ret_val != 0) {  
  30.      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  31.                   "H264EncoderImpl::InitEncode() fails to create encoder ret_val %d",  
  32.                    ret_val);  
  33.       return WEBRTC_VIDEO_CODEC_ERROR;  
  34.     }  
  35.   }  
  36.   SEncParamBase param;  
  37.   memset (param, 0, sizeof(SEncParamBase));  
  38.   param.iUsageType = CAMERA_VIDEO_REAL_TIME;  
  39.   param.iRCMode = RC_QUALITY_MODE;  
  40.   param.fMaxFrameRate = inst->maxFramerate;  
  41.   param.iPicWidth = inst->width;  
  42.   param.iPicHeight = inst->height;  
  43.   param.iTargetBitrate = inst->maxBitrate;  
  44.   
  45.   ret_val =  encoder_->Initialize(param);  
  46.   int videoFormat = videoFormatI420;  
  47.   encoder_->SetOption(ENCODER_OPTION_DATAFORMAT, &videoFormat);  
  48.   
  49.   if (ret_val != 0) {  
  50.       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  51.           "H264EncoderImpl::InitEncode() fails to initialize encoder ret_val %d",  
  52.           ret_val);  
  53.       WelsDestroySVCEncoder(encoder_);  
  54.       encoder_ = NULL;  
  55.       return WEBRTC_VIDEO_CODEC_ERROR;  
  56.   }  
  57.   
  58.   if (&codec_ != inst) {  
  59.     codec_ = *inst;  
  60.   }  
  61.   
  62.   if (encoded_image_._buffer != NULL) {  
  63.     delete [] encoded_image_._buffer;  
  64.   }  
  65.   encoded_image_._size = CalcBufferSize(kI420, codec_.width, codec_.height);  
  66.   encoded_image_._buffer = new uint8_t[encoded_image_._size];  
  67.   encoded_image_._completeFrame = true;  
  68.     
  69.   inited_ = true;  
  70.   WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCoding, -1,  
  71.                "H264EncoderImpl::InitEncode(width:%d, height:%d, framerate:%d, start_bitrate:%d, max_bitrate:%d)",  
  72.                inst->width, inst->height, inst->maxFramerate, inst->startBitrate, inst->maxBitrate);  
  73.   
  74.   return WEBRTC_VIDEO_CODEC_OK;  
  75. }  
Encode()方法中包含了两个功能，一方面是视频帧的编码，这一步骤同样基本可以参照OPENH264的编码流程
另一方面是将编码后数据封装为RTP包发送出去，具体的内容由WebRTC为我们提供的VCMEncodedFrameCallback类的Encoded方法实现，详见webrtc\modules\video_coding\main\source\generic_encoder.cc文件，对这一方法的调用则是在我们的H264EncoderImpl类的RegisterEncodeCompleteCallback方法中实现的，如下
[cpp] view plaincopy
  1. int H264EncoderImpl::RegisterEncodeCompleteCallback(  
  2.     EncodedImageCallback* callback) {  
  3.   encoded_complete_callback_ = callback;  
  4.   return WEBRTC_VIDEO_CODEC_OK;  
  5. }  
而我们需要做的只是获取与每个RTP fragment对应的NAL大小、类型等信息，并且写入RTPFragmentationHeader类中
Encode方法内容如下
[cpp] view plaincopy
  1. int H264EncoderImpl::Encode(const I420VideoFrame& input_image,  
  2.                            const CodecSpecificInfo* codec_specific_info,  
  3.                            const std::vector<VideoFrameType>* frame_types) {  
  4.   if (!inited_) {  
  5.     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;  
  6.   }  
  7.   if (input_image.IsZeroSize()) {  
  8.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  9.   }  
  10.   if (encoded_complete_callback_ == NULL) {  
  11.     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;  
  12.   }  
  13.   
  14.   VideoFrameType frame_type = kDeltaFrame;  
  15.   // We only support one stream at the moment.  
  16.   if (frame_types && frame_types->size() > 0) {  
  17.     frame_type = (*frame_types)[0];  
  18.   }  
  19.   
  20.   bool send_keyframe = (frame_type == kKeyFrame);  
  21.   if (send_keyframe) {  
  22.     encoder_->ForceIntraFrame(true);  
  23.     WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCoding, -1,  
  24.                  "H264EncoderImpl::EncodeKeyFrame(width:%d, height:%d)",  
  25.                  input_image.width(), input_image.height());  
  26.   }  
  27.   
  28.   // Check for change in frame size.  
  29.   if (input_image.width() != codec_.width ||  
  30.       input_image.height() != codec_.height) {  
  31.     int ret = UpdateCodecFrameSize(input_image);  
  32.     if (ret < 0) {  
  33.       return ret;  
  34.     }  
  35.   }  
  36.  //编码过程，整个Encode方法是会被反复调用的  
  37.   SFrameBSInfo info;  
  38.   memset(&info, 0, sizeof(SFrameBSInfo));  
  39.   
  40.   SSourcePicture pic;  
  41.   memset(&pic,0,sizeof(SSourcePicture));  
  42.   pic.iPicWidth = input_image.width();  
  43.   pic.iPicHeight = input_image.height();  
  44.   pic.iColorFormat = videoFormatI420;  
  45.   
  46.   pic.iStride[0] = input_image.stride(kYPlane);  
  47.   pic.iStride[1] = input_image.stride(kUPlane);  
  48.   pic.iStride[2] = input_image.stride(kVPlane);  
  49.   
  50.   pic.pData[0]   = const_cast<uint8_t*>(input_image.buffer(kYPlane));  
  51.   pic.pData[1]   = const_cast<uint8_t*>(input_image.buffer(kUPlane));  
  52.   pic.pData[2]   = const_cast<uint8_t*>(input_image.buffer(kVPlane));  
  53.   
  54.   int retVal = encoder_->EncodeFrame(&pic, &info);  
  55.   if (retVal == videoFrameTypeSkip) {  
  56.     return WEBRTC_VIDEO_CODEC_OK;  
  57.   }  
  58. //获取与每个RTP fragment对应的NAL大小、类型等信息  
  59.   int layer = 0;  
  60.   
  61.   uint32_t totalNaluCount = 0;  
  62.   while (layer < info.iLayerNum) {  
  63.       const SLayerBSInfo* layer_bs_info = &info.sLayerInfo[layer];  
  64.       if (layer_bs_info != NULL) {  
  65.           totalNaluCount += layer_bs_info->iNalCount;  
  66.       }  
  67.       layer++;  
  68.   }  
  69.   if (totalNaluCount == 0) {  
  70.       return WEBRTC_VIDEO_CODEC_OK;  
  71.   }  
  72. //这里我们认为每个分片恰好包含一个NAL单元，具体的RTP分片方法则由WebRTC的VCMPacketizationCallback实现，我们不用管  
  73.   RTPFragmentationHeader frag_info;  
  74.   frag_info.VerifyAndAllocateFragmentationHeader(totalNaluCount);  
  75.     
  76.   encoded_image_._length = 0;  
  77.   layer = 0;  
  78.   uint32_t totalNaluIndex = 0;  
  79.   
  80.   while (layer < info.iLayerNum) {  
  81.       const SLayerBSInfo* layer_bs_info = &info.sLayerInfo[layer];  
  82.       if (layer_bs_info != NULL) {  
  83.           int layer_size = 0;  
  84.           int nal_begin = 4;  
  85.           uint8_t* nal_buffer = NULL;  
  86.           char nal_type = 0;  
  87.           for (int nal_index = 0; nal_index < layer_bs_info->iNalCount; nal_index++) {  
  88.               nal_buffer = layer_bs_info->pBsBuf + nal_begin;  
  89.               nal_type = (nal_buffer[0] & 0x1F);  
  90.               layer_size += layer_bs_info->pNalLengthInByte[nal_index];  
  91.               nal_begin += layer_size;  
  92.               if (nal_type == 14) {  
  93.                   continue;  
  94.               }  
  95.               uint32_t currentNaluSize = layer_bs_info->pNalLengthInByte[nal_index] - 4;  
  96.               memcpy(encoded_image_._buffer + encoded_image_._length, nal_buffer, currentNaluSize);  
  97.               encoded_image_._length += currentNaluSize;  
  98.   
  99.               WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCoding, -1,  
  100.                             "H264EncoderImpl::Encode() nal_type %d, length:%d",  
  101.                              nal_type, encoded_image_._length);  
  102.                     
  103.               // Offset of pointer to data for each fragm.  
  104.               frag_info.fragmentationOffset[totalNaluIndex] = encoded_image_._length - currentNaluSize;  
  105.               // Data size for each fragmentation  
  106.               frag_info.fragmentationLength[totalNaluIndex] = currentNaluSize;  
  107.               // Payload type of each fragmentation  
  108.               frag_info.fragmentationPlType[totalNaluIndex] = nal_type;  
  109.               // Timestamp difference relative "now" for  
  110.               // each fragmentation  
  111.               frag_info.fragmentationTimeDiff[totalNaluIndex] = 0;  
  112.               totalNaluIndex++;  
  113.           } // for  
  114.       }  
  115.       layer++;  
  116.   }  
  117.   
  118.   
  119.           if (encoded_image_._length > 0) {  
  120.               encoded_image_._timeStamp = input_image.timestamp();  
  121.               encoded_image_.capture_time_ms_ = input_image.render_time_ms();  
  122.               encoded_image_._encodedHeight = codec_.height;  
  123.               encoded_image_._encodedWidth = codec_.width;  
  124.                           encoded_image_._frameType = frame_type;  
  125. // call back   
  126. encoded_complete_callback_->Encoded(encoded_image_, NULL, &frag_info);   
  127. }   
  128. return WEBRTC_VIDEO_CODEC_OK;  
  129. }  

最后是SetRate和SetChannelParameter两个方法，用于根据网络情况自适应改变码率和帧率，这里我们暂时不考虑，使用固定码率和帧率，二者的实现如下
[cpp] view plaincopy
  1. int H264EncoderImpl::SetRates(uint32_t new_bitrate_kbit,  
  2.                              uint32_t new_framerate) {  
  3.   WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCoding, -1,  
  4.                "H264EncoderImpl::SetRates(%d, %d)", new_bitrate_kbit, new_framerate);  
  5.   if (!inited_) {  
  6.     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;  
  7.   }  
  8.   if (new_framerate < 1) {  
  9.     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  10.   }  
  11.   // update bit rate  
  12.   if (codec_.maxBitrate > 0 && new_bitrate_kbit > codec_.maxBitrate) {  
  13.     new_bitrate_kbit = codec_.maxBitrate;  
  14.   }  
  15.   
  16.   return WEBRTC_VIDEO_CODEC_OK;  
  17. }  
[cpp] view plaincopy
  1. int H264EncoderImpl::SetChannelParameters(uint32_t packet_loss, int rtt) {  
  2.     return WEBRTC_VIDEO_CODEC_OK;  
  3. }  

由此编码功能的重新封装全部完成
解码功能的重新封装
定义H264DecoderImpl类如下，关键在于加入OPENH264解码功能核心类ISVCDecoder* decoder_;
[cpp] view plaincopy
  1. class H264DecoderImpl : public VideoDecoder{  
  2.  public:  
  3.   enum {  
  4.       MAX_ENCODED_IMAGE_SIZE = 32768  
  5.   };  
  6.   
  7.   H264DecoderImpl();  
  8.   
  9.   ~H264DecoderImpl();  
  10.   
  11.   int InitDecode(const VideoCodec* inst, int number_of_cores);  
  12.   
  13.   int Decode(const EncodedImage& input_image,  
  14.                      bool missing_frames,  
  15.                      const RTPFragmentationHeader* fragmentation,  
  16.                      const CodecSpecificInfo* codec_specific_info,  
  17.                      int64_t /*render_time_ms*/);  
  18.   
  19.   int RegisterDecodeCompleteCallback(DecodedImageCallback* callback);  
  20.   
  21.   int Release();  
  22.   
  23.   int Reset();  
  24.   
  25.   VideoDecoder* Copy();  
  26.   
  27.  private:  
  28.   I420VideoFrame decoded_image_;  
  29.   DecodedImageCallback* decode_complete_callback_;  
  30.   bool inited_;  
  31.   VideoCodec codec_;  
  32.   bool key_frame_required_;  
  33.   
  34.   ISVCDecoder* decoder_;  
  35.   unsigned char* buffer_with_start_code_;  
  36.   
  37. };    
还是一样，先来看一下OPENH264自己的基本解码流程
[cpp] view plaincopy
  1. //decoder declaration  
  2. ISVCDecoder *pSvcDecoder;  
  3. //input: encoded bitstream start position; should include start code prefix  
  4. unsigned char *pBuf =...;  
  5. //input: encoded bit stream length; should include the size of start code prefix  
  6. int iSize =...;  
  7. //output: [0~2] for Y,U,V buffer for Decoding only  
  8. unsigned char *pData[3] =...;  
  9. //in-out: for Decoding only: declare and initialize the output buffer info  
  10. memset(&sDstBufInfo, 0, sizeof(SBufferInfo));  
  11.   
  12. //decoder creation  
  13. CreateDecoder(pSvcDecoder);//declare required parameter  
  14. SDecodingParam sDecParam = {0};  
  15. sDecParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_AVC;  
  16.   
  17. //initialize the parameter and decoder context, allocate memory  
  18. Initialize(&sDecParam);  
  19. //do actual decoding process in slice level; this can be done in a loop until data ends  
  20. //for Decoding only  
  21.  iRet = DecodeFrameNoDelay(pBuf, iSize, pData, &sDstBufInfo);  
  22.  //or  
  23.  iRet = DecodeFrame2(pBuf, iSize, pData, &sDstBufInfo);  
  24.    
  25.  //for Decoding only, pData can be used for render.  
  26.  if (sDstBufInfo.iBufferStatus==1){  
  27.      output pData[0], pData[1], pData[2];  
  28.  }  
  29. //uninitialize the decoder and memory free  
  30. Uninitialize();  
  31. //destroy the decoder  
  32. DestroyDecoder();  


照葫芦画瓢，即可得出H264DecoderImpl类的各方法的具体实现
H264DecoderImpl()方法的实现如下
[cpp] view plaincopy
  1. H264DecoderImpl::H264DecoderImpl()  
  2.         : decode_complete_callback_(NULL),  
  3.         inited_(false),  
  4.         key_frame_required_(true)  
  5.         ,buffer_with_start_code_(NULL)  
  6.         ,decoder_(NULL)  
  7.     {  
  8.         memset(&codec_, 0, sizeof(codec_));  
  9.         buffer_with_start_code_ = new unsigned char[MAX_ENCODED_IMAGE_SIZE];  
  10.   
  11.     }  
Release()方法的实现如下，调用了OPENH264的Uninitialize和WelsDestroyDecoder方法
[cpp] view plaincopy
  1. int H264DecoderImpl::Release() {  
  2.         if (decoder_ != NULL) {  
  3.             decoder_->Uninitialize();  
  4.             WelsDestroyDecoder(decoder_);  
  5.             decoder_ = NULL;  
  6.         }  
  7.         inited_ = false;  
  8.         return WEBRTC_VIDEO_CODEC_OK;  
  9.     }  

InitDecode方法的实现如下，进行了OPENH264解码参数的设置和初始化
[cpp] view plaincopy
  1. int H264DecoderImpl::InitDecode(const VideoCodec* inst, int number_of_cores) {  
  2.         if (inst == NULL) {  
  3.             return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  4.         }  
  5.         int ret_val = Release();  
  6.         if (ret_val < 0) {  
  7.             return ret_val;  
  8.         }  
  9.   
  10.         if (&codec_ != inst) {  
  11.             // Save VideoCodec instance for later; mainly for duplicating the decoder.  
  12.             codec_ = *inst;  
  13.         }  
  14.         if (decoder_ == NULL) {  
  15.             ret_val = WelsCreateDecoder(&decoder_);  
  16.             if (ret_val != 0) {  
  17.                 decoder_ = NULL;  
  18.                 return WEBRTC_VIDEO_CODEC_ERROR;  
  19.             }  
  20.         }  
  21.         SDecodingParam dec_param;  
  22.         memset(&dec_param, 0, sizeof(SDecodingParam));  
  23.         dec_param.eOutputColorFormat = videoFormatI420;  
  24.         dec_param.uiTargetDqLayer = UCHAR_MAX;  
  25.         dec_param.eEcActiveIdc = ERROR_CON_FRAME_COPY_CROSS_IDR;  
  26.         dec_param.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_DEFAULT;  
  27.         ret_val = decoder_->Initialize(&dec_param);  
  28.         if (ret_val != 0) {  
  29.             decoder_->Uninitialize();  
  30.             WelsDestroyDecoder(decoder_);  
  31.             decoder_ = NULL;  
  32.             return WEBRTC_VIDEO_CODEC_ERROR;  
  33.         }  
  34.         inited_ = true;  
  35.   
  36.         // Always start with a complete key frame.  
  37.         key_frame_required_ = true;  
  38.         WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCoding, -1,  
  39.             "H264DecoderImpl::InitDecode(width:%d, height:%d, framerate:%d, start_bitrate:%d, max_bitrate:%d)",  
  40.             inst->width, inst->height, inst->maxFramerate, inst->startBitrate, inst->maxBitrate);  
  41.         return WEBRTC_VIDEO_CODEC_OK;  
  42.     }  
Decode方法的实现如下，包含两个功能，一是解码接收到的图像帧，这方面可以参照OPENh264的解码流程
另一个是将解码数据转换为YUV420P像素格式的数据供渲染显示，具体的渲染显示由WebRTC为我们提供的VCMDecodedFrameCallback类的Decoded方法实现，详见webrtc\modules\video_coding\main\source\generic_decoder.cc文件，对这一方法的调用则是在我们的H264DecoderImpl类的RegisterDecodeCompleteCallback方法中实现的，如下
[cpp] view plaincopy
  1. int H264DecoderImpl::RegisterDecodeCompleteCallback(  
  2.         DecodedImageCallback* callback) {  
  3.         decode_complete_callback_ = callback;  
  4.         return WEBRTC_VIDEO_CODEC_OK;  
  5.     }  

我们需要做的只是将解码数据转换为YUV数据，使用WebRTC的CreateFrame方法，整个Decode方法的实现如下
[cpp] view plaincopy
  1. int H264DecoderImpl::Decode(const EncodedImage& input_image,  
  2.         bool missing_frames,  
  3.         const RTPFragmentationHeader* fragmentation,  
  4.         const CodecSpecificInfo* codec_specific_info,  
  5.         int64_t /*render_time_ms*/) {  
  6.         if (!inited_) {  
  7.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  8.                 "H264DecoderImpl::Decode, decoder is not initialized");  
  9.             return WEBRTC_VIDEO_CODEC_UNINITIALIZED;  
  10.         }  
  11.   
  12.         if (decode_complete_callback_ == NULL) {  
  13.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  14.                 "H264DecoderImpl::Decode, decode complete call back is not set");  
  15.             return WEBRTC_VIDEO_CODEC_UNINITIALIZED;  
  16.         }  
  17.   
  18.         if (input_image._buffer == NULL) {  
  19.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  20.                 "H264DecoderImpl::Decode, null buffer");  
  21.             return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  
  22.         }  
  23.         if (!codec_specific_info) {  
  24.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  25.                 "H264EncoderImpl::Decode, no codec info");  
  26.             return WEBRTC_VIDEO_CODEC_ERROR;  
  27.         }  
  28.         if (codec_specific_info->codecType != kVideoCodecH264) {  
  29.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  30.                 "H264EncoderImpl::Decode, non h264 codec %d", codec_specific_info->codecType);  
  31.             return WEBRTC_VIDEO_CODEC_ERROR;  
  32.         }  
  33.   
  34.         WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideoCoding, -1,  
  35.             "H264DecoderImpl::Decode(frame_type:%d, length:%d",  
  36.             input_image._frameType, input_image._length);  
  37.   
  38.         void* data[3];  
  39.         SBufferInfo buffer_info;  
  40.         memset(data, 0, sizeof(data));  
  41.         memset(&buffer_info, 0, sizeof(SBufferInfo));  
  42.   
  43.         memset(buffer_with_start_code_, 0, MAX_ENCODED_IMAGE_SIZE);  
  44.         int encoded_image_size = 0;  
  45.             memcpy(buffer_with_start_code_ , input_image._buffer, input_image._length);  
  46.             encoded_image_size =  input_image._length;  
  47.   
  48.         DECODING_STATE rv = decoder_->DecodeFrame2(buffer_with_start_code_, encoded_image_size, (unsigned char**)data, &buffer_info);  
  49.   
  50.         if (rv != dsErrorFree) {  
  51.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  52.                 "H264DecoderImpl::Decode, openH264 decoding fails with error %d", rv);  
  53.             return WEBRTC_VIDEO_CODEC_ERROR;  
  54.         }  
  55.   
  56.         if (buffer_info.iBufferStatus == 1) {  
  57.             int size_y = buffer_info.UsrData.sSystemBuffer.iStride[0] * buffer_info.UsrData.sSystemBuffer.iHeight;  
  58.             int size_u = buffer_info.UsrData.sSystemBuffer.iStride[1] * (buffer_info.UsrData.sSystemBuffer.iHeight / 2);  
  59.             int size_v = buffer_info.UsrData.sSystemBuffer.iStride[1] * (buffer_info.UsrData.sSystemBuffer.iHeight / 2);  
  60.   
  61.             decoded_image_.CreateFrame(size_y, static_cast<uint8_t*>(data[0]),  
  62.                 size_u, static_cast<uint8_t*>(data[1]),  
  63.                 size_v, static_cast<uint8_t*>(data[2]),  
  64.                 buffer_info.UsrData.sSystemBuffer.iWidth,  
  65.                 buffer_info.UsrData.sSystemBuffer.iHeight,  
  66.                 buffer_info.UsrData.sSystemBuffer.iStride[0],  
  67.                 buffer_info.UsrData.sSystemBuffer.iStride[1],  
  68.                 buffer_info.UsrData.sSystemBuffer.iStride[1]);  
  69.   
  70.             decoded_image_.set_timestamp(input_image._timeStamp);  
  71.             decode_complete_callback_->Decoded(decoded_image_);  
  72.             return WEBRTC_VIDEO_CODEC_OK;  
  73.         }else {  
  74.             WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding, -1,  
  75.                 "H264DecoderImpl::Decode, buffer status:%d", buffer_info.iBufferStatus);  
  76.             return WEBRTC_VIDEO_CODEC_OK;  
  77.         }  
  78.     }  
最后是Reset和Copy方法，分别用于重置和复制，这里暂时用不到，二者的实现如下
[cpp] view plaincopy
  1. VideoDecoder* H264DecoderImpl::Copy() {  
  2.         // Sanity checks.  
  3.         if (!inited_) {  
  4.             // Not initialized.  
  5.             assert(false);  
  6.             return NULL;  
  7.         }  
  8.         if (decoded_image_.IsZeroSize()) {  
  9.             // Nothing has been decoded before; cannot clone.  
  10.             return NULL;  
  11.         }  
  12.         // Create a new VideoDecoder object  
  13.         H264DecoderImpl *copy = new H264DecoderImpl;  
  14.   
  15.         // Initialize the new decoder  
  16.         if (copy->InitDecode(&codec_, 1) != WEBRTC_VIDEO_CODEC_OK) {  
  17.             delete copy;  
  18.             return NULL;  
  19.         }  
  20.   
  21.         return static_cast<VideoDecoder*>(copy);  
  22.     }  

[cpp] view plaincopy
  1. int H264DecoderImpl::Reset() {  
  2.         if (!inited_) {  
  3.             return WEBRTC_VIDEO_CODEC_UNINITIALIZED;  
  4.         }  
  5.         InitDecode(&codec_, 1);  
  6.         return WEBRTC_VIDEO_CODEC_OK;  
  7.     }  

由此，对OPENH264解码功能的重新封装也全部完成
注册与调用
最后，我们要在主流程中（见上一篇文章）中注册OPENH264为外部编码器，使用RegisterExternalSendCodec和RegisterExternalReceiveCodec方法，如下
[cpp] view plaincopy
  1.        webrtc::H264Encoder *h264encoder = webrtc::H264Encoder::Create();  
  2. webrtc::H264Decoder *h264decoder = webrtc::H264Decoder::Create();  
  3.   
  4. webrtc::ViEExternalCodec* external_codec = webrtc::ViEExternalCodec  
  5.     ::GetInterface(ptrViE);  
  6. external_codec->RegisterExternalSendCodec(videoChannel, 88,  
  7.     h264encoder, false);  
  8. external_codec->RegisterExternalReceiveCodec(videoChannel,  
  9.     88, h264decoder, false);  
这里的88也可以改为其他数值，但是要与后面设置的videoCodec.plType值相符。
至此，就成功地将OPENH264集成到了WebRTC的VideoEngine中。

                                             
        0        0           
	
				
		









 mac mini 2014 换内存
    		mac mini 2014 换内存



原创粉丝点击



		

热门IT博客


热敏打印机排版软件热敏打印机排版软件




mysql 默认数据库路径mysql 默认数据库路径




黑莓9900下载软件




轩辕剑神臂进阶数据




淘宝到货没短信




马克斯cms x站模板




maya软件大小




commvault备份软件




echarts读取json文件




大数据分析 银行




邵阳网络推广




无线扫描枪可否存数据




云计算实验室建设方案




网管软件下载




淘宝汽车装饰品




ar.js




日本衰落 知乎




ubuntu怎么安装到u盘




股票预测软件




mycard点卡淘宝



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    服装网站建设
    商城网站建设
    行业门户网站建设
    网站建设软件
    深圳网站建设
    医疗网站建设
    网站定制
    北京网站制作
    苏州网站建设
    制作网站需要多少钱
    网站注册要多少钱
    网站建设流程
    大兴网站建设
    公司做个网站多少钱
    家居网站建设
    网站建设推广
    济宁网站建设
    免费搭建网站
    做个网站需要多少钱
    深圳网站设计
    深圳网站制作
    架设网站
    昆明网站建设
    互动网站建设
    建网站手续
    临沂建网站公司
    建网站的详细步骤
    网站建设的网站
    牡丹江建网站
    建网站多少费用
    松江做网站公司
    哪里有建网站的公司
    如何建网站卖东西
    建网站多钱
    建个网站大概多少钱
    网站建站系统选择
    免费建个人网站
    如何创建网站平台
    上海建网站需要多少钱
    盐城网站建设
    网站建设怎么样


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里