MediaSourcePlayer implements IsTypeSupported().

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"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/safe_numerics.h"
 #include "base/strings/stringprintf.h"
 #include "jni/MediaCodecBridge_jni.h"
 #include "media/base/bit_reader.h"
 #include "media/base/decrypt_config.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
 namespace media {
 
 enum { kBufferFlagEndOfStream = 4 };
 
-static const char* AudioCodecToMimeType(const AudioCodec codec) {
+static const std::string AudioCodecToMimeType(const AudioCodec codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
     case kCodecVorbis:
       return "audio/vorbis";
     case kCodecAAC:
       return "audio/mp4a-latm";
     default:
-      return NULL;
+      return std::string();
   }
 }
 
-static const char* VideoCodecToMimeType(const VideoCodec codec) {
+static const std::string VideoCodecToMimeType(const VideoCodec codec) {
   switch (codec) {
     case kCodecH264:
       return "video/avc";
     case kCodecVP8:
       return "video/x-vnd.on2.vp8";
     default:
-      return NULL;
+      return std::string();
   }
 }
 
+static const std::string CodecTypeToMimeType(const std::string& codec) {

[ddorwin, 2013/08/30 16:59:15]

What do you think of using the same type for this and the two methods above?

+  // TODO(xhwang): Shall we handle more detailed strings like "mp4a.40.2"?
+  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 == "vorbis")
+    return "audio/vorbis";
+  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;
 }
 
 // static
 const base::TimeDelta MediaCodecBridge::kTimeOutInfinity =
     base::TimeDelta::FromMicroseconds(-1);
 
 // static
 const base::TimeDelta MediaCodecBridge::kTimeOutNoWait =
     base::TimeDelta::FromMicroseconds(0);
 
 // static
 bool MediaCodecBridge::IsAvailable() {
   // MediaCodec is only available on JB and greater.
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 16;
 }
 
-MediaCodecBridge::MediaCodecBridge(const char* mime) {
+// static
+bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) {
+  JNIEnv* env = AttachCurrentThread();
+  std::string mime = CodecTypeToMimeType(codec);
+  if (mime.empty())
+    return false;
+  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
+  return !Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure).is_null();
+}
+
+// TODO(xhwang): Support creating secure MediaCodecBridge.
+MediaCodecBridge::MediaCodecBridge(const std::string& mime) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
-  DCHECK(mime);
 
-  ScopedJavaLocalRef<jstring> j_type = ConvertUTF8ToJavaString(env, mime);
-  j_media_codec_.Reset(Java_MediaCodecBridge_create(
-      env, j_type.obj()));
+  DCHECK(!mime.empty());
+  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
+  j_media_codec_.Reset(Java_MediaCodecBridge_create(env, j_mime.obj(), false));
 }
 
 MediaCodecBridge::~MediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   if (j_media_codec_.obj())
     Java_MediaCodecBridge_release(env, j_media_codec_.obj());
 }
 
 void MediaCodecBridge::StartInternal() {
@@ skipping 127 matching lines @@
   int size_to_copy = (buffer_capacity < size) ? buffer_capacity : size;
   // TODO(qinmin): Handling the case that not all the data can be copied.
   DCHECK(size_to_copy == size) <<
       "Failed to fill all the data into the input buffer. Size to fill: "
       << size << ". Size filled: " << size_to_copy;
   if (size_to_copy > 0)
     memcpy(direct_buffer, data, size_to_copy);
   return size_to_copy;
 }
 
-AudioCodecBridge::AudioCodecBridge(const char* mime)
+AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     : MediaCodecBridge(mime) {
 }
 
 bool AudioCodecBridge::Start(
     const AudioCodec codec, int sample_rate, int channel_count,
     const uint8* extra_data, size_t extra_data_size, bool play_audio,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
-  DCHECK(AudioCodecToMimeType(codec));
 
   if (!media_codec())
     return false;
 
+  std::string codec_string = AudioCodecToMimeType(codec);
+  if (codec_string.empty())
+    return false;
+
   ScopedJavaLocalRef<jstring> j_mime =
-      ConvertUTF8ToJavaString(env, AudioCodecToMimeType(codec));
+      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))
     return false;
 
   if (!Java_MediaCodecBridge_configureAudio(
       env, media_codec(), j_format.obj(), media_crypto, 0, play_audio)) {
     return false;
   }
+
   StartInternal();
   return true;
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(
     jobject j_format, const AudioCodec codec, const uint8* extra_data,
     size_t extra_data_size) {
   if (extra_data_size == 0)
     return true;
 
@@ skipping 107 matching lines @@
       base::android::ToJavaByteArray(env, buffer, numBytes);
   Java_MediaCodecBridge_playOutputBuffer(
       env, media_codec(), byte_array.obj());
 }
 
 void AudioCodecBridge::SetVolume(double volume) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
-VideoCodecBridge::VideoCodecBridge(const char* mime)
+VideoCodecBridge::VideoCodecBridge(const std::string& mime)
     : MediaCodecBridge(mime) {
 }
 
 bool VideoCodecBridge::Start(
     const VideoCodec codec, const gfx::Size& size, jobject surface,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
-  DCHECK(VideoCodecToMimeType(codec));
 
   if (!media_codec())
     return false;
 
+  std::string codec_string = VideoCodecToMimeType(codec);
+  if (codec_string.empty())
+    return false;
+
   ScopedJavaLocalRef<jstring> j_mime =
-      ConvertUTF8ToJavaString(env, VideoCodecToMimeType(codec));
+      ConvertUTF8ToJavaString(env, codec_string);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoFormat(
           env, j_mime.obj(), size.width(), size.height()));
   DCHECK(!j_format.is_null());
   if (!Java_MediaCodecBridge_configureVideo(
       env, media_codec(), j_format.obj(), surface, media_crypto, 0)) {
     return false;
   }
   StartInternal();
   return true;
 }
 
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec codec) {
-  const char* mime = AudioCodecToMimeType(codec);
-  return mime ? new AudioCodecBridge(mime) : NULL;
+  const std::string mime = AudioCodecToMimeType(codec);
+  return mime.empty() ? NULL : new AudioCodecBridge(mime);
 }
 
 VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec) {
-  const char* mime = VideoCodecToMimeType(codec);
-  return mime ? new VideoCodecBridge(mime) : NULL;
+  const std::string mime = VideoCodecToMimeType(codec);
+  return mime.empty() ? NULL : new VideoCodecBridge(mime);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media