Rename browser side MediaCodec-based decoders

media/base/android/audio_media_codec_decoder.cc

 // Copyright 2015 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/base/android/media_codec_audio_decoder.h"
+#include "media/base/android/audio_media_codec_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/media_statistics.h"
 #include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/demuxer_stream.h"
 
 namespace {
 
 // Use 16bit PCM for audio output. Keep this value in sync with the output
 // format we passed to AudioTrack in MediaCodecBridge.
 const int kBytesPerAudioOutputSample = 2;
 }
 
 namespace media {
 
-MediaCodecAudioDecoder::MediaCodecAudioDecoder(
+AudioMediaCodecDecoder::AudioMediaCodecDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     FrameStatistics* frame_statistics,
     const base::Closure& request_data_cb,
     const base::Closure& starvation_cb,
     const base::Closure& decoder_drained_cb,
     const base::Closure& stop_done_cb,
     const base::Closure& waiting_for_decryption_key_cb,
     const base::Closure& error_cb,
     const SetTimeCallback& update_current_time_cb)
     : MediaCodecDecoder("AudioDecoder",
                         media_task_runner,
                         frame_statistics,
                         request_data_cb,
                         starvation_cb,
                         decoder_drained_cb,
                         stop_done_cb,
                         waiting_for_decryption_key_cb,
                         error_cb),
       volume_(-1.0),
       bytes_per_frame_(0),
       output_sampling_rate_(0),
       frame_count_(0),
-      update_current_time_cb_(update_current_time_cb) {
-}
+      update_current_time_cb_(update_current_time_cb) {}
 
-MediaCodecAudioDecoder::~MediaCodecAudioDecoder() {
+AudioMediaCodecDecoder::~AudioMediaCodecDecoder() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "AudioDecoder::~AudioDecoder()";
   ReleaseDecoderResources();
 }
 
-const char* MediaCodecAudioDecoder::class_name() const {
+const char* AudioMediaCodecDecoder::class_name() const {
   return "AudioDecoder";
 }
 
-bool MediaCodecAudioDecoder::HasStream() const {
+bool AudioMediaCodecDecoder::HasStream() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return configs_.audio_codec != kUnknownAudioCodec;
 }
 
-void MediaCodecAudioDecoder::SetDemuxerConfigs(const DemuxerConfigs& configs) {
+void AudioMediaCodecDecoder::SetDemuxerConfigs(const DemuxerConfigs& configs) {
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << configs;
 
   configs_ = configs;
   if (!media_codec_bridge_)
     output_sampling_rate_ = configs.audio_sampling_rate;
 }
 
-bool MediaCodecAudioDecoder::IsContentEncrypted() const {
+bool AudioMediaCodecDecoder::IsContentEncrypted() const {
   // Make sure SetDemuxerConfigs() as been called.
   DCHECK(configs_.audio_codec != kUnknownAudioCodec);
   return configs_.is_audio_encrypted;
 }
 
-void MediaCodecAudioDecoder::ReleaseDecoderResources() {
+void AudioMediaCodecDecoder::ReleaseDecoderResources() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DoEmergencyStop();
 
   ReleaseMediaCodec();
 }
 
-void MediaCodecAudioDecoder::Flush() {
+void AudioMediaCodecDecoder::Flush() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   MediaCodecDecoder::Flush();
   frame_count_ = 0;
 }
 
-void MediaCodecAudioDecoder::SetVolume(double volume) {
+void AudioMediaCodecDecoder::SetVolume(double volume) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << volume;
 
   volume_ = volume;
   SetVolumeInternal();
 }
 
-void MediaCodecAudioDecoder::SetBaseTimestamp(base::TimeDelta base_timestamp) {
+void AudioMediaCodecDecoder::SetBaseTimestamp(base::TimeDelta base_timestamp) {
   // Called from Media thread and Decoder thread. When called from Media thread
   // Decoder thread should not be running.
 
   DVLOG(1) << __FUNCTION__ << " " << base_timestamp;
 
   base_timestamp_ = base_timestamp;
   if (audio_timestamp_helper_)
     audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
 }
 
-bool MediaCodecAudioDecoder::IsCodecReconfigureNeeded(
+bool AudioMediaCodecDecoder::IsCodecReconfigureNeeded(
     const DemuxerConfigs& next) const {
   if (always_reconfigure_for_tests_)
     return true;
 
   return configs_.audio_codec != next.audio_codec ||
          configs_.audio_channels != next.audio_channels ||
          configs_.audio_sampling_rate != next.audio_sampling_rate ||
          configs_.is_audio_encrypted != next.is_audio_encrypted ||
          configs_.audio_extra_data.size() != next.audio_extra_data.size() ||
          !std::equal(configs_.audio_extra_data.begin(),
                      configs_.audio_extra_data.end(),
                      next.audio_extra_data.begin());
 }
 
-MediaCodecDecoder::ConfigStatus MediaCodecAudioDecoder::ConfigureInternal(
+MediaCodecDecoder::ConfigStatus AudioMediaCodecDecoder::ConfigureInternal(
     jobject media_crypto) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (configs_.audio_codec == kUnknownAudioCodec) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << " configuration parameters are required";
     return kConfigFailure;
   }
@@ skipping 22 matching lines @@
   bytes_per_frame_ = kBytesPerAudioOutputSample * configs_.audio_channels;
   frame_count_ = 0;
   ResetTimestampHelper();
 
   if (!codec_created_for_tests_cb_.is_null())
     media_task_runner_->PostTask(FROM_HERE, codec_created_for_tests_cb_);
 
   return kConfigOk;
 }
 
-void MediaCodecAudioDecoder::OnOutputFormatChanged() {
+void AudioMediaCodecDecoder::OnOutputFormatChanged() {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DCHECK(media_codec_bridge_);
 
   int old_sampling_rate = output_sampling_rate_;
   output_sampling_rate_ = media_codec_bridge_->GetOutputSamplingRate();
   if (output_sampling_rate_ != old_sampling_rate)
     ResetTimestampHelper();
 }
 
-void MediaCodecAudioDecoder::Render(int buffer_index,
+void AudioMediaCodecDecoder::Render(int buffer_index,
                                     size_t offset,
                                     size_t size,
                                     RenderMode render_mode,
                                     base::TimeDelta pts,
                                     bool eos_encountered) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts << " "
            << AsString(render_mode);
 
@@ skipping 61 matching lines @@
           FROM_HERE, base::Bind(update_current_time_cb_, now_playing,
                                 last_buffered, false));
     }
   }
 
   media_codec_bridge_->ReleaseOutputBuffer(buffer_index, false);
 
   CheckLastFrame(eos_encountered, false);  // no delayed tasks
 }
 
-void MediaCodecAudioDecoder::SetVolumeInternal() {
+void AudioMediaCodecDecoder::SetVolumeInternal() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   if (media_codec_bridge_) {
     static_cast<AudioCodecBridge*>(media_codec_bridge_.get())
         ->SetVolume(volume_);
   }
 }
 
-void MediaCodecAudioDecoder::ResetTimestampHelper() {
+void AudioMediaCodecDecoder::ResetTimestampHelper() {
   // Media thread or Decoder thread
   // When this method is called on Media thread, decoder thread
   // should not be running.
 
   if (audio_timestamp_helper_)
     base_timestamp_ = audio_timestamp_helper_->GetTimestamp();
 
   audio_timestamp_helper_.reset(
       new AudioTimestampHelper(configs_.audio_sampling_rate));
 
   audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
 }
 
 }  // namespace media