| /* |
| * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| /* |
| * vp8.cc |
| * |
| * This file contains the WEBRTC VP8 wrapper implementation |
| * |
| */ |
| #include "vp8.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| |
| #include "module_common_types.h" |
| #include "reference_picture_selection.h" |
| #include "temporal_layers.h" |
| #include "tick_util.h" |
| #include "vpx/vpx_encoder.h" |
| #include "vpx/vpx_decoder.h" |
| #include "vpx/vp8cx.h" |
| #include "vpx/vp8dx.h" |
| |
| enum { kVp8ErrorPropagationTh = 30 }; |
| |
| namespace webrtc |
| { |
| |
| VP8Encoder::VP8Encoder(): |
| _encodedImage(), |
| _encodedCompleteCallback(NULL), |
| _width(0), |
| _height(0), |
| _maxBitRateKbit(0), |
| _maxFrameRate(30), |
| _inited(false), |
| _timeStamp(0), |
| _pictureID(0), |
| _simulcastIdx(0), |
| _feedbackModeOn(false), |
| _cpuSpeed(-6), // default value |
| _rcMaxIntraTarget(0), |
| _tokenPartitions(VP8_ONE_TOKENPARTITION), |
| _rps(new ReferencePictureSelection), |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| _temporalLayers(NULL), |
| #endif |
| _encoder(NULL), |
| _cfg(NULL), |
| _raw(NULL) |
| { |
| WebRtc_UWord32 seed = (WebRtc_UWord32)TickTime::MillisecondTimestamp(); |
| srand(seed); |
| } |
| |
| VP8Encoder::~VP8Encoder() |
| { |
| Release(); |
| delete _rps; |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::VersionStatic(WebRtc_Word8* version, WebRtc_Word32 length) |
| { |
| const char* str = vpx_codec_iface_name(vpx_codec_vp8_cx()); |
| WebRtc_Word32 verLen = (WebRtc_Word32)strlen(str); |
| // Accounting for "\0" and "\n" (to be added a bit later) |
| if (verLen + 2 > length) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| strcpy(version, str); |
| strcat(version, "\n"); |
| return (verLen + 2); |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::Version(WebRtc_Word8 *version, WebRtc_Word32 length) const |
| { |
| return VersionStatic(version, length); |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::Release() |
| { |
| if (_encodedImage._buffer != NULL) |
| { |
| delete [] _encodedImage._buffer; |
| _encodedImage._buffer = NULL; |
| } |
| if (_encoder != NULL) |
| { |
| if (vpx_codec_destroy(_encoder)) |
| { |
| return WEBRTC_VIDEO_CODEC_MEMORY; |
| } |
| delete _encoder; |
| _encoder = NULL; |
| } |
| if (_cfg != NULL) |
| { |
| delete _cfg; |
| _cfg = NULL; |
| } |
| if (_raw != NULL) |
| { |
| vpx_img_free(_raw); |
| delete _raw; |
| _raw = NULL; |
| } |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| if (_temporalLayers != NULL) |
| { |
| delete _temporalLayers; |
| _temporalLayers = NULL; |
| } |
| #endif |
| _inited = false; |
| |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::Reset() |
| { |
| if (!_inited) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| |
| if (_encoder != NULL) |
| { |
| if (vpx_codec_destroy(_encoder)) |
| { |
| return WEBRTC_VIDEO_CODEC_MEMORY; |
| } |
| delete _encoder; |
| _encoder = NULL; |
| } |
| |
| _timeStamp = 0; |
| _encoder = new vpx_codec_ctx_t; |
| _rps->Init(); |
| |
| return InitAndSetControlSettings(); |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::SetRates(WebRtc_UWord32 newBitRateKbit, WebRtc_UWord32 newFrameRate) |
| { |
| if (!_inited) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| if (_encoder->err) |
| { |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| if (newFrameRate < 1) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| |
| // update bit rate |
| if (_maxBitRateKbit > 0 && |
| newBitRateKbit > static_cast<WebRtc_UWord32>(_maxBitRateKbit)) |
| { |
| newBitRateKbit = _maxBitRateKbit; |
| } |
| _cfg->rc_target_bitrate = newBitRateKbit; // in kbit/s |
| |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| if (_temporalLayers) |
| { |
| _temporalLayers->ConfigureBitrates(newBitRateKbit, _cfg); |
| } |
| #endif |
| _maxFrameRate = newFrameRate; |
| |
| // update encoder context |
| if (vpx_codec_enc_config_set(_encoder, _cfg)) |
| { |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::InitEncode(const VideoCodec* inst, |
| WebRtc_Word32 numberOfCores, |
| WebRtc_UWord32 /*maxPayloadSize */) |
| { |
| if (inst == NULL) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| if (inst->maxFramerate < 1) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| // allow zero to represent an unspecified maxBitRate |
| if (inst->maxBitrate > 0 && inst->startBitrate > inst->maxBitrate) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| if (inst->width < 1 || inst->height < 1) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| if (numberOfCores < 1) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| _feedbackModeOn = inst->codecSpecific.VP8.feedbackModeOn; |
| |
| WebRtc_Word32 retVal = Release(); |
| if (retVal < 0) |
| { |
| return retVal; |
| } |
| if (_encoder == NULL) |
| { |
| _encoder = new vpx_codec_ctx_t; |
| } |
| if (_cfg == NULL) |
| { |
| _cfg = new vpx_codec_enc_cfg_t; |
| } |
| if (_raw == NULL) |
| { |
| _raw = new vpx_image_t; |
| } |
| |
| _timeStamp = 0; |
| _maxBitRateKbit = inst->maxBitrate; |
| _maxFrameRate = inst->maxFramerate; |
| _width = inst->width; |
| _height = inst->height; |
| |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| if (inst->codecSpecific.VP8.numberOfTemporalLayers > 1) |
| { |
| assert(_temporalLayers == NULL); |
| _temporalLayers = |
| new TemporalLayers(inst->codecSpecific.VP8.numberOfTemporalLayers); |
| } |
| #endif |
| |
| // random start 16 bits is enough. |
| _pictureID = ((WebRtc_UWord16)rand()) & 0x7FFF; |
| |
| // allocate memory for encoded image |
| if (_encodedImage._buffer != NULL) |
| { |
| delete [] _encodedImage._buffer; |
| } |
| _encodedImage._size = (3 * inst->width * inst->height) >> 1; |
| _encodedImage._buffer = new WebRtc_UWord8[_encodedImage._size]; |
| _encodedImage._completeFrame = true; |
| |
| vpx_img_alloc(_raw, IMG_FMT_I420, inst->width, inst->height, 1); |
| // populate encoder configuration with default values |
| if (vpx_codec_enc_config_default(vpx_codec_vp8_cx(), _cfg, 0)) |
| { |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| _cfg->g_w = inst->width; |
| _cfg->g_h = inst->height; |
| if (_maxBitRateKbit > 0 && |
| inst->startBitrate > static_cast<unsigned int>(_maxBitRateKbit)) |
| { |
| _cfg->rc_target_bitrate = _maxBitRateKbit; |
| } |
| else |
| { |
| _cfg->rc_target_bitrate = inst->startBitrate; // in kbit/s |
| } |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| if (_temporalLayers) |
| { |
| _temporalLayers->ConfigureBitrates(inst->startBitrate, _cfg); |
| } |
| #endif |
| // setting the time base of the codec |
| _cfg->g_timebase.num = 1; |
| _cfg->g_timebase.den = 90000; |
| |
| // Set the error resilience mode according to user settings. |
| switch (inst->codecSpecific.VP8.resilience) { |
| case kResilienceOff: |
| _cfg->g_error_resilient = 0; |
| break; |
| case kResilientStream: |
| _cfg->g_error_resilient = 1; // TODO(holmer): Replace with |
| // VPX_ERROR_RESILIENT_DEFAULT when we |
| // drop support for libvpx 9.6.0. |
| break; |
| case kResilientFrames: |
| #ifdef INDEPENDENT_PARTITIONS |
| _cfg->g_error_resilient = VPX_ERROR_RESILIENT_DEFAULT | |
| VPX_ERROR_RESILIENT_PARTITIONS; |
| #else |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; // Not supported |
| #endif |
| break; |
| } |
| |
| _cfg->g_lag_in_frames = 0; // 0- no frame lagging |
| |
| // Determining number of threads based on the image size |
| |
| if (_width * _height > 704 * 576 && numberOfCores > 1) |
| // 2 threads when larger than 4CIF |
| _cfg->g_threads = 2; |
| else |
| _cfg->g_threads = 1; |
| |
| // rate control settings |
| _cfg->rc_dropframe_thresh = 30; |
| _cfg->rc_end_usage = VPX_CBR; |
| _cfg->g_pass = VPX_RC_ONE_PASS; |
| _cfg->rc_resize_allowed = 0; |
| _cfg->rc_min_quantizer = 8; |
| _cfg->rc_max_quantizer = 56; |
| _cfg->rc_undershoot_pct = 100; |
| _cfg->rc_overshoot_pct = 15; |
| _cfg->rc_buf_initial_sz = 500; |
| _cfg->rc_buf_optimal_sz = 600; |
| _cfg->rc_buf_sz = 1000; |
| // set the maximum target size of any key-frame. |
| _rcMaxIntraTarget = MaxIntraTarget(_cfg->rc_buf_optimal_sz); |
| |
| if (_feedbackModeOn) |
| { |
| // Disable periodic key frames if we get feedback from the decoder |
| // through SLI and RPSI. |
| _cfg->kf_mode = VPX_KF_DISABLED; |
| } |
| else |
| { |
| _cfg->kf_mode = VPX_KF_AUTO; |
| _cfg->kf_max_dist = 3000; |
| } |
| switch (inst->codecSpecific.VP8.complexity) |
| { |
| case kComplexityHigh: |
| { |
| _cpuSpeed = -5; |
| break; |
| } |
| case kComplexityHigher: |
| { |
| _cpuSpeed = -4; |
| break; |
| } |
| case kComplexityMax: |
| { |
| _cpuSpeed = -3; |
| break; |
| } |
| default: |
| { |
| _cpuSpeed = -6; |
| break; |
| } |
| } |
| _rps->Init(); |
| |
| return InitAndSetControlSettings(); |
| } |
| |
| |
| WebRtc_Word32 |
| VP8Encoder::InitAndSetControlSettings() |
| { |
| // construct encoder context |
| vpx_codec_enc_cfg_t cfg_copy = *_cfg; |
| vpx_codec_flags_t flags = 0; |
| // TODO(holmer): We should make a smarter decision on the number of |
| // partitions. Eight is probably not the optimal number for low resolution |
| // video. |
| |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| flags |= VPX_CODEC_USE_OUTPUT_PARTITION; |
| #endif |
| if (vpx_codec_enc_init(_encoder, vpx_codec_vp8_cx(), _cfg, flags)) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| vpx_codec_control(_encoder, VP8E_SET_STATIC_THRESHOLD, 800); |
| vpx_codec_control(_encoder, VP8E_SET_CPUUSED, _cpuSpeed); |
| vpx_codec_control(_encoder, VP8E_SET_TOKEN_PARTITIONS, |
| static_cast<vp8e_token_partitions>(_tokenPartitions)); |
| vpx_codec_control(_encoder, VP8E_SET_NOISE_SENSITIVITY, 2); |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| vpx_codec_control(_encoder, VP8E_SET_MAX_INTRA_BITRATE_PCT, |
| _rcMaxIntraTarget); |
| #endif |
| *_cfg = cfg_copy; |
| |
| _inited = true; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_UWord32 |
| VP8Encoder::MaxIntraTarget(WebRtc_UWord32 optimalBuffersize) |
| { |
| // Set max to the optimal buffer level (normalized by target BR), |
| // and scaled by a scalePar. |
| // Max target size = scalePar * optimalBufferSize * targetBR[Kbps]. |
| // This values is presented in percentage of perFrameBw: |
| // perFrameBw = targetBR[Kbps] * 1000 / frameRate. |
| // The target in % is as follows: |
| |
| float scalePar = 0.5; |
| WebRtc_UWord32 targetPct = (optimalBuffersize * scalePar) * |
| _maxFrameRate / 10; |
| |
| // Don't go below 3 times the per frame bandwidth. |
| const WebRtc_UWord32 minIntraTh = 300; |
| targetPct = (targetPct < minIntraTh) ? minIntraTh: targetPct; |
| |
| return targetPct; |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::Encode(const RawImage& inputImage, |
| const CodecSpecificInfo* codecSpecificInfo, |
| const VideoFrameType* frameTypes) |
| { |
| if (!_inited) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| if (inputImage._buffer == NULL) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| if (_encodedCompleteCallback == NULL) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| if (codecSpecificInfo) |
| { |
| _simulcastIdx = codecSpecificInfo->codecSpecific.VP8.simulcastIdx; |
| } |
| else |
| { |
| _simulcastIdx = 0; |
| } |
| // image in vpx_image_t format |
| _raw->planes[PLANE_Y] = inputImage._buffer; |
| _raw->planes[PLANE_U] = &inputImage._buffer[_height * _width]; |
| _raw->planes[PLANE_V] = &inputImage._buffer[_height * _width * 5 >> 2]; |
| |
| int flags = 0; |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| if (_temporalLayers) { |
| flags |= _temporalLayers->EncodeFlags(); |
| } |
| #endif |
| bool sendKeyFrame = frameTypes && (*frameTypes == kKeyFrame); |
| if (sendKeyFrame) |
| { |
| // Key frame request from caller. |
| // Will update both golden and alt-ref. |
| flags = VPX_EFLAG_FORCE_KF; |
| } else if (_feedbackModeOn && codecSpecificInfo) { |
| // Handle RPSI and SLI messages and set up the appropriate encode flags. |
| bool sendRefresh = false; |
| if (codecSpecificInfo->codecType == kVideoCodecVP8) { |
| if (codecSpecificInfo->codecSpecific.VP8.hasReceivedRPSI) { |
| _rps->ReceivedRPSI( |
| codecSpecificInfo->codecSpecific.VP8.pictureIdRPSI); |
| } |
| if (codecSpecificInfo->codecSpecific.VP8.hasReceivedSLI) { |
| sendRefresh = _rps->ReceivedSLI(inputImage._timeStamp); |
| } |
| } |
| flags = _rps->EncodeFlags(_pictureID, sendRefresh, inputImage._timeStamp); |
| } |
| |
| // TODO(holmer): Ideally the duration should be the timestamp diff of this |
| // frame and the next frame to be encoded, which we don't have. Instead we |
| // would like to use the duration of the previous frame. Unfortunately the |
| // rate control seems to be off with that setup. Using the average input |
| // frame rate to calculate an average duration for now. |
| assert(_maxFrameRate > 0); |
| WebRtc_UWord32 duration = 90000 / _maxFrameRate; |
| if (vpx_codec_encode(_encoder, _raw, _timeStamp, duration, flags, |
| VPX_DL_REALTIME)) |
| { |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| _timeStamp += duration; |
| |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| return GetEncodedPartitions(inputImage); |
| #else |
| return GetEncodedFrame(inputImage); |
| #endif |
| } |
| |
| void VP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific, |
| const vpx_codec_cx_pkt& pkt) { |
| assert(codec_specific != NULL); |
| codec_specific->codecType = kVideoCodecVP8; |
| CodecSpecificInfoVP8 *vp8Info = &(codec_specific->codecSpecific.VP8); |
| vp8Info->pictureId = _pictureID; |
| vp8Info->simulcastIdx = _simulcastIdx; |
| vp8Info->keyIdx = kNoKeyIdx; // TODO(hlundin) populate this |
| vp8Info->nonReference = (pkt.data.frame.flags & VPX_FRAME_IS_DROPPABLE); |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| if (_temporalLayers) { |
| _temporalLayers->PopulateCodecSpecific( |
| (pkt.data.frame.flags & VPX_FRAME_IS_KEY) ? true : false, vp8Info); |
| } else { |
| #endif |
| vp8Info->temporalIdx = kNoTemporalIdx; |
| vp8Info->layerSync = false; |
| vp8Info->tl0PicIdx = kNoTl0PicIdx; |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| } |
| #endif |
| _pictureID = (_pictureID + 1) & 0x7FFF; // prepare next |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::GetEncodedFrame(const RawImage& input_image) |
| { |
| vpx_codec_iter_t iter = NULL; |
| _encodedImage._frameType = kDeltaFrame; |
| const vpx_codec_cx_pkt_t *pkt= vpx_codec_get_cx_data(_encoder, &iter); |
| if (pkt == NULL) { |
| if (!_encoder->err) { |
| // dropped frame |
| return WEBRTC_VIDEO_CODEC_OK; |
| } else { |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| } |
| else if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) |
| { |
| CodecSpecificInfo codecSpecific; |
| PopulateCodecSpecific(&codecSpecific, *pkt); |
| |
| assert(pkt->data.frame.sz <= _encodedImage._size); |
| memcpy(_encodedImage._buffer, pkt->data.frame.buf, pkt->data.frame.sz); |
| _encodedImage._length = WebRtc_UWord32(pkt->data.frame.sz); |
| _encodedImage._encodedHeight = _raw->h; |
| _encodedImage._encodedWidth = _raw->w; |
| |
| // check if encoded frame is a key frame |
| if (pkt->data.frame.flags & VPX_FRAME_IS_KEY) |
| { |
| _encodedImage._frameType = kKeyFrame; |
| _rps->EncodedKeyFrame(_pictureID); |
| } |
| |
| if (_encodedImage._length > 0) |
| { |
| _encodedImage._timeStamp = input_image._timeStamp; |
| |
| // Figure out where partition boundaries are located. |
| RTPFragmentationHeader fragInfo; |
| fragInfo.VerifyAndAllocateFragmentationHeader(2); // two partitions: 1st and 2nd |
| |
| // First partition |
| fragInfo.fragmentationOffset[0] = 0; |
| WebRtc_UWord8 *firstByte = _encodedImage._buffer; |
| WebRtc_UWord32 tmpSize = (firstByte[2] << 16) | (firstByte[1] << 8) |
| | firstByte[0]; |
| fragInfo.fragmentationLength[0] = (tmpSize >> 5) & 0x7FFFF; |
| fragInfo.fragmentationPlType[0] = 0; // not known here |
| fragInfo.fragmentationTimeDiff[0] = 0; |
| |
| // Second partition |
| fragInfo.fragmentationOffset[1] = fragInfo.fragmentationLength[0]; |
| fragInfo.fragmentationLength[1] = _encodedImage._length - |
| fragInfo.fragmentationLength[0]; |
| fragInfo.fragmentationPlType[1] = 0; // not known here |
| fragInfo.fragmentationTimeDiff[1] = 0; |
| |
| _encodedCompleteCallback->Encoded(_encodedImage, &codecSpecific, |
| &fragInfo); |
| } |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| WebRtc_Word32 |
| VP8Encoder::GetEncodedPartitions(const RawImage& input_image) { |
| vpx_codec_iter_t iter = NULL; |
| int part_idx = 0; |
| _encodedImage._length = 0; |
| _encodedImage._frameType = kDeltaFrame; |
| RTPFragmentationHeader frag_info; |
| frag_info.VerifyAndAllocateFragmentationHeader((1 << _tokenPartitions) + 1); |
| CodecSpecificInfo codecSpecific; |
| |
| const vpx_codec_cx_pkt_t *pkt = NULL; |
| while ((pkt = vpx_codec_get_cx_data(_encoder, &iter)) != NULL) { |
| switch(pkt->kind) { |
| case VPX_CODEC_CX_FRAME_PKT: { |
| memcpy(&_encodedImage._buffer[_encodedImage._length], |
| pkt->data.frame.buf, |
| pkt->data.frame.sz); |
| frag_info.fragmentationOffset[part_idx] = _encodedImage._length; |
| frag_info.fragmentationLength[part_idx] = pkt->data.frame.sz; |
| frag_info.fragmentationPlType[part_idx] = 0; // not known here |
| frag_info.fragmentationTimeDiff[part_idx] = 0; |
| _encodedImage._length += pkt->data.frame.sz; |
| assert(_encodedImage._length <= _encodedImage._size); |
| ++part_idx; |
| break; |
| } |
| default: { |
| break; |
| } |
| } |
| // End of frame |
| if ((pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT) == 0) { |
| // check if encoded frame is a key frame |
| if (pkt->data.frame.flags & VPX_FRAME_IS_KEY) |
| { |
| _encodedImage._frameType = kKeyFrame; |
| _rps->EncodedKeyFrame(_pictureID); |
| } |
| PopulateCodecSpecific(&codecSpecific, *pkt); |
| break; |
| } |
| } |
| if (_encodedImage._length > 0) { |
| _encodedImage._timeStamp = input_image._timeStamp; |
| _encodedImage._encodedHeight = _raw->h; |
| _encodedImage._encodedWidth = _raw->w; |
| _encodedCompleteCallback->Encoded(_encodedImage, &codecSpecific, |
| &frag_info); |
| } |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| #endif |
| |
| WebRtc_Word32 |
| VP8Encoder::SetChannelParameters(WebRtc_UWord32 packetLoss, int rtt) { |
| _rps->SetRtt(rtt); |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Encoder::RegisterEncodeCompleteCallback(EncodedImageCallback* callback) |
| { |
| _encodedCompleteCallback = callback; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| VP8Decoder::VP8Decoder(): |
| _decodeCompleteCallback(NULL), |
| _inited(false), |
| _feedbackModeOn(false), |
| _decoder(NULL), |
| _inst(NULL), |
| _numCores(1), |
| _lastKeyFrame(), |
| _imageFormat(VPX_IMG_FMT_NONE), |
| _refFrame(NULL), |
| _propagationCnt(-1), |
| _latestKeyFrameComplete(false) |
| { |
| } |
| |
| VP8Decoder::~VP8Decoder() |
| { |
| _inited = true; // in order to do the actual release |
| Release(); |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::Reset() |
| { |
| if (!_inited) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| if (_inst != NULL) |
| { |
| VideoCodec inst; |
| inst = *_inst; |
| InitDecode(&inst, _numCores); |
| } |
| else |
| { |
| InitDecode(NULL, _numCores); |
| } |
| _propagationCnt = -1; |
| _latestKeyFrameComplete = false; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::InitDecode(const VideoCodec* inst, |
| WebRtc_Word32 numberOfCores) |
| { |
| WebRtc_Word32 retVal = Release(); |
| if (retVal < 0 ) |
| { |
| return retVal; |
| } |
| if (_decoder == NULL) |
| { |
| _decoder = new vpx_dec_ctx_t; |
| } |
| if (inst && inst->codecType == kVideoCodecVP8) { |
| _feedbackModeOn = inst->codecSpecific.VP8.feedbackModeOn; |
| } |
| |
| vpx_codec_dec_cfg_t cfg; |
| // Setting number of threads to a constant value (1) |
| cfg.threads = 1; |
| cfg.h = cfg.w = 0; // set after decode |
| |
| vpx_codec_flags_t flags = 0; |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| flags = VPX_CODEC_USE_ERROR_CONCEALMENT | VPX_CODEC_USE_POSTPROC; |
| #ifdef INDEPENDENT_PARTITIONS |
| flags |= VPX_CODEC_USE_INPUT_PARTITION; |
| #endif |
| #endif |
| |
| if (vpx_codec_dec_init(_decoder, vpx_codec_vp8_dx(), &cfg, flags)) |
| { |
| return WEBRTC_VIDEO_CODEC_MEMORY; |
| } |
| |
| #if WEBRTC_LIBVPX_VERSION >= 971 |
| |
| vp8_postproc_cfg_t ppcfg; |
| // Disable deblocking for now due to uninitialized memory being returned. |
| ppcfg.post_proc_flag = 0; |
| // Strength of deblocking filter. Valid range:[0,16] |
| //ppcfg.deblocking_level = 3; |
| vpx_codec_control(_decoder, VP8_SET_POSTPROC, &ppcfg); |
| #endif |
| |
| // Save VideoCodec instance for later; mainly for duplicating the decoder. |
| if (inst && inst != _inst) |
| { |
| if (!_inst) |
| { |
| _inst = new VideoCodec; |
| } |
| *_inst = *inst; |
| } |
| _numCores = numberOfCores; |
| _propagationCnt = -1; |
| _latestKeyFrameComplete = false; |
| |
| _inited = true; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::Decode(const EncodedImage& inputImage, |
| bool missingFrames, |
| const RTPFragmentationHeader* fragmentation, |
| const CodecSpecificInfo* codecSpecificInfo, |
| WebRtc_Word64 /*renderTimeMs*/) |
| { |
| if (!_inited) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| if (_decodeCompleteCallback == NULL) |
| { |
| return WEBRTC_VIDEO_CODEC_UNINITIALIZED; |
| } |
| if (inputImage._buffer == NULL && inputImage._length > 0) |
| { |
| // Reset to avoid requesting key frames too often. |
| if (_propagationCnt > 0) |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| |
| #ifdef INDEPENDENT_PARTITIONS |
| if (fragmentation == NULL) |
| { |
| return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
| } |
| #endif |
| |
| // Restrict error propagation using key frame requests. Disabled when |
| // the feedback mode is enabled (RPS). |
| // Reset on a key frame refresh. |
| if (!_feedbackModeOn) { |
| if (inputImage._frameType == kKeyFrame && inputImage._completeFrame) |
| _propagationCnt = -1; |
| // Start count on first loss. |
| else if ((!inputImage._completeFrame || missingFrames) && |
| _propagationCnt == -1) |
| _propagationCnt = 0; |
| if (_propagationCnt >= 0) |
| _propagationCnt++; |
| } |
| |
| vpx_dec_iter_t iter = NULL; |
| vpx_image_t* img; |
| WebRtc_Word32 ret; |
| |
| // Check for missing frames. |
| if (missingFrames) |
| { |
| // Call decoder with zero data length to signal missing frames. |
| if (vpx_codec_decode(_decoder, NULL, 0, 0, VPX_DL_REALTIME)) |
| { |
| // Reset to avoid requesting key frames too often. |
| if (_propagationCnt > 0) |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| img = vpx_codec_get_frame(_decoder, &iter); |
| iter = NULL; |
| } |
| |
| #ifdef INDEPENDENT_PARTITIONS |
| if (DecodePartitions(inputImage, fragmentation)) |
| { |
| // Reset to avoid requesting key frames too often. |
| if (_propagationCnt > 0) |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| #else |
| WebRtc_UWord8* buffer = inputImage._buffer; |
| if (inputImage._length == 0) |
| { |
| buffer = NULL; // Triggers full frame concealment. |
| } |
| if (vpx_codec_decode(_decoder, |
| buffer, |
| inputImage._length, |
| 0, |
| VPX_DL_REALTIME)) |
| { |
| // Reset to avoid requesting key frames too often. |
| if (_propagationCnt > 0) |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| #endif |
| |
| // Store encoded frame if key frame. (Used in Copy method.) |
| if (inputImage._frameType == kKeyFrame && inputImage._buffer != NULL) |
| { |
| const WebRtc_UWord32 bytesToCopy = inputImage._length; |
| if (_lastKeyFrame._size < bytesToCopy) |
| { |
| delete [] _lastKeyFrame._buffer; |
| _lastKeyFrame._buffer = NULL; |
| _lastKeyFrame._size = 0; |
| } |
| |
| WebRtc_UWord8* tempBuffer = _lastKeyFrame._buffer; // Save buffer ptr. |
| WebRtc_UWord32 tempSize = _lastKeyFrame._size; // Save size. |
| _lastKeyFrame = inputImage; // Shallow copy. |
| _lastKeyFrame._buffer = tempBuffer; // Restore buffer ptr. |
| _lastKeyFrame._size = tempSize; // Restore buffer size. |
| if (!_lastKeyFrame._buffer) |
| { |
| // Allocate memory. |
| _lastKeyFrame._size = bytesToCopy; |
| _lastKeyFrame._buffer = new WebRtc_UWord8[_lastKeyFrame._size]; |
| } |
| // Copy encoded frame. |
| memcpy(_lastKeyFrame._buffer, inputImage._buffer, bytesToCopy); |
| _lastKeyFrame._length = bytesToCopy; |
| } |
| |
| img = vpx_codec_get_frame(_decoder, &iter); |
| ret = ReturnFrame(img, inputImage._timeStamp); |
| if (ret != 0) |
| { |
| // Reset to avoid requesting key frames too often. |
| if (ret < 0 && _propagationCnt > 0) |
| _propagationCnt = 0; |
| return ret; |
| } |
| |
| if (_feedbackModeOn) { |
| // Whenever we receive an incomplete key frame all reference buffers will |
| // be corrupt. If that happens we must request new key frames until we |
| // decode a complete. |
| if (inputImage._frameType == kKeyFrame) |
| _latestKeyFrameComplete = inputImage._completeFrame; |
| if (!_latestKeyFrameComplete) |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| |
| // Check for reference updates and last reference buffer corruption and |
| // signal successful reference propagation or frame corruption to the |
| // encoder. |
| int referenceUpdates = 0; |
| if (vpx_codec_control(_decoder, VP8D_GET_LAST_REF_UPDATES, |
| &referenceUpdates)) { |
| // Reset to avoid requesting key frames too often. |
| if (_propagationCnt > 0) |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| int corrupted = 0; |
| if (vpx_codec_control(_decoder, VP8D_GET_FRAME_CORRUPTED, &corrupted)) { |
| // Reset to avoid requesting key frames too often. |
| if (_propagationCnt > 0) |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| WebRtc_Word16 pictureId = -1; |
| if (codecSpecificInfo) { |
| pictureId = codecSpecificInfo->codecSpecific.VP8.pictureId; |
| } |
| if (pictureId > -1) { |
| if (((referenceUpdates & VP8_GOLD_FRAME) || |
| (referenceUpdates & VP8_ALTR_FRAME)) && !corrupted) { |
| _decodeCompleteCallback->ReceivedDecodedReferenceFrame(pictureId); |
| } |
| _decodeCompleteCallback->ReceivedDecodedFrame(pictureId); |
| } |
| if (corrupted) { |
| // we can decode but with artifacts |
| return WEBRTC_VIDEO_CODEC_REQUEST_SLI; |
| } |
| } |
| |
| // Check Vs. threshold |
| if (_propagationCnt > kVp8ErrorPropagationTh) |
| { |
| // Reset to avoid requesting key frames too often. |
| _propagationCnt = 0; |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::DecodePartitions(const EncodedImage& input_image, |
| const RTPFragmentationHeader* fragmentation) { |
| for (int i = 0; i < fragmentation->fragmentationVectorSize; ++i) { |
| const WebRtc_UWord8* partition = input_image._buffer + |
| fragmentation->fragmentationOffset[i]; |
| const WebRtc_UWord32 partition_length = |
| fragmentation->fragmentationLength[i]; |
| if (vpx_codec_decode(_decoder, |
| partition, |
| partition_length, |
| 0, |
| VPX_DL_REALTIME)) { |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| } |
| } |
| |
| // Signal end of frame data. If there was no frame data this will trigger |
| // a full frame concealment. |
| if (vpx_codec_decode(_decoder, NULL, 0, 0, VPX_DL_REALTIME)) |
| return WEBRTC_VIDEO_CODEC_ERROR; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::ReturnFrame(const vpx_image_t* img, WebRtc_UWord32 timeStamp) |
| { |
| if (img == NULL) |
| { |
| // Decoder OK and NULL image => No show frame |
| return WEBRTC_VIDEO_CODEC_NO_OUTPUT; |
| } |
| |
| // Allocate memory for decoded image |
| WebRtc_UWord32 requiredSize = (3 * img->d_h * img->d_w) >> 1; |
| if (requiredSize > _decodedImage._size) |
| { |
| delete [] _decodedImage._buffer; |
| _decodedImage._buffer = NULL; |
| } |
| if (_decodedImage._buffer == NULL) |
| { |
| _decodedImage._size = requiredSize; |
| _decodedImage._buffer = new WebRtc_UWord8[_decodedImage._size]; |
| } |
| |
| WebRtc_UWord8* buf; |
| WebRtc_UWord32 pos = 0; |
| WebRtc_UWord32 plane, y; |
| |
| for (plane = 0; plane < 3; plane++) |
| { |
| unsigned int width = (plane ? (img->d_w + 1) >> 1 : img->d_w); |
| unsigned int height = (plane ? (img->d_h + 1) >> 1 : img->d_h); |
| buf = img->planes[plane]; |
| for(y = 0; y < height; y++) |
| { |
| memcpy(&_decodedImage._buffer[pos], buf, width); |
| pos += width; |
| buf += img->stride[plane]; |
| } |
| } |
| |
| // Set image parameters |
| _decodedImage._height = img->d_h; |
| _decodedImage._width = img->d_w; |
| _decodedImage._length = (3 * img->d_h * img->d_w) >> 1; |
| _decodedImage._timeStamp = timeStamp; |
| WebRtc_Word32 ret = _decodeCompleteCallback->Decoded(_decodedImage); |
| if (ret != 0) |
| return ret; |
| |
| // Remember image format for later |
| _imageFormat = img->fmt; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::RegisterDecodeCompleteCallback(DecodedImageCallback* callback) |
| { |
| _decodeCompleteCallback = callback; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| WebRtc_Word32 |
| VP8Decoder::Release() |
| { |
| if (_decodedImage._buffer != NULL) |
| { |
| delete [] _decodedImage._buffer; |
| _decodedImage._buffer = NULL; |
| } |
| if (_lastKeyFrame._buffer != NULL) |
| { |
| delete [] _lastKeyFrame._buffer; |
| _lastKeyFrame._buffer = NULL; |
| } |
| if (_decoder != NULL) |
| { |
| if(vpx_codec_destroy(_decoder)) |
| { |
| return WEBRTC_VIDEO_CODEC_MEMORY; |
| } |
| delete _decoder; |
| _decoder = NULL; |
| } |
| if (_inst != NULL) |
| { |
| delete _inst; |
| _inst = NULL; |
| } |
| if (_refFrame != NULL) |
| { |
| vpx_img_free(&_refFrame->img); |
| delete _refFrame; |
| _refFrame = NULL; |
| } |
| |
| _inited = false; |
| return WEBRTC_VIDEO_CODEC_OK; |
| } |
| |
| VideoDecoder* |
| VP8Decoder::Copy() |
| { |
| // Sanity checks. |
| if (!_inited) |
| { |
| // Not initialized. |
| assert(false); |
| return NULL; |
| } |
| if (_decodedImage._buffer == NULL) |
| { |
| // Nothing has been decoded before; cannot clone. |
| return NULL; |
| } |
| if (_lastKeyFrame._buffer == NULL) |
| { |
| // Cannot clone if we have no key frame to start with. |
| return NULL; |
| } |
| |
| // Create a new VideoDecoder object |
| VP8Decoder *copyTo = new VP8Decoder; |
| |
| // Initialize the new decoder |
| if (copyTo->InitDecode(_inst, _numCores) != WEBRTC_VIDEO_CODEC_OK) |
| { |
| delete copyTo; |
| return NULL; |
| } |
| |
| // Inject last key frame into new decoder. |
| if (vpx_codec_decode(copyTo->_decoder, _lastKeyFrame._buffer, |
| _lastKeyFrame._length, NULL, VPX_DL_REALTIME)) |
| { |
| delete copyTo; |
| return NULL; |
| } |
| |
| // Allocate memory for reference image copy |
| assert(_decodedImage._width > 0); |
| assert(_decodedImage._height > 0); |
| assert(_imageFormat > VPX_IMG_FMT_NONE); |
| // Check if frame format has changed. |
| if (_refFrame && |
| (_decodedImage._width != _refFrame->img.d_w || |
| _decodedImage._height != _refFrame->img.d_h || |
| _imageFormat != _refFrame->img.fmt)) |
| { |
| vpx_img_free(&_refFrame->img); |
| delete _refFrame; |
| _refFrame = NULL; |
| } |
| |
| |
| if (!_refFrame) |
| { |
| _refFrame = new vpx_ref_frame_t; |
| |
| if(!vpx_img_alloc(&_refFrame->img, |
| static_cast<vpx_img_fmt_t>(_imageFormat), |
| _decodedImage._width, _decodedImage._height, 1)) |
| { |
| assert(false); |
| delete copyTo; |
| return NULL; |
| } |
| } |
| |
| const vpx_ref_frame_type_t typeVec[] = { VP8_LAST_FRAME, VP8_GOLD_FRAME, |
| VP8_ALTR_FRAME }; |
| for (WebRtc_UWord32 ix = 0; |
| ix < sizeof(typeVec) / sizeof(vpx_ref_frame_type_t); ++ix) |
| { |
| _refFrame->frame_type = typeVec[ix]; |
| if (CopyReference(copyTo) < 0) |
| { |
| delete copyTo; |
| return NULL; |
| } |
| } |
| |
| // Copy all member variables (that are not set in initialization). |
| copyTo->_feedbackModeOn = _feedbackModeOn; |
| copyTo->_imageFormat = _imageFormat; |
| copyTo->_lastKeyFrame = _lastKeyFrame; // Shallow copy. |
| // Allocate memory. (Discard copied _buffer pointer.) |
| copyTo->_lastKeyFrame._buffer = new WebRtc_UWord8[_lastKeyFrame._size]; |
| memcpy(copyTo->_lastKeyFrame._buffer, _lastKeyFrame._buffer, |
| _lastKeyFrame._length); |
| |
| // Initialize _decodedImage. |
| copyTo->_decodedImage = _decodedImage; // Shallow copy |
| copyTo->_decodedImage._buffer = NULL; |
| if (_decodedImage._size) |
| { |
| copyTo->_decodedImage._buffer = new WebRtc_UWord8[_decodedImage._size]; |
| } |
| |
| return static_cast<VideoDecoder*>(copyTo); |
| } |
| |
| int VP8Decoder::CopyReference(VP8Decoder* copyTo) |
| { |
| // The type of frame to copy should be set in _refFrame->frame_type |
| // before the call to this function. |
| if (vpx_codec_control(_decoder, VP8_COPY_REFERENCE, _refFrame) |
| != VPX_CODEC_OK) |
| { |
| return -1; |
| } |
| if (vpx_codec_control(copyTo->_decoder, VP8_SET_REFERENCE, _refFrame) |
| != VPX_CODEC_OK) |
| { |
| return -1; |
| } |
| return 0; |
| } |
| |
| |
| } // namespace webrtc |
