Refactor MediaCodecBridge to add support for NDK APIs

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/media_codec_bridge.h"
+#include "media/base/android/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
 
 #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/numerics/safe_conversions.h"
 #include "base/strings/string_util.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::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaIntArrayToIntVector;
 using base::android::ScopedJavaLocalRef;
 
-#define RETURN_ON_ERROR(condition)                          \
-  do {                                                           \
-    if (!(condition)) {                                          \
+#define RETURN_ON_ERROR(condition)                             \
+  do {                                                         \
+    if (!(condition)) {                                        \
       LOG(ERROR) << "Unable to parse AAC header: " #condition; \
-      return false;                                              \
-    }                                                            \
+      return false;                                            \
+    }                                                          \
   } while (0)
 
 namespace media {
 
 enum {
   kBufferFlagSyncFrame = 1,    // BUFFER_FLAG_SYNC_FRAME
   kBufferFlagEndOfStream = 4,  // BUFFER_FLAG_END_OF_STREAM
   kConfigureFlagEncode = 1,    // CONFIGURE_FLAG_ENCODE
 };
 
+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 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";
@@ skipping 10 matching lines @@
       return "video/hevc";
     case kCodecVP8:
       return "video/x-vnd.on2.vp8";
     case kCodecVP9:
       return "video/x-vnd.on2.vp9";
     default:
       return std::string();
   }
 }
 
