Avoid resetting encoder on identical settings.

BUG=1681
R=holmer@google.com, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/1481005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4049 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/video_coding/main/source/codec_database.cc

@@ -47,6 +47,7 @@ VCMCodecDataBase::VCMCodecDataBase(int id)
       number_of_cores_(0),
       max_payload_size_(kDefaultPayloadSize),
       periodic_key_frames_(false),
+      pending_encoder_reset_(true),
       current_enc_is_external_(false),
       send_codec_(),
       receive_codec_(),
@@ -148,17 +149,18 @@ void VCMCodecDataBase::ResetSender() {
 }
 
 // Assuming only one registered encoder - since only one used, no need for more.
-bool VCMCodecDataBase::RegisterSendCodec(
+bool VCMCodecDataBase::SetSendCodec(
     const VideoCodec* send_codec,
     int number_of_cores,
-    int max_payload_size) {
+    int max_payload_size,
+    VCMEncodedFrameCallback* encoded_frame_callback) {
   if (!send_codec) {
     return false;
   }
   if (max_payload_size <= 0) {
     max_payload_size = kDefaultPayloadSize;
   }
-  if (number_of_cores < 0 || number_of_cores > 32) {
+  if (number_of_cores <= 0 || number_of_cores > 32) {
     return false;
   }
   if (send_codec->plType <= 0) {
@@ -171,23 +173,86 @@ bool VCMCodecDataBase::RegisterSendCodec(
   if (send_codec->codecType == kVideoCodecUnknown) {
     return false;
   }
-  number_of_cores_ = number_of_cores;
+  bool reset_required = pending_encoder_reset_;
-  max_payload_size_ = max_payload_size;
+  if (number_of_cores_ != number_of_cores) {
+    number_of_cores_ = number_of_cores;
+    reset_required = true;
+  }
+  if (max_payload_size_ != max_payload_size) {
+    max_payload_size_ = max_payload_size;
+    reset_required = true;
+  }
 
-  memcpy(&send_codec_, send_codec, sizeof(VideoCodec));
+  VideoCodec new_send_codec;
+  memcpy(&new_send_codec, send_codec, sizeof(new_send_codec));
 
-  if (send_codec_.maxBitrate == 0) {
+  if (new_send_codec.maxBitrate == 0) {
     // max is one bit per pixel
-    send_codec_.maxBitrate = (static_cast<int>(send_codec_.height) *
+    new_send_codec.maxBitrate = (static_cast<int>(send_codec->height) *
-        static_cast<int>(send_codec_.width) *
+        static_cast<int>(send_codec->width) *
-        static_cast<int>(send_codec_.maxFramerate)) / 1000;
+        static_cast<int>(send_codec->maxFramerate)) / 1000;
-    if (send_codec_.startBitrate > send_codec_.maxBitrate) {
+    if (send_codec->startBitrate > new_send_codec.maxBitrate) {
       // But if the user tries to set a higher start bit rate we will
       // increase the max accordingly.
-      send_codec_.maxBitrate = send_codec_.startBitrate;
+      new_send_codec.maxBitrate = send_codec->startBitrate;
     }
   }
 
+  if (!reset_required) {
+    reset_required = RequiresEncoderReset(new_send_codec);
+  }
+
+  memcpy(&send_codec_, &new_send_codec, sizeof(send_codec_));
+
+  if (!reset_required) {
+    encoded_frame_callback->SetPayloadType(send_codec->plType);
+    if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) < 0) {
+      return false;
+    }
+    return true;
+  }
+
+  // If encoder exists, will destroy it and create new one.
+  DeleteEncoder();
+  if (send_codec->plType == external_payload_type_) {
+    // External encoder.
+    ptr_encoder_ = new VCMGenericEncoder(*external_encoder_, internal_source_);
+    current_enc_is_external_ = true;
+  } else {
+    ptr_encoder_ = CreateEncoder(send_codec->codecType);
+    current_enc_is_external_ = false;
+  }
+  encoded_frame_callback->SetPayloadType(send_codec->plType);
+  if (!ptr_encoder_) {
+    WEBRTC_TRACE(webrtc::kTraceError,
+                 webrtc::kTraceVideoCoding,
+                 VCMId(id_),
+                 "Failed to create encoder: %s.",
+                 send_codec->plName);
+    return false;
+  }
+  if (ptr_encoder_->InitEncode(send_codec,
+                               number_of_cores_,
+                               max_payload_size_) < 0) {
+    WEBRTC_TRACE(webrtc::kTraceError,
+                 webrtc::kTraceVideoCoding,
+                 VCMId(id_),
+                 "Failed to initialize encoder: %s.",
+                 send_codec->plName);
+    DeleteEncoder();
+    return false;
+  } else if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) < 0) {
+    DeleteEncoder();
+    return false;
+  }
+
+  // Intentionally don't check return value since the encoder registration
+  // shouldn't fail because the codec doesn't support changing the periodic key
+  // frame setting.
+  ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
+
+  pending_encoder_reset_ = false;
+
   return true;
 }
 
@@ -239,48 +304,72 @@ void VCMCodecDataBase::RegisterExternalEncoder(
   external_encoder_ = external_encoder;
   external_payload_type_ = payload_type;
   internal_source_ = internal_source;
+  pending_encoder_reset_ = true;
 }
 
-VCMGenericEncoder* VCMCodecDataBase::GetEncoder(
+bool VCMCodecDataBase::RequiresEncoderReset(const VideoCodec& new_send_codec) {
-    const VideoCodec* settings,
+  if (ptr_encoder_ == NULL) {
-    VCMEncodedFrameCallback* encoded_frame_callback) {
+    return true;
-  // If encoder exists, will destroy it and create new one.
-  DeleteEncoder();
-  if (settings->plType == external_payload_type_) {
-    // External encoder.
-    ptr_encoder_ = new VCMGenericEncoder(*external_encoder_, internal_source_);
-    current_enc_is_external_ = true;
-  } else {
-    ptr_encoder_ = CreateEncoder(settings->codecType);
-    current_enc_is_external_ = false;
   }
-  encoded_frame_callback->SetPayloadType(settings->plType);
+
-  if (!ptr_encoder_) {
+  // Does not check startBitrate or maxFramerate
-    WEBRTC_TRACE(webrtc::kTraceError,
+  if (new_send_codec.codecType != send_codec_.codecType ||
-                 webrtc::kTraceVideoCoding,
+      strcmp(new_send_codec.plName, send_codec_.plName) != 0 ||
-                 VCMId(id_),
+      new_send_codec.plType != send_codec_.plType ||
-                 "Failed to create encoder: %s.",
+      new_send_codec.width != send_codec_.width ||
-                 settings->plName);
+      new_send_codec.height != send_codec_.height ||
-    return NULL;
+      new_send_codec.maxBitrate != send_codec_.maxBitrate ||
+      new_send_codec.minBitrate != send_codec_.minBitrate ||
+      new_send_codec.qpMax != send_codec_.qpMax ||
+      new_send_codec.numberOfSimulcastStreams !=
+          send_codec_.numberOfSimulcastStreams ||
+      new_send_codec.mode != send_codec_.mode ||
+      new_send_codec.extra_options != send_codec_.extra_options) {
+    return true;
   }
-  if (ptr_encoder_->InitEncode(settings, number_of_cores_, max_payload_size_) <
+
-      0) {
+  switch (new_send_codec.codecType) {
-    WEBRTC_TRACE(webrtc::kTraceError,
+    case kVideoCodecVP8:
-                 webrtc::kTraceVideoCoding,
+      if (memcmp(&new_send_codec.codecSpecific.VP8,
-                 VCMId(id_),
+                 &send_codec_.codecSpecific.VP8,
-                 "Failed to initialize encoder: %s.",
+                 sizeof(new_send_codec.codecSpecific.VP8)) !=
-                 settings->plName);
+          0) {
-    DeleteEncoder();
+        return true;
-    return NULL;
+      }
-  } else if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) <
+      break;
-      0) {
+    case kVideoCodecGeneric:
-    DeleteEncoder();
+      if (memcmp(&new_send_codec.codecSpecific.Generic,
-    return NULL;
+                 &send_codec_.codecSpecific.Generic,
+                 sizeof(new_send_codec.codecSpecific.Generic)) !=
+          0) {
+        return true;
+      }
+      break;
+    // Known codecs without payload-specifics
+    case kVideoCodecI420:
+    case kVideoCodecRED:
+    case kVideoCodecULPFEC:
+      break;
+    // Unknown codec type, reset just to be sure.
+    case kVideoCodecUnknown:
+      return true;
   }
-  // Intentionally don't check return value since the encoder registration
+
-  // shouldn't fail because the codec doesn't support changing the periodic key
+  if (new_send_codec.numberOfSimulcastStreams > 0) {
-  // frame setting.
+    for (unsigned char i = 0; i < new_send_codec.numberOfSimulcastStreams;
-  ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
+         ++i) {
+      if (memcmp(&new_send_codec.simulcastStream[i],
+                 &send_codec_.simulcastStream[i],
+                 sizeof(new_send_codec.simulcastStream[i])) !=
+          0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+VCMGenericEncoder* VCMCodecDataBase::GetEncoder() {
   return ptr_encoder_;
 }
 

webrtc/modules/video_coding/main/source/codec_database.h

@@ -68,9 +68,10 @@ class VCMCodecDataBase {
   // Sets the sender side codec and initiates the desired codec given the
   // VideoCodec struct.
   // Returns true if the codec was successfully registered, false otherwise.
-  bool RegisterSendCodec(const VideoCodec* send_codec,
+  bool SetSendCodec(const VideoCodec* send_codec,
-                         int number_of_cores,
+                    int number_of_cores,
-                         int max_payload_size);
+                    int max_payload_size,
+                    VCMEncodedFrameCallback* encoded_frame_callback);
 
   // Gets the current send codec. Relevant for internal codecs only.
   // Returns true if there is a send codec, false otherwise.
@@ -93,15 +94,7 @@ class VCMCodecDataBase {
   // if the external encoder was the send codec before being deregistered.
   bool DeregisterExternalEncoder(uint8_t payload_type, bool* was_send_codec);
 
-  // Returns an encoder specified by the payload type in |settings|. The
+  VCMGenericEncoder* GetEncoder();
-  // encoded frame callback of the encoder is set to |encoded_frame_callback|.
-  // If no such encoder already exists an instance will be created and
-  // initialized using |settings|.
-  // NULL is returned if no encoder with the specified payload type was found
-  // and the function failed to create one.
-  VCMGenericEncoder* GetEncoder(
-      const VideoCodec* settings,
-      VCMEncodedFrameCallback* encoded_frame_callback);
 
   bool SetPeriodicKeyFrames(bool enable);
 
@@ -165,6 +158,9 @@ class VCMCodecDataBase {
                                           VideoCodec* new_codec,
                                           bool* external) const;
 
+  // Determines whether a new codec has to be created or not.
+  // Checks every setting apart from maxFramerate and startBitrate.
+  bool RequiresEncoderReset(const VideoCodec& send_codec);
   // Create an internal encoder given a codec type.
   VCMGenericEncoder* CreateEncoder(const VideoCodecType type) const;
 
@@ -182,6 +178,7 @@ class VCMCodecDataBase {
   int number_of_cores_;
   int max_payload_size_;
   bool periodic_key_frames_;
+  bool pending_encoder_reset_;
   bool current_enc_is_external_;
   VideoCodec send_codec_;
   VideoCodec receive_codec_;

webrtc/modules/video_coding/main/source/generic_encoder.h

@@ -85,40 +85,41 @@ public:
     VCMGenericEncoder(VideoEncoder& encoder, bool internalSource = false);
     ~VCMGenericEncoder();
     /**
-    *	Free encoder memory
+    * Free encoder memory
     */
     int32_t Release();
     /**
-    *	Initialize the encoder with the information from the VideoCodec
+    * Initialize the encoder with the information from the VideoCodec
     */
     int32_t InitEncode(const VideoCodec* settings,
-                             int32_t numberOfCores,
+                       int32_t numberOfCores,
-                             uint32_t maxPayloadSize);
+                       uint32_t maxPayloadSize);
     /**
-    *	Encode raw image
+    * Encode raw image
-    *	inputFrame        : Frame containing raw image
+    * inputFrame        : Frame containing raw image
-    *	codecSpecificInfo : Specific codec data
+    * codecSpecificInfo : Specific codec data
-    *	cameraFrameRate	  :	request or information from the remote side
+    * cameraFrameRate   : Request or information from the remote side
-    *	frameType         : The requested frame type to encode
+    * frameType         : The requested frame type to encode
     */
     int32_t Encode(const I420VideoFrame& inputFrame,
-                         const CodecSpecificInfo* codecSpecificInfo,
+                   const CodecSpecificInfo* codecSpecificInfo,
-                         const std::vector<FrameType>& frameTypes);
+                   const std::vector<FrameType>& frameTypes);
     /**
     * Set new target bitrate (bits/s) and framerate.
     * Return Value: new bit rate if OK, otherwise <0s.
     */
-    int32_t SetRates(uint32_t target_bitrate,
+    int32_t SetRates(uint32_t target_bitrate, uint32_t frameRate);
-                           uint32_t frameRate);
     /**
     * Set a new packet loss rate and a new round-trip time in milliseconds.
     */
     int32_t SetChannelParameters(int32_t packetLoss, int rtt);
     int32_t CodecConfigParameters(uint8_t* buffer, int32_t size);
     /**
-    * Register a transport callback which will be called to deliver the encoded buffers
+    * Register a transport callback which will be called to deliver the encoded
+    * buffers
     */
-    int32_t RegisterEncodeCallback(VCMEncodedFrameCallback* VCMencodedFrameCallback);
+    int32_t RegisterEncodeCallback(
+        VCMEncodedFrameCallback* VCMencodedFrameCallback);
     /**
     * Get encoder bit rate
     */
@@ -138,8 +139,8 @@ private:
     VideoEncoder&               _encoder;
     VideoCodecType              _codecType;
     VCMEncodedFrameCallback*    _VCMencodedFrameCallback;
-    uint32_t              _bitRate;
+    uint32_t                    _bitRate;
-    uint32_t              _frameRate;
+    uint32_t                    _frameRate;
     bool                        _internalSource;
 }; // end of VCMGenericEncoder class
 

webrtc/modules/video_coding/main/source/video_coding_impl.cc

@@ -325,26 +325,22 @@ VideoCodingModuleImpl::RegisterSendCodec(const VideoCodec* sendCodec,
                                          uint32_t maxPayloadSize)
 {
     CriticalSectionScoped cs(_sendCritSect);
-    if (sendCodec == NULL)
+    if (sendCodec == NULL) {
-    {
         return VCM_PARAMETER_ERROR;
     }
-    bool ret = _codecDataBase.RegisterSendCodec(sendCodec, numberOfCores,
-                                                maxPayloadSize);
-    if (!ret)
-    {
-        return -1;
-    }
 
-    _encoder = _codecDataBase.GetEncoder(sendCodec, &_encodedFrameCallback);
+    bool ret = _codecDataBase.SetSendCodec(sendCodec, numberOfCores,
-    if (_encoder == NULL)
+                                           maxPayloadSize,
-    {
+                                           &_encodedFrameCallback);
+    if (!ret) {
         WEBRTC_TRACE(webrtc::kTraceError,
                      webrtc::kTraceVideoCoding,
                      VCMId(_id),
                      "Failed to initialize encoder");
         return VCM_CODEC_ERROR;
     }
+
+    _encoder = _codecDataBase.GetEncoder();
     _sendCodecType = sendCodec->codecType;
     int numLayers = (_sendCodecType != kVideoCodecVP8) ? 1 :
                         sendCodec->codecSpecific.VP8.numberOfTemporalLayers;