media: Enable Opus support in Clank <video> and MSE

media/base/android/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/media_codec_bridge.h"
 
 #include <jni.h>
 #include <string>
 
 #include "base/android/build_info.h"
@@ skipping 23 matching lines @@
   kBufferFlagEndOfStream = 4,  // BUFFER_FLAG_END_OF_STREAM
   kConfigureFlagEncode = 1,    // CONFIGURE_FLAG_ENCODE
 };
 
 static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
     case kCodecVorbis:
       return "audio/vorbis";
+    case kCodecOpus:
+      return "audio/opus";
     case kCodecAAC:
       return "audio/mp4a-latm";
     default:
       return std::string();
   }
 }
 
 static const std::string VideoCodecToAndroidMimeType(const VideoCodec& codec) {
   switch (codec) {
     case kCodecH264:
@@ skipping 12 matching lines @@
   if (codec == "avc1")
     return "video/avc";
   if (codec == "mp4a")
     return "audio/mp4a-latm";
   if (codec == "vp8" || codec == "vp8.0")
     return "video/x-vnd.on2.vp8";
   if (codec == "vp9" || codec == "vp9.0")
     return "video/x-vnd.on2.vp9";
   if (codec == "vorbis")
     return "audio/vorbis";
+  if (codec == "opus")
+    return "audio/opus";
   return std::string();
 }
 
 // TODO(qinmin): using a map to help all the conversions in this class.
 static const std::string AndroidMimeTypeToCodecType(const std::string& mime) {
   if (mime == "video/mp4v-es")
     return "mp4v";
   if (mime == "video/avc")
     return "avc1";
   if (mime == "video/x-vnd.on2.vp8")
     return "vp8";
   if (mime == "video/x-vnd.on2.vp9")
     return "vp9";
   if (mime == "audio/mp4a-latm")
     return "mp4a";
   if (mime == "audio/mpeg")
     return "mp3";
   if (mime == "audio/vorbis")
     return "vorbis";
+  if (mime == "audio/opus")
+    return "opus";
   return std::string();
 }
 
 static ScopedJavaLocalRef<jintArray>
 ToJavaIntArray(JNIEnv* env, scoped_ptr<jint[]> native_array, int size) {
   ScopedJavaLocalRef<jintArray> j_array(env, env->NewIntArray(size));
   env->SetIntArrayRegion(j_array.obj(), 0, size, native_array.get());
   return j_array;
 }
 
@@ skipping 403 matching lines @@
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     // Audio codec doesn't care about security level and there is no need for
     // audio encoding yet.
     : MediaCodecBridge(mime, false, MEDIA_CODEC_DECODER) {}
 
 bool AudioCodecBridge::Start(const AudioCodec& codec,
                              int sample_rate,
                              int channel_count,
                              const uint8* extra_data,
                              size_t extra_data_size,
+                             int64 codec_delay_ns,
+                             int64 seek_preroll_ns,
                              bool play_audio,
                              jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
 
   if (!media_codec())
     return false;
 
   std::string codec_string = AudioCodecToAndroidMimeType(codec);
   if (codec_string.empty())
     return false;
 
   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))
+  if (!ConfigureMediaFormat(j_format.obj(), codec, extra_data, extra_data_size,
+                            codec_delay_ns, seek_preroll_ns)) {
     return false;
+  }
 
   if (!Java_MediaCodecBridge_configureAudio(
            env, media_codec(), j_format.obj(), media_crypto, 0, play_audio)) {
     return false;
   }
 
   return StartInternal();
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(jobject j_format,
                                             const AudioCodec& codec,
                                             const uint8* extra_data,
-                                            size_t extra_data_size) {
+                                            size_t extra_data_size,
+                                            int64 codec_delay_ns,
+                                            int64 seek_preroll_ns) {
   if (extra_data_size == 0)
     return true;
 
   JNIEnv* env = AttachCurrentThread();
   switch (codec) {
     case kCodecVorbis: {
       if (extra_data[0] != 2) {
         LOG(ERROR) << "Invalid number of vorbis headers before the codec "
                    << "header: " << extra_data[0];
         return false;
@@ skipping 71 matching lines @@
       ScopedJavaLocalRef<jbyteArray> byte_array =
           base::android::ToJavaByteArray(env, csd, kCsdLength);
       Java_MediaCodecBridge_setCodecSpecificData(
           env, j_format, 0, byte_array.obj());
 
       // TODO(qinmin): pass an extra variable to this function to determine
       // whether we need to call this.
       Java_MediaCodecBridge_setFrameHasADTSHeader(env, j_format);
       break;
     }
+    case kCodecOpus: {
+      if (codec_delay_ns < 0 || seek_preroll_ns < 0) {
+        LOG(ERROR) << "Invalid Opus Header";
+        return false;
+      }
+
+      // csd0 - Opus Header
+      ScopedJavaLocalRef<jbyteArray> csd0 = base::android::ToJavaByteArray(
+          env, extra_data, extra_data_size);

[Tom Finegan, 2015/01/22 02:35:14]

I'd wrap after the =, assuming it fits.. And even if it doesn't fit, that seems
to be the prevailing local style.

/pedantic

[vignesh, 2015/01/22 21:29:50]

Done.

+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0, csd0.obj());
+
+      // csd1 - Codec Delay
+      ScopedJavaLocalRef<jbyteArray> csd1 = base::android::ToJavaByteArray(
+          env, reinterpret_cast<const uint8*>(&codec_delay_ns),
+          sizeof(int64_t));
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1, csd1.obj());
+
+      // csd2 - Seek Preroll
+      ScopedJavaLocalRef<jbyteArray> csd2 = base::android::ToJavaByteArray(
+          env, reinterpret_cast<const uint8*>(&seek_preroll_ns),
+          sizeof(int64_t));
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 2, csd1.obj());
+      break;
+    }
     default:
       LOG(ERROR) << "Invalid header encountered for codec: "
                  << AudioCodecToAndroidMimeType(codec);
       return false;
   }
   return true;
 }
 
 int64 AudioCodecBridge::PlayOutputBuffer(int index, size_t size) {
   DCHECK_LE(0, index);
@@ skipping 139 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(
       env, media_codec(), width, height);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media