Add MediaCodecAudioDecoder implementation

media/base/android/sdk_media_codec_bridge.cc

 // Copyright (c) 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/base/android/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 327 matching lines @@
 bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
   return MediaCodecUtil::IsKnownUnaccelerated(
       AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
 }
 
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     // Audio codec doesn't care about security level and there is no need for
     // audio encoding yet.
     : SdkMediaCodecBridge(mime, false, MEDIA_CODEC_DECODER) {}
 
+bool AudioCodecBridge::ConfigureAndStart(const AudioDecoderConfig& config,
+                                         bool play_audio,
+                                         jobject media_crypto) {
+  const int channel_count =
+      ChannelLayoutToChannelCount(config.channel_layout());
+  const int64_t codec_delay_ns = base::Time::kNanosecondsPerSecond *
+                                 config.codec_delay() /
+                                 config.samples_per_second();
+  const int64_t seek_preroll_ns =
+      1000LL * config.seek_preroll().InMicroseconds();
+
+  return ConfigureAndStart(config.codec(), config.samples_per_second(),
+                           channel_count, config.extra_data().data(),
+                           config.extra_data().size(), codec_delay_ns,
+                           seek_preroll_ns, play_audio, media_crypto);
+}
+
 bool AudioCodecBridge::ConfigureAndStart(const AudioCodec& codec,
                                          int sample_rate,
                                          int channel_count,
                                          const uint8_t* extra_data,
                                          size_t extra_data_size,
                                          int64_t codec_delay_ns,
                                          int64_t seek_preroll_ns,
                                          bool play_audio,
                                          jobject media_crypto) {
-  JNIEnv* env = AttachCurrentThread();
+  DVLOG(2) << __FUNCTION__ << ": "
+           << " codec:" << GetCodecName(codec)
+           << " samples_per_second:" << sample_rate
+           << " channel_count:" << channel_count
+           << " codec_delay_ns:" << codec_delay_ns
+           << " seek_preroll_ns:" << seek_preroll_ns
+           << " extra data size:" << extra_data_size
+           << " play audio:" << play_audio << " media_crypto:" << media_crypto;
 
   if (!media_codec())
     return false;
 
   std::string codec_string = AudioCodecToAndroidMimeType(codec);
   if (codec_string.empty())
     return false;
 
+  JNIEnv* env = AttachCurrentThread();
+
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, codec_string);
   ScopedJavaLocalRef<jobject> j_format(Java_MediaCodecBridge_createAudioFormat(
       env, j_mime.obj(), sample_rate, channel_count));
   DCHECK(!j_format.is_null());
 
   if (!ConfigureMediaFormat(j_format.obj(), codec, extra_data, extra_data_size,
                             codec_delay_ns, seek_preroll_ns)) {
     return false;
   }
@@ skipping 256 matching lines @@
   if (adaptive_playback_supported_for_testing_ == 0)
     return false;
   else if (adaptive_playback_supported_for_testing_ > 0)
     return true;
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
                                                            width, height);
 }
 
 }  // namespace media