[Cast] Repurpose CastInitializationStatus for variable frame size support.

media/cast/sender/audio_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/audio_encoder.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 38 matching lines @@
            Codec codec,
            int num_channels,
            int sampling_rate,
            int samples_per_frame,
            const FrameEncodedCallback& callback)
       : cast_environment_(cast_environment),
         codec_(codec),
         num_channels_(num_channels),
         samples_per_frame_(samples_per_frame),
         callback_(callback),
-        cast_initialization_status_(STATUS_AUDIO_UNINITIALIZED),
+        operational_status_(STATUS_UNINITIALIZED),
         frame_duration_(base::TimeDelta::FromMicroseconds(
             base::Time::kMicrosecondsPerSecond * samples_per_frame_ /
             sampling_rate)),
         buffer_fill_end_(0),
         frame_id_(0),
         frame_rtp_timestamp_(0),
         samples_dropped_from_buffer_(0) {
     // Support for max sampling rate of 48KHz, 2 channels, 100 ms duration.
     const int kMaxSamplesTimesChannelsPerFrame = 48 * 2 * 100;
     if (num_channels_ <= 0 || samples_per_frame_ <= 0 ||
         frame_duration_ == base::TimeDelta() ||
         samples_per_frame_ * num_channels_ > kMaxSamplesTimesChannelsPerFrame) {
-      cast_initialization_status_ = STATUS_INVALID_AUDIO_CONFIGURATION;
+      operational_status_ = STATUS_INVALID_CONFIGURATION;
     }
   }
 
