blob: 6cc41e6fceceed21028d425c1a1575d81901c2ae [file] [log] [blame]
// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "starboard/android/shared/media_codec_bridge.h"
#include "starboard/android/shared/media_capabilities_cache.h"
#include "starboard/common/string.h"
namespace starboard {
namespace android {
namespace shared {
namespace {
// See
// https://developer.android.com/reference/android/media/MediaFormat.html#COLOR_RANGE_FULL.
const jint COLOR_RANGE_FULL = 1;
const jint COLOR_RANGE_LIMITED = 2;
// Not defined in MediaFormat. Represents unspecified color ID range.
const jint COLOR_RANGE_UNSPECIFIED = 0;
const jint COLOR_STANDARD_BT2020 = 6;
const jint COLOR_STANDARD_BT601_NTSC = 4;
const jint COLOR_STANDARD_BT601_PAL = 2;
const jint COLOR_STANDARD_BT709 = 1;
const jint COLOR_TRANSFER_HLG = 7;
const jint COLOR_TRANSFER_LINEAR = 1;
const jint COLOR_TRANSFER_SDR_VIDEO = 3;
const jint COLOR_TRANSFER_ST2084 = 6;
// A special value to represent that no mapping between an SbMedia* HDR
// metadata value and Android HDR metadata value is possible. This value
// implies that HDR playback should not be attempted.
const jint COLOR_VALUE_UNKNOWN = -1;
jint SbMediaPrimaryIdToColorStandard(SbMediaPrimaryId primary_id) {
switch (primary_id) {
case kSbMediaPrimaryIdBt709:
return COLOR_STANDARD_BT709;
case kSbMediaPrimaryIdBt2020:
return COLOR_STANDARD_BT2020;
default:
return COLOR_VALUE_UNKNOWN;
}
}
jint SbMediaTransferIdToColorTransfer(SbMediaTransferId transfer_id) {
switch (transfer_id) {
case kSbMediaTransferIdBt709:
return COLOR_TRANSFER_SDR_VIDEO;
case kSbMediaTransferIdSmpteSt2084:
return COLOR_TRANSFER_ST2084;
case kSbMediaTransferIdAribStdB67:
return COLOR_TRANSFER_HLG;
default:
return COLOR_VALUE_UNKNOWN;
}
}
jint SbMediaRangeIdToColorRange(SbMediaRangeId range_id) {
switch (range_id) {
case kSbMediaRangeIdLimited:
return COLOR_RANGE_LIMITED;
case kSbMediaRangeIdFull:
return COLOR_RANGE_FULL;
case kSbMediaRangeIdUnspecified:
return COLOR_RANGE_UNSPECIFIED;
default:
return COLOR_VALUE_UNKNOWN;
}
}
} // namespace
extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_media_MediaCodecBridge_nativeOnMediaCodecFrameRendered(
JNIEnv* env,
jobject unused_this,
jlong native_media_codec_bridge,
jlong presentation_time_us,
jlong render_at_system_time_ns) {
MediaCodecBridge* media_codec_bridge =
reinterpret_cast<MediaCodecBridge*>(native_media_codec_bridge);
SB_DCHECK(media_codec_bridge);
media_codec_bridge->OnMediaCodecFrameRendered(presentation_time_us);
}
extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_media_MediaCodecBridge_nativeOnMediaCodecError(
JniEnvExt* env,
jobject unused_this,
jlong native_media_codec_bridge,
jboolean is_recoverable,
jboolean is_transient,
jstring diagnostic_info) {
MediaCodecBridge* media_codec_bridge =
reinterpret_cast<MediaCodecBridge*>(native_media_codec_bridge);
SB_DCHECK(media_codec_bridge);
std::string diagnostic_info_in_str =
env->GetStringStandardUTFOrAbort(diagnostic_info);
media_codec_bridge->OnMediaCodecError(is_recoverable, is_transient,
diagnostic_info_in_str);
}
extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_media_MediaCodecBridge_nativeOnMediaCodecInputBufferAvailable(
JNIEnv* env,
jobject unused_this,
jlong native_media_codec_bridge,
jint buffer_index) {
MediaCodecBridge* media_codec_bridge =
reinterpret_cast<MediaCodecBridge*>(native_media_codec_bridge);
SB_DCHECK(media_codec_bridge);
media_codec_bridge->OnMediaCodecInputBufferAvailable(buffer_index);
}
extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_media_MediaCodecBridge_nativeOnMediaCodecOutputBufferAvailable(
JNIEnv* env,
jobject unused_this,
jlong native_media_codec_bridge,
jint buffer_index,
jint flags,
jint offset,
jlong presentation_time_us,
jint size) {
MediaCodecBridge* media_codec_bridge =
reinterpret_cast<MediaCodecBridge*>(native_media_codec_bridge);
SB_DCHECK(media_codec_bridge);
media_codec_bridge->OnMediaCodecOutputBufferAvailable(
buffer_index, flags, offset, presentation_time_us, size);
}
extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_media_MediaCodecBridge_nativeOnMediaCodecOutputFormatChanged(
JNIEnv* env,
jobject unused_this,
jlong native_media_codec_bridge) {
MediaCodecBridge* media_codec_bridge =
reinterpret_cast<MediaCodecBridge*>(native_media_codec_bridge);
SB_DCHECK(media_codec_bridge);
media_codec_bridge->OnMediaCodecOutputFormatChanged();
}
// static
scoped_ptr<MediaCodecBridge> MediaCodecBridge::CreateAudioMediaCodecBridge(
const AudioStreamInfo& audio_stream_info,
Handler* handler,
jobject j_media_crypto) {
bool is_passthrough = false;
const char* mime =
SupportedAudioCodecToMimeType(audio_stream_info.codec, &is_passthrough);
if (!mime) {
SB_LOG(ERROR) << "Unsupported codec " << audio_stream_info.codec << ".";
return scoped_ptr<MediaCodecBridge>(NULL);
}
std::string decoder_name =
MediaCapabilitiesCache::GetInstance()->FindAudioDecoder(
mime, /* bitrate = */ 0,
/* must_support_tunnel_mode = */ false);
if (decoder_name.empty()) {
SB_LOG(ERROR) << "Failed to find decoder for " << audio_stream_info.codec
<< ".";
return scoped_ptr<MediaCodecBridge>(NULL);
}
JniEnvExt* env = JniEnvExt::Get();
ScopedLocalJavaRef<jbyteArray> configuration_data;
if (audio_stream_info.codec == kSbMediaAudioCodecOpus &&
!audio_stream_info.audio_specific_config.empty()) {
configuration_data.Reset(env->NewByteArrayFromRaw(
reinterpret_cast<const jbyte*>(
audio_stream_info.audio_specific_config.data()),
audio_stream_info.audio_specific_config.size()));
}
ScopedLocalJavaRef<jstring> j_mime(env->NewStringStandardUTFOrAbort(mime));
ScopedLocalJavaRef<jstring> j_decoder_name(
env->NewStringStandardUTFOrAbort(decoder_name.c_str()));
scoped_ptr<MediaCodecBridge> native_media_codec_bridge(
new MediaCodecBridge(handler));
jobject j_media_codec_bridge = env->CallStaticObjectMethodOrAbort(
"dev/cobalt/media/MediaCodecBridge", "createAudioMediaCodecBridge",
"(JLjava/lang/String;Ljava/lang/String;IILandroid/media/MediaCrypto;"
"[B)Ldev/cobalt/media/MediaCodecBridge;",
reinterpret_cast<jlong>(native_media_codec_bridge.get()), j_mime.Get(),
j_decoder_name.Get(), audio_stream_info.samples_per_second,
audio_stream_info.number_of_channels, j_media_crypto,
configuration_data.Get());
if (!j_media_codec_bridge) {
SB_LOG(ERROR) << "Failed to create codec bridge for "
<< audio_stream_info.codec << ".";
return scoped_ptr<MediaCodecBridge>(NULL);
}
j_media_codec_bridge = env->ConvertLocalRefToGlobalRef(j_media_codec_bridge);
native_media_codec_bridge->Initialize(j_media_codec_bridge);
return native_media_codec_bridge.Pass();
}
// static
scoped_ptr<MediaCodecBridge> MediaCodecBridge::CreateVideoMediaCodecBridge(
SbMediaVideoCodec video_codec,
int width,
int height,
int fps,
Handler* handler,
jobject j_surface,
jobject j_media_crypto,
const SbMediaColorMetadata* color_metadata,
bool require_secured_decoder,
bool require_software_codec,
int tunnel_mode_audio_session_id,
bool force_big_endian_hdr_metadata,
bool force_improved_support_check,
std::string* error_message) {
SB_DCHECK(error_message);
const char* mime = SupportedVideoCodecToMimeType(video_codec);
if (!mime) {
*error_message = FormatString("Unsupported mime for codec %d", video_codec);
return scoped_ptr<MediaCodecBridge>(NULL);
}
const bool must_support_secure = require_secured_decoder;
const bool must_support_hdr = color_metadata;
const bool must_support_tunnel_mode = tunnel_mode_audio_session_id != -1;
// On first pass, try to find a decoder with HDR if the color info is
// non-null.
std::string decoder_name =
MediaCapabilitiesCache::GetInstance()->FindVideoDecoder(
mime, must_support_secure, must_support_hdr, require_software_codec,
must_support_tunnel_mode, force_improved_support_check,
/* frame_width = */ 0,
/* frame_height = */ 0,
/* bitrate = */ 0,
/* fps = */ 0);
if (decoder_name.empty() && color_metadata) {
// On second pass, forget HDR.
decoder_name = MediaCapabilitiesCache::GetInstance()->FindVideoDecoder(
mime, must_support_secure, /* must_support_hdr = */ false,
require_software_codec, must_support_tunnel_mode,
force_improved_support_check, /* frame_width = */ 0,
/* frame_height = */ 0,
/* bitrate = */ 0,
/* fps = */ 0);
}
if (decoder_name.empty()) {
*error_message =
FormatString("Failed to find decoder: %s, mustSupportSecure: %d.", mime,
!!j_media_crypto);
return scoped_ptr<MediaCodecBridge>(NULL);
}
JniEnvExt* env = JniEnvExt::Get();
ScopedLocalJavaRef<jstring> j_mime(env->NewStringStandardUTFOrAbort(mime));
ScopedLocalJavaRef<jstring> j_decoder_name(
env->NewStringStandardUTFOrAbort(decoder_name.c_str()));
ScopedLocalJavaRef<jobject> j_color_info(nullptr);
if (color_metadata) {
jint color_standard =
SbMediaPrimaryIdToColorStandard(color_metadata->primaries);
jint color_transfer =
SbMediaTransferIdToColorTransfer(color_metadata->transfer);
jint color_range = SbMediaRangeIdToColorRange(color_metadata->range);
if (color_standard != COLOR_VALUE_UNKNOWN &&
color_transfer != COLOR_VALUE_UNKNOWN &&
color_range != COLOR_VALUE_UNKNOWN) {
const auto& mastering_metadata = color_metadata->mastering_metadata;
j_color_info.Reset(env->NewObjectOrAbort(
"dev/cobalt/media/MediaCodecBridge$ColorInfo", "(IIIFFFFFFFFFFIIZ)V",
color_range, color_standard, color_transfer,
mastering_metadata.primary_r_chromaticity_x,
mastering_metadata.primary_r_chromaticity_y,
mastering_metadata.primary_g_chromaticity_x,
mastering_metadata.primary_g_chromaticity_y,
mastering_metadata.primary_b_chromaticity_x,
mastering_metadata.primary_b_chromaticity_y,
mastering_metadata.white_point_chromaticity_x,
mastering_metadata.white_point_chromaticity_y,
mastering_metadata.luminance_max, mastering_metadata.luminance_min,
color_metadata->max_cll, color_metadata->max_fall,
force_big_endian_hdr_metadata));
}
}
ScopedLocalJavaRef<jobject> j_create_media_codec_bridge_result(
env->NewObjectOrAbort(
"dev/cobalt/media/MediaCodecBridge$CreateMediaCodecBridgeResult",
"()V"));
scoped_ptr<MediaCodecBridge> native_media_codec_bridge(
new MediaCodecBridge(handler));
env->CallStaticVoidMethodOrAbort(
"dev/cobalt/media/MediaCodecBridge", "createVideoMediaCodecBridge",
"(JLjava/lang/String;Ljava/lang/String;IIILandroid/view/Surface;"
"Landroid/media/MediaCrypto;"
"Ldev/cobalt/media/MediaCodecBridge$ColorInfo;"
"I"
"Ldev/cobalt/media/MediaCodecBridge$CreateMediaCodecBridgeResult;)"
"V",
reinterpret_cast<jlong>(native_media_codec_bridge.get()), j_mime.Get(),
j_decoder_name.Get(), width, height, fps, j_surface, j_media_crypto,
j_color_info.Get(), tunnel_mode_audio_session_id,
j_create_media_codec_bridge_result.Get());
jobject j_media_codec_bridge = env->CallObjectMethodOrAbort(
j_create_media_codec_bridge_result.Get(), "mediaCodecBridge",
"()Ldev/cobalt/media/MediaCodecBridge;");
if (!j_media_codec_bridge) {
ScopedLocalJavaRef<jstring> j_error_message(
env->CallObjectMethodOrAbort(j_create_media_codec_bridge_result.Get(),
"errorMessage", "()Ljava/lang/String;"));
*error_message = env->GetStringStandardUTFOrAbort(j_error_message.Get());
return scoped_ptr<MediaCodecBridge>(NULL);
}
j_media_codec_bridge = env->ConvertLocalRefToGlobalRef(j_media_codec_bridge);
native_media_codec_bridge->Initialize(j_media_codec_bridge);
return native_media_codec_bridge.Pass();
}
MediaCodecBridge::~MediaCodecBridge() {
if (!j_media_codec_bridge_) {
return;
}
JniEnvExt* env = JniEnvExt::Get();
env->CallVoidMethodOrAbort(j_media_codec_bridge_, "stop", "()V");
env->CallVoidMethodOrAbort(j_media_codec_bridge_, "release", "()V");
env->DeleteGlobalRef(j_media_codec_bridge_);
j_media_codec_bridge_ = NULL;
SB_DCHECK(j_reused_get_output_format_result_);
env->DeleteGlobalRef(j_reused_get_output_format_result_);
j_reused_get_output_format_result_ = NULL;
}
jobject MediaCodecBridge::GetInputBuffer(jint index) {
SB_DCHECK(index >= 0);
return JniEnvExt::Get()->CallObjectMethodOrAbort(
j_media_codec_bridge_, "getInputBuffer", "(I)Ljava/nio/ByteBuffer;",
index);
}
jint MediaCodecBridge::QueueInputBuffer(jint index,
jint offset,
jint size,
jlong presentation_time_microseconds,
jint flags) {
return JniEnvExt::Get()->CallIntMethodOrAbort(
j_media_codec_bridge_, "queueInputBuffer", "(IIIJI)I", index, offset,
size, presentation_time_microseconds, flags);
}
jint MediaCodecBridge::QueueSecureInputBuffer(
jint index,
jint offset,
const SbDrmSampleInfo& drm_sample_info,
jlong presentation_time_microseconds) {
JniEnvExt* env = JniEnvExt::Get();
ScopedLocalJavaRef<jbyteArray> j_iv(env->NewByteArrayFromRaw(
reinterpret_cast<const jbyte*>(drm_sample_info.initialization_vector),
drm_sample_info.initialization_vector_size));
ScopedLocalJavaRef<jbyteArray> j_key_id(env->NewByteArrayFromRaw(
reinterpret_cast<const jbyte*>(drm_sample_info.identifier),
drm_sample_info.identifier_size));
// Reshape the sub sample mapping like this:
// [(c0, e0), (c1, e1), ...] -> [c0, c1, ...] and [e0, e1, ...]
int32_t subsample_count = drm_sample_info.subsample_count;
scoped_array<jint> clear_bytes(new jint[subsample_count]);
scoped_array<jint> encrypted_bytes(new jint[subsample_count]);
for (int i = 0; i < subsample_count; ++i) {
clear_bytes[i] = drm_sample_info.subsample_mapping[i].clear_byte_count;
encrypted_bytes[i] =
drm_sample_info.subsample_mapping[i].encrypted_byte_count;
}
ScopedLocalJavaRef<jintArray> j_clear_bytes(
env->NewIntArrayFromRaw(clear_bytes.get(), subsample_count));
ScopedLocalJavaRef<jintArray> j_encrypted_bytes(
env->NewIntArrayFromRaw(encrypted_bytes.get(), subsample_count));
jint cipher_mode = CRYPTO_MODE_AES_CTR;
jint blocks_to_encrypt = 0;
jint blocks_to_skip = 0;
if (drm_sample_info.encryption_scheme == kSbDrmEncryptionSchemeAesCbc) {
cipher_mode = CRYPTO_MODE_AES_CBC;
blocks_to_encrypt = drm_sample_info.encryption_pattern.crypt_byte_block;
blocks_to_skip = drm_sample_info.encryption_pattern.skip_byte_block;
}
return env->CallIntMethodOrAbort(
j_media_codec_bridge_, "queueSecureInputBuffer", "(II[B[B[I[IIIIIJ)I",
index, offset, j_iv.Get(), j_key_id.Get(), j_clear_bytes.Get(),
j_encrypted_bytes.Get(), subsample_count, cipher_mode, blocks_to_encrypt,
blocks_to_skip, presentation_time_microseconds);
}
jobject MediaCodecBridge::GetOutputBuffer(jint index) {
SB_DCHECK(index >= 0);
return JniEnvExt::Get()->CallObjectMethodOrAbort(
j_media_codec_bridge_, "getOutputBuffer", "(I)Ljava/nio/ByteBuffer;",
index);
}
void MediaCodecBridge::ReleaseOutputBuffer(jint index, jboolean render) {
JniEnvExt::Get()->CallVoidMethodOrAbort(
j_media_codec_bridge_, "releaseOutputBuffer", "(IZ)V", index, render);
}
void MediaCodecBridge::ReleaseOutputBufferAtTimestamp(
jint index,
jlong render_timestamp_ns) {
JniEnvExt::Get()->CallVoidMethodOrAbort(j_media_codec_bridge_,
"releaseOutputBuffer", "(IJ)V", index,
render_timestamp_ns);
}
void MediaCodecBridge::SetPlaybackRate(double playback_rate) {
JniEnvExt::Get()->CallVoidMethodOrAbort(
j_media_codec_bridge_, "setPlaybackRate", "(D)V", playback_rate);
}
jint MediaCodecBridge::Flush() {
return JniEnvExt::Get()->CallIntMethodOrAbort(j_media_codec_bridge_, "flush",
"()I");
}
SurfaceDimensions MediaCodecBridge::GetOutputDimensions() {
JniEnvExt* env = JniEnvExt::Get();
env->CallVoidMethodOrAbort(
j_media_codec_bridge_, "getOutputFormat",
"(Ldev/cobalt/media/MediaCodecBridge$GetOutputFormatResult;)V",
j_reused_get_output_format_result_);
return {env->CallIntMethodOrAbort(j_reused_get_output_format_result_, "width",
"()I"),
env->CallIntMethodOrAbort(j_reused_get_output_format_result_,
"height", "()I")};
}
AudioOutputFormatResult MediaCodecBridge::GetAudioOutputFormat() {
JniEnvExt* env = JniEnvExt::Get();
env->CallVoidMethodOrAbort(
j_media_codec_bridge_, "getOutputFormat",
"(Ldev/cobalt/media/MediaCodecBridge$GetOutputFormatResult;)V",
j_reused_get_output_format_result_);
jint status = env->CallIntMethodOrAbort(j_reused_get_output_format_result_,
"status", "()I");
if (status == MEDIA_CODEC_ERROR) {
return {status, 0, 0};
}
return {status,
env->CallIntMethodOrAbort(j_reused_get_output_format_result_,
"sampleRate", "()I"),
env->CallIntMethodOrAbort(j_reused_get_output_format_result_,
"channelCount", "()I")};
}
void MediaCodecBridge::OnMediaCodecError(bool is_recoverable,
bool is_transient,
const std::string& diagnostic_info) {
handler_->OnMediaCodecError(is_recoverable, is_transient, diagnostic_info);
}
void MediaCodecBridge::OnMediaCodecInputBufferAvailable(int buffer_index) {
handler_->OnMediaCodecInputBufferAvailable(buffer_index);
}
void MediaCodecBridge::OnMediaCodecOutputBufferAvailable(
int buffer_index,
int flags,
int offset,
int64_t presentation_time_us,
int size) {
handler_->OnMediaCodecOutputBufferAvailable(buffer_index, flags, offset,
presentation_time_us, size);
}
void MediaCodecBridge::OnMediaCodecOutputFormatChanged() {
handler_->OnMediaCodecOutputFormatChanged();
}
void MediaCodecBridge::OnMediaCodecFrameRendered(SbTime frame_timestamp) {
handler_->OnMediaCodecFrameRendered(frame_timestamp);
}
MediaCodecBridge::MediaCodecBridge(Handler* handler) : handler_(handler) {
SB_DCHECK(handler_);
}
void MediaCodecBridge::Initialize(jobject j_media_codec_bridge) {
SB_DCHECK(j_media_codec_bridge);
j_media_codec_bridge_ = j_media_codec_bridge;
JniEnvExt* env = JniEnvExt::Get();
SB_DCHECK(env->GetObjectRefType(j_media_codec_bridge_) == JNIGlobalRefType);
j_reused_get_output_format_result_ = env->NewObjectOrAbort(
"dev/cobalt/media/MediaCodecBridge$GetOutputFormatResult", "()V");
SB_DCHECK(j_reused_get_output_format_result_);
j_reused_get_output_format_result_ =
env->ConvertLocalRefToGlobalRef(j_reused_get_output_format_result_);
}
} // namespace shared
} // namespace android
} // namespace starboard