[Cast] EncodedAudioFrame+EncodedVideoFrame+reference_time --> EncodedFrame

media/cast/audio_receiver/audio_decoder.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.
 
 #include "media/cast/audio_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/stl_util.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.
@@ skipping 10 matching lines @@
         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::EncodedAudioFrame> encoded_frame,
+  void DecodeFrame(scoped_ptr<transport::EncodedFrame> encoded_frame,
                    const DecodeFrameCallback& callback) {
     DCHECK_EQ(cast_initialization_status_, STATUS_AUDIO_INITIALIZED);
 
-    scoped_ptr<AudioBus> decoded_audio;
-    if (encoded_frame->codec != codec_) {
-      NOTREACHED();
-      cast_environment_->PostTask(CastEnvironment::MAIN,
-                                  FROM_HERE,
-                                  base::Bind(callback,
-                                             base::Passed(&decoded_audio),
-                                             false));
-    }
-
     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();
         is_continuous = false;
       }
     } else {
       seen_first_frame_ = true;
     }
     last_frame_id_ = encoded_frame->frame_id;
 
-    decoded_audio = Decode(
-        reinterpret_cast<uint8*>(string_as_array(&encoded_frame->data)),
+    scoped_ptr<AudioBus> decoded_audio = Decode(
+        encoded_frame->mutable_bytes(),
         static_cast<int>(encoded_frame->data.size()));
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(callback,
                                            base::Passed(&decoded_audio),
                                            is_continuous));
   }
 
  protected:
   friend class base::RefCountedThreadSafe<ImplBase>;
@@ skipping 149 matching lines @@
 
 AudioDecoder::~AudioDecoder() {}
 
 CastInitializationStatus AudioDecoder::InitializationResult() const {
   if (impl_)
     return impl_->InitializationResult();
   return STATUS_UNSUPPORTED_AUDIO_CODEC;
 }
 
 void AudioDecoder::DecodeFrame(
-    scoped_ptr<transport::EncodedAudioFrame> encoded_frame,
+    scoped_ptr<transport::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