Add MediaCodecAudioDecoder implementation

media/renderers/default_renderer_factory.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/renderers/default_renderer_factory.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 10 matching lines @@
 #include "media/filters/ffmpeg_audio_decoder.h"
 #if !defined(DISABLE_FFMPEG_VIDEO_DECODERS)
 #include "media/filters/ffmpeg_video_decoder.h"
 #endif
 #endif
 
 #if !defined(MEDIA_DISABLE_LIBVPX)
 #include "media/filters/vpx_video_decoder.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include "media/filters/android/android_audio_decoder.h"
+#endif
+
 namespace media {
 
 DefaultRendererFactory::DefaultRendererFactory(
     const scoped_refptr<MediaLog>& media_log,
     GpuVideoAcceleratorFactories* gpu_factories,
     const AudioHardwareConfig& audio_hardware_config)
     : media_log_(media_log),
       gpu_factories_(gpu_factories),
       audio_hardware_config_(audio_hardware_config) {}
 
 DefaultRendererFactory::~DefaultRendererFactory() {
 }
 
 scoped_ptr<Renderer> DefaultRendererFactory::CreateRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     AudioRendererSink* audio_renderer_sink,
     VideoRendererSink* video_renderer_sink) {
   DCHECK(audio_renderer_sink);
 
   // Create our audio decoders and renderer.
   ScopedVector<AudioDecoder> audio_decoders;
 
+#if defined(OS_ANDROID)

[DaleCurtis, 2016/02/04 23:15:31]

This should be pushed after FFmpeg/Opus so they are preferred (faster to
initialize too).  Please remove the DVLOGs from the final patch set too.

[Tima Vaisburd, 2016/02/06 03:54:12]

I just forgot to remove debugging code. I'm keeping the call to
AndroidAudioDecoder for now, but it has to be replaced with MojoAudioDecoder
later, as Xiaohan said.

+  DVLOG(1) << __FUNCTION__ << ": adding AndroidAudioDecoder";
+  audio_decoders.push_back(new AndroidAudioDecoder(media_task_runner));

[xhwang, 2016/02/05 21:37:37]

The DefaultRendererFactory will be used in the render process side. So here we
should push a MojoAudioDecoder. And as Dale mentioned, it should be after other
decoders. Note that all other decoders doesn't support encrypted streams, so
they will fail immediately and we'll fall back to the MojoAudioDecoder which
supports encrypted streams.

Since we don't have a MojoAudioDecoder yet, we can make this change later.

That being said, this code can be used to test your current CL (with
--no-sandbox).

[Tima Vaisburd, 2016/02/06 03:54:12]

Acknowledged.

+#endif
+
 #if !defined(MEDIA_DISABLE_FFMPEG)
+  DVLOG(1) << __FUNCTION__ << ": adding FFMpegAudioDecoder";
   audio_decoders.push_back(
       new FFmpegAudioDecoder(media_task_runner, media_log_));
 #endif
 
+  DVLOG(1) << __FUNCTION__ << ": adding OpusAudioDecoder";

[xhwang, 2016/02/05 21:37:37]

nit: It's not very interesting to know what decoders we pushed. I feel it more
interesting to know which decoder is selected.... 

That being said, if you want to list all decoders that has been pushed, we can
print it out in DecoderSelector before we start selecting decoders. The code
will be something like iterate the vector and call GetDisplayName() on each
decoder.

[Tima Vaisburd, 2016/02/06 03:54:12]

As I said before, I just forgot to remove the debugging code. Deleted now.

   audio_decoders.push_back(new OpusAudioDecoder(media_task_runner));
 
   scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
       media_task_runner, audio_renderer_sink, std::move(audio_decoders),
       audio_hardware_config_, media_log_));
 
   // Create our video decoders and renderer.
   ScopedVector<VideoDecoder> video_decoders;
 
   // |gpu_factories_| requires that its entry points be called on its
@@ skipping 16 matching lines @@
   scoped_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
       media_task_runner, worker_task_runner, video_renderer_sink,
       std::move(video_decoders), true, gpu_factories_, media_log_));
 
   // Create renderer.
   return scoped_ptr<Renderer>(new RendererImpl(
       media_task_runner, std::move(audio_renderer), std::move(video_renderer)));
 }
 
 }  // namespace media