Name SimulcastEncoderApdater on InitEncode.

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.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 118 matching lines @@
  private:
   webrtc::SimulcastEncoderAdapter* const adapter_;
   const size_t stream_idx_;
 };
 
 }  // namespace
 
 namespace webrtc {
 
 SimulcastEncoderAdapter::SimulcastEncoderAdapter(VideoEncoderFactory* factory)
-    : factory_(factory), encoded_complete_callback_(NULL) {
+    : factory_(factory),
+      encoded_complete_callback_(NULL),
+      implementation_name_("SimulcastEncoderAdapter") {
   memset(&codec_, 0, sizeof(webrtc::VideoCodec));
 }
 
 SimulcastEncoderAdapter::~SimulcastEncoderAdapter() {
   Release();
 }
 
 int SimulcastEncoderAdapter::Release() {
   // TODO(pbos): Keep the last encoder instance but call ::Release() on it, then
   // re-use this instance in ::InitEncode(). This means that changing
@@ skipping 35 matching lines @@
   }
 
   codec_ = *inst;
 
   // Special mode when screensharing on a single stream.
   if (number_of_streams == 1 && inst->mode == kScreensharing) {
     screensharing_tl_factory_.reset(new ScreenshareTemporalLayersFactory());
     codec_.codecSpecific.VP8.tl_factory = screensharing_tl_factory_.get();
   }
 
+  std::string implementation_name;
   // Create |number_of_streams| of encoder instances and init them.
   for (int i = 0; i < number_of_streams; ++i) {
     VideoCodec stream_codec;
     bool send_stream = true;
     if (!doing_simulcast) {
       stream_codec = codec_;
       stream_codec.numberOfSimulcastStreams = 1;
     } else {
       bool highest_resolution_stream = (i == (number_of_streams - 1));
       PopulateStreamCodec(&codec_, i, number_of_streams,
                           highest_resolution_stream, &stream_codec,
                           &send_stream);
     }
 
     // TODO(ronghuawu): Remove once this is handled in VP8EncoderImpl.
     if (stream_codec.qpMax < kDefaultMinQp) {
       stream_codec.qpMax = kDefaultMaxQp;
     }
 
     VideoEncoder* encoder = factory_->Create();
     ret = encoder->InitEncode(&stream_codec, number_of_cores, max_payload_size);
     if (ret < 0) {
       Release();
       return ret;
     }
     EncodedImageCallback* callback = new AdapterEncodedImageCallback(this, i);
     encoder->RegisterEncodeCompleteCallback(callback);
     streaminfos_.push_back(StreamInfo(encoder, callback, stream_codec.width,
                                       stream_codec.height, send_stream));
+    if (i != 0)
+      implementation_name += ", ";
+    implementation_name += streaminfos_[i].encoder->ImplementationName();
   }
+  implementation_name_ =
+      "SimulcastEncoderAdapter (" + implementation_name + ")";
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int SimulcastEncoderAdapter::Encode(
     const VideoFrame& input_image,
     const CodecSpecificInfo* codec_specific_info,
     const std::vector<FrameType>* frame_types) {
   if (!Initialized()) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
@@ skipping 252 matching lines @@
 bool SimulcastEncoderAdapter::SupportsNativeHandle() const {
   // We should not be calling this method before streaminfos_ are configured.
   RTC_DCHECK(!streaminfos_.empty());
   // TODO(pbos): Support textures when using more than one encoder.
   if (streaminfos_.size() != 1)
     return false;
   return streaminfos_[0].encoder->SupportsNativeHandle();
 }
 
 const char* SimulcastEncoderAdapter::ImplementationName() const {
-  // We should not be calling this method before streaminfos_ are configured.
-  RTC_DCHECK(!streaminfos_.empty());
-  // TODO(pbos): Support multiple implementation names for different encoders.
-  return streaminfos_[0].encoder->ImplementationName();
+  return implementation_name_.c_str();
 }
 
 }  // namespace webrtc