-static const std::string CodecTypeToAndroidMimeType(const std::string& codec) {
-  // TODO(xhwang): Shall we handle more detailed strings like "mp4a.40.2"?
-  if (codec == "avc1")
-    return "video/avc";
-  if (codec == "hvc1")
-    return "video/hevc";
-  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/hevc")
-    return "hvc1";
-  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;
-}
-
-// static
-bool MediaCodecBridge::IsAvailable() {
-  // MediaCodec is only available on JB and greater.
-  if (base::android::BuildInfo::GetInstance()->sdk_int() < 16)
-    return false;
-  // Blacklist some devices on Jellybean as for MediaCodec support is buggy.
-  // http://crbug.com/365494.
-  if (base::android::BuildInfo::GetInstance()->sdk_int() == 16) {
-    std::string model(base::android::BuildInfo::GetInstance()->model());
-    return model != "GT-I9100" && model != "GT-I9300" && model != "GT-N7000";
-  }
-  return true;
-}
-
-// static
-bool MediaCodecBridge::SupportsSetParameters() {
-  // MediaCodec.setParameters() is only available starting with K.
-  return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
-}
-
-// static
-bool MediaCodecBridge::SupportsGetName() {
-  // MediaCodec.getName() is only available on JB MR2 and greater.
-  return base::android::BuildInfo::GetInstance()->sdk_int() >= 18;
-}
-
-// static
-std::vector<MediaCodecBridge::CodecsInfo> MediaCodecBridge::GetCodecsInfo() {
-  std::vector<CodecsInfo> codecs_info;
-  if (!IsAvailable())
-    return codecs_info;
-
-  JNIEnv* env = AttachCurrentThread();
-  std::string mime_type;
-  ScopedJavaLocalRef<jobjectArray> j_codec_info_array =
-      Java_MediaCodecBridge_getCodecsInfo(env);
-  jsize len = env->GetArrayLength(j_codec_info_array.obj());
-  for (jsize i = 0; i < len; ++i) {
-    ScopedJavaLocalRef<jobject> j_info(
-        env, env->GetObjectArrayElement(j_codec_info_array.obj(), i));
-    ScopedJavaLocalRef<jstring> j_codec_type =
-        Java_CodecInfo_codecType(env, j_info.obj());
-    ConvertJavaStringToUTF8(env, j_codec_type.obj(), &mime_type);
-    ScopedJavaLocalRef<jstring> j_codec_name =
-        Java_CodecInfo_codecName(env, j_info.obj());
-    CodecsInfo info;
-    info.codecs = AndroidMimeTypeToCodecType(mime_type);
-    ConvertJavaStringToUTF8(env, j_codec_name.obj(), &info.name);
-    info.direction = static_cast<MediaCodecDirection>(
-        Java_CodecInfo_direction(env, j_info.obj()));
-    codecs_info.push_back(info);
-  }
-  return codecs_info;
-}
-
-// static
-std::string MediaCodecBridge::GetDefaultCodecName(
-    const std::string& mime_type,
-    MediaCodecDirection direction) {
-  if (!IsAvailable())
-    return std::string();
-
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
-  ScopedJavaLocalRef<jstring> j_codec_name =
-      Java_MediaCodecBridge_getDefaultCodecName(env, j_mime.obj(), direction);
-  return ConvertJavaStringToUTF8(env, j_codec_name.obj());
-}
-
-// static
-std::set<int> MediaCodecBridge::GetEncoderColorFormats(
-    const std::string& mime_type) {
-  std::set<int> color_formats;
-  if (!IsAvailable())
-    return color_formats;
-
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
-  ScopedJavaLocalRef<jintArray> j_color_format_array =
-      Java_MediaCodecBridge_getEncoderColorFormatsForMime(env, j_mime.obj());
-
-  if (j_color_format_array.obj()) {
-    std::vector<int> formats;
-    JavaIntArrayToIntVector(env, j_color_format_array.obj(), &formats);
-    color_formats = std::set<int>(formats.begin(), formats.end());
-  }
-
-  return color_formats;
-}
-
-// static
-bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) {
-  if (!IsAvailable())
-    return false;
-
-  JNIEnv* env = AttachCurrentThread();
-  std::string mime = CodecTypeToAndroidMimeType(codec);
-  if (mime.empty())
-    return false;
-  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
-  ScopedJavaLocalRef<jobject> j_media_codec_bridge =
-      Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, false);
-  if (!j_media_codec_bridge.is_null()) {
-    Java_MediaCodecBridge_release(env, j_media_codec_bridge.obj());
-    return true;
-  }
-  return false;
-}
-
-// static
-bool MediaCodecBridge::IsKnownUnaccelerated(const std::string& mime_type,
-                                            MediaCodecDirection direction) {
-  if (!IsAvailable())
-    return true;
-
-  std::string codec_name;
-  if (SupportsGetName()) {
-    codec_name = GetDefaultCodecName(mime_type, direction);
-  } else {
-    std::string codec_type = AndroidMimeTypeToCodecType(mime_type);
-    std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info =
-        MediaCodecBridge::GetCodecsInfo();
-    for (size_t i = 0; i < codecs_info.size(); ++i) {
-      if (codecs_info[i].codecs == codec_type &&
-          codecs_info[i].direction == direction) {
-        codec_name = codecs_info[i].name;
-        break;
-      }
-    }
-  }
-  DVLOG(1) << __PRETTY_FUNCTION__ << "Default codec for " << mime_type <<
-      " : " << codec_name;
-  // It would be nice if MediaCodecInfo externalized some notion of
-  // HW-acceleration but it doesn't. Android Media guidance is that the
-  // "OMX.google" prefix is always used for SW decoders, so that's what we
-  // use. "OMX.SEC.*" codec is Samsung software implementation - report it
-  // as unaccelerated as well. Also temporary blacklist Exynos and MediaTek
-  // devices while HW decoder video freezes and distortions are
-  // investigated - http://crbug.com/446974.
-  if (codec_name.length() > 0) {
-    return (base::StartsWith(codec_name, "OMX.google.",
-                             base::CompareCase::SENSITIVE) ||
-            base::StartsWith(codec_name, "OMX.SEC.",
-                             base::CompareCase::SENSITIVE) ||
-            base::StartsWith(codec_name, "OMX.MTK.",
-                             base::CompareCase::SENSITIVE) ||
-            base::StartsWith(codec_name, "OMX.Exynos.",
-                             base::CompareCase::SENSITIVE));
-  }
-  return true;
-}
-
-MediaCodecBridge::MediaCodecBridge(const std::string& mime,
-                                   bool is_secure,
-                                   MediaCodecDirection direction) {
+SdkMediaCodecBridge::SdkMediaCodecBridge(const std::string& mime,
+                                         bool is_secure,
+                                         MediaCodecDirection direction) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   DCHECK(!mime.empty());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   j_media_codec_.Reset(
       Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, direction));
 }
 
