Derive current layer from TL frame config.

webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc

 /*
  *  Copyright (c) 2012 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 114 matching lines @@
 
 VP8Encoder* VP8Encoder::Create() {
   return new VP8EncoderImpl();
 }
 
 VP8Decoder* VP8Decoder::Create() {
   return new VP8DecoderImpl();
 }
 
 vpx_enc_frame_flags_t VP8EncoderImpl::EncodeFlags(
-    TemporalReferences references) {
+    TemporalLayers::FrameConfig references) {
   RTC_DCHECK(!references.drop_frame);
 
   vpx_enc_frame_flags_t flags = 0;
 
-  if ((references.last_buffer_flags & kReference) == 0)
+  if ((references.last_buffer_flags & TemporalLayers::kReference) == 0)
     flags |= VP8_EFLAG_NO_REF_LAST;
-  if ((references.last_buffer_flags & kUpdate) == 0)
+  if ((references.last_buffer_flags & TemporalLayers::kUpdate) == 0)
     flags |= VP8_EFLAG_NO_UPD_LAST;
-  if ((references.golden_buffer_flags & kReference) == 0)
+  if ((references.golden_buffer_flags & TemporalLayers::kReference) == 0)
     flags |= VP8_EFLAG_NO_REF_GF;
-  if ((references.golden_buffer_flags & kUpdate) == 0)
+  if ((references.golden_buffer_flags & TemporalLayers::kUpdate) == 0)
     flags |= VP8_EFLAG_NO_UPD_GF;
-  if ((references.arf_buffer_flags & kReference) == 0)
+  if ((references.arf_buffer_flags & TemporalLayers::kReference) == 0)
     flags |= VP8_EFLAG_NO_REF_ARF;
-  if ((references.arf_buffer_flags & kUpdate) == 0)
+  if ((references.arf_buffer_flags & TemporalLayers::kUpdate) == 0)
     flags |= VP8_EFLAG_NO_UPD_ARF;
   if (references.freeze_entropy)
     flags |= VP8_EFLAG_NO_UPD_ENTROPY;
 
   return flags;
 }
 
 VP8EncoderImpl::VP8EncoderImpl()
     : use_gf_boost_(webrtc::field_trial::IsEnabled(kVp8GfBoostFieldTrial)),
       encoded_complete_callback_(nullptr),
@@ skipping 537 matching lines @@
         raw_images_[i - 1].stride[VPX_PLANE_U],
         raw_images_[i - 1].planes[VPX_PLANE_V],
         raw_images_[i - 1].stride[VPX_PLANE_V], raw_images_[i - 1].d_w,
         raw_images_[i - 1].d_h, raw_images_[i].planes[VPX_PLANE_Y],
         raw_images_[i].stride[VPX_PLANE_Y], raw_images_[i].planes[VPX_PLANE_U],
         raw_images_[i].stride[VPX_PLANE_U], raw_images_[i].planes[VPX_PLANE_V],
         raw_images_[i].stride[VPX_PLANE_V], raw_images_[i].d_w,
         raw_images_[i].d_h, libyuv::kFilterBilinear);
   }
   vpx_enc_frame_flags_t flags[kMaxSimulcastStreams];
+  TemporalLayers::FrameConfig tl_configs[kMaxSimulcastStreams];
   for (size_t i = 0; i < encoders_.size(); ++i) {
-    TemporalReferences tl_config =
-        temporal_layers_[i]->UpdateLayerConfig(frame.timestamp());
+    tl_configs[i] = temporal_layers_[i]->UpdateLayerConfig(frame.timestamp());
 
-    if (tl_config.drop_frame) {
+    if (tl_configs[i].drop_frame) {
       // Drop this frame.
       return WEBRTC_VIDEO_CODEC_OK;
     }
-    flags[i] = EncodeFlags(tl_config);
+    flags[i] = EncodeFlags(tl_configs[i]);
   }
   bool send_key_frame = false;
   for (size_t i = 0; i < key_frame_request_.size() && i < send_stream_.size();
        ++i) {
     if (key_frame_request_[i] && send_stream_[i]) {
       send_key_frame = true;
       break;
     }
   }
   if (!send_key_frame && frame_types) {
@@ skipping 32 matching lines @@
     // change isn't stored in configurations_ so change will be discarded at
     // the next update.
     vpx_codec_enc_cfg_t temp_config;
     memcpy(&temp_config, &configurations_[i], sizeof(vpx_codec_enc_cfg_t));
     if (temporal_layers_[stream_idx]->UpdateConfiguration(&temp_config)) {
       if (vpx_codec_enc_config_set(&encoders_[i], &temp_config))
         return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     vpx_codec_control(&encoders_[i], VP8E_SET_FRAME_FLAGS, flags[stream_idx]);
-    vpx_codec_control(&encoders_[i], VP8E_SET_TEMPORAL_LAYER_ID,
-                      temporal_layers_[stream_idx]->CurrentLayerId());
+    vpx_codec_control(
+        &encoders_[i], VP8E_SET_TEMPORAL_LAYER_ID,
+        temporal_layers_[stream_idx]->GetTemporalLayerId(tl_configs[i]));
   }
   // 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(codec_.maxFramerate > 0);
   uint32_t duration = 90000 / codec_.maxFramerate;
 
   // Note we must pass 0 for |flags| field in encode call below since they are
   // set above in |vpx_codec_control| function for each encoder/spatial layer.
   int error = vpx_codec_encode(&encoders_[0], &raw_images_[0], timestamp_,
                                duration, 0, VPX_DL_REALTIME);
   // Reset specific intra frame thresholds, following the key frame.
   if (send_key_frame) {
     vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                       rc_max_intra_target_);
   }
   if (error)
     return WEBRTC_VIDEO_CODEC_ERROR;
   timestamp_ += duration;
   // Examines frame timestamps only.
-  return GetEncodedPartitions(frame);
+  return GetEncodedPartitions(tl_configs, frame);
 }
 
 void VP8EncoderImpl::PopulateCodecSpecific(
     CodecSpecificInfo* codec_specific,
+    TemporalLayers::FrameConfig tl_config,
     const vpx_codec_cx_pkt_t& pkt,
     int stream_idx,
     uint32_t timestamp) {
   assert(codec_specific != NULL);
   codec_specific->codecType = kVideoCodecVP8;
   codec_specific->codec_name = ImplementationName();
   CodecSpecificInfoVP8* vp8Info = &(codec_specific->codecSpecific.VP8);
   vp8Info->pictureId = picture_id_[stream_idx];
   if (pkt.data.frame.flags & VPX_FRAME_IS_KEY) {
     last_key_frame_picture_id_[stream_idx] = picture_id_[stream_idx];
   }
   vp8Info->simulcastIdx = stream_idx;
   vp8Info->keyIdx = kNoKeyIdx;  // TODO(hlundin) populate this
   vp8Info->nonReference = (pkt.data.frame.flags & VPX_FRAME_IS_DROPPABLE) != 0;
   temporal_layers_[stream_idx]->PopulateCodecSpecific(
-      (pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, vp8Info, timestamp);
+      (pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, tl_config, vp8Info,
+      timestamp);
   // Prepare next.
   picture_id_[stream_idx] = (picture_id_[stream_idx] + 1) & 0x7FFF;
 }
 
-int VP8EncoderImpl::GetEncodedPartitions(const VideoFrame& input_image) {
+int VP8EncoderImpl::GetEncodedPartitions(
+    const TemporalLayers::FrameConfig tl_configs[],
+    const VideoFrame& input_image) {
   int bw_resolutions_disabled =
       (encoders_.size() > 1) ? NumStreamsDisabled(send_stream_) : -1;
 
   int stream_idx = static_cast<int>(encoders_.size()) - 1;
   int result = WEBRTC_VIDEO_CODEC_OK;
   for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
        ++encoder_idx, --stream_idx) {
     vpx_codec_iter_t iter = NULL;
     int part_idx = 0;
     encoded_images_[encoder_idx]._length = 0;
@@ skipping 29 matching lines @@
         }
         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) {
           encoded_images_[encoder_idx]._frameType = kVideoFrameKey;
         }
-        PopulateCodecSpecific(&codec_specific, *pkt, stream_idx,
-                              input_image.timestamp());
+        PopulateCodecSpecific(&codec_specific, tl_configs[stream_idx], *pkt,
+                              stream_idx, input_image.timestamp());
         break;
       }
     }
     encoded_images_[encoder_idx]._timeStamp = input_image.timestamp();
     encoded_images_[encoder_idx].capture_time_ms_ =
         input_image.render_time_ms();
     encoded_images_[encoder_idx].rotation_ = input_image.rotation();
     encoded_images_[encoder_idx].content_type_ =
         (codec_.mode == kScreensharing) ? VideoContentType::SCREENSHARE
                                         : VideoContentType::UNSPECIFIED;
@@ skipping 268 matching lines @@
   buffer_pool_.Release();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP8DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 }  // namespace webrtc