[Cast] Repurpose CastInitializationStatus for variable frame size support.

media/cast/sender/external_video_encoder.cc

 // Copyright 2014 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.
 
 #include "media/cast/sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
@@ skipping 45 matching lines @@
 // SingleThreadTaskRunner, except for the task_runner() accessor.
 class ExternalVideoEncoder::VEAClientImpl
     : public VideoEncodeAccelerator::Client,
       public base::RefCountedThreadSafe<VEAClientImpl> {
  public:
   VEAClientImpl(
       const scoped_refptr<CastEnvironment>& cast_environment,
       const scoped_refptr<base::SingleThreadTaskRunner>& encoder_task_runner,
       scoped_ptr<media::VideoEncodeAccelerator> vea,
       int max_frame_rate,
+      const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
+        status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
         video_encode_accelerator_(vea.Pass()),
         encoder_active_(false),
         last_encoded_frame_id_(kStartFrameId),
         key_frame_encountered_(false) {
   }
 
   base::SingleThreadTaskRunner* task_runner() const {
     return task_runner_.get();
   }
 
   void Initialize(const gfx::Size& frame_size,
                   VideoCodecProfile codec_profile,
-                  int start_bit_rate,
-                  const CastInitializationCallback& initialization_cb) {
+                  int start_bit_rate) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     DCHECK(!frame_size.IsEmpty());
 
     encoder_active_ = video_encode_accelerator_->Initialize(
         media::VideoFrame::I420,
         frame_size,
         codec_profile,
         start_bit_rate,
         this);
 
     UMA_HISTOGRAM_BOOLEAN("Cast.Sender.VideoEncodeAcceleratorInitializeSuccess",
                           encoder_active_);
 
-    if (!initialization_cb.is_null()) {
-      cast_environment_->PostTask(
-          CastEnvironment::MAIN,
-          FROM_HERE,
-          base::Bind(initialization_cb,
-                     encoder_active_ ? STATUS_VIDEO_INITIALIZED :
-                         STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED));
-    }
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(status_change_cb_,
+                   encoder_active_ ? STATUS_INITIALIZED :
+                       STATUS_CODEC_INIT_FAILED));
   }
 
   void SetBitRate(int bit_rate) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     video_encode_accelerator_->RequestEncodingParametersChange(bit_rate,
                                                                max_frame_rate_);
   }
 
   void EncodeVideoFrame(
@@ skipping 11 matching lines @@
         reference_time,
         frame_encoded_callback));
 
     // BitstreamBufferReady will be called once the encoder is done.
     video_encode_accelerator_->Encode(video_frame, key_frame_requested);
   }
 
  protected:
   void NotifyError(VideoEncodeAccelerator::Error error) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
-    VLOG(1) << "ExternalVideoEncoder NotifyError: " << error;
+
+    DCHECK(error != VideoEncodeAccelerator::kInvalidArgumentError &&
+           error != VideoEncodeAccelerator::kIllegalStateError);
 
     encoder_active_ = false;
-    // TODO(miu): Plumbing is required to bubble this up to the CastSession and
-    // beyond.
+
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(status_change_cb_, STATUS_CODEC_RUNTIME_ERROR));
+
     // TODO(miu): Force-flush all |in_progress_frame_encodes_| immediately so
     // pending frames do not become stuck, freezing VideoSender.
   }
 
   // Called to allocate the input and output buffers.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 122 matching lines @@
       video_encode_accelerator_->UseOutputBitstreamBuffer(
           media::BitstreamBuffer(static_cast<int32>(i),
                                  output_buffers_[i]->handle(),
                                  output_buffers_[i]->mapped_size()));
     }
   }
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   const int max_frame_rate_;
+  const StatusChangeCallback status_change_cb_;  // Must be run on MAIN thread.
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   bool encoder_active_;
   uint32 last_encoded_frame_id_;
   bool key_frame_encountered_;
   std::string stream_header_;
 
   // Shared memory buffers for output with the VideoAccelerator.
   ScopedVector<base::SharedMemory> output_buffers_;
 
   // FIFO list.
   std::list<InProgressFrameEncode> in_progress_frame_encodes_;
 
   DISALLOW_COPY_AND_ASSIGN(VEAClientImpl);
 };
 
 ExternalVideoEncoder::ExternalVideoEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const VideoSenderConfig& video_config,
     const gfx::Size& frame_size,