-MediaCodecBridge::~MediaCodecBridge() {
+SdkMediaCodecBridge::~SdkMediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   if (j_media_codec_.obj())
     Java_MediaCodecBridge_release(env, j_media_codec_.obj());
 }
 
-bool MediaCodecBridge::StartInternal() {
-  JNIEnv* env = AttachCurrentThread();
-  return Java_MediaCodecBridge_start(env, j_media_codec_.obj());
-}
-
-MediaCodecStatus MediaCodecBridge::Reset() {
+MediaCodecStatus SdkMediaCodecBridge::Reset() {
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_flush(env, j_media_codec_.obj()));
 }
 
-void MediaCodecBridge::Stop() {
+bool SdkMediaCodecBridge::Start() {
+  JNIEnv* env = AttachCurrentThread();
+  return Java_MediaCodecBridge_start(env, j_media_codec_.obj());
+}
+
+void SdkMediaCodecBridge::Stop() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_stop(env, j_media_codec_.obj());
 }
 
-void MediaCodecBridge::GetOutputFormat(int* width, int* height) {
+void SdkMediaCodecBridge::GetOutputFormat(int* width, int* height) {
   JNIEnv* env = AttachCurrentThread();
 
   *width = Java_MediaCodecBridge_getOutputWidth(env, j_media_codec_.obj());
   *height = Java_MediaCodecBridge_getOutputHeight(env, j_media_codec_.obj());
 }
 
-int MediaCodecBridge::GetOutputSamplingRate() {
+int SdkMediaCodecBridge::GetOutputSamplingRate() {
   JNIEnv* env = AttachCurrentThread();
 
   return Java_MediaCodecBridge_getOutputSamplingRate(env, j_media_codec_.obj());
 }
 
-MediaCodecStatus MediaCodecBridge::QueueInputBuffer(
+MediaCodecStatus SdkMediaCodecBridge::QueueInputBuffer(
     int index,
-    const uint8* data,
+    const uint8_t* data,
     size_t data_size,
     const base::TimeDelta& presentation_time) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
   if (data_size >
-      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max()))
+      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
+  }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
   JNIEnv* env = AttachCurrentThread();
-  return static_cast<MediaCodecStatus>(
-      Java_MediaCodecBridge_queueInputBuffer(env,
-                                             j_media_codec_.obj(),
-                                             index,
-                                             0,
-                                             data_size,
-                                             presentation_time.InMicroseconds(),
-                                             0));
-}
-
-MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
-    int index,
-    const uint8_t* data,
-    size_t data_size,
-    const std::string& key_id,
-    const std::string& iv,
-    const std::vector<SubsampleEntry>& subsamples,
-    const base::TimeDelta& presentation_time) {
-  return QueueSecureInputBuffer(
-      index, data, data_size, reinterpret_cast<const uint8_t*>(key_id.data()),
-      key_id.size(), reinterpret_cast<const uint8_t*>(iv.data()), iv.size(),
-      subsamples.empty() ? nullptr : &subsamples[0], subsamples.size(),
-      presentation_time);
+  return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer(
+      env, j_media_codec_.obj(), index, 0, data_size,
+      presentation_time.InMicroseconds(), 0));
 }
 
 // TODO(timav): Combine this and above methods together keeping only the first
 // interface after we switch to Spitzer pipeline.
-MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
+MediaCodecStatus SdkMediaCodecBridge::QueueSecureInputBuffer(
     int index,
-    const uint8* data,
+    const uint8_t* data,
     size_t data_size,
-    const uint8* key_id,
-    int key_id_size,
-    const uint8* iv,
-    int iv_size,
+    const std::vector<char>& key_id,
+    const std::vector<char>& iv,
     const SubsampleEntry* subsamples,
     int subsamples_size,
     const base::TimeDelta& presentation_time) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
   if (data_size >
-      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max()))
+      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
+  }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> j_key_id =
-      base::android::ToJavaByteArray(env, key_id, key_id_size);
-  ScopedJavaLocalRef<jbyteArray> j_iv =
-      base::android::ToJavaByteArray(env, iv, iv_size);
+  ScopedJavaLocalRef<jbyteArray> j_key_id = base::android::ToJavaByteArray(
+      env, reinterpret_cast<const uint8_t*>(key_id.data()), key_id.size());
+  ScopedJavaLocalRef<jbyteArray> j_iv = base::android::ToJavaByteArray(
+      env, reinterpret_cast<const uint8_t*>(iv.data()), iv.size());
 
   // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array|
   // to indicate that all data is encrypted. But it doesn't specify what
   // |cypher_array| and |subsamples_size| should be in that case. Passing
   // one subsample here just to be on the safe side.
   int new_subsamples_size = subsamples_size == 0 ? 1 : subsamples_size;
 
   scoped_ptr<jint[]> native_clear_array(new jint[new_subsamples_size]);
   scoped_ptr<jint[]> native_cypher_array(new jint[new_subsamples_size]);
 
   if (subsamples_size == 0) {
     DCHECK(!subsamples);
     native_clear_array[0] = 0;
     native_cypher_array[0] = data_size;
   } else {
     DCHECK_GT(subsamples_size, 0);
     DCHECK(subsamples);
     for (int i = 0; i < subsamples_size; ++i) {
-      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16>::max());
+      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16_t>::max());
       if (subsamples[i].cypher_bytes >
-          static_cast<uint32>(std::numeric_limits<jint>::max())) {
+          static_cast<uint32_t>(std::numeric_limits<jint>::max())) {
         return MEDIA_CODEC_ERROR;
       }
 
       native_clear_array[i] = subsamples[i].clear_bytes;
       native_cypher_array[i] = subsamples[i].cypher_bytes;
     }
   }
 
   ScopedJavaLocalRef<jintArray> clear_array =
       ToJavaIntArray(env, native_clear_array.Pass(), new_subsamples_size);
   ScopedJavaLocalRef<jintArray> cypher_array =
       ToJavaIntArray(env, native_cypher_array.Pass(), new_subsamples_size);
 
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueSecureInputBuffer(
-          env,
-          j_media_codec_.obj(),
-          index,
-          0,
-          j_iv.obj(),
-          j_key_id.obj(),
-          clear_array.obj(),
-          cypher_array.obj(),
-          new_subsamples_size,
+          env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
+          clear_array.obj(), cypher_array.obj(), new_subsamples_size,
           presentation_time.InMicroseconds()));
 }
 
