Don't re-randomize picture_id/tl0_pic_idx when re-initializing internal encoders.

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 115 matching lines @@
 VP8Encoder* VP8Encoder::Create() {
   return new VP8EncoderImpl();
 }
 
 VP8Decoder* VP8Decoder::Create() {
   return new VP8DecoderImpl();
 }
 
 VP8EncoderImpl::VP8EncoderImpl()
     : use_gf_boost_(webrtc::field_trial::IsEnabled(kVp8GfBoostFieldTrial)),
+      random_(rtc::TimeMicros()),

[stefan-webrtc, 2017/04/20 09:28:09]

Mostly FYI, but we discovered today that TimeMicros gives us millisecond
granularity on Windows.

[brandtr, 2017/04/24 07:53:47]

Changed to TimeMillis(). That should be granular enough.

       encoded_complete_callback_(nullptr),
       inited_(false),
       timestamp_(0),
       qp_max_(56),  // Setting for max quantizer.
       cpu_speed_default_(-6),
       number_of_cores_(0),
       rc_max_intra_target_(0),
       key_frame_request_(kMaxSimulcastStreams, false) {
-  uint32_t seed = rtc::Time32();
-  srand(seed);
-
   picture_id_.reserve(kMaxSimulcastStreams);
+  for (int i = 0; i < kMaxSimulcastStreams; ++i) {
+    picture_id_.push_back(random_.Rand<uint16_t>() & 0x7FFF);
+    tl0_pic_idx_.push_back(random_.Rand<uint8_t>());
+  }
   last_key_frame_picture_id_.reserve(kMaxSimulcastStreams);
   temporal_layers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
   encoded_images_.reserve(kMaxSimulcastStreams);
   send_stream_.reserve(kMaxSimulcastStreams);
   cpu_speed_.assign(kMaxSimulcastStreams, cpu_speed_default_);
   encoders_.reserve(kMaxSimulcastStreams);
   configurations_.reserve(kMaxSimulcastStreams);
   downsampling_factors_.reserve(kMaxSimulcastStreams);
 }
@@ skipping 17 matching lines @@
     }
     encoders_.pop_back();
   }
   configurations_.clear();
   send_stream_.clear();
   cpu_speed_.clear();
   while (!raw_images_.empty()) {
     vpx_img_free(&raw_images_.back());
     raw_images_.pop_back();
   }
-  while (!temporal_layers_.empty()) {
-    delete temporal_layers_.back();
-    temporal_layers_.pop_back();
+  for (size_t i = 0; i < temporal_layers_.size(); ++i) {
+    tl0_pic_idx_[i] = temporal_layers_[i]->Tl0PicIdx();
   }
+  temporal_layers_.clear();
   inited_ = false;
   return ret_val;
 }
 
 int VP8EncoderImpl::SetRateAllocation(const BitrateAllocation& bitrate,
                                       uint32_t new_framerate) {
   if (!inited_)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
   if (encoders_[0].err)
@@ skipping 64 matching lines @@
   }
   send_stream_[stream_idx] = send_stream;
 }
 
 void VP8EncoderImpl::SetupTemporalLayers(int num_streams,
                                          int num_temporal_layers,
                                          const VideoCodec& codec) {
   RTC_DCHECK(codec.VP8().tl_factory != nullptr);
   const TemporalLayersFactory* tl_factory = codec.VP8().tl_factory;
   if (num_streams == 1) {
-    temporal_layers_.push_back(
-        tl_factory->Create(0, num_temporal_layers, rand()));
+    temporal_layers_.emplace_back(
+        tl_factory->Create(0, num_temporal_layers, tl0_pic_idx_[0]));
   } else {
     for (int i = 0; i < num_streams; ++i) {
       RTC_CHECK_GT(num_temporal_layers, 0);
       int layers = std::max(static_cast<uint8_t>(1),
                             codec.simulcastStream[i].numberOfTemporalLayers);
-      temporal_layers_.push_back(tl_factory->Create(i, layers, rand()));
+      temporal_layers_.emplace_back(
+          tl_factory->Create(i, layers, tl0_pic_idx_[i]));
     }
   }
 }
 
 int VP8EncoderImpl::InitEncode(const VideoCodec* inst,
                                int number_of_cores,
                                size_t /*maxPayloadSize */) {
   if (inst == NULL) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
@@ skipping 36 matching lines @@
   timestamp_ = 0;
   codec_ = *inst;
 
   // Code expects simulcastStream resolutions to be correct, make sure they are
   // filled even when there are no simulcast layers.
   if (codec_.numberOfSimulcastStreams == 0) {
     codec_.simulcastStream[0].width = codec_.width;
     codec_.simulcastStream[0].height = codec_.height;
   }
 
-  picture_id_.resize(number_of_streams);
   last_key_frame_picture_id_.resize(number_of_streams);
   encoded_images_.resize(number_of_streams);
   encoders_.resize(number_of_streams);
   configurations_.resize(number_of_streams);
   downsampling_factors_.resize(number_of_streams);
   raw_images_.resize(number_of_streams);
   send_stream_.resize(number_of_streams);
   send_stream_[0] = true;  // For non-simulcast case.
   cpu_speed_.resize(number_of_streams);
   std::fill(key_frame_request_.begin(), key_frame_request_.end(), false);
 
   int idx = number_of_streams - 1;
   for (int i = 0; i < (number_of_streams - 1); ++i, --idx) {
     int gcd = GCD(inst->simulcastStream[idx].width,
                   inst->simulcastStream[idx - 1].width);
     downsampling_factors_[i].num = inst->simulcastStream[idx].width / gcd;
     downsampling_factors_[i].den = inst->simulcastStream[idx - 1].width / gcd;
     send_stream_[i] = false;
   }
   if (number_of_streams > 1) {
     send_stream_[number_of_streams - 1] = false;
     downsampling_factors_[number_of_streams - 1].num = 1;
     downsampling_factors_[number_of_streams - 1].den = 1;
   }
   for (int i = 0; i < number_of_streams; ++i) {
-    // Random start, 16 bits is enough.
-    picture_id_[i] = static_cast<uint16_t>(rand()) & 0x7FFF;  // NOLINT
     last_key_frame_picture_id_[i] = -1;
     // allocate memory for encoded image
     if (encoded_images_[i]._buffer != NULL) {
       delete[] encoded_images_[i]._buffer;
     }
     encoded_images_[i]._size =
         CalcBufferSize(kI420, codec_.width, codec_.height);
     encoded_images_[i]._buffer = new uint8_t[encoded_images_[i]._size];
     encoded_images_[i]._completeFrame = true;
   }
@@ skipping 777 matching lines @@
   buffer_pool_.Release();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP8DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 }  // namespace webrtc