-    const CastInitializationCallback& initialization_cb,
+    const StatusChangeCallback& status_change_cb,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
     : cast_environment_(cast_environment),
       create_video_encode_memory_cb_(create_video_encode_memory_cb),
       bit_rate_(video_config.start_bitrate),
       key_frame_requested_(false),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK_GT(video_config.max_frame_rate, 0);
   DCHECK(!frame_size.IsEmpty());
+  DCHECK(!status_change_cb.is_null());
   DCHECK(!create_vea_cb.is_null());
   DCHECK(!create_video_encode_memory_cb_.is_null());
   DCHECK_GT(bit_rate_, 0);
 
   VideoCodecProfile codec_profile;
   switch (video_config.codec) {
     case CODEC_VIDEO_VP8:
       codec_profile = media::VP8PROFILE_ANY;
       break;
     case CODEC_VIDEO_H264:
       codec_profile = media::H264PROFILE_MAIN;
       break;
     case CODEC_VIDEO_FAKE:
       NOTREACHED() << "Fake software video encoder cannot be external";
       // ...flow through to next case...
     default:
       cast_environment_->PostTask(
           CastEnvironment::MAIN,
           FROM_HERE,
-          base::Bind(initialization_cb, STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED));
+          base::Bind(status_change_cb, STATUS_UNSUPPORTED_CODEC));
       return;
   }
 
   create_vea_cb.Run(
       base::Bind(&ExternalVideoEncoder::OnCreateVideoEncodeAccelerator,
                  weak_factory_.GetWeakPtr(),
                  frame_size,
                  codec_profile,
                  video_config.max_frame_rate,
-                 initialization_cb));
+                 status_change_cb));
 }
 
 ExternalVideoEncoder::~ExternalVideoEncoder() {
 }
 
 bool ExternalVideoEncoder::CanEncodeVariedFrameSizes() const {
   return false;
 }
 
 bool ExternalVideoEncoder::EncodeVideoFrame(
@@ skipping 35 matching lines @@
 }
 
 void ExternalVideoEncoder::LatestFrameIdToReference(uint32 /*frame_id*/) {
   // Do nothing.  Not supported.
 }
 
 void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
     const gfx::Size& frame_size,
     VideoCodecProfile codec_profile,
     int max_frame_rate,
-    const CastInitializationCallback& initialization_cb,
+    const StatusChangeCallback& status_change_cb,
     scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
     scoped_ptr<media::VideoEncodeAccelerator> vea) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   // The callback will be invoked with null pointers in the case where the
   // system does not support or lacks the resources to provide GPU-accelerated
   // video encoding.
   if (!encoder_task_runner || !vea) {
-    if (!initialization_cb.is_null()) {
-      cast_environment_->PostTask(
-          CastEnvironment::MAIN,
-          FROM_HERE,
-          base::Bind(initialization_cb, STATUS_INVALID_VIDEO_CONFIGURATION));
-    }
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(status_change_cb, STATUS_CODEC_INIT_FAILED));
     return;
   }
 
   DCHECK(!client_);
   client_ = new VEAClientImpl(cast_environment_,
                               encoder_task_runner,
                               vea.Pass(),
                               max_frame_rate,
+                              status_change_cb,
                               create_video_encode_memory_cb_);
   client_->task_runner()->PostTask(FROM_HERE,
                                    base::Bind(&VEAClientImpl::Initialize,
                                               client_,
                                               frame_size,
                                               codec_profile,
-                                              bit_rate_,
-                                              initialization_cb));
+                                              bit_rate_));
 }
 
 }  //  namespace cast
 }  //  namespace media