-void MediaCodecBridge::QueueEOS(int input_buffer_index) {
+void SdkMediaCodecBridge::QueueEOS(int input_buffer_index) {
   DVLOG(3) << __PRETTY_FUNCTION__ << ": " << input_buffer_index;
   JNIEnv* env = AttachCurrentThread();
-  Java_MediaCodecBridge_queueInputBuffer(env,
-                                         j_media_codec_.obj(),
-                                         input_buffer_index,
-                                         0,
-                                         0,
-                                         0,
+  Java_MediaCodecBridge_queueInputBuffer(env, j_media_codec_.obj(),
+                                         input_buffer_index, 0, 0, 0,
                                          kBufferFlagEndOfStream);
 }
 
-MediaCodecStatus MediaCodecBridge::DequeueInputBuffer(
+MediaCodecStatus SdkMediaCodecBridge::DequeueInputBuffer(
     const base::TimeDelta& timeout,
     int* index) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer(
       env, j_media_codec_.obj(), timeout.InMicroseconds());
   *index = Java_DequeueInputResult_index(env, result.obj());
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_DequeueInputResult_status(env, result.obj()));
   DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
            << ", index: " << *index;
   return status;
 }
 
-MediaCodecStatus MediaCodecBridge::DequeueOutputBuffer(
+MediaCodecStatus SdkMediaCodecBridge::DequeueOutputBuffer(
     const base::TimeDelta& timeout,
     int* index,
     size_t* offset,
     size_t* size,
     base::TimeDelta* presentation_time,
     bool* end_of_stream,
     bool* key_frame) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
-      Java_MediaCodecBridge_dequeueOutputBuffer(
-          env, j_media_codec_.obj(), timeout.InMicroseconds());
+      Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_.obj(),
+                                                timeout.InMicroseconds());
   *index = Java_DequeueOutputResult_index(env, result.obj());
   *offset = base::checked_cast<size_t>(
       Java_DequeueOutputResult_offset(env, result.obj()));
   *size = base::checked_cast<size_t>(
       Java_DequeueOutputResult_numBytes(env, result.obj()));
   if (presentation_time) {
     *presentation_time = base::TimeDelta::FromMicroseconds(
         Java_DequeueOutputResult_presentationTimeMicroseconds(env,
                                                               result.obj()));
   }
   int flags = Java_DequeueOutputResult_flags(env, result.obj());
   if (end_of_stream)
     *end_of_stream = flags & kBufferFlagEndOfStream;
   if (key_frame)
     *key_frame = flags & kBufferFlagSyncFrame;
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
       Java_DequeueOutputResult_status(env, result.obj()));
   DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
            << ", index: " << *index << ", offset: " << *offset
            << ", size: " << *size << ", flags: " << flags;
   return status;
 }
 
-void MediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
+void SdkMediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
   DVLOG(3) << __PRETTY_FUNCTION__ << ": " << index;
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
-  Java_MediaCodecBridge_releaseOutputBuffer(
-      env, j_media_codec_.obj(), index, render);
+  Java_MediaCodecBridge_releaseOutputBuffer(env, j_media_codec_.obj(), index,
+                                            render);
 }
 
-int MediaCodecBridge::GetOutputBuffersCount() {
+int SdkMediaCodecBridge::GetOutputBuffersCount() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_getOutputBuffersCount(env, j_media_codec_.obj());
 }
 
-size_t MediaCodecBridge::GetOutputBuffersCapacity() {
+size_t SdkMediaCodecBridge::GetOutputBuffersCapacity() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_getOutputBuffersCapacity(env,
                                                         j_media_codec_.obj());
 }
 
-void MediaCodecBridge::GetInputBuffer(int input_buffer_index,
-                                      uint8** data,
-                                      size_t* capacity) {
+void SdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
+                                         uint8_t** data,
+                                         size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
       env, j_media_codec_.obj(), input_buffer_index));
-  *data = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj()));
-  *capacity = base::checked_cast<size_t>(
-      env->GetDirectBufferCapacity(j_buffer.obj()));
+  *data = static_cast<uint8_t*>(env->GetDirectBufferAddress(j_buffer.obj()));
+  *capacity =
+      base::checked_cast<size_t>(env->GetDirectBufferCapacity(j_buffer.obj()));
 }
 
-bool MediaCodecBridge::CopyFromOutputBuffer(int index,
-                                            size_t offset,
-                                            void* dst,
-                                            int dst_size) {
+bool SdkMediaCodecBridge::CopyFromOutputBuffer(int index,
+                                               size_t offset,
+                                               void* dst,
+                                               int dst_size) {
   void* src_data = nullptr;
-  int src_capacity = GetOutputBufferAddress(index, offset, &src_data);
-  if (src_capacity < dst_size)
+  size_t src_capacity = GetOutputBufferAddress(index, offset, &src_data);
+  if (src_capacity < offset ||
+      src_capacity - offset < static_cast<size_t>(dst_size)) {
     return false;
-  memcpy(dst, src_data, dst_size);
+  }
+  memcpy(dst, static_cast<uint8*>(src_data) + offset, dst_size);
   return true;
 }
 
-int MediaCodecBridge::GetOutputBufferAddress(int index,
-                                             size_t offset,
-                                             void** addr) {
+int SdkMediaCodecBridge::GetOutputBufferAddress(int index,
+                                                size_t offset,
+                                                void** addr) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(
       Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), index));
