Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(420)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: media/base/android/media_codec_bridge.cc

Issue 1472943002: Refactor MediaCodecBridge to add support for NDK APIs (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: fix crazy linker issue Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/base/android/media_codec_bridge.h ('k') | media/base/android/media_codec_bridge_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/base/android/media_codec_bridge.cc
diff --git a/media/base/android/media_codec_bridge.cc b/media/base/android/media_codec_bridge.cc
index 9acec2147ab807f236083764a859a13f8a634d76..ca5588f4e65824745a0e111f5f63d4279c64b19b 100644
--- a/media/base/android/media_codec_bridge.cc
+++ b/media/base/android/media_codec_bridge.cc
@@ -11,14 +11,8 @@
#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;
@@ -27,321 +21,11 @@ using base::android::ConvertUTF8ToJavaString;
using base::android::JavaIntArrayToIntVector;
using base::android::ScopedJavaLocalRef;
-#define RETURN_ON_ERROR(condition) \
- do { \
- if (!(condition)) { \
- LOG(ERROR) << "Unable to parse AAC header: " #condition; \
- 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 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:
- return "video/avc";
- case kCodecHEVC:
- 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();
+MediaCodecBridge::MediaCodecBridge() {}
- 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) {
- 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() {
- 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() {
- JNIEnv* env = AttachCurrentThread();
- return static_cast<MediaCodecStatus>(
- Java_MediaCodecBridge_flush(env, j_media_codec_.obj()));
-}
-
-void MediaCodecBridge::Stop() {
- JNIEnv* env = AttachCurrentThread();
- Java_MediaCodecBridge_stop(env, j_media_codec_.obj());
-}
-
-void MediaCodecBridge::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() {
- JNIEnv* env = AttachCurrentThread();
-
- return Java_MediaCodecBridge_getOutputSamplingRate(env, j_media_codec_.obj());
-}
-
-MediaCodecStatus MediaCodecBridge::QueueInputBuffer(
- int index,
- const uint8* 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()))
- 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));
-}
+MediaCodecBridge::~MediaCodecBridge() {}
MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
int index,
@@ -351,205 +35,25 @@ MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
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);
-}
-
-// TODO(timav): Combine this and above methods together keeping only the first
-// interface after we switch to Spitzer pipeline.
-MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
- int index,
- const uint8* data,
- size_t data_size,
- const uint8* key_id,
- int key_id_size,
- const uint8* iv,
- int iv_size,
- 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()))
- 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);
-
- // 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());
- if (subsamples[i].cypher_bytes >
- static_cast<uint32>(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,
- presentation_time.InMicroseconds()));
-}
-
-void MediaCodecBridge::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,
- kBufferFlagEndOfStream);
-}
-
-MediaCodecStatus MediaCodecBridge::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(
- 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());
- *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) {
- DVLOG(3) << __PRETTY_FUNCTION__ << ": " << index;
- JNIEnv* env = AttachCurrentThread();
- CHECK(env);
-
- Java_MediaCodecBridge_releaseOutputBuffer(
- env, j_media_codec_.obj(), index, render);
+ const std::vector<char> key_vec(key_id.begin(), key_id.end());
+ const std::vector<char> iv_vec(iv.begin(), iv.end());
+ return QueueSecureInputBuffer(index, data, data_size, key_vec, iv_vec,
+ subsamples.empty() ? nullptr : &subsamples[0],
+ subsamples.size(), presentation_time);
}
int MediaCodecBridge::GetOutputBuffersCount() {
- JNIEnv* env = AttachCurrentThread();
- return Java_MediaCodecBridge_getOutputBuffersCount(env, j_media_codec_.obj());
+ return 0;
}
size_t MediaCodecBridge::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) {
- 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()));
-}
-
-bool MediaCodecBridge::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)
- return false;
- memcpy(dst, src_data, dst_size);
- return true;
-}
-
-int MediaCodecBridge::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;
- return env->GetDirectBufferCapacity(j_buffer.obj()) - offset;
+ return 0;
}
bool MediaCodecBridge::FillInputBuffer(int index,
const uint8_t* data,
size_t size) {
- uint8* dst = NULL;
+ uint8_t* dst = nullptr;
size_t capacity = 0;
GetInputBuffer(index, &dst, &capacity);
CHECK(dst);
@@ -564,334 +68,4 @@ bool MediaCodecBridge::FillInputBuffer(int index,
return true;
}
-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,
- 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,
- int64 codec_delay_ns,
- int64 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;
- // 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());
- // 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());
- 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;
- 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];
- 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());
-
- // 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) {
- 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));
- 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, 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) {
- 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);
- 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(
- 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;
-
- const std::string mime = VideoCodecToAndroidMimeType(codec);
- if (mime.empty())
- return NULL;
-
- scoped_ptr<VideoCodecBridge> bridge(
- new VideoCodecBridge(mime, is_secure, MEDIA_CODEC_DECODER));
- if (!bridge->media_codec())
- return NULL;
-
- 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;
- }
-
- return bridge->StartInternal() ? bridge.release() : NULL;
-}
-
-// 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;
-
- const std::string mime = VideoCodecToAndroidMimeType(codec);
- if (mime.empty())
- return NULL;
-
- scoped_ptr<VideoCodecBridge> bridge(
- new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER));
- if (!bridge->media_codec())
- return NULL;
-
- 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));
- DCHECK(!j_format.is_null());
- if (!Java_MediaCodecBridge_configureVideo(env,
- bridge->media_codec(),
- j_format.obj(),
- NULL,
- NULL,
- kConfigureFlagEncode)) {
- return NULL;
- }
-
- return bridge->StartInternal() ? bridge.release() : NULL;
-}
-
-VideoCodecBridge::VideoCodecBridge(const std::string& mime,
- bool is_secure,
- MediaCodecDirection direction)
- : MediaCodecBridge(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);
-}
-
} // namespace media
« no previous file with comments | « media/base/android/media_codec_bridge.h ('k') | media/base/android/media_codec_bridge_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698