Revert of Cast: Fix threading issues in VideoEncoderImpl

media/cast/video_sender/codecs/vp8/vp8_encoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // TODO (pwestin): add a link to the design document describing the generic
 // protocol and the VP8 specific details.
 #include "media/cast/video_sender/codecs/vp8/vp8_encoder.h"
 
 #include <vector>
 
@@ skipping 10 matching lines @@
 
 Vp8Encoder::Vp8Encoder(const VideoSenderConfig& video_config,
                        uint8 max_unacked_frames)
     : cast_config_(video_config),
       use_multiple_video_buffers_(
           cast_config_.max_number_of_video_buffers_used ==
           kNumberOfVp8VideoBuffers),
       max_number_of_repeated_buffers_in_a_row_(
           (max_unacked_frames > kNumberOfVp8VideoBuffers) ?
           ((max_unacked_frames - 1) / kNumberOfVp8VideoBuffers) : 0),
+      config_(new vpx_codec_enc_cfg_t()),
+      encoder_(new vpx_codec_ctx_t()),
+      // Creating a wrapper to the image - setting image data to NULL. Actual
+      // pointer will be set during encode. Setting align to 1, as it is
+      // meaningless (actual memory is not allocated).
+      raw_image_(vpx_img_wrap(NULL, IMG_FMT_I420, video_config.width,
+                              video_config.height, 1, NULL)),
       key_frame_requested_(true),
       timestamp_(0),
       last_encoded_frame_id_(kStartFrameId),
       number_of_repeated_buffers_(0) {
   // TODO(pwestin): we need to figure out how to synchronize the acking with the
   // internal state of the encoder, ideally the encoder will tell if we can
   // send another frame.
   DCHECK(!use_multiple_video_buffers_ ||
          max_number_of_repeated_buffers_in_a_row_ == 0) <<  "Invalid config";
 
   // VP8 have 3 buffers available for prediction, with
   // max_number_of_video_buffers_used set to 1 we maximize the coding efficiency
   // however in this mode we can not skip frames in the receiver to catch up
   // after a temporary network outage; with max_number_of_video_buffers_used
   // set to 3 we allow 2 frames to be skipped by the receiver without error
   // propagation.
   DCHECK(cast_config_.max_number_of_video_buffers_used == 1 ||
          cast_config_.max_number_of_video_buffers_used ==
              kNumberOfVp8VideoBuffers) << "Invalid argument";
 
-  thread_checker_.DetachFromThread();
+  for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
+    acked_frame_buffers_[i] = true;
+    used_buffers_frame_id_[i] = kStartFrameId;
+  }
+  InitEncode(video_config.number_of_cores);
 }
 
 Vp8Encoder::~Vp8Encoder() {
   vpx_codec_destroy(encoder_.get());
   vpx_img_free(raw_image_);
 }
 
-void Vp8Encoder::Initialize() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  config_.reset(new vpx_codec_enc_cfg_t());
-  encoder_.reset(new vpx_codec_ctx_t());
-
-  // Creating a wrapper to the image - setting image data to NULL. Actual
-  // pointer will be set during encode. Setting align to 1, as it is
-  // meaningless (actual memory is not allocated).
-  raw_image_ = vpx_img_wrap(NULL, IMG_FMT_I420, cast_config_.width,
-                            cast_config_.height, 1, NULL);
-
-  for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
-    acked_frame_buffers_[i] = true;
-    used_buffers_frame_id_[i] = kStartFrameId;
-  }
-  InitEncode(cast_config_.number_of_cores);
-}
-
 void Vp8Encoder::InitEncode(int number_of_cores) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   // Populate encoder configuration with default values.
   if (vpx_codec_enc_config_default(vpx_codec_vp8_cx(), config_.get(), 0)) {
     DCHECK(false) << "Invalid return value";
   }
   config_->g_w = cast_config_.width;
   config_->g_h = cast_config_.height;
   config_->rc_target_bitrate = cast_config_.start_bitrate / 1000;  // In kbit/s.
 
   // Setting the codec time base.
   config_->g_timebase.num = 1;
@@ skipping 41 matching lines @@
   }
   vpx_codec_control(encoder_.get(), VP8E_SET_STATIC_THRESHOLD, 1);
   vpx_codec_control(encoder_.get(), VP8E_SET_NOISE_SENSITIVITY, 0);
   vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, -6);
   vpx_codec_control(encoder_.get(), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                     rc_max_intra_target);
 }
 
 bool Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
                         transport::EncodedVideoFrame* encoded_image) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   // Image in vpx_image_t format.
   // Input image is const. VP8's raw image is not defined as const.
   raw_image_->planes[PLANE_Y] =
       const_cast<uint8*>(video_frame->data(VideoFrame::kYPlane));
   raw_image_->planes[PLANE_U] =
       const_cast<uint8*>(video_frame->data(VideoFrame::kUPlane));
   raw_image_->planes[PLANE_V] =
       const_cast<uint8*>(video_frame->data(VideoFrame::kVPlane));
 
   raw_image_->stride[VPX_PLANE_Y] = video_frame->stride(VideoFrame::kYPlane);
@@ skipping 185 matching lines @@
     case kNoBuffer:
       *flags |= VP8_EFLAG_NO_UPD_ARF;
       *flags |= VP8_EFLAG_NO_UPD_GF;
       *flags |= VP8_EFLAG_NO_UPD_LAST;
       *flags |= VP8_EFLAG_NO_UPD_ENTROPY;
       break;
   }
 }
 
 void Vp8Encoder::UpdateRates(uint32 new_bitrate) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   uint32 new_bitrate_kbit = new_bitrate / 1000;
   if (config_->rc_target_bitrate == new_bitrate_kbit) return;
 
   config_->rc_target_bitrate = new_bitrate_kbit;
 
   // Update encoder context.
   if (vpx_codec_enc_config_set(encoder_.get(), config_.get())) {
     DCHECK(false) << "Invalid return value";
   }
 }
 
 void Vp8Encoder::LatestFrameIdToReference(uint32 frame_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   if (!use_multiple_video_buffers_) return;
 
   VLOG(1) << "VP8 ok to reference frame:" << static_cast<int>(frame_id);
   for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
     if (frame_id == used_buffers_frame_id_[i]) {
       acked_frame_buffers_[i] = true;
     }
   }
 }
 
 void Vp8Encoder::GenerateKeyFrame() {
-  DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_requested_ = true;
 }
 
 // Calculate the max size of the key frame relative to a normal delta frame.
 uint32 Vp8Encoder::MaxIntraTarget(uint32 optimal_buffer_size_ms) const {
   // Set max to the optimal buffer level (normalized by target BR),
   // and scaled by a scale_parameter.
   // Max target size = scalePar * optimalBufferSize * targetBR[Kbps].
   // This values is presented in percentage of perFrameBw:
   // perFrameBw = targetBR[Kbps] * 1000 / frameRate.
   // The target in % is as follows:
 
   float scale_parameter = 0.5;
   uint32 target_pct = optimal_buffer_size_ms * scale_parameter *
       cast_config_.max_frame_rate / 10;
 
   // Don't go below 3 times the per frame bandwidth.
   return std::max(target_pct, kMinIntra);
 }
 
 }  // namespace cast
 }  // namespace media