-  *addr = reinterpret_cast<uint8*>(
-      env->GetDirectBufferAddress(j_buffer.obj())) + offset;
+  *addr =
+      reinterpret_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj())) +
+      offset;
   return env->GetDirectBufferCapacity(j_buffer.obj()) - offset;
 }
 
-bool MediaCodecBridge::FillInputBuffer(int index,
-                                       const uint8_t* data,
-                                       size_t size) {
-  uint8* dst = NULL;
-  size_t capacity = 0;
-  GetInputBuffer(index, &dst, &capacity);
-  CHECK(dst);
+// static
+bool SdkMediaCodecBridge::RegisterSdkMediaCodecBridge(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
 
-  if (size > capacity) {
-    LOG(ERROR) << "Input buffer size " << size
-               << " exceeds MediaCodec input buffer capacity: " << capacity;
-    return false;
-  }
+// static
+AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
+  if (!MediaCodecUtil::IsMediaCodecAvailable())
+    return nullptr;
 
-  memcpy(dst, data, size);
-  return true;
+  const std::string mime = AudioCodecToAndroidMimeType(codec);
+  return mime.empty() ? nullptr : new AudioCodecBridge(mime);
+}
+
+// static
+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.
-    : MediaCodecBridge(mime, false, MEDIA_CODEC_DECODER) {}
+    : SdkMediaCodecBridge(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) {
+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();
 
   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,
                             codec_delay_ns, seek_preroll_ns)) {
     return false;
   }
 
-  if (!Java_MediaCodecBridge_configureAudio(
-           env, media_codec(), j_format.obj(), media_crypto, 0, play_audio)) {
+  if (!Java_MediaCodecBridge_configureAudio(env, media_codec(), j_format.obj(),
+                                            media_crypto, 0, play_audio)) {
     return false;
   }
 
-  return StartInternal();
+  return Start();
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(jobject j_format,
                                             const AudioCodec& codec,
-                                            const uint8* extra_data,
+                                            const uint8_t* extra_data,
                                             size_t extra_data_size,
-                                            int64 codec_delay_ns,
-                                            int64 seek_preroll_ns) {
+                                            int64_t codec_delay_ns,
+                                            int64_t seek_preroll_ns) {
   if (extra_data_size == 0 && codec != kCodecOpus)
     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;
       }
 
       size_t header_length[2];
       // |total_length| keeps track of the total number of bytes before the last
       // header.
       size_t total_length = 1;
-      const uint8* current_pos = extra_data;
+      const uint8_t* current_pos = extra_data;
       // Calculate the length of the first 2 headers.
       for (int i = 0; i < 2; ++i) {
         header_length[i] = 0;
         while (total_length < extra_data_size) {
           size_t size = *(++current_pos);
           total_length += 1 + size;
           if (total_length > 0x80000000) {
             LOG(ERROR) << "Vorbis header size too large";
             return false;
           }
           header_length[i] += size;
           if (size < 0xFF)
             break;
         }
         if (total_length >= extra_data_size) {
           LOG(ERROR) << "Invalid vorbis header size in the extra data";
           return false;
         }
       }
       current_pos++;
       // The first header is identification header.
       ScopedJavaLocalRef<jbyteArray> first_header =
           base::android::ToJavaByteArray(env, current_pos, header_length[0]);
-      Java_MediaCodecBridge_setCodecSpecificData(
-          env, j_format, 0, first_header.obj());
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0,
+                                                 first_header.obj());
       // The last header is codec header.
       ScopedJavaLocalRef<jbyteArray> last_header =