-  CastInitializationStatus InitializationResult() const {
-    return cast_initialization_status_;
+  OperationalStatus InitializationResult() const {
+    return operational_status_;
   }
 
   int samples_per_frame() const {
     return samples_per_frame_;
   }
 
   base::TimeDelta frame_duration() const { return frame_duration_; }
 
   void EncodeAudio(scoped_ptr<AudioBus> audio_bus,
                    const base::TimeTicks& recorded_time) {
-    DCHECK_EQ(cast_initialization_status_, STATUS_AUDIO_INITIALIZED);
+    DCHECK_EQ(operational_status_, STATUS_INITIALIZED);
     DCHECK(!recorded_time.is_null());
 
     // Determine whether |recorded_time| is consistent with the amount of audio
     // data having been processed in the past.  Resolve the underrun problem by
     // dropping data from the internal buffer and skipping ahead the next
     // frame's RTP timestamp by the estimated number of frames missed.  On the
     // other hand, don't attempt to resolve overruns: A receiver should
     // gracefully deal with an excess of audio data.
     base::TimeDelta buffer_fill_duration =
         buffer_fill_end_ * frame_duration_ / samples_per_frame_;
@@ skipping 63 matching lines @@
                                          int buffer_fill_offset,
                                          int num_samples) = 0;
   virtual bool EncodeFromFilledBuffer(std::string* out) = 0;
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const Codec codec_;
   const int num_channels_;
   const int samples_per_frame_;
   const FrameEncodedCallback callback_;
 
-  // Subclass' ctor is expected to set this to STATUS_AUDIO_INITIALIZED.
-  CastInitializationStatus cast_initialization_status_;
+  // Subclass' ctor is expected to set this to STATUS_INITIALIZED.
+  OperationalStatus operational_status_;
 
   // The duration of one frame of encoded audio samples. Derived from
   // |samples_per_frame_| and the sampling rate.
   const base::TimeDelta frame_duration_;
 
  private:
   // In the case where a call to EncodeAudio() cannot completely fill the
   // buffer, this points to the position at which to populate data in a later
   // call.
   int buffer_fill_end_;
@@ skipping 32 matching lines @@
            const FrameEncodedCallback& callback)
       : ImplBase(cast_environment,
                  CODEC_AUDIO_OPUS,
                  num_channels,
                  sampling_rate,
                  sampling_rate / kDefaultFramesPerSecond, /* 10 ms frames */
                  callback),
         encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]),
         opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())),
         buffer_(new float[num_channels * samples_per_frame_]) {
-    if (ImplBase::cast_initialization_status_ != STATUS_AUDIO_UNINITIALIZED ||
+    if (ImplBase::operational_status_ != STATUS_UNINITIALIZED ||
         sampling_rate % samples_per_frame_ != 0 ||
         !IsValidFrameDuration(frame_duration_)) {
       return;
     }
     if (opus_encoder_init(opus_encoder_,
                           sampling_rate,
                           num_channels,
                           OPUS_APPLICATION_AUDIO) != OPUS_OK) {
-      ImplBase::cast_initialization_status_ =
-          STATUS_INVALID_AUDIO_CONFIGURATION;
+      ImplBase::operational_status_ = STATUS_INVALID_CONFIGURATION;
       return;
     }
-    ImplBase::cast_initialization_status_ = STATUS_AUDIO_INITIALIZED;
+    ImplBase::operational_status_ = STATUS_INITIALIZED;
 
     if (bitrate <= 0) {
       // Note: As of 2013-10-31, the encoder in "auto bitrate" mode would use a
       // variable bitrate up to 102kbps for 2-channel, 48 kHz audio and a 10 ms
       // frame size.  The opus library authors may, of course, adjust this in
       // later versions.
       bitrate = OPUS_AUTO;
     }
     CHECK_EQ(opus_encoder_ctl(opus_encoder_, OPUS_SET_BITRATE(bitrate)),
              OPUS_OK);
@@ skipping 86 matching lines @@
                  kAccessUnitSamples,
                  callback),
         input_buffer_(AudioBus::Create(num_channels, kAccessUnitSamples)),
         input_bus_(AudioBus::CreateWrapper(num_channels)),
         max_access_unit_size_(0),
         output_buffer_(nullptr),
         converter_(nullptr),
         file_(nullptr),
         num_access_units_(0),
         can_resume_(true) {
-    if (ImplBase::cast_initialization_status_ != STATUS_AUDIO_UNINITIALIZED) {
+    if (ImplBase::operational_status_ != STATUS_UNINITIALIZED) {
       return;
     }
     if (!Initialize(sampling_rate, bitrate)) {
-      ImplBase::cast_initialization_status_ =
-          STATUS_INVALID_AUDIO_CONFIGURATION;
+      ImplBase::operational_status_ = STATUS_INVALID_CONFIGURATION;
       return;
     }
-    ImplBase::cast_initialization_status_ = STATUS_AUDIO_INITIALIZED;
+    ImplBase::operational_status_ = STATUS_INITIALIZED;
   }
 
  private:
   ~AppleAacImpl() override { Teardown(); }
 
   // Destroys the existing audio converter and file, if any.
   void Teardown() {
     if (converter_) {
       AudioConverterDispose(converter_);
       converter_ = nullptr;
@@ skipping 335 matching lines @@
             int num_channels,
             int sampling_rate,
             const FrameEncodedCallback& callback)
       : ImplBase(cast_environment,
                  CODEC_AUDIO_PCM16,
                  num_channels,
                  sampling_rate,
                  sampling_rate / kDefaultFramesPerSecond, /* 10 ms frames */
                  callback),
         buffer_(new int16[num_channels * samples_per_frame_]) {
-    if (ImplBase::cast_initialization_status_ != STATUS_AUDIO_UNINITIALIZED)
+    if (ImplBase::operational_status_ != STATUS_UNINITIALIZED)
       return;
-    cast_initialization_status_ = STATUS_AUDIO_INITIALIZED;
+    operational_status_ = STATUS_INITIALIZED;
   }
 
  private:
   ~Pcm16Impl() override {}
 
   void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                  int source_offset,
                                  int buffer_fill_offset,
                                  int num_samples) override {
     audio_bus->ToInterleavedPartial(
@@ skipping 57 matching lines @@
                             frame_encoded_callback);
       break;
     default:
       NOTREACHED() << "Unsupported or unspecified codec for audio encoder";
       break;
   }
 }
 
 AudioEncoder::~AudioEncoder() {}
 
-CastInitializationStatus AudioEncoder::InitializationResult() const {
+OperationalStatus AudioEncoder::InitializationResult() const {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
   if (impl_.get()) {
     return impl_->InitializationResult();
   }
-  return STATUS_UNSUPPORTED_AUDIO_CODEC;
+  return STATUS_UNSUPPORTED_CODEC;
 }
 
 int AudioEncoder::GetSamplesPerFrame() const {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
-  if (InitializationResult() != STATUS_AUDIO_INITIALIZED) {
+  if (InitializationResult() != STATUS_INITIALIZED) {
     NOTREACHED();
     return std::numeric_limits<int>::max();
   }
   return impl_->samples_per_frame();
 }
 
 base::TimeDelta AudioEncoder::GetFrameDuration() const {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
-  if (InitializationResult() != STATUS_AUDIO_INITIALIZED) {
+  if (InitializationResult() != STATUS_INITIALIZED) {
     NOTREACHED();
     return base::TimeDelta();
   }
   return impl_->frame_duration();
 }
 
 void AudioEncoder::InsertAudio(scoped_ptr<AudioBus> audio_bus,
                                const base::TimeTicks& recorded_time) {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
   DCHECK(audio_bus.get());
-  if (InitializationResult() != STATUS_AUDIO_INITIALIZED) {
+  if (InitializationResult() != STATUS_INITIALIZED) {
     NOTREACHED();
     return;
   }
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
                                          impl_,
                                          base::Passed(&audio_bus),
                                          recorded_time));
 }
 
 }  // namespace cast
 }  // namespace media