Call InitDecode with proper resolution.

webrtc/modules/video_coding/codec_database.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 490 matching lines @@
 }
 
 VideoCodecType VCMCodecDataBase::ReceiveCodec() const {
   if (!ptr_decoder_) {
     return kVideoCodecUnknown;
   }
   return receive_codec_.codecType;
 }
 
 VCMGenericDecoder* VCMCodecDataBase::GetDecoder(
-    uint8_t payload_type, VCMDecodedFrameCallback* decoded_frame_callback) {
+    const VCMEncodedFrame& frame,
+    VCMDecodedFrameCallback* decoded_frame_callback) {
+  uint8_t payload_type = frame.PayloadType();
   if (payload_type == receive_codec_.plType || payload_type == 0) {
     return ptr_decoder_;
   }
   // Check for exisitng decoder, if exists - delete.
   if (ptr_decoder_) {
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = NULL;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
   }
-  ptr_decoder_ = CreateAndInitDecoder(payload_type, &receive_codec_);
+  ptr_decoder_ = CreateAndInitDecoder(frame, &receive_codec_);
   if (!ptr_decoder_) {
     return NULL;
   }
   VCMReceiveCallback* callback = decoded_frame_callback->UserReceiveCallback();
   if (callback) callback->OnIncomingPayloadType(receive_codec_.plType);
   if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback)
       < 0) {
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = NULL;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
@@ skipping 19 matching lines @@
   if (ext_item == nullptr)
     return true;
   return ext_item->internal_render_timing;
 }
 
 bool VCMCodecDataBase::MatchesCurrentResolution(int width, int height) const {
   return send_codec_.width == width && send_codec_.height == height;
 }
 
 VCMGenericDecoder* VCMCodecDataBase::CreateAndInitDecoder(
-    uint8_t payload_type,
+    const VCMEncodedFrame& frame,
     VideoCodec* new_codec) const {
+  uint8_t payload_type = frame.PayloadType();
   assert(new_codec);
   const VCMDecoderMapItem* decoder_item = FindDecoderItem(payload_type);
   if (!decoder_item) {
     LOG(LS_ERROR) << "Can't find a decoder associated with payload type: "
                   << static_cast<int>(payload_type);
     return NULL;
   }
   VCMGenericDecoder* ptr_decoder = NULL;
   const VCMExtDecoderMapItem* external_dec_item =
       FindExternalDecoderItem(payload_type);
   if (external_dec_item) {
     // External codec.
     ptr_decoder = new VCMGenericDecoder(
         *external_dec_item->external_decoder_instance, true);
   } else {
     // Create decoder.
     ptr_decoder = CreateDecoder(decoder_item->settings->codecType);
   }
   if (!ptr_decoder)
     return NULL;
 
+  // Copy over input resolutions to prevent codec reinitialization due to
+  // the first frame being of a different resolution than the database values.
+  // This is best effort, since there's no guarantee that width/height have been
+  // parsed yet (and may be zero).
+  if (frame.EncodedImage()._encodedWidth > 0 &&
+      frame.EncodedImage()._encodedHeight > 0) {
+    decoder_item->settings->width = frame.EncodedImage()._encodedWidth;
+    decoder_item->settings->height = frame.EncodedImage()._encodedHeight;
+  }
   if (ptr_decoder->InitDecode(decoder_item->settings.get(),
                               decoder_item->number_of_cores) < 0) {
     ReleaseDecoder(ptr_decoder);
-    return NULL;
+    return nullptr;

[mflodman, 2015/11/27 09:20:21]

I'd prefer to use NULL or nullptr, not mix both in the same file. And of the two
I of course I do prefer nullptr ;)

[pbos-webrtc, 2015/11/27 13:23:40]

Done.

   }
   memcpy(new_codec, decoder_item->settings.get(), sizeof(VideoCodec));
   return ptr_decoder;
 }
 
 void VCMCodecDataBase::DeleteEncoder() {
   if (!ptr_encoder_)
     return;
   ptr_encoder_->Release();
   ptr_encoder_.reset();
@@ skipping 30 matching lines @@
 
 const VCMExtDecoderMapItem* VCMCodecDataBase::FindExternalDecoderItem(
     uint8_t payload_type) const {
   ExternalDecoderMap::const_iterator it = dec_external_map_.find(payload_type);
   if (it != dec_external_map_.end()) {
     return (*it).second;
   }
   return NULL;
 }
 }  // namespace webrtc