-          base::android::ToJavaByteArray(
-              env, extra_data + total_length, extra_data_size - total_length);
-      Java_MediaCodecBridge_setCodecSpecificData(
-          env, j_format, 1, last_header.obj());
+          base::android::ToJavaByteArray(env, extra_data + total_length,
+                                         extra_data_size - total_length);
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1,
+                                                 last_header.obj());
       break;
     }
     case kCodecAAC: {
       media::BitReader reader(extra_data, extra_data_size);
 
       // The following code is copied from aac.cc
       // TODO(qinmin): refactor the code in aac.cc to make it more reusable.
-      uint8 profile = 0;
-      uint8 frequency_index = 0;
-      uint8 channel_config = 0;
+      uint8_t profile = 0;
+      uint8_t frequency_index = 0;
+      uint8_t channel_config = 0;
       RETURN_ON_ERROR(reader.ReadBits(5, &profile));
       RETURN_ON_ERROR(reader.ReadBits(4, &frequency_index));
 
       if (0xf == frequency_index)
         RETURN_ON_ERROR(reader.SkipBits(24));
       RETURN_ON_ERROR(reader.ReadBits(4, &channel_config));
 
       if (profile == 5 || profile == 29) {
         // Read extension config.
         RETURN_ON_ERROR(reader.ReadBits(4, &frequency_index));
         if (frequency_index == 0xf)
           RETURN_ON_ERROR(reader.SkipBits(24));
         RETURN_ON_ERROR(reader.ReadBits(5, &profile));
       }
 
       if (profile < 1 || profile > 4 || frequency_index == 0xf ||
           channel_config > 7) {
         LOG(ERROR) << "Invalid AAC header";
         return false;
       }
       const size_t kCsdLength = 2;
-      uint8 csd[kCsdLength];
+      uint8_t csd[kCsdLength];
       csd[0] = profile << 3 | frequency_index >> 1;
       csd[1] = (frequency_index & 0x01) << 7 | channel_config << 3;
       ScopedJavaLocalRef<jbyteArray> byte_array =
           base::android::ToJavaByteArray(env, csd, kCsdLength);
-      Java_MediaCodecBridge_setCodecSpecificData(
-          env, j_format, 0, byte_array.obj());
+      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 (!extra_data || extra_data_size == 0 ||
-          codec_delay_ns < 0 || seek_preroll_ns < 0) {
+      if (!extra_data || extra_data_size == 0 || 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);
       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));
+      ScopedJavaLocalRef<jbyteArray> csd1 = base::android::ToJavaByteArray(
+          env, reinterpret_cast<const uint8_t*>(&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));
+      ScopedJavaLocalRef<jbyteArray> csd2 = base::android::ToJavaByteArray(
+          env, reinterpret_cast<const uint8_t*>(&seek_preroll_ns),
+          sizeof(int64_t));
       Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 2, csd2.obj());
       break;
     }
     default:
       LOG(ERROR) << "Invalid header encountered for codec: "
                  << AudioCodecToAndroidMimeType(codec);
       return false;
   }
   return true;
 }
 
-int64 AudioCodecBridge::PlayOutputBuffer(int index,
-                                         size_t size,
-                                         size_t offset,
-                                         bool postpone) {
+int64_t AudioCodecBridge::PlayOutputBuffer(int index,
+                                           size_t size,
+                                           size_t offset,
+                                           bool postpone) {
   DCHECK_LE(0, index);
   int numBytes = base::checked_cast<int>(size);
 
   void* buffer = nullptr;
   int capacity = GetOutputBufferAddress(index, offset, &buffer);
   numBytes = std::min(capacity, numBytes);
   CHECK_GE(numBytes, 0);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> byte_array = base::android::ToJavaByteArray(
-          env, static_cast<uint8*>(buffer), numBytes);
+      env, static_cast<uint8_t*>(buffer), numBytes);
   return Java_MediaCodecBridge_playOutputBuffer(env, media_codec(),
                                                 byte_array.obj(), postpone);
 }
 
 void AudioCodecBridge::SetVolume(double volume) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
 // static
-AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
-  if (!MediaCodecBridge::IsAvailable())
-    return NULL;
-
-  const std::string mime = AudioCodecToAndroidMimeType(codec);
-  return mime.empty() ? NULL : new AudioCodecBridge(mime);
-}
-
-// static
-bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
-  return MediaCodecBridge::IsKnownUnaccelerated(
-      AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
-}
-
-// static
 bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec,
                                             MediaCodecDirection direction) {
-  return MediaCodecBridge::IsKnownUnaccelerated(
+  return MediaCodecUtil::IsKnownUnaccelerated(
       VideoCodecToAndroidMimeType(codec), direction);
 }
 
 // static
 VideoCodecBridge* VideoCodecBridge::CreateDecoder(const VideoCodec& codec,
                                                   bool is_secure,
                                                   const gfx::Size& size,
                                                   jobject surface,
                                                   jobject media_crypto) {
-  if (!MediaCodecBridge::IsAvailable())
-    return NULL;
+  if (!MediaCodecUtil::IsMediaCodecAvailable())
+    return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
-    return NULL;
+    return nullptr;
 
   scoped_ptr<VideoCodecBridge> bridge(
       new VideoCodecBridge(mime, is_secure, MEDIA_CODEC_DECODER));
   if (!bridge->media_codec())
-    return NULL;
+    return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoDecoderFormat(
           env, j_mime.obj(), size.width(), size.height()));
   DCHECK(!j_format.is_null());
-  if (!Java_MediaCodecBridge_configureVideo(env,
-                                            bridge->media_codec(),
-                                            j_format.obj(),
-                                            surface,
-                                            media_crypto,
-                                            0)) {
-    return NULL;
+  if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(),
+                                            j_format.obj(), surface,
+                                            media_crypto, 0)) {
+    return nullptr;
   }
 
-  return bridge->StartInternal() ? bridge.release() : NULL;
+  return bridge->Start() ? bridge.release() : nullptr;
 }
 
 // static
 VideoCodecBridge* VideoCodecBridge::CreateEncoder(const VideoCodec& codec,
                                                   const gfx::Size& size,
                                                   int bit_rate,
                                                   int frame_rate,
                                                   int i_frame_interval,
                                                   int color_format) {
-  if (!MediaCodecBridge::IsAvailable())
-    return NULL;
+  if (!MediaCodecUtil::IsMediaCodecAvailable())
+    return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
-    return NULL;
+    return nullptr;
 
   scoped_ptr<VideoCodecBridge> bridge(
       new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER));
   if (!bridge->media_codec())
-    return NULL;
+    return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
-      Java_MediaCodecBridge_createVideoEncoderFormat(env,
-                                                     j_mime.obj(),
-                                                     size.width(),
-                                                     size.height(),
-                                                     bit_rate,
-                                                     frame_rate,
-                                                     i_frame_interval,
-                                                     color_format));
+      Java_MediaCodecBridge_createVideoEncoderFormat(
+          env, j_mime.obj(), size.width(), size.height(), bit_rate, frame_rate,
+          i_frame_interval, color_format));
   DCHECK(!j_format.is_null());
-  if (!Java_MediaCodecBridge_configureVideo(env,
-                                            bridge->media_codec(),
-                                            j_format.obj(),
-                                            NULL,
-                                            NULL,
+  if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(),
+                                            j_format.obj(), nullptr, nullptr,
                                             kConfigureFlagEncode)) {
-    return NULL;
+    return nullptr;
   }
 
-  return bridge->StartInternal() ? bridge.release() : NULL;
+  return bridge->Start() ? bridge.release() : nullptr;
 }
 
 VideoCodecBridge::VideoCodecBridge(const std::string& mime,
                                    bool is_secure,
                                    MediaCodecDirection direction)
-    : MediaCodecBridge(mime, is_secure, direction),
+    : SdkMediaCodecBridge(mime, is_secure, direction),
       adaptive_playback_supported_for_testing_(-1) {}
 
 void VideoCodecBridge::SetVideoBitrate(int bps) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVideoBitrate(env, media_codec(), bps);
 }
 
 void VideoCodecBridge::RequestKeyFrameSoon() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_requestKeyFrameSoon(env, media_codec());
 }
 
 bool VideoCodecBridge::IsAdaptivePlaybackSupported(int width, int height) {
   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);
-}
-
-bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
-  return RegisterNativesImpl(env);
+  return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
+                                                           width, height);
 }
 
 }  // namespace media