Cast: Reshuffle files under media/cast

media/cast/receiver/audio_decoder.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/receiver/audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/sys_byteorder.h"
 #include "media/cast/cast_defines.h"
 #include "third_party/opus/src/include/opus.h"
 
 namespace media {
 namespace cast {
 
 // Base class that handles the common problem of detecting dropped frames, and
 // then invoking the Decode() method implemented by the subclasses to convert
 // the encoded payload data into usable audio data.
 class AudioDecoder::ImplBase
     : public base::RefCountedThreadSafe<AudioDecoder::ImplBase> {
  public:
   ImplBase(const scoped_refptr<CastEnvironment>& cast_environment,
-           transport::Codec codec,
+           Codec codec,
            int num_channels,
            int sampling_rate)
       : cast_environment_(cast_environment),
         codec_(codec),
         num_channels_(num_channels),
         cast_initialization_status_(STATUS_AUDIO_UNINITIALIZED),
         seen_first_frame_(false) {
     if (num_channels_ <= 0 || sampling_rate <= 0 || sampling_rate % 100 != 0)
       cast_initialization_status_ = STATUS_INVALID_AUDIO_CONFIGURATION;
   }
 
   CastInitializationStatus InitializationResult() const {
     return cast_initialization_status_;
   }
 
-  void DecodeFrame(scoped_ptr<transport::EncodedFrame> encoded_frame,
+  void DecodeFrame(scoped_ptr<EncodedFrame> encoded_frame,
                    const DecodeFrameCallback& callback) {
     DCHECK_EQ(cast_initialization_status_, STATUS_AUDIO_INITIALIZED);
 
     COMPILE_ASSERT(sizeof(encoded_frame->frame_id) == sizeof(last_frame_id_),
                    size_of_frame_id_types_do_not_match);
     bool is_continuous = true;
     if (seen_first_frame_) {
       const uint32 frames_ahead = encoded_frame->frame_id - last_frame_id_;
       if (frames_ahead > 1) {
         RecoverBecauseFramesWereDropped();
@@ skipping 17 matching lines @@
  protected:
   friend class base::RefCountedThreadSafe<ImplBase>;
   virtual ~ImplBase() {}
 
   virtual void RecoverBecauseFramesWereDropped() {}
 
   // Note: Implementation of Decode() is allowed to mutate |data|.
   virtual scoped_ptr<AudioBus> Decode(uint8* data, int len) = 0;
 
   const scoped_refptr<CastEnvironment> cast_environment_;
-  const transport::Codec codec_;
+  const Codec codec_;
   const int num_channels_;
 
   // Subclass' ctor is expected to set this to STATUS_AUDIO_INITIALIZED.
   CastInitializationStatus cast_initialization_status_;
 
  private:
   bool seen_first_frame_;
   uint32 last_frame_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImplBase);
 };
 
 class AudioDecoder::OpusImpl : public AudioDecoder::ImplBase {
  public:
   OpusImpl(const scoped_refptr<CastEnvironment>& cast_environment,
            int num_channels,
            int sampling_rate)
       : ImplBase(cast_environment,
-                 transport::CODEC_AUDIO_OPUS,
+                 CODEC_AUDIO_OPUS,
                  num_channels,
                  sampling_rate),
         decoder_memory_(new uint8[opus_decoder_get_size(num_channels)]),
         opus_decoder_(reinterpret_cast<OpusDecoder*>(decoder_memory_.get())),
         max_samples_per_frame_(
             kOpusMaxFrameDurationMillis * sampling_rate / 1000),
         buffer_(new float[max_samples_per_frame_ * num_channels]) {
     if (ImplBase::cast_initialization_status_ != STATUS_AUDIO_UNINITIALIZED)
       return;
     if (opus_decoder_init(opus_decoder_, sampling_rate, num_channels) !=
@@ skipping 49 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(OpusImpl);
 };
 
 class AudioDecoder::Pcm16Impl : public AudioDecoder::ImplBase {
  public:
   Pcm16Impl(const scoped_refptr<CastEnvironment>& cast_environment,
             int num_channels,
             int sampling_rate)
       : ImplBase(cast_environment,
-                 transport::CODEC_AUDIO_PCM16,
+                 CODEC_AUDIO_PCM16,
                  num_channels,
                  sampling_rate) {
     if (ImplBase::cast_initialization_status_ != STATUS_AUDIO_UNINITIALIZED)
       return;
     ImplBase::cast_initialization_status_ = STATUS_AUDIO_INITIALIZED;
   }
 
  private:
   virtual ~Pcm16Impl() {}
 
@@ skipping 15 matching lines @@
     return audio_bus.Pass();
   }
 
   DISALLOW_COPY_AND_ASSIGN(Pcm16Impl);
 };
 
 AudioDecoder::AudioDecoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     int channels,
     int sampling_rate,
-    transport::Codec codec)
+    Codec codec)
     : cast_environment_(cast_environment) {
   switch (codec) {
-    case transport::CODEC_AUDIO_OPUS:
+    case CODEC_AUDIO_OPUS:
       impl_ = new OpusImpl(cast_environment, channels, sampling_rate);
       break;
-    case transport::CODEC_AUDIO_PCM16:
+    case CODEC_AUDIO_PCM16:
       impl_ = new Pcm16Impl(cast_environment, channels, sampling_rate);
       break;
     default:
       NOTREACHED() << "Unknown or unspecified codec.";
       break;
   }
 }
 
 AudioDecoder::~AudioDecoder() {}
 
 CastInitializationStatus AudioDecoder::InitializationResult() const {
   if (impl_)
     return impl_->InitializationResult();
   return STATUS_UNSUPPORTED_AUDIO_CODEC;
 }
 
 void AudioDecoder::DecodeFrame(
-    scoped_ptr<transport::EncodedFrame> encoded_frame,
+    scoped_ptr<EncodedFrame> encoded_frame,
     const DecodeFrameCallback& callback) {
   DCHECK(encoded_frame.get());
   DCHECK(!callback.is_null());
   if (!impl_ || impl_->InitializationResult() != STATUS_AUDIO_INITIALIZED) {
     callback.Run(make_scoped_ptr<AudioBus>(NULL), false);
     return;
   }
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioDecoder::ImplBase::DecodeFrame,
                                          impl_,
                                          base::Passed(&encoded_frame),
                                          callback));
 }
 
 }  // namespace cast
 }  // namespace media