Small cleanup in VP9EncoderImpl::GetEncodedLayerFrame.

webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc

 /*
  *  Copyright (c) 2014 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.
  *
  */
@@ skipping 227 matching lines @@
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (inst->codecSpecific.VP9.numberOfTemporalLayers > 3) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // libvpx currently supports only one or two spatial layers.
   if (inst->codecSpecific.VP9.numberOfSpatialLayers > 2) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
-  int retVal = Release();
-  if (retVal < 0) {
-    return retVal;
+  int ret_val = Release();
+  if (ret_val < 0) {
+    return ret_val;
   }
   if (encoder_ == NULL) {
     encoder_ = new vpx_codec_ctx_t;
   }
   if (config_ == NULL) {
     config_ = new vpx_codec_enc_cfg_t;
   }
   timestamp_ = 0;
   if (&codec_ != inst) {
     codec_ = *inst;
@@ skipping 382 matching lines @@
                             svc_internal_.svc_params.scaling_factor_num[i] /
                             svc_internal_.svc_params.scaling_factor_den[i];
     }
     if (!vp9_info->flexible_mode) {
       vp9_info->gof.CopyGofInfoVP9(gof_);
     }
   }
 }
 
 int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
-  encoded_image_._length = 0;
-  encoded_image_._frameType = kVideoFrameDelta;
-  RTPFragmentationHeader frag_info;
-  // Note: no data partitioning in VP9, so 1 partition only. We keep this
-  // fragmentation data for now, until VP9 packetizer is implemented.
-  frag_info.VerifyAndAllocateFragmentationHeader(1);
-  int part_idx = 0;
-  CodecSpecificInfo codec_specific;
+  RTC_DCHECK_EQ(pkt->kind, VPX_CODEC_CX_FRAME_PKT);
 
   if (pkt->data.frame.sz > encoded_image_._size) {
     delete[] encoded_image_._buffer;
     encoded_image_._size = pkt->data.frame.sz;
     encoded_image_._buffer = new uint8_t[encoded_image_._size];
   }
+  memcpy(encoded_image_._buffer, pkt->data.frame.buf, pkt->data.frame.sz);
+  encoded_image_._length = pkt->data.frame.sz;
 
-  assert(pkt->kind == VPX_CODEC_CX_FRAME_PKT);
-  memcpy(&encoded_image_._buffer[encoded_image_._length], pkt->data.frame.buf,
-         pkt->data.frame.sz);
-  frag_info.fragmentationOffset[part_idx] = encoded_image_._length;
-  frag_info.fragmentationLength[part_idx] =
-      static_cast<uint32_t>(pkt->data.frame.sz);
+  // Note: no data partitioning in VP9, so 1 partition only. We keep this
+  // fragmentation data for now, until VP9 packetizer is implemented.

[stefan-webrtc, 2016/01/25 13:57:38]

It is already implemented, right? Is this comment valid?

[åsapersson, 2016/01/26 07:55:32]

Updated comment.

+  int part_idx = 0;
+  RTPFragmentationHeader frag_info;
+  frag_info.VerifyAndAllocateFragmentationHeader(1);
+  frag_info.fragmentationOffset[part_idx] = 0;
+  frag_info.fragmentationLength[part_idx] = pkt->data.frame.sz;
   frag_info.fragmentationPlType[part_idx] = 0;
   frag_info.fragmentationTimeDiff[part_idx] = 0;
-  encoded_image_._length += static_cast<uint32_t>(pkt->data.frame.sz);
 
   vpx_svc_layer_id_t layer_id = {0};
   vpx_codec_control(encoder_, VP9E_GET_SVC_LAYER_ID, &layer_id);
   if (is_flexible_mode_ && codec_.mode == kScreensharing)
     spatial_layer_->LayerFrameEncoded(
         static_cast<unsigned int>(encoded_image_._length),
         layer_id.spatial_layer_id);
 
-  assert(encoded_image_._length <= encoded_image_._size);
-
   // End of frame.
   // Check if encoded frame is a key frame.
+  encoded_image_._frameType = kVideoFrameDelta;
   if (pkt->data.frame.flags & VPX_FRAME_IS_KEY) {
     encoded_image_._frameType = kVideoFrameKey;
   }
+  RTC_DCHECK_LE(encoded_image_._length, encoded_image_._size);
+
+  CodecSpecificInfo codec_specific;
   PopulateCodecSpecific(&codec_specific, *pkt, input_image_->timestamp());
 
   if (encoded_image_._length > 0) {
     TRACE_COUNTER1("webrtc", "EncodedFrameSize", encoded_image_._length);
     encoded_image_._timeStamp = input_image_->timestamp();
     encoded_image_.capture_time_ms_ = input_image_->render_time_ms();
     encoded_image_._encodedHeight = raw_->d_h;
     encoded_image_._encodedWidth = raw_->d_w;
     encoded_complete_callback_->Encoded(encoded_image_, &codec_specific,
                                         &frag_info);
@@ skipping 285 matching lines @@
   frame_buffer_pool_.ClearPool();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP9DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 }  // namespace webrtc