Merge changes from topic "revert-3341640-fix-b-364310317-fix-ANAPIC-comments-3-SRPURNABEL" into main
* changes:
Revert "Audio CAP: Address ANAPIC comments, Part 3 (Split back A..."
Revert "Audio CAP: Address ANAPIC comments, Part 3."
Revert "Audio CAP: Address ANAPIC comments, Part 3 (example & to..."
diff --git a/Android.bp b/Android.bp
index 0c7ed6e..c716a06 100644
--- a/Android.bp
+++ b/Android.bp
@@ -135,6 +135,7 @@
aidl_interface {
name: "av-audio-types-aidl",
+ unstable: true,
host_supported: true,
vendor_available: true,
double_loadable: true,
@@ -154,28 +155,4 @@
sdk_version: "module_current",
},
},
- versions_with_info: [
- {
- version: "1",
- imports: ["android.hardware.audio.core-V2"],
- },
- ],
- frozen: false,
-
-}
-
-latest_av_audio_types_aidl = "av-audio-types-aidl-V2"
-
-cc_defaults {
- name: "latest_av_audio_types_aidl_ndk_shared",
- shared_libs: [
- latest_av_audio_types_aidl + "-ndk",
- ],
-}
-
-cc_defaults {
- name: "latest_av_audio_types_aidl_ndk_static",
- static_libs: [
- latest_av_audio_types_aidl + "-ndk",
- ],
}
diff --git a/aidl_api/av-audio-types-aidl/1/.hash b/aidl_api/av-audio-types-aidl/1/.hash
deleted file mode 100644
index 0002682..0000000
--- a/aidl_api/av-audio-types-aidl/1/.hash
+++ /dev/null
@@ -1 +0,0 @@
-ef1bc5ed9db445fbfc116cdec6e6ad081458ee40
diff --git a/aidl_api/av-audio-types-aidl/1/android/media/audio/IHalAdapterVendorExtension.aidl b/aidl_api/av-audio-types-aidl/1/android/media/audio/IHalAdapterVendorExtension.aidl
deleted file mode 100644
index a9aa2c1..0000000
--- a/aidl_api/av-audio-types-aidl/1/android/media/audio/IHalAdapterVendorExtension.aidl
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2023 The Android Open Source Project
- *
- * 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.
- */
-///////////////////////////////////////////////////////////////////////////////
-// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
-///////////////////////////////////////////////////////////////////////////////
-
-// This file is a snapshot of an AIDL file. Do not edit it manually. There are
-// two cases:
-// 1). this is a frozen version file - do not edit this in any case.
-// 2). this is a 'current' file. If you make a backwards compatible change to
-// the interface (from the latest frozen version), the build system will
-// prompt you to update this file with `m <name>-update-api`.
-//
-// You must not make a backward incompatible change to any AIDL file built
-// with the aidl_interface module type with versions property set. The module
-// type is used to build AIDL files in a way that they can be used across
-// independently updatable components of the system. If a device is shipped
-// with such a backward incompatible change, it has a high risk of breaking
-// later when a module using the interface is updated, e.g., Mainline modules.
-
-package android.media.audio;
-/* @hide */
-interface IHalAdapterVendorExtension {
- @utf8InCpp String[] parseVendorParameterIds(android.media.audio.IHalAdapterVendorExtension.ParameterScope scope, in @utf8InCpp String rawKeys);
- void parseVendorParameters(android.media.audio.IHalAdapterVendorExtension.ParameterScope scope, in @utf8InCpp String rawKeysAndValues, out android.hardware.audio.core.VendorParameter[] syncParameters, out android.hardware.audio.core.VendorParameter[] asyncParameters);
- android.hardware.audio.core.VendorParameter[] parseBluetoothA2dpReconfigureOffload(in @utf8InCpp String rawValue);
- android.hardware.audio.core.VendorParameter[] parseBluetoothLeReconfigureOffload(in @utf8InCpp String rawValue);
- @utf8InCpp String processVendorParameters(android.media.audio.IHalAdapterVendorExtension.ParameterScope scope, in android.hardware.audio.core.VendorParameter[] parameters);
- enum ParameterScope {
- MODULE = 0,
- STREAM = 1,
- }
-}
diff --git a/aidl_api/av-audio-types-aidl/current/android/media/audio/IHalAdapterVendorExtension.aidl b/aidl_api/av-audio-types-aidl/current/android/media/audio/IHalAdapterVendorExtension.aidl
deleted file mode 100644
index a9aa2c1..0000000
--- a/aidl_api/av-audio-types-aidl/current/android/media/audio/IHalAdapterVendorExtension.aidl
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2023 The Android Open Source Project
- *
- * 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.
- */
-///////////////////////////////////////////////////////////////////////////////
-// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
-///////////////////////////////////////////////////////////////////////////////
-
-// This file is a snapshot of an AIDL file. Do not edit it manually. There are
-// two cases:
-// 1). this is a frozen version file - do not edit this in any case.
-// 2). this is a 'current' file. If you make a backwards compatible change to
-// the interface (from the latest frozen version), the build system will
-// prompt you to update this file with `m <name>-update-api`.
-//
-// You must not make a backward incompatible change to any AIDL file built
-// with the aidl_interface module type with versions property set. The module
-// type is used to build AIDL files in a way that they can be used across
-// independently updatable components of the system. If a device is shipped
-// with such a backward incompatible change, it has a high risk of breaking
-// later when a module using the interface is updated, e.g., Mainline modules.
-
-package android.media.audio;
-/* @hide */
-interface IHalAdapterVendorExtension {
- @utf8InCpp String[] parseVendorParameterIds(android.media.audio.IHalAdapterVendorExtension.ParameterScope scope, in @utf8InCpp String rawKeys);
- void parseVendorParameters(android.media.audio.IHalAdapterVendorExtension.ParameterScope scope, in @utf8InCpp String rawKeysAndValues, out android.hardware.audio.core.VendorParameter[] syncParameters, out android.hardware.audio.core.VendorParameter[] asyncParameters);
- android.hardware.audio.core.VendorParameter[] parseBluetoothA2dpReconfigureOffload(in @utf8InCpp String rawValue);
- android.hardware.audio.core.VendorParameter[] parseBluetoothLeReconfigureOffload(in @utf8InCpp String rawValue);
- @utf8InCpp String processVendorParameters(android.media.audio.IHalAdapterVendorExtension.ParameterScope scope, in android.hardware.audio.core.VendorParameter[] parameters);
- enum ParameterScope {
- MODULE = 0,
- STREAM = 1,
- }
-}
diff --git a/apex/Android.bp b/apex/Android.bp
index b0d7c02..356bf03 100644
--- a/apex/Android.bp
+++ b/apex/Android.bp
@@ -173,6 +173,7 @@
"mediaswcodec",
],
native_shared_libs: [
+ "libapexcodecs",
"libcodec2_hidl@1.0",
"libcodec2_hidl@1.1",
"libcodec2_hidl@1.2",
diff --git a/apex/ld.config.txt b/apex/ld.config.txt
index 4dc5fb1..c24d51f 100644
--- a/apex/ld.config.txt
+++ b/apex/ld.config.txt
@@ -33,7 +33,7 @@
# TODO: replace the following when apex has a way to auto-generate this list
# namespace.default.link.platform.shared_libs = %LLNDK_LIBRARIES%
# namespace.default.link.platform.shared_libs += %SANITIZER_RUNTIME_LIBRARIES%
-namespace.default.link.platform.shared_libs = libEGL.so:libGLESv1_CM.so:libGLESv2.so:libGLESv3.so:libandroid_net.so:libc.so:libcgrouprc.so:libclang_rt.asan-aarch64-android.so:libclang_rt.asan-arm-android.so:libclang_rt.hwasan-aarch64-android.so:libclang_rt.asan-i686-android.so:libclang_rt.asan-x86_64-android.so:libdl.so:libft2.so:liblog.so:libm.so:libmediandk.so:libnativewindow.so:libneuralnetworks.so:libsync.so:libvndksupport.so:libdl_android.so:libvulkan.so:libbinder_ndk.so
+namespace.default.link.platform.shared_libs = libEGL.so:libGLESv1_CM.so:libGLESv2.so:libGLESv3.so:libandroid_net.so:libc.so:libclang_rt.asan-aarch64-android.so:libclang_rt.asan-arm-android.so:libclang_rt.hwasan-aarch64-android.so:libclang_rt.asan-i686-android.so:libclang_rt.asan-x86_64-android.so:libdl.so:libft2.so:liblog.so:libm.so:libmediandk.so:libnativewindow.so:libneuralnetworks.so:libsync.so:libvndksupport.so:libdl_android.so:libvulkan.so:libbinder_ndk.so
###############################################################################
# "platform" namespace
@@ -138,7 +138,7 @@
# TODO: replace the following when apex has a way to auto-generate this list
# namespace.sphal.link.platform.shared_libs = %LLNDK_LIBRARIES%
# namespace.sphal.link.platform.shared_libs += %SANITIZER_RUNTIME_LIBRARIES%
-namespace.sphal.link.platform.shared_libs = libEGL.so:libGLESv1_CM.so:libGLESv2.so:libGLESv3.so:libandroid_net.so:libc.so:libcgrouprc.so:libclang_rt.asan-aarch64-android.so:libclang_rt.asan-arm-android.so:libclang_rt.hwasan-aarch64-android.so:libclang_rt.asan-i686-android.so:libclang_rt.asan-x86_64-android.so:libdl.so:libft2.so:liblog.so:libm.so:libmediandk.so:libnativewindow.so:libneuralnetworks.so:libsync.so:libvndksupport.so:libvulkan.so:libbinder_ndk.so
+namespace.sphal.link.platform.shared_libs = libEGL.so:libGLESv1_CM.so:libGLESv2.so:libGLESv3.so:libandroid_net.so:libc.so:libclang_rt.asan-aarch64-android.so:libclang_rt.asan-arm-android.so:libclang_rt.hwasan-aarch64-android.so:libclang_rt.asan-i686-android.so:libclang_rt.asan-x86_64-android.so:libdl.so:libft2.so:liblog.so:libm.so:libmediandk.so:libnativewindow.so:libneuralnetworks.so:libsync.so:libvndksupport.so:libvulkan.so:libbinder_ndk.so
# Add a link for libz.so which is llndk on devices where VNDK is not enforced.
namespace.sphal.link.platform.shared_libs += libz.so
diff --git a/drm/libmediadrm/DrmHalHidl.cpp b/drm/libmediadrm/DrmHalHidl.cpp
index c8c6e8e..33ea5ea 100644
--- a/drm/libmediadrm/DrmHalHidl.cpp
+++ b/drm/libmediadrm/DrmHalHidl.cpp
@@ -339,7 +339,7 @@
DrmUtils::LOG2BI("makeDrmFactories: using default passthrough drm instance");
factories.push_back(passthrough);
} else {
- DrmUtils::LOG2BE("Failed to find passthrough drm factories");
+ DrmUtils::LOG2BW("Failed to find passthrough drm factories");
}
}
return factories;
diff --git a/media/aconfig/codec_fwk.aconfig b/media/aconfig/codec_fwk.aconfig
index ee697ee..96fb3e3 100644
--- a/media/aconfig/codec_fwk.aconfig
+++ b/media/aconfig/codec_fwk.aconfig
@@ -7,6 +7,7 @@
flag {
name: "aidl_hal_input_surface"
+ is_exported: true
namespace: "codec_fwk"
description: "Feature flags for enabling AIDL HAL InputSurface handling"
bug: "201479783"
@@ -21,6 +22,13 @@
}
flag {
+ name: "codec_availability"
+ namespace: "codec_fwk"
+ description: "Feature flag for codec availability HAL API support"
+ bug: "363282971"
+}
+
+flag {
name: "codec_buffer_state_cleanup"
namespace: "codec_fwk"
description: "Bugfix flag for more buffer state cleanup in MediaCodec"
diff --git a/media/audio/aconfig/Android.bp b/media/audio/aconfig/Android.bp
index a5aeff2..5f4a6a1 100644
--- a/media/audio/aconfig/Android.bp
+++ b/media/audio/aconfig/Android.bp
@@ -116,7 +116,11 @@
package: "android.media.audio",
container: "system",
srcs: ["audio_framework.aconfig"],
- visibility: ["//frameworks/base/api"],
+ visibility: [
+ "//frameworks/base/api",
+ "//frameworks/base/core/res",
+ ],
+ exportable: true,
}
aconfig_declarations {
@@ -149,6 +153,20 @@
}
java_aconfig_library {
+ name: "android.media.audio-aconfig-exported-java",
+ aconfig_declarations: "android.media.audio-aconfig",
+ defaults: ["framework-minus-apex-aconfig-java-defaults"],
+ min_sdk_version: "Tiramisu",
+ mode: "exported",
+ apex_available: [
+ "com.android.btservices",
+ ],
+ visibility: [
+ "//packages/modules/Bluetooth:__subpackages__",
+ ],
+}
+
+java_aconfig_library {
name: "android.media.audiopolicy-aconfig-java",
aconfig_declarations: "android.media.audiopolicy-aconfig",
defaults: ["framework-minus-apex-aconfig-java-defaults"],
diff --git a/media/audio/aconfig/audio_framework.aconfig b/media/audio/aconfig/audio_framework.aconfig
index ea5f26d..b155bac 100644
--- a/media/audio/aconfig/audio_framework.aconfig
+++ b/media/audio/aconfig/audio_framework.aconfig
@@ -23,6 +23,14 @@
}
flag {
+ name: "deprecate_stream_bt_sco"
+ namespace: "media_audio"
+ description: "Deprecate STREAM_BLUETOOTH_SCO"
+ is_exported: true
+ bug: "376756660"
+}
+
+flag {
name: "feature_spatial_audio_headtracking_low_latency"
is_exported: true
namespace: "media_audio"
diff --git a/media/codec2/components/apv/C2SoftApvDec.cpp b/media/codec2/components/apv/C2SoftApvDec.cpp
index 0617d06..77305ce 100644
--- a/media/codec2/components/apv/C2SoftApvDec.cpp
+++ b/media/codec2/components/apv/C2SoftApvDec.cpp
@@ -279,6 +279,10 @@
if (isHalPixelFormatSupported((AHardwareBuffer_Format)HAL_PIXEL_FORMAT_YCBCR_P010)) {
pixelFormats.push_back(HAL_PIXEL_FORMAT_YCBCR_P010);
}
+ if (isHalPixelFormatSupported((AHardwareBuffer_Format)AHARDWAREBUFFER_FORMAT_YCbCr_P210)) {
+ pixelFormats.push_back(AHARDWAREBUFFER_FORMAT_YCbCr_P210);
+ }
+
// If color format surface isn't added to supported formats, there is no way to know
// when the color-format is configured to surface. This is necessary to be able to
// choose 10-bit format while decoding 10-bit clips in surface mode.
@@ -374,6 +378,8 @@
(void)mayBlock;
ALOGV("%s", __FUNCTION__);
// take default values for all unspecified fields, and coded values for specified ones
+ ALOGV("%s - coded range: %u, primaries: %u, transfer: %u, matrix: %u",
+ __func__, coded.v.range, coded.v.primaries, coded.v.transfer, coded.v.matrix);
me.set().range = coded.v.range == RANGE_UNSPECIFIED ? def.v.range : coded.v.range;
me.set().primaries =
coded.v.primaries == PRIMARIES_UNSPECIFIED ? def.v.primaries : coded.v.primaries;
@@ -493,10 +499,13 @@
mOutBufferFlush(nullptr),
mIvColorformat(IV_YUV_420P),
mOutputDelay(kDefaultOutputDelay),
+ mHeaderDecoded(false),
+ mOutIndex(0u),
+ mHalPixelFormat(HAL_PIXEL_FORMAT_YV12),
mWidth(320),
mHeight(240),
- mHeaderDecoded(false),
- mOutIndex(0u) {
+ mSignalledOutputEos(false),
+ mSignalledError(false) {
oapvdHandle = NULL;
oapvmHandle = NULL;
outputCsp = OUTPUT_CSP_NATIVE;
@@ -714,6 +723,22 @@
}
}
+static void copyBufferP210(uint16_t *dstY, uint16_t *dstUV, const uint16_t *srcY,
+ const uint16_t *srcUV, size_t srcYStride, size_t srcUVStride, size_t dstYStride,
+ size_t dstUVStride, size_t width, size_t height) {
+ for (size_t y = 0; y < height; ++y) {
+ memcpy(dstY, srcY, width * sizeof(uint16_t));
+ srcY += srcYStride;
+ dstY += dstYStride;
+ }
+
+ for (size_t y = 0; y < height; ++y) {
+ memcpy(dstUV, srcUV, width * sizeof(uint16_t));
+ srcUV += srcUVStride;
+ dstUV += dstUVStride;
+ }
+}
+
static void copyBufferFromYUV422ToYV12(uint8_t* dstY, uint8_t* dstU, uint8_t* dstV,
const uint8_t* srcY, const uint8_t* srcU,
const uint8_t* srcV, size_t srcYStride, size_t srcUStride,
@@ -989,28 +1014,81 @@
}
}
+void C2SoftApvDec::getVuiParams(VuiColorAspects* buffer) {
+ VuiColorAspects vuiColorAspects;
+ vuiColorAspects.primaries = buffer->primaries;
+ vuiColorAspects.transfer = buffer->transfer;
+ vuiColorAspects.coeffs = buffer->coeffs;
+ vuiColorAspects.fullRange = buffer->fullRange;
+
+ // convert vui aspects to C2 values if changed
+ if (!(vuiColorAspects == mBitstreamColorAspects)) {
+ mBitstreamColorAspects = vuiColorAspects;
+ ColorAspects sfAspects;
+ C2StreamColorAspectsInfo::input codedAspects = { 0u };
+ ColorUtils::convertIsoColorAspectsToCodecAspects(
+ vuiColorAspects.primaries, vuiColorAspects.transfer, vuiColorAspects.coeffs,
+ vuiColorAspects.fullRange, sfAspects);
+ if (!C2Mapper::map(sfAspects.mPrimaries, &codedAspects.primaries)) {
+ codedAspects.primaries = C2Color::PRIMARIES_UNSPECIFIED;
+ }
+ if (!C2Mapper::map(sfAspects.mRange, &codedAspects.range)) {
+ codedAspects.range = C2Color::RANGE_UNSPECIFIED;
+ }
+ if (!C2Mapper::map(sfAspects.mMatrixCoeffs, &codedAspects.matrix)) {
+ codedAspects.matrix = C2Color::MATRIX_UNSPECIFIED;
+ }
+ if (!C2Mapper::map(sfAspects.mTransfer, &codedAspects.transfer)) {
+ codedAspects.transfer = C2Color::TRANSFER_UNSPECIFIED;
+ }
+ ALOGV("colorAspects: primaries:%d, transfer:%d, coeffs:%d, fullRange:%d",
+ codedAspects.primaries, codedAspects.transfer, codedAspects.matrix,
+ codedAspects.range);
+ std::vector<std::unique_ptr<C2SettingResult>> failures;
+ mIntf->config({&codedAspects}, C2_MAY_BLOCK, &failures);
+ }
+}
+
status_t C2SoftApvDec::outputBuffer(const std::shared_ptr<C2BlockPool>& pool,
const std::unique_ptr<C2Work>& work) {
if (!(work && pool)) return BAD_VALUE;
- oapv_imgb_t* imgbOutput;
+ oapv_imgb_t* imgbOutput = nullptr;
std::shared_ptr<C2GraphicBlock> block;
if (ofrms.num_frms > 0) {
- oapv_frm_t* frm = &ofrms.frm[0];
- imgbOutput = frm->imgb;
+ for(int i = 0; i < ofrms.num_frms; i++) {
+ oapv_frm_t* frm = &ofrms.frm[0];
+ if(frm->pbu_type == OAPV_PBU_TYPE_PRIMARY_FRAME) {
+ imgbOutput = frm->imgb;
+ break;
+ }
+ }
+ if(imgbOutput == nullptr) {
+ ALOGW("No OAPV primary frame");
+ return false;
+ }
} else {
ALOGW("No output frames");
return false;
}
bool isMonochrome = OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CS_YCBCR400;
+ // TODO: use bitstream color aspect after vui parsing
+ VuiColorAspects colorAspect;
+ colorAspect.primaries = 2;
+ colorAspect.transfer = 2;
+ colorAspect.coeffs = 2;
+ colorAspect.fullRange = 1;
+ getVuiParams(&colorAspect);
+
uint32_t format = HAL_PIXEL_FORMAT_YV12;
std::shared_ptr<C2StreamColorAspectsInfo::output> codedColorAspects;
if (OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 10 &&
mPixelFormatInfo->value != HAL_PIXEL_FORMAT_YCBCR_420_888) {
IntfImpl::Lock lock = mIntf->lock();
codedColorAspects = mIntf->getColorAspects_l();
+
bool allowRGBA1010102 = false;
if (codedColorAspects->primaries == C2Color::PRIMARIES_BT2020 &&
codedColorAspects->matrix == C2Color::MATRIX_BT2020 &&
@@ -1067,7 +1145,34 @@
size_t dstUStride = layout.planes[C2PlanarLayout::PLANE_U].rowInc;
size_t dstVStride = layout.planes[C2PlanarLayout::PLANE_V].rowInc;
- if (format == HAL_PIXEL_FORMAT_YCBCR_P010) {
+ if(format == AHARDWAREBUFFER_FORMAT_YCbCr_P210) {
+ if(OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 10) {
+ const uint16_t *srcY = (const uint16_t *)imgbOutput->a[0];
+ const uint16_t *srcU = (const uint16_t *)imgbOutput->a[1];
+ const uint16_t *srcV = (const uint16_t *)imgbOutput->a[2];
+ size_t srcYStride = imgbOutput->s[0] / 2;
+ size_t srcUStride = imgbOutput->s[1] / 2;
+ size_t srcVStride = imgbOutput->s[2] / 2;
+ dstYStride /= 2;
+ dstUStride /= 2;
+ dstVStride /= 2;
+ ALOGV("OAPV_CS_P210 buffer");
+ copyBufferP210((uint16_t *)dstY, (uint16_t *)dstU, srcY, srcU,
+ srcYStride, srcUStride, dstYStride, dstUStride, mWidth, mHeight);
+ } else {
+ ALOGE("Not supported convder from bd:%d, format: %d(%s), to format: %d(%s)",
+ OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs),
+ OAPV_CS_GET_FORMAT(imgbOutput->cs),
+ OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR420 ?
+ "YUV420" : (OAPV_CS_GET_FORMAT(imgbOutput->cs) == OAPV_CF_YCBCR422 ?
+ "YUV422" : "UNKNOWN"),
+ format,
+ format == HAL_PIXEL_FORMAT_YCBCR_P010 ?
+ "P010" : (format == HAL_PIXEL_FORMAT_YCBCR_420_888 ?
+ "YUV420" : (format == HAL_PIXEL_FORMAT_YV12 ? "YV12" : "UNKNOWN"))
+ );
+ }
+ } else if(format == HAL_PIXEL_FORMAT_YCBCR_P010) {
if (OAPV_CS_GET_BIT_DEPTH(imgbOutput->cs) == 10) {
const uint16_t* srcY = (const uint16_t*)imgbOutput->a[0];
const uint16_t* srcU = (const uint16_t*)imgbOutput->a[1];
diff --git a/media/codec2/components/apv/C2SoftApvDec.h b/media/codec2/components/apv/C2SoftApvDec.h
index 22bfcff..05afdb2 100644
--- a/media/codec2/components/apv/C2SoftApvDec.h
+++ b/media/codec2/components/apv/C2SoftApvDec.h
@@ -66,7 +66,7 @@
namespace android {
-struct C2SoftApvDec : public SimpleC2Component {
+struct C2SoftApvDec final : public SimpleC2Component {
class IntfImpl;
C2SoftApvDec(const char* name, c2_node_id_t id, const std::shared_ptr<IntfImpl>& intfImpl);
@@ -118,6 +118,26 @@
uint32_t mHeight;
bool mSignalledOutputEos;
bool mSignalledError;
+ // Color aspects. These are ISO values and are meant to detect changes in aspects to avoid
+ // converting them to C2 values for each frame
+ struct VuiColorAspects {
+ uint8_t primaries;
+ uint8_t transfer;
+ uint8_t coeffs;
+ uint8_t fullRange;
+
+ // default color aspects
+ VuiColorAspects()
+ : primaries(C2Color::PRIMARIES_UNSPECIFIED),
+ transfer(C2Color::TRANSFER_UNSPECIFIED),
+ coeffs(C2Color::MATRIX_UNSPECIFIED),
+ fullRange(C2Color::RANGE_UNSPECIFIED) { }
+
+ bool operator==(const VuiColorAspects &o) {
+ return primaries == o.primaries && transfer == o.transfer && coeffs == o.coeffs
+ && fullRange == o.fullRange;
+ }
+ } mBitstreamColorAspects;
oapvd_t oapvdHandle;
oapvm_t oapvmHandle;
@@ -126,6 +146,8 @@
int outputCsp;
+ void getVuiParams(VuiColorAspects* buffer);
+
C2_DO_NOT_COPY(C2SoftApvDec);
};
diff --git a/media/codec2/components/apv/C2SoftApvEnc.cpp b/media/codec2/components/apv/C2SoftApvEnc.cpp
index 999c08d..d6a9597 100644
--- a/media/codec2/components/apv/C2SoftApvEnc.cpp
+++ b/media/codec2/components/apv/C2SoftApvEnc.cpp
@@ -221,11 +221,14 @@
.withSetter(CodedColorAspectsSetter, mColorAspects)
.build());
std::vector<uint32_t> pixelFormats = {
- HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
+ HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
};
if (isHalPixelFormatSupported((AHardwareBuffer_Format)HAL_PIXEL_FORMAT_YCBCR_P010)) {
pixelFormats.push_back(HAL_PIXEL_FORMAT_YCBCR_P010);
}
+ if (isHalPixelFormatSupported((AHardwareBuffer_Format)AHARDWAREBUFFER_FORMAT_YCbCr_P210)) {
+ pixelFormats.push_back(AHARDWAREBUFFER_FORMAT_YCbCr_P210);
+ }
addParameter(DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT)
.withDefault(new C2StreamPixelFormatInfo::input(
0u, HAL_PIXEL_FORMAT_YCBCR_P010))
@@ -505,6 +508,8 @@
mReceivedFrames = 0;
mReceivedFirstFrame = false;
mColorFormat = OAPV_CF_PLANAR2;
+ memset(&mInputFrames, 0, sizeof(mInputFrames));
+ memset(&mReconFrames, 0, sizeof(mReconFrames));
return C2_OK;
}
@@ -512,6 +517,7 @@
for (int32_t i = 0; i < MAX_NUM_FRMS; i++) {
if (mInputFrames.frm[i].imgb != nullptr) {
imgb_release(mInputFrames.frm[i].imgb);
+ mInputFrames.frm[i].imgb = nullptr;
}
}
@@ -620,12 +626,6 @@
return C2_NO_MEMORY;
}
- /* Calculate SDR to HDR mapping values */
- mSdrToHdrMapping.clear();
- for (int32_t i = 0; i < 256; i++) {
- mSdrToHdrMapping.push_back((uint16_t)(i * 1023 / 255 + 0.5));
- }
-
mStarted = true;
mInitEncoder = true;
return C2_OK;
@@ -689,26 +689,48 @@
switch (layout.type) {
case C2PlanarLayout::TYPE_RGB:
- [[fallthrough]];
- case C2PlanarLayout::TYPE_RGBA: {
- // TODO: Add RGBA1010102 support
ALOGE("Not supported RGB color format");
return C2_BAD_VALUE;
+ case C2PlanarLayout::TYPE_RGBA: {
+ [[fallthrough]];
+ }
+ case C2PlanarLayout::TYPE_YUVA: {
+ ALOGV("Convert from ABGR2101010 to P210");
+ uint16_t *dstY, *dstU, *dstV;
+ dstY = (uint16_t*)inputFrames->frm[0].imgb->a[0];
+ dstU = (uint16_t*)inputFrames->frm[0].imgb->a[1];
+ dstV = (uint16_t*)inputFrames->frm[0].imgb->a[2];
+ convertRGBA1010102ToYUV420Planar16(dstY, dstU, dstV, (uint32_t*)(input->data()[0]),
+ layout.planes[layout.PLANE_Y].rowInc / 4, width,
+ height, mColorAspects->matrix,
+ mColorAspects->range);
+ break;
}
case C2PlanarLayout::TYPE_YUV: {
if (IsP010(*input)) {
if (mColorFormat == OAPV_CF_YCBCR422) {
ColorConvertP010ToYUV422P10le(input, inputFrames->frm[0].imgb);
} else if (mColorFormat == OAPV_CF_PLANAR2) {
- ColorConvertP010ToP210(input, inputFrames->frm[0].imgb);
+ uint16_t *srcY = (uint16_t*)(input->data()[0]);
+ uint16_t *srcUV = (uint16_t*)(input->data()[1]);
+ uint16_t *dstY = (uint16_t*)inputFrames->frm[0].imgb->a[0];
+ uint16_t *dstUV = (uint16_t*)inputFrames->frm[0].imgb->a[1];
+ convertP010ToP210(dstY, dstUV, srcY, srcUV,
+ input->width(), input->width(), input->width(),
+ input->height());
} else {
ALOGE("Not supported color format. %d", mColorFormat);
return C2_BAD_VALUE;
}
} else if (IsNV12(*input)) {
- ColorConvertNv12ToP210(input, inputFrames->frm[0].imgb);
- } else if (IsNV21(*input)) {
- ColorConvertNv12ToP210(input, inputFrames->frm[0].imgb);
+ uint8_t *srcY = (uint8_t*)input->data()[0];
+ uint8_t *srcUV = (uint8_t*)input->data()[1];
+ uint16_t *dstY = (uint16_t*)inputFrames->frm[0].imgb->a[0];
+ uint16_t *dstUV = (uint16_t*)inputFrames->frm[0].imgb->a[1];
+ convertSemiPlanar8ToP210(dstY, dstUV, srcY, srcUV,
+ input->width(), input->width(), input->width(),
+ input->width(), input->width(), input->height(),
+ CONV_FORMAT_I420);
} else if (IsYUV420(*input)) {
return C2_BAD_VALUE;
} else if (IsI420(*input)) {
@@ -728,46 +750,6 @@
return C2_OK;
}
-void C2SoftApvEnc::ColorConvertNv12ToP210(const C2GraphicView* const input, oapv_imgb_t* imgb) {
- auto width = input->width();
- auto height = input->height();
-
- auto* yPlane = (uint8_t*)input->data()[0];
- auto* uvPlane = (uint8_t*)input->data()[1];
-
- auto* dst = (uint16_t*)imgb->a[0];
- int32_t lumaOffset = 0;
- for (int32_t y = 0; y < height; ++y) {
- for (int32_t x = 0; x < width; ++x) {
- lumaOffset = y * width + x;
- dst[lumaOffset] = (mSdrToHdrMapping[yPlane[lumaOffset]] << 6) |
- ((mSdrToHdrMapping[yPlane[lumaOffset]] & 0x300) >> 3);
- }
- }
-
- auto* dst_uv = (uint16_t*)imgb->a[1];
- uint32_t uvDstStride = width;
- int32_t srcOffset = 0;
- int32_t dstOffset1 = 0, dstOffset2 = 0;
- int32_t tmp1 = 0, tmp2 = 0;
- for (int32_t y = 0; y < height / 2; ++y) {
- for (int32_t x = 0; x < width; x += 2) {
- srcOffset = y * width + x;
- dstOffset1 = (y * 2) * width + x;
- dstOffset2 = ((y * 2) + 1) * width + x;
-
- tmp1 = (mSdrToHdrMapping[uvPlane[srcOffset]] << 6) |
- ((mSdrToHdrMapping[uvPlane[srcOffset]] & 0x300) >> 3);
- tmp2 = (mSdrToHdrMapping[uvPlane[srcOffset + 1]] << 6) |
- ((mSdrToHdrMapping[uvPlane[srcOffset + 1]] & 0x300) >> 3);
- dst_uv[dstOffset1] = (uint16_t)tmp1;
- dst_uv[dstOffset1 + 1] = (uint16_t)tmp2;
- dst_uv[dstOffset2] = (uint16_t)tmp1;
- dst_uv[dstOffset2 + 1] = (uint16_t)tmp2;
- }
- }
-}
-
C2Config::level_t C2SoftApvEnc::decisionApvLevel(int32_t width, int32_t height, int32_t fps,
int32_t bitrate, int32_t band) {
C2Config::level_t level = C2Config::LEVEL_APV_1_BAND_0;
@@ -882,30 +864,6 @@
return level;
}
-void C2SoftApvEnc::ColorConvertP010ToP210(const C2GraphicView* const input, oapv_imgb_t* imgb) {
- auto width = input->width();
- auto height = input->height();
-
- auto* yPlane = (uint8_t*)input->data()[0];
- auto* uvPlane = (uint8_t*)input->data()[1];
- uint32_t uvStride = width * 2;
-
- auto* src = yPlane;
- auto* dst = (uint8_t*)imgb->a[0];
- std::memcpy(dst, src, width * height * 2);
-
- auto* dst_uv = (uint8_t*)imgb->a[1];
- int32_t offset1 = 0, offset2 = 0;
- for (int32_t y = 0; y < height / 2; ++y) {
- offset1 = (y * 2) * uvStride;
- offset2 = (y * 2 + 1) * uvStride;
- src = uvPlane + (y * uvStride);
-
- std::memcpy(dst_uv + offset1, src, uvStride);
- std::memcpy(dst_uv + offset2, src, uvStride);
- }
-}
-
void C2SoftApvEnc::ColorConvertP010ToYUV422P10le(const C2GraphicView* const input,
oapv_imgb_t* imgb) {
uint32_t width = input->width();
diff --git a/media/codec2/components/apv/C2SoftApvEnc.h b/media/codec2/components/apv/C2SoftApvEnc.h
index 445b042..fc4ad7d 100644
--- a/media/codec2/components/apv/C2SoftApvEnc.h
+++ b/media/codec2/components/apv/C2SoftApvEnc.h
@@ -31,11 +31,11 @@
#define APV_QP_MIN 1
#define APV_QP_MAX 51
-struct C2SoftApvEnc : public SimpleC2Component {
+struct C2SoftApvEnc final : public SimpleC2Component {
class IntfImpl;
C2SoftApvEnc(const char* name, c2_node_id_t id, const std::shared_ptr<IntfImpl>& intfImpl);
- ~C2SoftApvEnc();
+ virtual ~C2SoftApvEnc();
// From SimpleC2Component
c2_status_t onInit() override;
@@ -65,9 +65,7 @@
void showEncoderParams(oapve_cdesc_t* cdsc);
- void ColorConvertNv12ToP210(const C2GraphicView* const input, oapv_imgb_t* imgb);
void ColorConvertP010ToYUV422P10le(const C2GraphicView* const input, oapv_imgb_t* imgb);
- void ColorConvertP010ToP210(const C2GraphicView* const input, oapv_imgb_t* imgb);
void createCsdData(const std::unique_ptr<C2Work>& work, oapv_bitb_t* bitb,
uint32_t encodedSize);
@@ -106,7 +104,6 @@
oapve_t mEncoderId;
oapvm_t mMetaId;
uint8_t* mBitstreamBuf = nullptr;
- std::vector<uint16_t> mSdrToHdrMapping;
bool mReceivedFirstFrame = false;
C2_DO_NOT_COPY(C2SoftApvEnc);
};
diff --git a/media/codec2/components/base/SimpleC2Component.cpp b/media/codec2/components/base/SimpleC2Component.cpp
index aec6523..a03f24f 100644
--- a/media/codec2/components/base/SimpleC2Component.cpp
+++ b/media/codec2/components/base/SimpleC2Component.cpp
@@ -463,6 +463,19 @@
}
}
+void convertP010ToP210(uint16_t *dstY, uint16_t *dstUV, const uint16_t *srcY, const uint16_t *srcUV,
+ size_t srcUVStride, size_t dstUVStride, size_t width, size_t height) {
+ std::memcpy(dstY, srcY, width * height * sizeof(uint16_t));
+
+ int32_t offsetTop, offsetBot;
+ for (size_t y = 0; y < (height + 1) / 2; ++y) {
+ offsetTop = (y * 2) * dstUVStride;
+ offsetBot = (y * 2 + 1) * dstUVStride;
+ std::memcpy(dstUV + offsetTop, srcUV + (y * srcUVStride), srcUVStride * sizeof(uint16_t));
+ std::memcpy(dstUV + offsetBot, srcUV + (y * srcUVStride), srcUVStride * sizeof(uint16_t));
+ }
+}
+
static const int16_t bt709Matrix_10bit[2][3][3] = {
{ { 218, 732, 74 }, { -117, -395, 512 }, { 512, -465, -47 } }, /* RANGE_FULL */
{ { 186, 627, 63 }, { -103, -345, 448 }, { 448, -407, -41 } }, /* RANGE_LIMITED */
@@ -517,6 +530,45 @@
}
}
+void convertRGBA1010102ToP210(uint16_t* dstY, uint16_t* dstUV, const uint32_t* srcRGBA,
+ size_t srcRGBStride, size_t width, size_t height,
+ C2Color::matrix_t colorMatrix, C2Color::range_t colorRange) {
+ uint16_t r, g, b;
+ int32_t i32Y, i32U, i32V;
+ uint16_t zeroLvl = colorRange == C2Color::RANGE_FULL ? 0 : 64;
+ uint16_t maxLvlLuma = colorRange == C2Color::RANGE_FULL ? 1023 : 940;
+ uint16_t maxLvlChroma = colorRange == C2Color::RANGE_FULL ? 1023 : 960;
+ // set default range as limited
+ if (colorRange != C2Color::RANGE_FULL) {
+ colorRange = C2Color::RANGE_LIMITED;
+ }
+ const int16_t(*weights)[3] = (colorMatrix == C2Color::MATRIX_BT709)
+ ? bt709Matrix_10bit[colorRange - 1]
+ : bt2020Matrix_10bit[colorRange - 1];
+
+ for (size_t y = 0; y < height; ++y) {
+ for (size_t x = 0; x < width; ++x) {
+ b = (srcRGBA[x] >> 20) & 0x3FF;
+ g = (srcRGBA[x] >> 10) & 0x3FF;
+ r = srcRGBA[x] & 0x3FF;
+
+ i32Y = ((r * weights[0][0] + g * weights[0][1] + b * weights[0][2] + 512) >> 10) +
+ zeroLvl;
+ dstY[x] = (CLIP3(zeroLvl, i32Y, maxLvlLuma) << 6) & 0xFFC0;
+ if (x % 2 == 0) {
+ i32U = ((r * weights[1][0] + g * weights[1][1] + b * weights[1][2] + 512) >> 10) +
+ 512;
+ i32V = ((r * weights[2][0] + g * weights[2][1] + b * weights[2][2] + 512) >> 10) +
+ 512;
+ dstUV[x] = (CLIP3(zeroLvl, i32U, maxLvlChroma) << 6) & 0xFFC0;
+ dstUV[x + 1] = (CLIP3(zeroLvl, i32V, maxLvlChroma) << 6) & 0xFFC0;
+ }
+ }
+ srcRGBA += srcRGBStride;
+ dstY += width;
+ }
+}
+
void convertPlanar16ToY410OrRGBA1010102(uint8_t* dst, const uint16_t* srcY, const uint16_t* srcU,
const uint16_t* srcV, size_t srcYStride, size_t srcUStride,
size_t srcVStride, size_t dstStride, size_t width,
@@ -631,6 +683,36 @@
isMonochrome);
}
}
+
+void convertSemiPlanar8ToP210(uint16_t *dstY, uint16_t *dstUV,
+ const uint8_t *srcY, const uint8_t *srcUV,
+ size_t srcYStride, size_t srcUVStride,
+ size_t dstYStride, size_t dstUVStride,
+ uint32_t width, uint32_t height,
+ CONV_FORMAT_T format) {
+ if (format != CONV_FORMAT_I420) {
+ ALOGE("No support for semi-planar8 to P210. format is %d", format);
+ return;
+ }
+
+ for (int32_t y = 0; y < height; ++y) {
+ for (int32_t x = 0; x < width; ++x) {
+ dstY[x] = ((uint16_t)((double)srcY[x] * 1023 / 255 + 0.5) << 6) & 0xFFC0;
+ }
+ dstY += dstYStride;
+ srcY += srcYStride;
+ }
+
+ for (int32_t y = 0; y < height / 2; ++y) {
+ for (int32_t x = 0; x < width; ++x) {
+ dstUV[x] = dstUV[dstUVStride + x] =
+ ((uint16_t)((double)srcUV[x] * 1023 / 255 + 0.5) << 6) & 0xFFC0;
+ }
+ srcUV += srcUVStride;
+ dstUV += dstUVStride << 1;
+ }
+}
+
std::unique_ptr<C2Work> SimpleC2Component::WorkQueue::pop_front() {
std::unique_ptr<C2Work> work = std::move(mQueue.front().work);
mQueue.pop_front();
diff --git a/media/codec2/components/base/include/SimpleC2Component.h b/media/codec2/components/base/include/SimpleC2Component.h
index b28c47e..4306e55 100644
--- a/media/codec2/components/base/include/SimpleC2Component.h
+++ b/media/codec2/components/base/include/SimpleC2Component.h
@@ -68,10 +68,19 @@
size_t dstUStride, size_t dstVStride, size_t width,
size_t height, bool isMonochrome = false);
+void convertP010ToP210(uint16_t *dstY, uint16_t *dstUV, const uint16_t *srcY,
+ const uint16_t *srcUV, size_t srcUVStride, size_t dstUVStride,
+ size_t width, size_t height);
+
void convertRGBA1010102ToYUV420Planar16(uint16_t* dstY, uint16_t* dstU, uint16_t* dstV,
const uint32_t* srcRGBA, size_t srcRGBStride, size_t width,
size_t height, C2Color::matrix_t colorMatrix,
C2Color::range_t colorRange);
+
+void convertRGBA1010102ToP210(uint16_t* dstY, uint16_t* dstUV, const uint32_t* srcRGBA,
+ size_t srcRGBStride, size_t width, size_t height,
+ C2Color::matrix_t colorMatrix, C2Color::range_t colorRange);
+
void convertPlanar16ToY410OrRGBA1010102(uint8_t* dst, const uint16_t* srcY, const uint16_t* srcU,
const uint16_t* srcV, size_t srcYStride, size_t srcUStride,
size_t srcVStride, size_t dstStride, size_t width,
@@ -96,6 +105,12 @@
size_t srcUStride, size_t srcVStride, size_t dstYStride,
size_t dstUStride, size_t dstVStride, uint32_t width, uint32_t height,
bool isMonochrome, CONV_FORMAT_T format);
+void convertSemiPlanar8ToP210(uint16_t *dstY, uint16_t *dstUV,
+ const uint8_t *srcY, const uint8_t *srcUV,
+ size_t srcYStride, size_t srcUVStride,
+ size_t dstYStride, size_t dstUVStride,
+ uint32_t width, uint32_t height,
+ CONV_FORMAT_T format);
class SimpleC2Component
: public C2Component, public std::enable_shared_from_this<SimpleC2Component> {
diff --git a/media/codec2/hal/client/client.cpp b/media/codec2/hal/client/client.cpp
index 80735cb..6348e42 100644
--- a/media/codec2/hal/client/client.cpp
+++ b/media/codec2/hal/client/client.cpp
@@ -21,7 +21,9 @@
#include <utils/Trace.h>
#include <codec2/aidl/GraphicBufferAllocator.h>
+#include <codec2/common/HalSelection.h>
#include <codec2/hidl/client.h>
+
#include <C2Debug.h>
#include <C2BufferPriv.h>
#include <C2Config.h> // for C2StreamUsageTuning
@@ -1832,9 +1834,7 @@
std::shared_ptr<Codec2Client::InputSurface> Codec2Client::CreateInputSurface(
char const* serviceName) {
- int32_t inputSurfaceSetting = ::android::base::GetIntProperty(
- "debug.stagefright.c2inputsurface", int32_t(0));
- if (inputSurfaceSetting <= 0) {
+ if (!IsCodec2AidlInputSurfaceSelected()) {
return nullptr;
}
size_t index = GetServiceNames().size();
diff --git a/media/codec2/hal/common/Android.bp b/media/codec2/hal/common/Android.bp
index 0638363..886391b 100644
--- a/media/codec2/hal/common/Android.bp
+++ b/media/codec2/hal/common/Android.bp
@@ -56,13 +56,17 @@
"libaconfig_storage_read_api_cc",
],
- static_libs: ["aconfig_mediacodec_flags_c_lib"],
+ static_libs: [
+ "aconfig_mediacodec_flags_c_lib",
+ "android.media.codec-aconfig-cc",
+ ],
}
cc_defaults {
name: "libcodec2_hal_selection",
static_libs: [
"aconfig_mediacodec_flags_c_lib",
+ "android.media.codec-aconfig-cc",
"libcodec2_hal_selection_static",
],
shared_libs: [
diff --git a/media/codec2/hal/common/HalSelection.cpp b/media/codec2/hal/common/HalSelection.cpp
index d3ea181..5bf4fbe 100644
--- a/media/codec2/hal/common/HalSelection.cpp
+++ b/media/codec2/hal/common/HalSelection.cpp
@@ -21,6 +21,7 @@
// NOTE: due to dependency from mainline modules cannot use libsysprop
// #include <android/sysprop/MediaProperties.sysprop.h>
#include <android-base/properties.h>
+#include <android_media_codec.h>
#include <com_android_media_codec_flags.h>
#include <codec2/common/HalSelection.h>
@@ -66,4 +67,20 @@
return false;
}
+bool IsCodec2AidlInputSurfaceSelected() {
+ if (!IsCodec2AidlHalSelected()) {
+ return false;
+ }
+
+ int32_t inputSurfaceSetting = ::android::base::GetIntProperty(
+ "debug.stagefright.c2inputsurface", int32_t(0));
+ if (inputSurfaceSetting <= 0) {
+ return false;
+ }
+ if (!android::media::codec::provider_->aidl_hal_input_surface()) {
+ return false;
+ }
+ return true;
+}
+
} // namespace android
diff --git a/media/codec2/hal/common/include/codec2/common/HalSelection.h b/media/codec2/hal/common/include/codec2/common/HalSelection.h
index 7c77515..bf0c7c5 100644
--- a/media/codec2/hal/common/include/codec2/common/HalSelection.h
+++ b/media/codec2/hal/common/include/codec2/common/HalSelection.h
@@ -22,6 +22,9 @@
// Returns true iff AIDL c2 HAL is selected for the system
bool IsCodec2AidlHalSelected();
+// Returns true iff AIDL c2 InputSurface interface is selected for the system
+bool IsCodec2AidlInputSurfaceSelected();
+
} // namespace android
#endif // CODEC2_HAL_SELECTION_H
diff --git a/media/codec2/sfplugin/CCodecConfig.cpp b/media/codec2/sfplugin/CCodecConfig.cpp
index a943626..897a696 100644
--- a/media/codec2/sfplugin/CCodecConfig.cpp
+++ b/media/codec2/sfplugin/CCodecConfig.cpp
@@ -1907,7 +1907,7 @@
bottom = c2_min(bottom, height);
if (right > left && bottom > top) {
C2Rect rect(right - left, bottom - top);
- rect.at(left, top);
+ rect = rect.at(left, top);
c2QpOffsetRects.push_back(C2QpOffsetRectStruct(rect, offset));
} else {
ALOGE("Rects configuration %s is not valid.", box);
diff --git a/media/codec2/sfplugin/Codec2InfoBuilder.cpp b/media/codec2/sfplugin/Codec2InfoBuilder.cpp
index 692f700..fd242a1 100644
--- a/media/codec2/sfplugin/Codec2InfoBuilder.cpp
+++ b/media/codec2/sfplugin/Codec2InfoBuilder.cpp
@@ -740,6 +740,7 @@
pixelFormatMap[HAL_PIXEL_FORMAT_YCBCR_P010] = COLOR_FormatYUVP010;
pixelFormatMap[HAL_PIXEL_FORMAT_RGBA_1010102] = COLOR_Format32bitABGR2101010;
pixelFormatMap[HAL_PIXEL_FORMAT_RGBA_FP16] = COLOR_Format64bitABGRFloat;
+ pixelFormatMap[AHARDWAREBUFFER_FORMAT_YCbCr_P210] = COLOR_FormatYUVP210;
std::shared_ptr<C2StoreFlexiblePixelFormatDescriptorsInfo> pixelFormatInfo;
std::vector<std::unique_ptr<C2Param>> heapParams;
diff --git a/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp b/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp
index 7a33af4..aa87e97 100644
--- a/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp
+++ b/media/codec2/sfplugin/utils/Codec2CommonUtils.cpp
@@ -64,6 +64,13 @@
return kVendorApiLevel >= __ANDROID_API_T__;
}
+static bool isP210Allowed() {
+ static const int32_t kVendorApiLevel =
+ base::GetIntProperty<int32_t>("ro.vendor.api_level", 0);
+
+ return kVendorApiLevel > __ANDROID_API_V__;
+}
+
bool isHalPixelFormatSupported(AHardwareBuffer_Format format) {
// HAL_PIXEL_FORMAT_YCBCR_P010 requirement was added in T VSR, although it could have been
// supported prior to this.
@@ -76,6 +83,12 @@
return false;
}
+ // P210 is not available before Android B
+ if (format == (AHardwareBuffer_Format)AHARDWAREBUFFER_FORMAT_YCbCr_P210 &&
+ !isP210Allowed()) {
+ return false;
+ }
+
// Default scenario --- the consumer is display or GPU
const AHardwareBuffer_Desc consumableForDisplayOrGpu = {
.width = 320,
diff --git a/media/codec2/vndk/platform/C2BqBuffer.cpp b/media/codec2/vndk/platform/C2BqBuffer.cpp
index 665f9fc..17dfe9c 100644
--- a/media/codec2/vndk/platform/C2BqBuffer.cpp
+++ b/media/codec2/vndk/platform/C2BqBuffer.cpp
@@ -997,7 +997,7 @@
return -1;
}
- if (toUsage != graphicBuffer->getUsage()) {
+ if ((toUsage & graphicBuffer->getUsage()) != toUsage) {
sp<GraphicBuffer> newBuffer = new GraphicBuffer(
graphicBuffer->handle, GraphicBuffer::CLONE_HANDLE,
graphicBuffer->width, graphicBuffer->height, graphicBuffer->format,
diff --git a/media/janitors/media_solutions_OWNERS b/media/janitors/media_solutions_OWNERS
index 95c2b97..004fa30 100644
--- a/media/janitors/media_solutions_OWNERS
+++ b/media/janitors/media_solutions_OWNERS
@@ -17,3 +17,8 @@
# MediaRouter and native mirroring only:
aquilescanta@google.com
+
+# Emergency rollbacks and fixes outside LON timezone
+jmtrivi@google.com # US-MTV
+lajos@google.com # US-MTV
+scottnien@google.com # TW-NTC
diff --git a/media/libaaudio/fuzzer/Android.bp b/media/libaaudio/fuzzer/Android.bp
index b369a62..67c6715 100644
--- a/media/libaaudio/fuzzer/Android.bp
+++ b/media/libaaudio/fuzzer/Android.bp
@@ -58,8 +58,6 @@
"libaudioclient",
"libaudioutils",
"libbase_ndk",
- "libcgrouprc",
- "libcgrouprc_format",
"libcutils",
"libjsoncpp",
"liblog",
diff --git a/media/libaudioclient/aidl/fuzzer/Android.bp b/media/libaudioclient/aidl/fuzzer/Android.bp
index a215c0b..14e528f 100644
--- a/media/libaudioclient/aidl/fuzzer/Android.bp
+++ b/media/libaudioclient/aidl/fuzzer/Android.bp
@@ -24,8 +24,6 @@
"android.hardware.audio.common@7.0-enums",
"audiopermissioncontroller",
"libaudiomockhal",
- "libcgrouprc",
- "libcgrouprc_format",
"libfakeservicemanager",
"libjsoncpp",
"libmediametricsservice",
diff --git a/media/libaudioclient/fuzzer/Android.bp b/media/libaudioclient/fuzzer/Android.bp
index 8bca8df..65ada70 100644
--- a/media/libaudioclient/fuzzer/Android.bp
+++ b/media/libaudioclient/fuzzer/Android.bp
@@ -37,8 +37,6 @@
"effect-aidl-cpp",
"libaudioclient",
"libbase",
- "libcgrouprc",
- "libcgrouprc_format",
"libcutils",
"libjsoncpp",
"liblog",
diff --git a/media/libaudioclient/tests/Android.bp b/media/libaudioclient/tests/Android.bp
index ddf14a3..3941280 100644
--- a/media/libaudioclient/tests/Android.bp
+++ b/media/libaudioclient/tests/Android.bp
@@ -107,7 +107,6 @@
"framework-permission-aidl-cpp",
"libaudioutils",
"libbase",
- "libcgrouprc",
"libdl",
"libmedia",
"libmedia_helper",
diff --git a/media/libaudiohal/impl/Android.bp b/media/libaudiohal/impl/Android.bp
index f5dec56..0dd0f74 100644
--- a/media/libaudiohal/impl/Android.bp
+++ b/media/libaudiohal/impl/Android.bp
@@ -201,11 +201,11 @@
"latest_android_hardware_audio_core_sounddose_ndk_shared",
"latest_android_hardware_audio_effect_ndk_shared",
"latest_android_media_audio_common_types_ndk_shared",
- "latest_av_audio_types_aidl_ndk_shared",
],
shared_libs: [
"android.hardware.common-V2-ndk",
"android.hardware.common.fmq-V1-ndk",
+ "av-audio-types-aidl-ndk",
"libaudio_aidl_conversion_common_cpp",
"libaudio_aidl_conversion_common_ndk",
"libaudio_aidl_conversion_common_ndk_cpp",
diff --git a/media/libmedia/Android.bp b/media/libmedia/Android.bp
index 8a962c6..ee6ad00 100644
--- a/media/libmedia/Android.bp
+++ b/media/libmedia/Android.bp
@@ -260,6 +260,8 @@
srcs: [
"AudioCapabilities.cpp",
"CodecCapabilities.cpp",
+ "EncoderCapabilities.cpp",
+ "VideoCapabilities.cpp",
"CodecCapabilitiesUtils.cpp",
],
diff --git a/media/libmedia/AudioCapabilities.cpp b/media/libmedia/AudioCapabilities.cpp
index 1a92307..dbbe9e8 100644
--- a/media/libmedia/AudioCapabilities.cpp
+++ b/media/libmedia/AudioCapabilities.cpp
@@ -30,19 +30,19 @@
return mBitrateRange;
}
-const std::vector<int>& AudioCapabilities::getSupportedSampleRates() const {
+const std::vector<int32_t>& AudioCapabilities::getSupportedSampleRates() const {
return mSampleRates;
}
-const std::vector<Range<int>>&
+const std::vector<Range<int32_t>>&
AudioCapabilities::getSupportedSampleRateRanges() const {
return mSampleRateRanges;
}
-int AudioCapabilities::getMaxInputChannelCount() const {
- int overallMax = 0;
+int32_t AudioCapabilities::getMaxInputChannelCount() const {
+ int32_t overallMax = 0;
for (int i = mInputChannelRanges.size() - 1; i >= 0; i--) {
- int lmax = mInputChannelRanges[i].upper();
+ int32_t lmax = mInputChannelRanges[i].upper();
if (lmax > overallMax) {
overallMax = lmax;
}
@@ -50,10 +50,10 @@
return overallMax;
}
-int AudioCapabilities::getMinInputChannelCount() const {
- int overallMin = MAX_INPUT_CHANNEL_COUNT;
+int32_t AudioCapabilities::getMinInputChannelCount() const {
+ int32_t overallMin = MAX_INPUT_CHANNEL_COUNT;
for (int i = mInputChannelRanges.size() - 1; i >= 0; i--) {
- int lmin = mInputChannelRanges[i].lower();
+ int32_t lmin = mInputChannelRanges[i].lower();
if (lmin < overallMin) {
overallMin = lmin;
}
@@ -61,7 +61,7 @@
return overallMin;
}
-const std::vector<Range<int>>&
+const std::vector<Range<int32_t>>&
AudioCapabilities::getInputChannelCountRanges() const {
return mInputChannelRanges;
}
@@ -86,40 +86,41 @@
}
void AudioCapabilities::initWithPlatformLimits() {
- mBitrateRange = Range<int>(0, INT32_MAX);
- mInputChannelRanges.push_back(Range<int>(1, MAX_INPUT_CHANNEL_COUNT));
+ mBitrateRange = Range<int32_t>(0, INT32_MAX);
+ mInputChannelRanges.push_back(Range<int32_t>(1, MAX_INPUT_CHANNEL_COUNT));
- const int minSampleRate = base::GetIntProperty("ro.mediacodec.min_sample_rate", 7350);
- const int maxSampleRate = base::GetIntProperty("ro.mediacodec.max_sample_rate", 192000);
- mSampleRateRanges.push_back(Range<int>(minSampleRate, maxSampleRate));
+ const int32_t minSampleRate = base::GetIntProperty("ro.mediacodec.min_sample_rate", 7350);
+ const int32_t maxSampleRate = base::GetIntProperty("ro.mediacodec.max_sample_rate", 192000);
+ mSampleRateRanges.push_back(Range<int32_t>(minSampleRate, maxSampleRate));
}
-bool AudioCapabilities::supports(std::optional<int> sampleRate,
- std::optional<int> inputChannels) {
+bool AudioCapabilities::supports(std::optional<int32_t> sampleRate,
+ std::optional<int32_t> inputChannels) {
// channels and sample rates are checked orthogonally
if (inputChannels
&& !std::any_of(mInputChannelRanges.begin(), mInputChannelRanges.end(),
- [inputChannels](const Range<int> &a) { return a.contains(inputChannels.value()); })) {
+ [inputChannels](const Range<int32_t> &a) {
+ return a.contains(inputChannels.value()); })) {
return false;
}
if (sampleRate
&& !std::any_of(mSampleRateRanges.begin(), mSampleRateRanges.end(),
- [sampleRate](const Range<int> &a) { return a.contains(sampleRate.value()); })) {
+ [sampleRate](const Range<int32_t> &a) { return a.contains(sampleRate.value()); })) {
return false;
}
return true;
}
-bool AudioCapabilities::isSampleRateSupported(int sampleRate) {
- return supports(std::make_optional<int>(sampleRate), std::nullopt);
+bool AudioCapabilities::isSampleRateSupported(int32_t sampleRate) {
+ return supports(std::make_optional<int32_t>(sampleRate), std::nullopt);
}
-void AudioCapabilities::limitSampleRates(std::vector<int> rates) {
- std::vector<Range<int>> sampleRateRanges;
+void AudioCapabilities::limitSampleRates(std::vector<int32_t> rates) {
+ std::vector<Range<int32_t>> sampleRateRanges;
std::sort(rates.begin(), rates.end());
- for (int rate : rates) {
- if (supports(std::make_optional<int>(rate), std::nullopt /* channels */)) {
- sampleRateRanges.push_back(Range<int>(rate, rate));
+ for (int32_t rate : rates) {
+ if (supports(std::make_optional<int32_t>(rate), std::nullopt /* channels */)) {
+ sampleRateRanges.push_back(Range<int32_t>(rate, rate));
}
}
mSampleRateRanges = intersectSortedDistinctRanges(mSampleRateRanges, sampleRateRanges);
@@ -133,11 +134,11 @@
}
}
-void AudioCapabilities::limitSampleRates(std::vector<Range<int>> rateRanges) {
+void AudioCapabilities::limitSampleRates(std::vector<Range<int32_t>> rateRanges) {
sortDistinctRanges(&rateRanges);
mSampleRateRanges = intersectSortedDistinctRanges(mSampleRateRanges, rateRanges);
// check if all values are discrete
- for (Range<int> range: mSampleRateRanges) {
+ for (Range<int32_t> range: mSampleRateRanges) {
if (range.lower() != range.upper()) {
mSampleRates.clear();
return;
@@ -147,10 +148,10 @@
}
void AudioCapabilities::applyLevelLimits() {
- std::vector<int> sampleRates;
- std::optional<Range<int>> sampleRateRange;
- std::optional<Range<int>> bitRates;
- int maxChannels = MAX_INPUT_CHANNEL_COUNT;
+ std::vector<int32_t> sampleRates;
+ std::optional<Range<int32_t>> sampleRateRange;
+ std::optional<Range<int32_t>> bitRates;
+ int32_t maxChannels = MAX_INPUT_CHANNEL_COUNT;
// const char *mediaType = mMediaType.c_str();
if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_MPEG)) {
@@ -158,15 +159,15 @@
8000, 11025, 12000,
16000, 22050, 24000,
32000, 44100, 48000 };
- bitRates = Range<int>(8000, 320000);
+ bitRates = Range<int32_t>(8000, 320000);
maxChannels = 2;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AMR_NB)) {
sampleRates = { 8000 };
- bitRates = Range<int>(4750, 12200);
+ bitRates = Range<int32_t>(4750, 12200);
maxChannels = 1;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AMR_WB)) {
sampleRates = { 16000 };
- bitRates = Range<int>(6600, 23850);
+ bitRates = Range<int32_t>(6600, 23850);
maxChannels = 1;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AAC)) {
sampleRates = {
@@ -175,32 +176,32 @@
22050, 24000, 32000,
44100, 48000, 64000,
88200, 96000 };
- bitRates = Range<int>(8000, 510000);
+ bitRates = Range<int32_t>(8000, 510000);
maxChannels = 48;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_VORBIS)) {
- bitRates = Range<int>(32000, 500000);
- sampleRateRange = Range<int>(8000, 192000);
+ bitRates = Range<int32_t>(32000, 500000);
+ sampleRateRange = Range<int32_t>(8000, 192000);
maxChannels = 255;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_OPUS)) {
- bitRates = Range<int>(6000, 510000);
+ bitRates = Range<int32_t>(6000, 510000);
sampleRates = { 8000, 12000, 16000, 24000, 48000 };
maxChannels = 255;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_RAW)) {
- sampleRateRange = Range<int>(1, 192000);
- bitRates = Range<int>(1, 10000000);
+ sampleRateRange = Range<int32_t>(1, 192000);
+ bitRates = Range<int32_t>(1, 10000000);
maxChannels = MAX_NUM_CHANNELS;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_FLAC)) {
- sampleRateRange = Range<int>(1, 655350);
+ sampleRateRange = Range<int32_t>(1, 655350);
// lossless codec, so bitrate is ignored
maxChannels = 255;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_G711_ALAW)
|| base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_G711_MLAW)) {
sampleRates = { 8000 };
- bitRates = Range<int>(64000, 64000);
+ bitRates = Range<int32_t>(64000, 64000);
// platform allows multiple channels for this format
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_MSGSM)) {
sampleRates = { 8000 };
- bitRates = Range<int>(13000, 13000);
+ bitRates = Range<int32_t>(13000, 13000);
maxChannels = 1;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AC3)) {
maxChannels = 6;
@@ -208,34 +209,34 @@
maxChannels = 16;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_EAC3_JOC)) {
sampleRates = { 48000 };
- bitRates = Range<int>(32000, 6144000);
+ bitRates = Range<int32_t>(32000, 6144000);
maxChannels = 16;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AC4)) {
sampleRates = { 44100, 48000, 96000, 192000 };
- bitRates = Range<int>(16000, 2688000);
+ bitRates = Range<int32_t>(16000, 2688000);
maxChannels = 24;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_DTS)) {
sampleRates = { 44100, 48000 };
- bitRates = Range<int>(96000, 1524000);
+ bitRates = Range<int32_t>(96000, 1524000);
maxChannels = 6;
} else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_DTS_HD)) {
for (ProfileLevel profileLevel: mProfileLevels) {
switch (profileLevel.mProfile) {
case DTS_HDProfileLBR:
sampleRates = { 22050, 24000, 44100, 48000 };
- bitRates = Range<int>(32000, 768000);
+ bitRates = Range<int32_t>(32000, 768000);
break;
case DTS_HDProfileHRA:
case DTS_HDProfileMA:
sampleRates = { 44100, 48000, 88200, 96000, 176400, 192000 };
- bitRates = Range<int>(96000, 24500000);
+ bitRates = Range<int32_t>(96000, 24500000);
break;
default:
ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile,
mMediaType.c_str());
mError |= ERROR_CAPABILITIES_UNRECOGNIZED;
sampleRates = { 44100, 48000, 88200, 96000, 176400, 192000 };
- bitRates = Range<int>(96000, 24500000);
+ bitRates = Range<int32_t>(96000, 24500000);
}
}
maxChannels = 8;
@@ -244,12 +245,12 @@
switch (profileLevel.mProfile) {
case DTS_UHDProfileP2:
sampleRates = { 48000 };
- bitRates = Range<int>(96000, 768000);
+ bitRates = Range<int32_t>(96000, 768000);
maxChannels = 10;
break;
case DTS_UHDProfileP1:
sampleRates = { 44100, 48000, 88200, 96000, 176400, 192000 };
- bitRates = Range<int>(96000, 24500000);
+ bitRates = Range<int32_t>(96000, 24500000);
maxChannels = 32;
break;
default:
@@ -257,7 +258,7 @@
mMediaType.c_str());
mError |= ERROR_CAPABILITIES_UNRECOGNIZED;
sampleRates = { 44100, 48000, 88200, 96000, 176400, 192000 };
- bitRates = Range<int>(96000, 24500000);
+ bitRates = Range<int32_t>(96000, 24500000);
maxChannels = 32;
}
}
@@ -270,24 +271,24 @@
if (!sampleRates.empty()) {
limitSampleRates(sampleRates);
} else if (sampleRateRange) {
- std::vector<Range<int>> rateRanges = { sampleRateRange.value() };
+ std::vector<Range<int32_t>> rateRanges = { sampleRateRange.value() };
limitSampleRates(rateRanges);
}
- Range<int> channelRange = Range<int>(1, maxChannels);
- std::vector<Range<int>> inputChannels = { channelRange };
+ Range<int32_t> channelRange = Range<int32_t>(1, maxChannels);
+ std::vector<Range<int32_t>> inputChannels = { channelRange };
applyLimits(inputChannels, bitRates);
}
void AudioCapabilities::applyLimits(
- const std::vector<Range<int>> &inputChannels,
+ const std::vector<Range<int32_t>> &inputChannels,
const std::optional<Range<int32_t>> &bitRates) {
// clamp & make a local copy
- std::vector<Range<int>> inputChannelsCopy(inputChannels.size());
+ std::vector<Range<int32_t>> inputChannelsCopy(inputChannels.size());
for (int i = 0; i < inputChannels.size(); i++) {
- int lower = inputChannels[i].clamp(1);
- int upper = inputChannels[i].clamp(MAX_INPUT_CHANNEL_COUNT);
- inputChannelsCopy[i] = Range<int>(lower, upper);
+ int32_t lower = inputChannels[i].clamp(1);
+ int32_t upper = inputChannels[i].clamp(MAX_INPUT_CHANNEL_COUNT);
+ inputChannelsCopy[i] = Range<int32_t>(lower, upper);
}
// sort, intersect with existing, & save channel list
@@ -300,16 +301,16 @@
}
void AudioCapabilities::parseFromInfo(const sp<AMessage> &format) {
- int maxInputChannels = MAX_INPUT_CHANNEL_COUNT;
- std::vector<Range<int>> channels = { Range<int>(1, maxInputChannels) };
+ int32_t maxInputChannels = MAX_INPUT_CHANNEL_COUNT;
+ std::vector<Range<int32_t>> channels = { Range<int32_t>(1, maxInputChannels) };
std::optional<Range<int32_t>> bitRates = POSITIVE_INT32;
AString rateAString;
if (format->findString("sample-rate-ranges", &rateAString)) {
std::vector<std::string> rateStrings = base::Split(std::string(rateAString.c_str()), ",");
- std::vector<Range<int>> rateRanges;
+ std::vector<Range<int32_t>> rateRanges;
for (std::string rateString : rateStrings) {
- std::optional<Range<int>> rateRange = ParseIntRange(rateString);
+ std::optional<Range<int32_t>> rateRange = Range<int32_t>::Parse(rateString);
if (!rateRange) {
continue;
}
@@ -322,9 +323,9 @@
AString valueStr;
if (format->findString("channel-ranges", &valueStr)) {
std::vector<std::string> channelStrings = base::Split(std::string(valueStr.c_str()), ",");
- std::vector<Range<int>> channelRanges;
+ std::vector<Range<int32_t>> channelRanges;
for (std::string channelString : channelStrings) {
- std::optional<Range<int>> channelRange = ParseIntRange(channelString);
+ std::optional<Range<int32_t>> channelRange = Range<int32_t>::Parse(channelString);
if (!channelRange) {
continue;
}
@@ -332,24 +333,25 @@
}
channels = channelRanges;
} else if (format->findString("channel-range", &valueStr)) {
- std::optional<Range<int>> oneRange = ParseIntRange(std::string(valueStr.c_str()));
+ std::optional<Range<int32_t>> oneRange
+ = Range<int32_t>::Parse(std::string(valueStr.c_str()));
if (oneRange) {
channels = { oneRange.value() };
}
} else if (format->findString("max-channel-count", &valueStr)) {
maxInputChannels = std::atoi(valueStr.c_str());
if (maxInputChannels == 0) {
- channels = { Range<int>(0, 0) };
+ channels = { Range<int32_t>(0, 0) };
} else {
- channels = { Range<int>(1, maxInputChannels) };
+ channels = { Range<int32_t>(1, maxInputChannels) };
}
} else if ((mError & ERROR_CAPABILITIES_UNSUPPORTED) != 0) {
maxInputChannels = 0;
- channels = { Range<int>(0, 0) };
+ channels = { Range<int32_t>(0, 0) };
}
if (format->findString("bitrate-range", &valueStr)) {
- std::optional<Range<int32_t>> parsedBitrate = ParseIntRange(valueStr.c_str());
+ std::optional<Range<int32_t>> parsedBitrate = Range<int32_t>::Parse(valueStr.c_str());
if (parsedBitrate) {
bitRates = bitRates.value().intersect(parsedBitrate.value());
}
@@ -374,11 +376,11 @@
bool AudioCapabilities::supportsFormat(const sp<AMessage> &format) {
int32_t sampleRateValue;
- std::optional<int> sampleRate = format->findInt32(KEY_SAMPLE_RATE, &sampleRateValue)
- ? std::make_optional<int>(sampleRateValue) : std::nullopt;
+ std::optional<int32_t> sampleRate = format->findInt32(KEY_SAMPLE_RATE, &sampleRateValue)
+ ? std::make_optional<int32_t>(sampleRateValue) : std::nullopt;
int32_t channelsValue;
- std::optional<int> channels = format->findInt32(KEY_CHANNEL_COUNT, &channelsValue)
- ? std::make_optional<int>(channelsValue) : std::nullopt;
+ std::optional<int32_t> channels = format->findInt32(KEY_CHANNEL_COUNT, &channelsValue)
+ ? std::make_optional<int32_t>(channelsValue) : std::nullopt;
if (!supports(sampleRate, channels)) {
return false;
diff --git a/media/libmedia/CodecCapabilities.cpp b/media/libmedia/CodecCapabilities.cpp
index 87eb4bc..407d376 100644
--- a/media/libmedia/CodecCapabilities.cpp
+++ b/media/libmedia/CodecCapabilities.cpp
@@ -17,6 +17,7 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "CodecCapabilities"
+#include <android-base/strings.h>
#include <utils/Log.h>
#include <media/CodecCapabilities.h>
#include <media/CodecCapabilitiesUtils.h>
@@ -25,6 +26,58 @@
namespace android {
+static const int32_t HEVCHighTierLevels =
+ HEVCHighTierLevel1 | HEVCHighTierLevel2 | HEVCHighTierLevel21 | HEVCHighTierLevel3 |
+ HEVCHighTierLevel31 | HEVCHighTierLevel4 | HEVCHighTierLevel41 | HEVCHighTierLevel5 |
+ HEVCHighTierLevel51 | HEVCHighTierLevel52 | HEVCHighTierLevel6 | HEVCHighTierLevel61 |
+ HEVCHighTierLevel62;
+
+static const int32_t DEFAULT_MAX_SUPPORTED_INSTANCES = 32;
+static const int32_t MAX_SUPPORTED_INSTANCES_LIMIT = 256;
+
+// must not contain KEY_PROFILE
+static const std::set<std::pair<std::string, AMessage::Type>> AUDIO_LEVEL_CRITICAL_FORMAT_KEYS = {
+ // We don't set level-specific limits for audio codecs today. Key candidates would
+ // be sample rate, bit rate or channel count.
+ // MediaFormat.KEY_SAMPLE_RATE,
+ // MediaFormat.KEY_CHANNEL_COUNT,
+ // MediaFormat.KEY_BIT_RATE,
+ { KEY_MIME, AMessage::kTypeString }
+};
+
+// CodecCapabilities Features
+static const std::vector<Feature> DECODER_FEATURES = {
+ Feature(FEATURE_AdaptivePlayback, (1 << 0), true),
+ Feature(FEATURE_SecurePlayback, (1 << 1), false),
+ Feature(FEATURE_TunneledPlayback, (1 << 2), false),
+ Feature(FEATURE_PartialFrame, (1 << 3), false),
+ Feature(FEATURE_FrameParsing, (1 << 4), false),
+ Feature(FEATURE_MultipleFrames, (1 << 5), false),
+ Feature(FEATURE_DynamicTimestamp, (1 << 6), false),
+ Feature(FEATURE_LowLatency, (1 << 7), true),
+ // feature to exclude codec from REGULAR codec list
+ Feature(FEATURE_SpecialCodec, (1 << 30), false, true),
+};
+static const std::vector<Feature> ENCODER_FEATURES = {
+ Feature(FEATURE_IntraRefresh, (1 << 0), false),
+ Feature(FEATURE_MultipleFrames, (1 << 1), false),
+ Feature(FEATURE_DynamicTimestamp, (1 << 2), false),
+ Feature(FEATURE_QpBounds, (1 << 3), false),
+ Feature(FEATURE_EncodingStatistics, (1 << 4), false),
+ Feature(FEATURE_HdrEditing, (1 << 5), false),
+ // feature to exclude codec from REGULAR codec list
+ Feature(FEATURE_SpecialCodec, (1 << 30), false, true),
+};
+
+// must not contain KEY_PROFILE
+static const std::set<std::pair<std::string, AMessage::Type>> VIDEO_LEVEL_CRITICAL_FORMAT_KEYS = {
+ { KEY_WIDTH, AMessage::kTypeInt32 },
+ { KEY_HEIGHT, AMessage::kTypeInt32 },
+ { KEY_FRAME_RATE, AMessage::kTypeInt32 },
+ { KEY_BIT_RATE, AMessage::kTypeInt32 },
+ { KEY_MIME, AMessage::kTypeString }
+};
+
bool CodecCapabilities::SupportsBitrate(Range<int32_t> bitrateRange,
const sp<AMessage> &format) {
// consider max bitrate over average bitrate for support
@@ -46,6 +99,212 @@
return true;
}
+bool CodecCapabilities::isFeatureSupported(const std::string &name) const {
+ return mFeaturesSupported.contains(name);
+}
+
+bool CodecCapabilities::isFeatureRequired(const std::string &name) const {
+ return mFeaturesRequired.contains(name);
+}
+
+std::vector<std::string> CodecCapabilities::validFeatures() const {
+ std::vector<std::string> res;
+ for (const Feature& feature : getValidFeatures()) {
+ if (!feature.mInternal) {
+ res.push_back(feature.mName);
+ }
+ }
+ return res;
+}
+
+std::vector<Feature> CodecCapabilities::getValidFeatures() const {
+ if (isEncoder()) {
+ return ENCODER_FEATURES;
+ } else {
+ return DECODER_FEATURES;
+ }
+}
+
+bool CodecCapabilities::isRegular() const {
+ // regular codecs only require default features
+ std::vector<Feature> features = getValidFeatures();
+ return std::all_of(features.begin(), features.end(),
+ [this](Feature feat){ return (feat.mDefault || !isFeatureRequired(feat.mName)); });
+}
+
+bool CodecCapabilities::isFormatSupported(const sp<AMessage> &format) const {
+ AString mediaType;
+ format->findString(KEY_MIME, &mediaType);
+ // mediaType must match if present
+ if (!base::EqualsIgnoreCase(mMediaType, mediaType.c_str())) {
+ return false;
+ }
+
+ // check feature support
+ for (Feature feat: getValidFeatures()) {
+ if (feat.mInternal) {
+ continue;
+ }
+
+ int32_t yesNo;
+ std::string key = KEY_FEATURE_;
+ key = key + feat.mName;
+ if (format->findInt32(key.c_str(), &yesNo)) {
+ continue;
+ }
+ if ((yesNo == 1 && !isFeatureSupported(feat.mName)) ||
+ (yesNo == 0 && isFeatureRequired(feat.mName))) {
+ return false;
+ }
+ }
+
+ int32_t profile;
+ if (format->findInt32(KEY_PROFILE, &profile)) {
+ int32_t level = -1;
+ format->findInt32(KEY_LEVEL, &level);
+ if (!supportsProfileLevel(profile, level)) {
+ return false;
+ }
+
+ // If we recognize this profile, check that this format is supported by the
+ // highest level supported by the codec for that profile. (Ignore specified
+ // level beyond the above profile/level check as level is only used as a
+ // guidance. E.g. AVC Level 1 CIF format is supported if codec supports level 1.1
+ // even though max size for Level 1 is QCIF. However, MPEG2 Simple Profile
+ // 1080p format is not supported even if codec supports Main Profile Level High,
+ // as Simple Profile does not support 1080p.
+ int32_t maxLevel = 0;
+ for (ProfileLevel pl : mProfileLevels) {
+ if (pl.mProfile == profile && pl.mLevel > maxLevel) {
+ // H.263 levels are not completely ordered:
+ // Level45 support only implies Level10 support
+ if (!base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_H263)
+ || pl.mLevel != H263Level45
+ || maxLevel == H263Level10) {
+ maxLevel = pl.mLevel;
+ }
+ }
+ }
+ std::shared_ptr<CodecCapabilities> levelCaps
+ = CreateFromProfileLevel(mMediaType, profile, maxLevel);
+ // We must remove the profile from this format otherwise levelCaps.isFormatSupported
+ // will get into this same condition and loop forever. Furthermore, since levelCaps
+ // does not contain features and bitrate specific keys, keep only keys relevant for
+ // a level check.
+ sp<AMessage> levelCriticalFormat = new AMessage;
+
+ // critical keys will always contain KEY_MIME, but should also contain others to be
+ // meaningful
+ if ((isVideo() || isAudio()) && levelCaps != nullptr) {
+ const std::set<std::pair<std::string, AMessage::Type>> criticalKeys =
+ isVideo() ? VIDEO_LEVEL_CRITICAL_FORMAT_KEYS : AUDIO_LEVEL_CRITICAL_FORMAT_KEYS;
+ for (std::pair<std::string, AMessage::Type> key : criticalKeys) {
+ if (format->contains(key.first.c_str())) {
+ // AMessage::ItemData value = format->findItem(key.c_str());
+ // levelCriticalFormat->setItem(key.c_str(), value);
+ switch (key.second) {
+ case AMessage::kTypeInt32: {
+ int32_t value;
+ format->findInt32(key.first.c_str(), &value);
+ levelCriticalFormat->setInt32(key.first.c_str(), value);
+ break;
+ }
+ case AMessage::kTypeString: {
+ AString value;
+ format->findString(key.first.c_str(), &value);
+ levelCriticalFormat->setString(key.first.c_str(), value);
+ break;
+ }
+ default:
+ ALOGE("Unsupported type");
+ }
+ }
+ }
+ if (!levelCaps->isFormatSupported(levelCriticalFormat)) {
+ return false;
+ }
+ }
+ }
+ if (mAudioCaps && !mAudioCaps->supportsFormat(format)) {
+ return false;
+ }
+ if (mVideoCaps && !mVideoCaps->supportsFormat(format)) {
+ return false;
+ }
+ if (mEncoderCaps && !mEncoderCaps->supportsFormat(format)) {
+ return false;
+ }
+ return true;
+}
+
+bool CodecCapabilities::supportsProfileLevel(int32_t profile, int32_t level) const {
+ for (ProfileLevel pl: mProfileLevels) {
+ if (pl.mProfile != profile) {
+ continue;
+ }
+
+ // No specific level requested
+ if (level == -1) {
+ return true;
+ }
+
+ // AAC doesn't use levels
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AAC)) {
+ return true;
+ }
+
+ // DTS doesn't use levels
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_DTS)
+ || base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_DTS_HD)
+ || base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_DTS_UHD)) {
+ return true;
+ }
+
+ // H.263 levels are not completely ordered:
+ // Level45 support only implies Level10 support
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_H263)) {
+ if (pl.mLevel != level && pl.mLevel == H263Level45
+ && level > H263Level10) {
+ continue;
+ }
+ }
+
+ // MPEG4 levels are not completely ordered:
+ // Level1 support only implies Level0 (and not Level0b) support
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_MPEG4)) {
+ if (pl.mLevel != level && pl.mLevel == MPEG4Level1
+ && level > MPEG4Level0) {
+ continue;
+ }
+ }
+
+ // HEVC levels incorporate both tiers and levels. Verify tier support.
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_HEVC)) {
+ bool supportsHighTier =
+ (pl.mLevel & HEVCHighTierLevels) != 0;
+ bool checkingHighTier = (level & HEVCHighTierLevels) != 0;
+ // high tier levels are only supported by other high tier levels
+ if (checkingHighTier && !supportsHighTier) {
+ continue;
+ }
+ }
+
+ if (pl.mLevel >= level) {
+ // if we recognize the listed profile/level, we must also recognize the
+ // profile/level arguments.
+ if (CreateFromProfileLevel(mMediaType, profile, pl.mLevel) != nullptr) {
+ return CreateFromProfileLevel(mMediaType, profile, level) != nullptr;
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+sp<AMessage> CodecCapabilities::getDefaultFormat() const {
+ return mDefaultFormat;
+}
+
const std::string& CodecCapabilities::getMediaType() {
return mMediaType;
}
@@ -54,4 +313,130 @@
return mProfileLevels;
}
+std::vector<uint32_t> CodecCapabilities::getColorFormats() const {
+ return mColorFormats;
+}
+
+int32_t CodecCapabilities::getMaxSupportedInstances() const {
+ return mMaxSupportedInstances;
+}
+
+bool CodecCapabilities::isAudio() const {
+ return mAudioCaps != nullptr;
+}
+
+std::shared_ptr<AudioCapabilities>
+ CodecCapabilities::getAudioCapabilities() const {
+ return mAudioCaps;
+}
+
+bool CodecCapabilities::isEncoder() const {
+ return mEncoderCaps != nullptr;
+}
+
+std::shared_ptr<EncoderCapabilities>
+ CodecCapabilities::getEncoderCapabilities() const {
+ return mEncoderCaps;
+}
+
+bool CodecCapabilities::isVideo() const {
+ return mVideoCaps != nullptr;
+}
+
+std::shared_ptr<VideoCapabilities> CodecCapabilities::getVideoCapabilities() const {
+ return mVideoCaps;
+}
+
+// static
+std::shared_ptr<CodecCapabilities> CodecCapabilities::CreateFromProfileLevel(
+ std::string mediaType, int32_t profile, int32_t level, int32_t maxConcurrentInstances) {
+ ProfileLevel pl;
+ pl.mProfile = profile;
+ pl.mLevel = level;
+ sp<AMessage> defaultFormat = new AMessage;
+ defaultFormat->setString(KEY_MIME, mediaType.c_str());
+
+ std::vector<ProfileLevel> pls;
+ pls.push_back(pl);
+ std::vector<uint32_t> colFmts;
+ sp<AMessage> capabilitiesInfo = new AMessage;
+ std::shared_ptr<CodecCapabilities> ret(new CodecCapabilities());
+ ret->init(pls, colFmts, true /* encoder */, defaultFormat, capabilitiesInfo,
+ maxConcurrentInstances);
+ if (ret->getErrors() != 0) {
+ return nullptr;
+ }
+ return ret;
+}
+
+void CodecCapabilities::init(std::vector<ProfileLevel> profLevs, std::vector<uint32_t> colFmts,
+ bool encoder, sp<AMessage> &defaultFormat, sp<AMessage> &capabilitiesInfo,
+ int32_t maxConcurrentInstances) {
+ mColorFormats = colFmts;
+ mDefaultFormat = defaultFormat;
+ mCapabilitiesInfo = capabilitiesInfo;
+
+ AString mediaTypeAStr;
+ mDefaultFormat->findString(KEY_MIME, &mediaTypeAStr);
+ mMediaType = mediaTypeAStr.c_str();
+
+ /* VP9 introduced profiles around 2016, so some VP9 codecs may not advertise any
+ supported profiles. Determine the level for them using the info they provide. */
+ if (profLevs.size() == 0 && mMediaType == MIMETYPE_VIDEO_VP9) {
+ ProfileLevel profLev;
+ profLev.mProfile = VP9Profile0;
+ profLev.mLevel = VideoCapabilities::EquivalentVP9Level(capabilitiesInfo);
+ profLevs.push_back(profLev);
+ }
+ mProfileLevels = profLevs;
+
+ if (mediaTypeAStr.startsWithIgnoreCase("audio/")) {
+ mAudioCaps = AudioCapabilities::Create(mMediaType, profLevs, capabilitiesInfo);
+ mAudioCaps->getDefaultFormat(mDefaultFormat);
+ } else if (mediaTypeAStr.startsWithIgnoreCase("video/")
+ || mediaTypeAStr.equalsIgnoreCase(MIMETYPE_IMAGE_ANDROID_HEIC)) {
+ mVideoCaps = VideoCapabilities::Create(mMediaType, profLevs, capabilitiesInfo);
+ }
+
+ if (encoder) {
+ mEncoderCaps = EncoderCapabilities::Create(mMediaType, profLevs, capabilitiesInfo);
+ mEncoderCaps->getDefaultFormat(mDefaultFormat);
+ }
+
+ mMaxSupportedInstances = maxConcurrentInstances > 0
+ ? maxConcurrentInstances : DEFAULT_MAX_SUPPORTED_INSTANCES;
+
+ int32_t maxInstances = mMaxSupportedInstances;
+ capabilitiesInfo->findInt32("max-concurrent-instances", &maxInstances);
+ mMaxSupportedInstances =
+ Range(1, MAX_SUPPORTED_INSTANCES_LIMIT).clamp(maxInstances);
+
+ mFeaturesRequired.clear();
+ mFeaturesSupported.clear();
+ for (Feature feat: getValidFeatures()) {
+ std::string key = KEY_FEATURE_;
+ key = key + feat.mName;
+ int yesNo = -1;
+ if (!capabilitiesInfo->findInt32(key.c_str(), &yesNo)) {
+ continue;
+ }
+ if (yesNo > 0) {
+ mFeaturesRequired.insert(feat.mName);
+ }
+ mFeaturesSupported.insert(feat.mName);
+ if (!feat.mInternal) {
+ mDefaultFormat->setInt32(key.c_str(), 1);
+ }
+ }
+}
+
+int32_t CodecCapabilities::getErrors() const {
+ if (mAudioCaps) {
+ return mAudioCaps->mError;
+ } else if (mVideoCaps) {
+ return mVideoCaps->mError;
+ }
+ return 0;
+}
+
} // namespace android
\ No newline at end of file
diff --git a/media/libmedia/CodecCapabilitiesUtils.cpp b/media/libmedia/CodecCapabilitiesUtils.cpp
index edfc9be..01bb24e 100644
--- a/media/libmedia/CodecCapabilitiesUtils.cpp
+++ b/media/libmedia/CodecCapabilitiesUtils.cpp
@@ -16,38 +16,146 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "CodecCapabilitiesUtils"
+
+#include <android-base/properties.h>
#include <utils/Log.h>
#include <algorithm>
#include <cmath>
-#include <regex>
+#include <cstdlib>
#include <string>
#include <vector>
#include <media/CodecCapabilitiesUtils.h>
-
+#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AUtils.h>
namespace android {
-std::optional<Range<int>> ParseIntRange(const std::string &str) {
+// VideoSize
+
+VideoSize::VideoSize(int32_t width, int32_t height) : mWidth(width), mHeight(height) {}
+
+VideoSize::VideoSize() : mWidth(0), mHeight(0) {}
+
+int32_t VideoSize::getWidth() const { return mWidth; }
+
+int32_t VideoSize::getHeight() const { return mHeight; }
+
+bool VideoSize::equals(VideoSize other) const {
+ return mWidth == other.mWidth && mHeight == other.mHeight;
+}
+
+bool VideoSize::empty() const {
+ return mWidth <= 0 || mHeight <= 0;
+}
+
+std::string VideoSize::toString() const {
+ return std::to_string(mWidth) + "x" + std::to_string(mHeight);
+}
+
+std::optional<VideoSize> VideoSize::ParseSize(std::string str) {
if (str.empty()) {
- ALOGW("could not parse empty integer range");
return std::nullopt;
}
- int lower, upper;
- std::regex regex("([0-9]+)-([0-9]+)");
+
+ std::regex regex("([0-9]+)([*x])([0-9]+)");
std::smatch match;
if (std::regex_match(str, match, regex)) {
- lower = std::atoi(match[1].str().c_str());
- upper = std::atoi(match[2].str().c_str());
- } else if (std::atoi(str.c_str()) != 0) {
- lower = upper = std::atoi(str.c_str());
+ long int w = strtol(match[1].str().c_str(), NULL, 10);
+ long int h = strtol(match[3].str().c_str(), NULL, 10);
+ return std::make_optional(VideoSize(w, h));
} else {
- ALOGW("could not parse integer range: %s", str.c_str());
+ ALOGW("could not parse size %s", str.c_str());
return std::nullopt;
}
- return std::make_optional<Range<int>>(lower, upper);
+}
+
+std::optional<std::pair<VideoSize, VideoSize>> VideoSize::ParseSizeRange(const std::string str) {
+ size_t ix = str.find_first_of('-');
+ if (ix != std::string::npos) {
+ std::optional<VideoSize> lowerOpt = VideoSize::ParseSize(str.substr(0, ix));
+ std::optional<VideoSize> upperOpt = VideoSize::ParseSize(str.substr(ix + 1));
+ if (!lowerOpt || !upperOpt) {
+ return std::nullopt;
+ }
+ return std::make_optional(
+ std::pair<VideoSize, VideoSize>(lowerOpt.value(), upperOpt.value()));
+ } else {
+ std::optional<VideoSize> opt = VideoSize::ParseSize(str);
+ if (!opt) {
+ return std::nullopt;
+ }
+ return std::make_optional(std::pair<VideoSize, VideoSize>(opt.value(), opt.value()));
+ }
+}
+
+Range<int32_t> VideoSize::GetAllowedDimensionRange() {
+#ifdef __LP64__
+ return Range<int32_t>(1, 32768);
+#else
+ int32_t value = base::GetIntProperty("media.resolution.limit.32bit", (int32_t)4096);
+ return Range<int32_t>(1, value);
+#endif
+}
+
+// Rational
+
+std::optional<Rational> Rational::Parse(std::string str) {
+ if (str.compare("NaN") == 0) {
+ return std::make_optional(NaN);
+ } else if (str.compare("Infinity") == 0) {
+ return std::make_optional(POSITIVE_INFINITY);
+ } else if (str.compare("-Infinity") == 0) {
+ return std::make_optional(NEGATIVE_INFINITY);
+ }
+
+ std::regex regex("([0-9]+)([:/])([0-9]+)");
+ std::smatch match;
+ if (std::regex_match(str, match, regex)) {
+ long int numerator = strtol(match[1].str().c_str(), NULL, 10);
+ long int denominator = strtol(match[3].str().c_str(), NULL, 10);
+ return std::make_optional(Rational(numerator, denominator));
+ } else {
+ ALOGW("could not parse string: %s to Rational", str.c_str());
+ return std::nullopt;
+ }
+}
+
+Rational Rational::scale(int32_t num, int32_t den) {
+ int32_t common = std::gcd(num, den);
+ num /= common;
+ den /= common;
+ return Rational(
+ (int32_t)(mNumerator * (double)num), // saturate to int
+ (int32_t)(mDenominator * (double)den)); // saturate to int
+}
+
+Range<Rational> Rational::ScaleRange(Range<Rational> range, int32_t num, int32_t den) {
+ if (num == den) {
+ return range;
+ }
+ return Range(
+ range.lower().scale(num, den),
+ range.upper().scale(num, den));
+}
+
+std::optional<Range<Rational>> Rational::ParseRange(const std::string str) {
+ size_t ix = str.find_first_of('-');
+ if (ix != std::string::npos) {
+ std::optional<Rational> lower = Parse(str.substr(0, ix));
+ std::optional<Rational> upper = Parse(str.substr(ix + 1));
+ if (!lower || !upper) {
+ return std::nullopt;
+ }
+ return std::make_optional<Range<Rational>>(lower.value(), upper.value());
+ } else {
+ std::optional<Rational> value = Parse(str);
+ if (!value) {
+ return std::nullopt;
+ }
+ return std::make_optional<Range<Rational>>(value.value(), value.value());
+ }
}
} // namespace android
\ No newline at end of file
diff --git a/media/libmedia/EncoderCapabilities.cpp b/media/libmedia/EncoderCapabilities.cpp
new file mode 100644
index 0000000..a840220
--- /dev/null
+++ b/media/libmedia/EncoderCapabilities.cpp
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2024, The Android Open Source Project
+ *
+ * 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.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "EncoderCapabilities"
+
+#include <android-base/strings.h>
+
+#include <media/CodecCapabilities.h>
+#include <media/EncoderCapabilities.h>
+#include <media/stagefright/MediaCodecConstants.h>
+
+namespace android {
+
+const Range<int>& EncoderCapabilities::getQualityRange() {
+ return mQualityRange;
+}
+
+const Range<int>& EncoderCapabilities::getComplexityRange() {
+ return mComplexityRange;
+}
+
+// static
+int EncoderCapabilities::ParseBitrateMode(std::string mode) {
+ for (Feature feat: sBitrateModes) {
+ if (base::EqualsIgnoreCase(feat.mName, mode)) {
+ return feat.mValue;
+ }
+ }
+ return 0;
+}
+
+bool EncoderCapabilities::isBitrateModeSupported(int mode) {
+ for (Feature feat : sBitrateModes) {
+ if (mode == feat.mValue) {
+ return (mBitControl & (1 << mode)) != 0;
+ }
+ }
+ return false;
+}
+
+// static
+std::shared_ptr<EncoderCapabilities> EncoderCapabilities::Create(std::string mediaType,
+ std::vector<ProfileLevel> profLevs, const sp<AMessage> &format) {
+ std::shared_ptr<EncoderCapabilities> caps(new EncoderCapabilities());
+ caps->init(mediaType, profLevs, format);
+ return caps;
+}
+
+void EncoderCapabilities::init(std::string mediaType, std::vector<ProfileLevel> profLevs,
+ const sp<AMessage> &format) {
+ // no support for complexity or quality yet
+ mMediaType = mediaType;
+ mProfileLevels = profLevs;
+ mComplexityRange = Range(0, 0);
+ mQualityRange = Range(0, 0);
+ mBitControl = (1 << BITRATE_MODE_VBR);
+
+ applyLevelLimits();
+ parseFromInfo(format);
+}
+
+void EncoderCapabilities::applyLevelLimits() {
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_FLAC)) {
+ mComplexityRange = Range(0, 8);
+ mBitControl = (1 << BITRATE_MODE_CQ);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AMR_NB)
+ || base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AMR_WB)
+ || base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_G711_ALAW)
+ || base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_G711_MLAW)
+ || base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_MSGSM)) {
+ mBitControl = (1 << BITRATE_MODE_CBR);
+ }
+}
+
+void EncoderCapabilities::parseFromInfo(const sp<AMessage> &format) {
+ AString complexityRangeAStr;
+ if (format->findString("complexity-range", &complexityRangeAStr)) {
+ std::optional<Range<int>> complexityRangeOpt
+ = Range<int32_t>::Parse(std::string(complexityRangeAStr.c_str()));
+ mComplexityRange = complexityRangeOpt.value_or(mComplexityRange);
+ // TODO should we limit this to level limits?
+ }
+ AString qualityRangeAStr;
+ if (format->findString("quality-range", &qualityRangeAStr)) {
+ std::optional<Range<int>> qualityRangeOpt
+ = Range<int32_t>::Parse(std::string(qualityRangeAStr.c_str()));
+ mQualityRange = qualityRangeOpt.value_or(mQualityRange);
+ }
+ AString bitrateModesAStr;
+ if (format->findString("feature-bitrate-modes", &bitrateModesAStr)) {
+ mBitControl = 0;
+ for (std::string mode: base::Split(std::string(bitrateModesAStr.c_str()), ",")) {
+ mBitControl |= (1 << ParseBitrateMode(mode));
+ }
+ }
+ format->findInt32("complexity-default", &mDefaultComplexity);
+ format->findInt32("quality-default", &mDefaultQuality);
+ AString qualityScaleAStr;
+ if (format->findString("quality-scale", &qualityScaleAStr)) {
+ mQualityScale = std::string(qualityScaleAStr.c_str());
+ }
+}
+
+bool EncoderCapabilities::supports(
+ std::optional<int> complexity, std::optional<int> quality, std::optional<int> profile) {
+ bool ok = true;
+ if (complexity) {
+ ok &= mComplexityRange.contains(complexity.value());
+ }
+ if (quality) {
+ ok &= mQualityRange.contains(quality.value());
+ }
+ if (profile) {
+ ok &= std::any_of(mProfileLevels.begin(), mProfileLevels.end(),
+ [&profile](ProfileLevel pl){ return pl.mProfile == profile.value(); });
+ }
+ return ok;
+}
+
+void EncoderCapabilities::getDefaultFormat(sp<AMessage> &format) {
+ // don't list trivial quality/complexity as default for now
+ if (mQualityRange.upper() != mQualityRange.lower()
+ && mDefaultQuality != 0) {
+ format->setInt32(KEY_QUALITY, mDefaultQuality);
+ }
+ if (mComplexityRange.upper() != mComplexityRange.lower()
+ && mDefaultComplexity != 0) {
+ format->setInt32(KEY_COMPLEXITY, mDefaultComplexity);
+ }
+ // bitrates are listed in order of preference
+ for (Feature feat : sBitrateModes) {
+ if ((mBitControl & (1 << feat.mValue)) != 0) {
+ format->setInt32(KEY_BITRATE_MODE, feat.mValue);
+ break;
+ }
+ }
+}
+
+bool EncoderCapabilities::supportsFormat(const sp<AMessage> &format) {
+ int32_t mode;
+ if (format->findInt32(KEY_BITRATE_MODE, &mode) && !isBitrateModeSupported(mode)) {
+ return false;
+ }
+
+ int tmp;
+ std::optional<int> complexity = std::nullopt;
+ if (format->findInt32(KEY_COMPLEXITY, &tmp)) {
+ complexity = tmp;
+ }
+
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_FLAC)) {
+ int flacComplexity;
+ if (format->findInt32(KEY_FLAC_COMPRESSION_LEVEL, &flacComplexity)) {
+ if (!complexity) {
+ complexity = flacComplexity;
+ } else if (flacComplexity != complexity.value()) {
+ ALOGE("Conflicting values for complexity and flac-compression-level,"
+ " which are %d and %d", complexity.value(), flacComplexity);
+ return false;
+ }
+ }
+ }
+
+ // other audio parameters
+ std::optional<int> profile = std::nullopt;
+ if (format->findInt32(KEY_PROFILE, &tmp)) {
+ profile = tmp;
+ }
+
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_AUDIO_AAC)) {
+ int aacProfile;
+ if (format->findInt32(KEY_AAC_PROFILE, &aacProfile)) {
+ if (!profile) {
+ profile = aacProfile;
+ } else if (aacProfile != profile.value()) {
+ ALOGE("Conflicting values for profile and aac-profile, which are %d and %d",
+ profile.value(), aacProfile);
+ return false;
+ }
+ }
+ }
+
+ std::optional<int> quality = std::nullopt;
+ if (format->findInt32(KEY_QUALITY, &tmp)) {
+ quality = tmp;
+ }
+
+ return supports(complexity, quality, profile);
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/media/libmedia/VideoCapabilities.cpp b/media/libmedia/VideoCapabilities.cpp
new file mode 100644
index 0000000..bd26b8c
--- /dev/null
+++ b/media/libmedia/VideoCapabilities.cpp
@@ -0,0 +1,1702 @@
+/*
+ * Copyright 2024, The Android Open Source Project
+ *
+ * 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.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "VideoCapabilities"
+
+#include <android-base/strings.h>
+
+#include <media/CodecCapabilities.h>
+#include <media/VideoCapabilities.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/MediaCodecConstants.h>
+
+#include <utils/Errors.h>
+
+namespace android {
+
+static const Range<int64_t> POSITIVE_INT64 = Range((int64_t)1, INT64_MAX);
+static const Range<int32_t> BITRATE_RANGE = Range<int32_t>(0, 500000000);
+static const Range<int32_t> FRAME_RATE_RANGE = Range<int32_t>(0, 960);
+static const Range<Rational> POSITIVE_RATIONALS =
+ Range<Rational>(Rational((int32_t)1, INT32_MAX), Rational(INT32_MAX, (int32_t)1));
+
+const Range<int32_t>& VideoCapabilities::getBitrateRange() const {
+ return mBitrateRange;
+}
+
+const Range<int32_t>& VideoCapabilities::getSupportedWidths() const {
+ return mWidthRange;
+}
+
+const Range<int32_t>& VideoCapabilities::getSupportedHeights() const {
+ return mHeightRange;
+}
+
+int32_t VideoCapabilities::getWidthAlignment() const {
+ return mWidthAlignment;
+}
+
+int32_t VideoCapabilities::getHeightAlignment() const {
+ return mHeightAlignment;
+}
+
+int32_t VideoCapabilities::getSmallerDimensionUpperLimit() const {
+ return mSmallerDimensionUpperLimit;
+}
+
+const Range<int32_t>& VideoCapabilities::getSupportedFrameRates() const {
+ return mFrameRateRange;
+}
+
+std::optional<Range<int32_t>> VideoCapabilities::getSupportedWidthsFor(int32_t height) const {
+ Range<int32_t> range = mWidthRange;
+ if (!mHeightRange.contains(height)
+ || (height % mHeightAlignment) != 0) {
+ ALOGE("unsupported height");
+ return std::nullopt;
+ }
+ const int32_t heightInBlocks = divUp(height, mBlockHeight);
+
+ // constrain by block count and by block aspect ratio
+ const int32_t minWidthInBlocks = std::max(
+ divUp(mBlockCountRange.lower(), heightInBlocks),
+ (int32_t)std::ceil(mBlockAspectRatioRange.lower().asDouble()
+ * heightInBlocks));
+ const int32_t maxWidthInBlocks = std::min(
+ mBlockCountRange.upper() / heightInBlocks,
+ (int32_t)(mBlockAspectRatioRange.upper().asDouble()
+ * heightInBlocks));
+ range = range.intersect(
+ (minWidthInBlocks - 1) * mBlockWidth + mWidthAlignment,
+ maxWidthInBlocks * mBlockWidth);
+
+ // constrain by smaller dimension limit
+ if (height > mSmallerDimensionUpperLimit) {
+ range = range.intersect(1, mSmallerDimensionUpperLimit);
+ }
+
+ // constrain by aspect ratio
+ range = range.intersect(
+ (int32_t)std::ceil(mAspectRatioRange.lower().asDouble()
+ * height),
+ (int32_t)(mAspectRatioRange.upper().asDouble() * height));
+ return range;
+}
+
+std::optional<Range<int32_t>> VideoCapabilities::getSupportedHeightsFor(int32_t width) const {
+ Range<int32_t> range = mHeightRange;
+ if (!mWidthRange.contains(width)
+ || (width % mWidthAlignment) != 0) {
+ ALOGE("unsupported width");
+ return std::nullopt;
+ }
+ const int32_t widthInBlocks = divUp(width, mBlockWidth);
+
+ // constrain by block count and by block aspect ratio
+ const int32_t minHeightInBlocks = std::max(
+ divUp(mBlockCountRange.lower(), widthInBlocks),
+ (int32_t)std::ceil(widthInBlocks /
+ mBlockAspectRatioRange.upper().asDouble()));
+ const int32_t maxHeightInBlocks = std::min(
+ mBlockCountRange.upper() / widthInBlocks,
+ (int32_t)(widthInBlocks /
+ mBlockAspectRatioRange.lower().asDouble()));
+ range = range.intersect(
+ (minHeightInBlocks - 1) * mBlockHeight + mHeightAlignment,
+ maxHeightInBlocks * mBlockHeight);
+
+ // constrain by smaller dimension limit
+ if (width > mSmallerDimensionUpperLimit) {
+ range = range.intersect(1, mSmallerDimensionUpperLimit);
+ }
+
+ // constrain by aspect ratio
+ range = range.intersect(
+ (int32_t)std::ceil(width /
+ mAspectRatioRange.upper().asDouble()),
+ (int32_t)(width / mAspectRatioRange.lower().asDouble()));
+ return range;
+}
+
+std::optional<Range<double>> VideoCapabilities::getSupportedFrameRatesFor(
+ int32_t width, int32_t height) const {
+ if (!supports(std::make_optional<int32_t>(width), std::make_optional<int32_t>(height),
+ std::nullopt /* rate */)) {
+ ALOGE("Unsupported size. width: %d, height: %d", width, height);
+ return std::nullopt;
+ }
+
+ const int32_t blockCount =
+ divUp(width, mBlockWidth) * divUp(height, mBlockHeight);
+
+ return std::make_optional(Range(
+ std::max(mBlocksPerSecondRange.lower() / (double) blockCount,
+ (double) mFrameRateRange.lower()),
+ std::min(mBlocksPerSecondRange.upper() / (double) blockCount,
+ (double) mFrameRateRange.upper())));
+}
+
+int32_t VideoCapabilities::getBlockCount(int32_t width, int32_t height) const {
+ return divUp(width, mBlockWidth) * divUp(height, mBlockHeight);
+}
+
+std::optional<VideoSize> VideoCapabilities::findClosestSize(
+ int32_t width, int32_t height) const {
+ int32_t targetBlockCount = getBlockCount(width, height);
+ std::optional<VideoSize> closestSize;
+ int32_t minDiff = INT32_MAX;
+ for (const auto &[size, range] : mMeasuredFrameRates) {
+ int32_t diff = std::abs(targetBlockCount -
+ getBlockCount(size.getWidth(), size.getHeight()));
+ if (diff < minDiff) {
+ minDiff = diff;
+ closestSize = size;
+ }
+ }
+ return closestSize;
+}
+
+std::optional<Range<double>> VideoCapabilities::estimateFrameRatesFor(
+ int32_t width, int32_t height) const {
+ std::optional<VideoSize> size = findClosestSize(width, height);
+ if (!size) {
+ return std::nullopt;
+ }
+ auto rangeItr = mMeasuredFrameRates.find(size.value());
+ if (rangeItr == mMeasuredFrameRates.end()) {
+ return std::nullopt;
+ }
+ Range<int64_t> range = rangeItr->second;
+ double ratio = getBlockCount(size.value().getWidth(), size.value().getHeight())
+ / (double)std::max(getBlockCount(width, height), 1);
+ return std::make_optional(Range(range.lower() * ratio, range.upper() * ratio));
+}
+
+std::optional<Range<double>> VideoCapabilities::getAchievableFrameRatesFor(
+ int32_t width, int32_t height) const {
+ if (!supports(std::make_optional<int32_t>(width), std::make_optional<int32_t>(height),
+ std::nullopt /* rate */)) {
+ ALOGE("Unsupported size. width: %d, height: %d", width, height);
+ return std::nullopt;
+ }
+
+ if (mMeasuredFrameRates.empty()) {
+ ALOGW("Codec did not publish any measurement data.");
+ return std::nullopt;
+ }
+
+ return estimateFrameRatesFor(width, height);
+}
+
+// VideoCapabilities::PerformancePoint
+
+int32_t VideoCapabilities::PerformancePoint::getMaxMacroBlocks() const {
+ return saturateInt64ToInt32(mWidth * (int64_t)mHeight);
+}
+
+int32_t VideoCapabilities::PerformancePoint::getWidth() const {
+ return mWidth;
+}
+
+int32_t VideoCapabilities::PerformancePoint::getHeight() const {
+ return mHeight;
+}
+
+int32_t VideoCapabilities::PerformancePoint::getMaxFrameRate() const {
+ return mMaxFrameRate;
+}
+
+int64_t VideoCapabilities::PerformancePoint::getMaxMacroBlockRate() const {
+ return mMaxMacroBlockRate;
+}
+
+VideoSize VideoCapabilities::PerformancePoint::getBlockSize() const {
+ return mBlockSize;
+}
+
+std::string VideoCapabilities::PerformancePoint::toString() const {
+ int64_t blockWidth = 16 * (int64_t)mBlockSize.getWidth();
+ int64_t blockHeight = 16 * (int64_t)mBlockSize.getHeight();
+ int32_t origRate = (int32_t)divUp(mMaxMacroBlockRate, (int64_t)getMaxMacroBlocks());
+ std::string info = std::to_string(mWidth * (int64_t)16) + "x"
+ + std::to_string(mHeight * (int64_t)16) + "@" + std::to_string(origRate);
+ if (origRate < mMaxFrameRate) {
+ info += ", max " + std::to_string(mMaxFrameRate) + "fps";
+ }
+ if (blockWidth > 16 || blockHeight > 16) {
+ info += ", " + std::to_string(blockWidth) + "x"
+ + std::to_string(blockHeight) + " blocks";
+ }
+ return "PerformancePoint(" + info + ")";
+}
+
+void VideoCapabilities::PerformancePoint::init(int32_t width, int32_t height,
+ int32_t frameRate, int32_t maxFrameRate, VideoSize blockSize) {
+ mBlockSize = VideoSize(divUp(blockSize.getWidth(), (int32_t)16),
+ divUp(blockSize.getHeight(), (int32_t)16));
+ // Use IsPowerOfTwoStrict as we do not want width and height to be 0;
+ if (!IsPowerOfTwoStrict(blockSize.getWidth()) || !IsPowerOfTwoStrict(blockSize.getHeight())) {
+ ALOGE("The width and height of a PerformancePoint must be the power of two and not zero."
+ " width: %d, height: %d", blockSize.getWidth(), blockSize.getHeight());
+ }
+
+ // these are guaranteed not to overflow as we decimate by 16
+ mWidth = (int32_t)(divUp(std::max(width, 1),
+ std::max(blockSize.getWidth(), 16))
+ * mBlockSize.getWidth());
+ mHeight = (int32_t)(divUp(std::max(height, 1),
+ std::max(blockSize.getHeight(), 16))
+ * mBlockSize.getHeight());
+ mMaxFrameRate = std::max(std::max(frameRate, maxFrameRate), 1);
+ mMaxMacroBlockRate = std::max(frameRate, 1) * (int64_t)getMaxMacroBlocks();
+}
+
+VideoCapabilities::PerformancePoint::PerformancePoint(int32_t width, int32_t height,
+ int32_t frameRate, int32_t maxFrameRate, VideoSize blockSize) {
+ init(width, height, frameRate, maxFrameRate, blockSize);
+}
+
+VideoCapabilities::PerformancePoint::PerformancePoint(VideoSize blockSize, int32_t width,
+ int32_t height, int32_t maxFrameRate, int64_t maxMacroBlockRate) :
+ mBlockSize(blockSize), mWidth(width), mHeight(height), mMaxFrameRate(maxFrameRate),
+ mMaxMacroBlockRate(maxMacroBlockRate) {}
+
+VideoCapabilities::PerformancePoint::PerformancePoint(
+ const PerformancePoint &pp, VideoSize newBlockSize) {
+ init(16 * pp.mWidth, 16 * pp.mHeight,
+ // guaranteed not to overflow as these were multiplied at construction
+ (int32_t)divUp(pp.mMaxMacroBlockRate, (int64_t)pp.getMaxMacroBlocks()),
+ pp.mMaxFrameRate,
+ VideoSize(std::max(newBlockSize.getWidth(), 16 * pp.mBlockSize.getWidth()),
+ std::max(newBlockSize.getHeight(), 16 * pp.mBlockSize.getHeight())));
+}
+
+VideoCapabilities::PerformancePoint::PerformancePoint(
+ int32_t width, int32_t height, int32_t frameRate) {
+ init(width, height, frameRate, frameRate /* maxFrameRate */, VideoSize(16, 16));
+}
+
+int32_t VideoCapabilities::PerformancePoint::saturateInt64ToInt32(int64_t value) const {
+ if (value < INT32_MIN) {
+ return INT32_MIN;
+ } else if (value > INT32_MAX) {
+ return INT32_MAX;
+ } else {
+ return (int32_t)value;
+ }
+}
+
+/* This method may overflow */
+int32_t VideoCapabilities::PerformancePoint::align(
+ int32_t value, int32_t alignment) const {
+ return divUp(value, alignment) * alignment;
+}
+
+bool VideoCapabilities::PerformancePoint::covers(
+ const sp<AMessage> &format) const {
+ int32_t width, height;
+ format->findInt32(KEY_WIDTH, &width);
+ format->findInt32(KEY_HEIGHT, &height);
+ double frameRate;
+ format->findDouble(KEY_FRAME_RATE, &frameRate);
+ PerformancePoint other = PerformancePoint(
+ width, height,
+ // safely convert ceil(double) to int through float cast and std::round
+ std::round((float)(std::ceil(frameRate)))
+ );
+ return covers(other);
+}
+
+bool VideoCapabilities::PerformancePoint::covers(
+ const PerformancePoint &other) const {
+ // convert performance points to common block size
+ VideoSize commonSize = getCommonBlockSize(other);
+ PerformancePoint aligned = PerformancePoint(*this, commonSize);
+ PerformancePoint otherAligned = PerformancePoint(other, commonSize);
+
+ return (aligned.getMaxMacroBlocks() >= otherAligned.getMaxMacroBlocks()
+ && aligned.mMaxFrameRate >= otherAligned.mMaxFrameRate
+ && aligned.mMaxMacroBlockRate >= otherAligned.mMaxMacroBlockRate);
+}
+
+VideoSize VideoCapabilities::PerformancePoint::getCommonBlockSize(
+ const PerformancePoint &other) const {
+ return VideoSize(
+ 16 * std::max(mBlockSize.getWidth(), other.mBlockSize.getWidth()),
+ 16 * std::max(mBlockSize.getHeight(), other.mBlockSize.getHeight()));
+}
+
+bool VideoCapabilities::PerformancePoint::equals(
+ const PerformancePoint &other) const {
+ // convert performance points to common block size
+ VideoSize commonSize = getCommonBlockSize(other);
+ PerformancePoint aligned = PerformancePoint(*this, commonSize);
+ PerformancePoint otherAligned = PerformancePoint(other, commonSize);
+
+ return (aligned.getMaxMacroBlocks() == otherAligned.getMaxMacroBlocks()
+ && aligned.mMaxFrameRate == otherAligned.mMaxFrameRate
+ && aligned.mMaxMacroBlockRate == otherAligned.mMaxMacroBlockRate);
+}
+
+// VideoCapabilities
+
+const std::vector<VideoCapabilities::PerformancePoint>&
+ VideoCapabilities::getSupportedPerformancePoints() const {
+ return mPerformancePoints;
+}
+
+bool VideoCapabilities::areSizeAndRateSupported(
+ int32_t width, int32_t height, double frameRate) const {
+ return supports(std::make_optional<int32_t>(width), std::make_optional<int32_t>(height),
+ std::make_optional<double>(frameRate));
+}
+
+bool VideoCapabilities::isSizeSupported(int32_t width, int32_t height) const {
+ return supports(std::make_optional<int32_t>(width), std::make_optional<int32_t>(height),
+ std::nullopt /* rate */);
+}
+
+bool VideoCapabilities::supports(std::optional<int32_t> width, std::optional<int32_t> height,
+ std::optional<double> rate) const {
+ bool ok = true;
+
+ if (width) {
+ ok &= mWidthRange.contains(width.value())
+ && (width.value() % mWidthAlignment == 0);
+ }
+ if (height) {
+ ok &= mHeightRange.contains(height.value())
+ && (height.value() % mHeightAlignment == 0);
+ }
+ if (rate) {
+ ok &= mFrameRateRange.contains(Range<int32_t>::RangeFor(rate.value()));
+ }
+ if (height && width) {
+ ok &= std::min(height.value(), width.value()) <= mSmallerDimensionUpperLimit;
+
+ const int32_t widthInBlocks = divUp(width.value(), mBlockWidth);
+ const int32_t heightInBlocks = divUp(height.value(), mBlockHeight);
+ const int32_t blockCount = widthInBlocks * heightInBlocks;
+ ok &= mBlockCountRange.contains(blockCount)
+ && mBlockAspectRatioRange.contains(
+ Rational(widthInBlocks, heightInBlocks))
+ && mAspectRatioRange.contains(Rational(width.value(), height.value()));
+ if (rate) {
+ double blocksPerSec = blockCount * rate.value();
+ ok &= mBlocksPerSecondRange.contains(
+ Range<int64_t>::RangeFor(blocksPerSec));
+ }
+ }
+ return ok;
+}
+
+bool VideoCapabilities::supportsFormat(const sp<AMessage> &format) const {
+ int32_t widthVal, heightVal;
+ std::optional<int32_t> width = format->findInt32(KEY_WIDTH, &widthVal)
+ ? std::make_optional<int32_t>(widthVal) : std::nullopt;
+ std::optional<int32_t> height = format->findInt32(KEY_HEIGHT, &heightVal)
+ ? std::make_optional<int32_t>(heightVal) : std::nullopt;
+ double rateVal;
+ std::optional<double> rate = format->findDouble(KEY_FRAME_RATE, &rateVal)
+ ? std::make_optional<double>(rateVal) : std::nullopt;
+
+ if (!supports(width, height, rate)) {
+ return false;
+ }
+
+ if (!CodecCapabilities::SupportsBitrate(mBitrateRange, format)) {
+ return false;
+ }
+
+ // we ignore color-format for now as it is not reliably reported by codec
+ return true;
+}
+
+// static
+std::shared_ptr<VideoCapabilities> VideoCapabilities::Create(std::string mediaType,
+ std::vector<ProfileLevel> profLevs, const sp<AMessage> &format) {
+ std::shared_ptr<VideoCapabilities> caps(new VideoCapabilities());
+ caps->init(mediaType, profLevs, format);
+ return caps;
+}
+
+void VideoCapabilities::init(std::string mediaType, std::vector<ProfileLevel> profLevs,
+ const sp<AMessage> &format) {
+ mMediaType = mediaType;
+ mProfileLevels = profLevs;
+ mError = 0;
+
+ initWithPlatformLimits();
+ applyLevelLimits();
+ parseFromInfo(format);
+ updateLimits();
+}
+
+VideoSize VideoCapabilities::getBlockSize() const {
+ return VideoSize(mBlockWidth, mBlockHeight);
+}
+
+const Range<int32_t>& VideoCapabilities::getBlockCountRange() const {
+ return mBlockCountRange;
+}
+
+const Range<int64_t>& VideoCapabilities::getBlocksPerSecondRange() const {
+ return mBlocksPerSecondRange;
+}
+
+Range<Rational> VideoCapabilities::getAspectRatioRange(bool blocks) const {
+ return blocks ? mBlockAspectRatioRange : mAspectRatioRange;
+}
+
+void VideoCapabilities::initWithPlatformLimits() {
+ mBitrateRange = BITRATE_RANGE;
+
+ mWidthRange = VideoSize::GetAllowedDimensionRange();
+ mHeightRange = VideoSize::GetAllowedDimensionRange();
+ mFrameRateRange = FRAME_RATE_RANGE;
+
+ mHorizontalBlockRange = VideoSize::GetAllowedDimensionRange();
+ mVerticalBlockRange = VideoSize::GetAllowedDimensionRange();
+
+ // full positive ranges are supported as these get calculated
+ mBlockCountRange = POSITIVE_INT32;
+ mBlocksPerSecondRange = POSITIVE_INT64;
+
+ mBlockAspectRatioRange = POSITIVE_RATIONALS;
+ mAspectRatioRange = POSITIVE_RATIONALS;
+
+ // YUV 4:2:0 requires 2:2 alignment
+ mWidthAlignment = 2;
+ mHeightAlignment = 2;
+ mBlockWidth = 2;
+ mBlockHeight = 2;
+ mSmallerDimensionUpperLimit = VideoSize::GetAllowedDimensionRange().upper();
+}
+
+std::vector<VideoCapabilities::PerformancePoint>
+ VideoCapabilities::getPerformancePoints(
+ const sp<AMessage> &format) const {
+ std::vector<PerformancePoint> ret;
+ AMessage::Type type;
+ for (int i = 0; i < format->countEntries(); i++) {
+ const char *name = format->getEntryNameAt(i, &type);
+ AString rangeStr;
+ if (!format->findString(name, &rangeStr)) {
+ continue;
+ }
+
+ const std::string key = std::string(name);
+ // looking for: performance-point-WIDTHxHEIGHT-range
+
+ // check none performance point
+ if (key == "performance-point-none" && ret.size() == 0) {
+ // This means that component knowingly did not publish performance points.
+ // This is different from when the component forgot to publish performance
+ // points.
+ return ret;
+ }
+
+ // parse size from key
+ std::regex sizeRegex("performance-point-(.+)-range");
+ std::smatch sizeMatch;
+ if (!std::regex_match(key, sizeMatch, sizeRegex)) {
+ continue;
+ }
+ std::optional<VideoSize> size = VideoSize::ParseSize(sizeMatch[1].str());
+ if (!size || size.value().getWidth() * size.value().getHeight() <= 0) {
+ continue;
+ }
+
+ // parse range from value
+ std::optional<Range<int64_t>> range = Range<int64_t>::Parse(std::string(rangeStr.c_str()));
+ if (!range || range.value().lower() < 0 || range.value().upper() < 0) {
+ continue;
+ }
+
+ PerformancePoint given = PerformancePoint(
+ size.value().getWidth(), size.value().getHeight(), (int32_t)range.value().lower(),
+ (int32_t)range.value().upper(), VideoSize(mBlockWidth, mBlockHeight));
+ PerformancePoint rotated = PerformancePoint(
+ size.value().getHeight(), size.value().getWidth(), (int32_t)range.value().lower(),
+ (int32_t)range.value().upper(), VideoSize(mBlockWidth, mBlockHeight));
+ ret.push_back(given);
+ if (!given.covers(rotated)) {
+ ret.push_back(rotated);
+ }
+ }
+
+ // check if the component specified no performance point indication
+ if (ret.size() == 0) {
+ return ret;
+ }
+
+ // sort reversed by area first, then by frame rate
+ std::sort(ret.begin(), ret.end(), [](const PerformancePoint &a, const PerformancePoint &b) {
+ return -((a.getMaxMacroBlocks() != b.getMaxMacroBlocks()) ?
+ (a.getMaxMacroBlocks() < b.getMaxMacroBlocks() ? -1 : 1) :
+ (a.getMaxMacroBlockRate() != b.getMaxMacroBlockRate()) ?
+ (a.getMaxMacroBlockRate() < b.getMaxMacroBlockRate() ? -1 : 1) :
+ (a.getMaxFrameRate() != b.getMaxFrameRate()) ?
+ (a.getMaxFrameRate() < b.getMaxFrameRate() ? -1 : 1) : 0);
+ });
+
+ return ret;
+}
+
+std::map<VideoSize, Range<int64_t>, VideoSizeCompare> VideoCapabilities
+ ::getMeasuredFrameRates(const sp<AMessage> &format) const {
+ std::map<VideoSize, Range<int64_t>, VideoSizeCompare> ret;
+ AMessage::Type type;
+ for (int i = 0; i < format->countEntries(); i++) {
+ const char *name = format->getEntryNameAt(i, &type);
+ AString rangeStr;
+ if (!format->findString(name, &rangeStr)) {
+ continue;
+ }
+
+ const std::string key = std::string(name);
+ // looking for: measured-frame-rate-WIDTHxHEIGHT-range
+
+ std::regex sizeRegex("measured-frame-rate-(.+)-range");
+ std::smatch sizeMatch;
+ if (!std::regex_match(key, sizeMatch, sizeRegex)) {
+ continue;
+ }
+
+ std::optional<VideoSize> size = VideoSize::ParseSize(sizeMatch[1].str());
+ if (!size || size.value().getWidth() * size.value().getHeight() <= 0) {
+ continue;
+ }
+
+ std::optional<Range<int64_t>> range = Range<int64_t>::Parse(std::string(rangeStr.c_str()));
+ if (!range || range.value().lower() < 0 || range.value().upper() < 0) {
+ continue;
+ }
+
+ ret.emplace(size.value(), range.value());
+ }
+ return ret;
+}
+
+// static
+std::optional<std::pair<Range<int32_t>, Range<int32_t>>> VideoCapabilities
+ ::ParseWidthHeightRanges(const std::string &str) {
+ std::optional<std::pair<VideoSize, VideoSize>> range = VideoSize::ParseSizeRange(str);
+ if (!range) {
+ ALOGW("could not parse size range: %s", str.c_str());
+ return std::nullopt;
+ }
+
+ return std::make_optional(std::pair(
+ Range(range.value().first.getWidth(), range.value().second.getWidth()),
+ Range(range.value().first.getHeight(), range.value().second.getHeight())));
+}
+
+// static
+int32_t VideoCapabilities::EquivalentVP9Level(const sp<AMessage> &format) {
+ int32_t blockSizeWidth = 8;
+ int32_t blockSizeHeight = 8;
+ // VideoSize *blockSizePtr = &VideoSize(8, 8);
+ AString blockSizeStr;
+ if (format->findString("block-size", &blockSizeStr)) {
+ std::optional<VideoSize> parsedBlockSize
+ = VideoSize::ParseSize(std::string(blockSizeStr.c_str()));
+ if (parsedBlockSize) {
+ // blockSize = parsedBlockSize.value();
+ blockSizeWidth = parsedBlockSize.value().getWidth();
+ blockSizeHeight = parsedBlockSize.value().getHeight();
+ }
+ }
+ int32_t BS = blockSizeWidth * blockSizeHeight;
+
+ int32_t FS = 0;
+ AString blockCountRangeStr;
+ if (format->findString("block-count-range", &blockCountRangeStr)) {
+ std::optional<Range<int>> counts = Range<int32_t>::Parse(
+ std::string(blockCountRangeStr.c_str()));
+ if (counts) {
+ FS = BS * counts.value().upper();
+ }
+ }
+
+ int64_t SR = 0;
+ AString blockRatesStr;
+ if (format->findString("blocks-per-second-range", &blockRatesStr)) {
+ std::optional<Range<int64_t>> blockRates
+ = Range<int64_t>::Parse(std::string(blockRatesStr.c_str()));
+ if (blockRates) {
+ // ToDo: Catch the potential overflow issue.
+ SR = BS * blockRates.value().upper();
+ }
+ }
+
+ int32_t D = 0;
+ AString dimensionRangesStr;
+ if (format->findString("size-range", &dimensionRangesStr)) {
+ std::optional<std::pair<Range<int>, Range<int>>> dimensionRanges =
+ ParseWidthHeightRanges(std::string(dimensionRangesStr.c_str()));
+ if (dimensionRanges) {
+ D = std::max(dimensionRanges.value().first.upper(),
+ dimensionRanges.value().second.upper());
+ }
+ }
+
+ int32_t BR = 0;
+ AString bitrateRangeStr;
+ if (format->findString("bitrate-range", &bitrateRangeStr)) {
+ std::optional<Range<int>> bitRates = Range<int32_t>::Parse(
+ std::string(bitrateRangeStr.c_str()));
+ if (bitRates) {
+ BR = divUp(bitRates.value().upper(), 1000);
+ }
+ }
+
+ if (SR <= 829440 && FS <= 36864 && BR <= 200 && D <= 512)
+ return VP9Level1;
+ if (SR <= 2764800 && FS <= 73728 && BR <= 800 && D <= 768)
+ return VP9Level11;
+ if (SR <= 4608000 && FS <= 122880 && BR <= 1800 && D <= 960)
+ return VP9Level2;
+ if (SR <= 9216000 && FS <= 245760 && BR <= 3600 && D <= 1344)
+ return VP9Level21;
+ if (SR <= 20736000 && FS <= 552960 && BR <= 7200 && D <= 2048)
+ return VP9Level3;
+ if (SR <= 36864000 && FS <= 983040 && BR <= 12000 && D <= 2752)
+ return VP9Level31;
+ if (SR <= 83558400 && FS <= 2228224 && BR <= 18000 && D <= 4160)
+ return VP9Level4;
+ if (SR <= 160432128 && FS <= 2228224 && BR <= 30000 && D <= 4160)
+ return VP9Level41;
+ if (SR <= 311951360 && FS <= 8912896 && BR <= 60000 && D <= 8384)
+ return VP9Level5;
+ if (SR <= 588251136 && FS <= 8912896 && BR <= 120000 && D <= 8384)
+ return VP9Level51;
+ if (SR <= 1176502272 && FS <= 8912896 && BR <= 180000 && D <= 8384)
+ return VP9Level52;
+ if (SR <= 1176502272 && FS <= 35651584 && BR <= 180000 && D <= 16832)
+ return VP9Level6;
+ if (SR <= 2353004544L && FS <= 35651584 && BR <= 240000 && D <= 16832)
+ return VP9Level61;
+ if (SR <= 4706009088L && FS <= 35651584 && BR <= 480000 && D <= 16832)
+ return VP9Level62;
+ // returning largest level
+ return VP9Level62;
+}
+
+void VideoCapabilities::parseFromInfo(const sp<AMessage> &format) {
+ VideoSize blockSize = VideoSize(mBlockWidth, mBlockHeight);
+ VideoSize alignment = VideoSize(mWidthAlignment, mHeightAlignment);
+ std::optional<Range<int32_t>> counts, widths, heights;
+ std::optional<Range<int32_t>> frameRates, bitRates;
+ std::optional<Range<int64_t>> blockRates;
+ std::optional<Range<Rational>> ratios, blockRatios;
+
+ AString blockSizeStr;
+ if (format->findString("block-size", &blockSizeStr)) {
+ std::optional<VideoSize> parsedBlockSize
+ = VideoSize::ParseSize(std::string(blockSizeStr.c_str()));
+ blockSize = parsedBlockSize.value_or(blockSize);
+ }
+ AString alignmentStr;
+ if (format->findString("alignment", &alignmentStr)) {
+ std::optional<VideoSize> parsedAlignment
+ = VideoSize::ParseSize(std::string(alignmentStr.c_str()));
+ alignment = parsedAlignment.value_or(alignment);
+ }
+ AString blockCountRangeStr;
+ if (format->findString("block-count-range", &blockCountRangeStr)) {
+ std::optional<Range<int>> parsedBlockCountRange =
+ Range<int32_t>::Parse(std::string(blockCountRangeStr.c_str()));
+ if (parsedBlockCountRange) {
+ counts = parsedBlockCountRange.value();
+ }
+ }
+ AString blockRatesStr;
+ if (format->findString("blocks-per-second-range", &blockRatesStr)) {
+ blockRates = Range<int64_t>::Parse(std::string(blockRatesStr.c_str()));
+ }
+ mMeasuredFrameRates = getMeasuredFrameRates(format);
+ mPerformancePoints = getPerformancePoints(format);
+ AString sizeRangesStr;
+ if (format->findString("size-range", &sizeRangesStr)) {
+ std::optional<std::pair<Range<int>, Range<int>>> sizeRanges =
+ ParseWidthHeightRanges(std::string(sizeRangesStr.c_str()));
+ if (sizeRanges) {
+ widths = sizeRanges.value().first;
+ heights = sizeRanges.value().second;
+ }
+ }
+ // for now this just means using the smaller max size as 2nd
+ // upper limit.
+ // for now we are keeping the profile specific "width/height
+ // in macroblocks" limits.
+ if (format->contains("feature-can-swap-width-height")) {
+ if (widths && heights) {
+ mSmallerDimensionUpperLimit =
+ std::min(widths.value().upper(), heights.value().upper());
+ widths = heights = widths.value().extend(heights.value());
+ } else {
+ ALOGW("feature can-swap-width-height is best used with size-range");
+ mSmallerDimensionUpperLimit =
+ std::min(mWidthRange.upper(), mHeightRange.upper());
+ mWidthRange = mHeightRange = mWidthRange.extend(mHeightRange);
+ }
+ }
+
+ AString ratioStr;
+ if (format->findString("block-aspect-ratio-range", &ratioStr)) {
+ ratios = Rational::ParseRange(std::string(ratioStr.c_str()));
+ }
+ AString blockRatiosStr;
+ if (format->findString("pixel-aspect-ratio-range", &blockRatiosStr)) {
+ blockRatios = Rational::ParseRange(std::string(blockRatiosStr.c_str()));
+ }
+ AString frameRatesStr;
+ if (format->findString("frame-rate-range", &frameRatesStr)) {
+ frameRates = Range<int32_t>::Parse(std::string(frameRatesStr.c_str()));
+ if (frameRates) {
+ frameRates = frameRates.value().intersect(FRAME_RATE_RANGE);
+ if (frameRates.value().empty()) {
+ ALOGW("frame rate range is out of limits");
+ frameRates = std::nullopt;
+ }
+ }
+ }
+ AString bitRatesStr;
+ if (format->findString("bitrate-range", &bitRatesStr)) {
+ bitRates = Range<int32_t>::Parse(std::string(bitRatesStr.c_str()));
+ if (bitRates) {
+ bitRates = bitRates.value().intersect(BITRATE_RANGE);
+ if (bitRates.value().empty()) {
+ ALOGW("bitrate range is out of limits");
+ bitRates = std::nullopt;
+ }
+ }
+ }
+
+ if (!IsPowerOfTwo(blockSize.getWidth()) || !IsPowerOfTwo(blockSize.getHeight())
+ || !IsPowerOfTwo(alignment.getWidth()) || !IsPowerOfTwo(alignment.getHeight())) {
+ ALOGE("The widths and heights of blockSizes and alignments must be the power of two."
+ " blockSize width: %d; blockSize height: %d;"
+ " alignment width: %d; alignment height: %d.",
+ blockSize.getWidth(), blockSize.getHeight(),
+ alignment.getWidth(), alignment.getHeight());
+ mError |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ return;
+ }
+
+ // update block-size and alignment
+ applyMacroBlockLimits(
+ INT32_MAX, INT32_MAX, INT32_MAX, INT64_MAX,
+ blockSize.getWidth(), blockSize.getHeight(),
+ alignment.getWidth(), alignment.getHeight());
+
+ if ((mError & ERROR_CAPABILITIES_UNSUPPORTED) != 0 || mAllowMbOverride) {
+ // codec supports profiles that we don't know.
+ // Use supplied values clipped to platform limits
+ if (widths) {
+ mWidthRange = VideoSize::GetAllowedDimensionRange().intersect(widths.value());
+ }
+ if (heights) {
+ mHeightRange = VideoSize::GetAllowedDimensionRange().intersect(heights.value());
+ }
+ if (counts) {
+ mBlockCountRange = POSITIVE_INT32.intersect(
+ counts.value().factor(mBlockWidth * mBlockHeight
+ / blockSize.getWidth() / blockSize.getHeight()));
+ }
+ if (blockRates) {
+ mBlocksPerSecondRange = POSITIVE_INT64.intersect(
+ blockRates.value().factor(mBlockWidth * mBlockHeight
+ / blockSize.getWidth() / blockSize.getHeight()));
+ }
+ if (blockRatios) {
+ mBlockAspectRatioRange = POSITIVE_RATIONALS.intersect(
+ Rational::ScaleRange(blockRatios.value(),
+ mBlockHeight / blockSize.getHeight(),
+ mBlockWidth / blockSize.getWidth()));
+ }
+ if (ratios) {
+ mAspectRatioRange = POSITIVE_RATIONALS.intersect(ratios.value());
+ }
+ if (frameRates) {
+ mFrameRateRange = FRAME_RATE_RANGE.intersect(frameRates.value());
+ }
+ if (bitRates) {
+ // only allow bitrate override if unsupported profiles were encountered
+ if ((mError & ERROR_CAPABILITIES_UNSUPPORTED) != 0) {
+ mBitrateRange = BITRATE_RANGE.intersect(bitRates.value());
+ } else {
+ mBitrateRange = mBitrateRange.intersect(bitRates.value());
+ }
+ }
+ } else {
+ // no unsupported profile/levels, so restrict values to known limits
+ if (widths) {
+ mWidthRange = mWidthRange.intersect(widths.value());
+ }
+ if (heights) {
+ mHeightRange = mHeightRange.intersect(heights.value());
+ }
+ if (counts) {
+ mBlockCountRange = mBlockCountRange.intersect(
+ counts.value().factor(mBlockWidth * mBlockHeight
+ / blockSize.getWidth() / blockSize.getHeight()));
+ }
+ if (blockRates) {
+ mBlocksPerSecondRange = mBlocksPerSecondRange.intersect(
+ blockRates.value().factor(mBlockWidth * mBlockHeight
+ / blockSize.getWidth() / blockSize.getHeight()));
+ }
+ if (blockRatios) {
+ mBlockAspectRatioRange = mBlockAspectRatioRange.intersect(
+ Rational::ScaleRange(blockRatios.value(),
+ mBlockHeight / blockSize.getHeight(),
+ mBlockWidth / blockSize.getWidth()));
+ }
+ if (ratios) {
+ mAspectRatioRange = mAspectRatioRange.intersect(ratios.value());
+ }
+ if (frameRates) {
+ mFrameRateRange = mFrameRateRange.intersect(frameRates.value());
+ }
+ if (bitRates) {
+ mBitrateRange = mBitrateRange.intersect(bitRates.value());
+ }
+ }
+ updateLimits();
+}
+
+void VideoCapabilities::applyBlockLimits(
+ int32_t blockWidth, int32_t blockHeight,
+ Range<int32_t> counts, Range<int64_t> rates, Range<Rational> ratios) {
+
+ if (!IsPowerOfTwo(blockWidth) || !IsPowerOfTwo(blockHeight)) {
+ ALOGE("blockWidth and blockHeight must be the power of two."
+ " blockWidth: %d; blockHeight: %d", blockWidth, blockHeight);
+ mError |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ return;
+ }
+
+ const int32_t newBlockWidth = std::max(blockWidth, mBlockWidth);
+ const int32_t newBlockHeight = std::max(blockHeight, mBlockHeight);
+
+ // factor will always be a power-of-2
+ int32_t factor =
+ newBlockWidth * newBlockHeight / mBlockWidth / mBlockHeight;
+ if (factor != 1) {
+ mBlockCountRange = mBlockCountRange.factor(factor);
+ mBlocksPerSecondRange = mBlocksPerSecondRange.factor(factor);
+ mBlockAspectRatioRange = Rational::ScaleRange(
+ mBlockAspectRatioRange,
+ newBlockHeight / mBlockHeight,
+ newBlockWidth / mBlockWidth);
+ mHorizontalBlockRange = mHorizontalBlockRange.factor(newBlockWidth / mBlockWidth);
+ mVerticalBlockRange = mVerticalBlockRange.factor(newBlockHeight / mBlockHeight);
+ }
+ factor = newBlockWidth * newBlockHeight / blockWidth / blockHeight;
+ if (factor != 1) {
+ counts = counts.factor(factor);
+ rates = rates.factor((int64_t)factor);
+ ratios = Rational::ScaleRange(
+ ratios, newBlockHeight / blockHeight,
+ newBlockWidth / blockWidth);
+ }
+ mBlockCountRange = mBlockCountRange.intersect(counts);
+ mBlocksPerSecondRange = mBlocksPerSecondRange.intersect(rates);
+ mBlockAspectRatioRange = mBlockAspectRatioRange.intersect(ratios);
+ mBlockWidth = newBlockWidth;
+ mBlockHeight = newBlockHeight;
+}
+
+void VideoCapabilities::applyAlignment(
+ int32_t widthAlignment, int32_t heightAlignment) {
+ if (!IsPowerOfTwo(widthAlignment) || !IsPowerOfTwo(heightAlignment)) {
+ ALOGE("width and height alignments must be the power of two."
+ " widthAlignment: %d; heightAlignment: %d", widthAlignment, heightAlignment);
+ mError |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ return;
+ }
+
+ if (widthAlignment > mBlockWidth || heightAlignment > mBlockHeight) {
+ // maintain assumption that 0 < alignment <= block-size
+ applyBlockLimits(
+ std::max(widthAlignment, mBlockWidth),
+ std::max(heightAlignment, mBlockHeight),
+ POSITIVE_INT32, POSITIVE_INT64, POSITIVE_RATIONALS);
+ }
+
+ mWidthAlignment = std::max(widthAlignment, mWidthAlignment);
+ mHeightAlignment = std::max(heightAlignment, mHeightAlignment);
+
+ mWidthRange = mWidthRange.align(mWidthAlignment);
+ mHeightRange = mHeightRange.align(mHeightAlignment);
+}
+
+void VideoCapabilities::updateLimits() {
+ // pixels -> blocks <- counts
+ mHorizontalBlockRange = mHorizontalBlockRange.intersect(
+ mWidthRange.factor(mBlockWidth));
+ mHorizontalBlockRange = mHorizontalBlockRange.intersect(
+ Range( mBlockCountRange.lower() / mVerticalBlockRange.upper(),
+ mBlockCountRange.upper() / mVerticalBlockRange.lower()));
+ mVerticalBlockRange = mVerticalBlockRange.intersect(
+ mHeightRange.factor(mBlockHeight));
+ mVerticalBlockRange = mVerticalBlockRange.intersect(
+ Range( mBlockCountRange.lower() / mHorizontalBlockRange.upper(),
+ mBlockCountRange.upper() / mHorizontalBlockRange.lower()));
+ mBlockCountRange = mBlockCountRange.intersect(
+ Range( mHorizontalBlockRange.lower()
+ * mVerticalBlockRange.lower(),
+ mHorizontalBlockRange.upper()
+ * mVerticalBlockRange.upper()));
+ mBlockAspectRatioRange = mBlockAspectRatioRange.intersect(
+ Rational(mHorizontalBlockRange.lower(), mVerticalBlockRange.upper()),
+ Rational(mHorizontalBlockRange.upper(), mVerticalBlockRange.lower()));
+
+ // blocks -> pixels
+ mWidthRange = mWidthRange.intersect(
+ (mHorizontalBlockRange.lower() - 1) * mBlockWidth + mWidthAlignment,
+ mHorizontalBlockRange.upper() * mBlockWidth);
+ mHeightRange = mHeightRange.intersect(
+ (mVerticalBlockRange.lower() - 1) * mBlockHeight + mHeightAlignment,
+ mVerticalBlockRange.upper() * mBlockHeight);
+ mAspectRatioRange = mAspectRatioRange.intersect(
+ Rational(mWidthRange.lower(), mHeightRange.upper()),
+ Rational(mWidthRange.upper(), mHeightRange.lower()));
+
+ mSmallerDimensionUpperLimit = std::min(
+ mSmallerDimensionUpperLimit,
+ std::min(mWidthRange.upper(), mHeightRange.upper()));
+
+ // blocks -> rate
+ mBlocksPerSecondRange = mBlocksPerSecondRange.intersect(
+ mBlockCountRange.lower() * (int64_t)mFrameRateRange.lower(),
+ mBlockCountRange.upper() * (int64_t)mFrameRateRange.upper());
+ mFrameRateRange = mFrameRateRange.intersect(
+ (int32_t)(mBlocksPerSecondRange.lower()
+ / mBlockCountRange.upper()),
+ (int32_t)(mBlocksPerSecondRange.upper()
+ / (double)mBlockCountRange.lower()));
+}
+
+void VideoCapabilities::applyMacroBlockLimits(
+ int32_t maxHorizontalBlocks, int32_t maxVerticalBlocks,
+ int32_t maxBlocks, int64_t maxBlocksPerSecond,
+ int32_t blockWidth, int32_t blockHeight,
+ int32_t widthAlignment, int32_t heightAlignment) {
+ applyMacroBlockLimits(
+ 1 /* minHorizontalBlocks */, 1 /* minVerticalBlocks */,
+ maxHorizontalBlocks, maxVerticalBlocks,
+ maxBlocks, maxBlocksPerSecond,
+ blockWidth, blockHeight, widthAlignment, heightAlignment);
+}
+
+void VideoCapabilities::applyMacroBlockLimits(
+ int32_t minHorizontalBlocks, int32_t minVerticalBlocks,
+ int32_t maxHorizontalBlocks, int32_t maxVerticalBlocks,
+ int32_t maxBlocks, int64_t maxBlocksPerSecond,
+ int32_t blockWidth, int32_t blockHeight,
+ int32_t widthAlignment, int32_t heightAlignment) {
+ applyAlignment(widthAlignment, heightAlignment);
+ applyBlockLimits(
+ blockWidth, blockHeight, Range((int32_t)1, maxBlocks),
+ Range((int64_t)1, maxBlocksPerSecond),
+ Range(Rational(1, maxVerticalBlocks), Rational(maxHorizontalBlocks, 1)));
+ mHorizontalBlockRange =
+ mHorizontalBlockRange.intersect(
+ divUp(minHorizontalBlocks, (mBlockWidth / blockWidth)),
+ maxHorizontalBlocks / (mBlockWidth / blockWidth));
+ mVerticalBlockRange =
+ mVerticalBlockRange.intersect(
+ divUp(minVerticalBlocks, (mBlockHeight / blockHeight)),
+ maxVerticalBlocks / (mBlockHeight / blockHeight));
+}
+
+void VideoCapabilities::applyLevelLimits() {
+ int64_t maxBlocksPerSecond = 0;
+ int32_t maxBlocks = 0;
+ int32_t maxBps = 0;
+ int32_t maxDPBBlocks = 0;
+
+ int errors = ERROR_CAPABILITIES_NONE_SUPPORTED;
+ const char *mediaType = mMediaType.c_str();
+ if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_AVC)) {
+ maxBlocks = 99;
+ maxBlocksPerSecond = 1485;
+ maxBps = 64000;
+ maxDPBBlocks = 396;
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ int32_t MBPS = 0, FS = 0, BR = 0, DPB = 0;
+ bool supported = true;
+ switch (profileLevel.mLevel) {
+ case AVCLevel1:
+ MBPS = 1485; FS = 99; BR = 64; DPB = 396; break;
+ case AVCLevel1b:
+ MBPS = 1485; FS = 99; BR = 128; DPB = 396; break;
+ case AVCLevel11:
+ MBPS = 3000; FS = 396; BR = 192; DPB = 900; break;
+ case AVCLevel12:
+ MBPS = 6000; FS = 396; BR = 384; DPB = 2376; break;
+ case AVCLevel13:
+ MBPS = 11880; FS = 396; BR = 768; DPB = 2376; break;
+ case AVCLevel2:
+ MBPS = 11880; FS = 396; BR = 2000; DPB = 2376; break;
+ case AVCLevel21:
+ MBPS = 19800; FS = 792; BR = 4000; DPB = 4752; break;
+ case AVCLevel22:
+ MBPS = 20250; FS = 1620; BR = 4000; DPB = 8100; break;
+ case AVCLevel3:
+ MBPS = 40500; FS = 1620; BR = 10000; DPB = 8100; break;
+ case AVCLevel31:
+ MBPS = 108000; FS = 3600; BR = 14000; DPB = 18000; break;
+ case AVCLevel32:
+ MBPS = 216000; FS = 5120; BR = 20000; DPB = 20480; break;
+ case AVCLevel4:
+ MBPS = 245760; FS = 8192; BR = 20000; DPB = 32768; break;
+ case AVCLevel41:
+ MBPS = 245760; FS = 8192; BR = 50000; DPB = 32768; break;
+ case AVCLevel42:
+ MBPS = 522240; FS = 8704; BR = 50000; DPB = 34816; break;
+ case AVCLevel5:
+ MBPS = 589824; FS = 22080; BR = 135000; DPB = 110400; break;
+ case AVCLevel51:
+ MBPS = 983040; FS = 36864; BR = 240000; DPB = 184320; break;
+ case AVCLevel52:
+ MBPS = 2073600; FS = 36864; BR = 240000; DPB = 184320; break;
+ case AVCLevel6:
+ MBPS = 4177920; FS = 139264; BR = 240000; DPB = 696320; break;
+ case AVCLevel61:
+ MBPS = 8355840; FS = 139264; BR = 480000; DPB = 696320; break;
+ case AVCLevel62:
+ MBPS = 16711680; FS = 139264; BR = 800000; DPB = 696320; break;
+ default:
+ ALOGW("Unrecognized level %d for %s", profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ switch (profileLevel.mProfile) {
+ case AVCProfileConstrainedHigh:
+ case AVCProfileHigh:
+ BR *= 1250; break;
+ case AVCProfileHigh10:
+ BR *= 3000; break;
+ case AVCProfileExtended:
+ case AVCProfileHigh422:
+ case AVCProfileHigh444:
+ ALOGW("Unsupported profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ supported = false;
+ FALLTHROUGH_INTENDED;
+ // fall through - treat as base profile
+ case AVCProfileConstrainedBaseline:
+ FALLTHROUGH_INTENDED;
+ case AVCProfileBaseline:
+ FALLTHROUGH_INTENDED;
+ case AVCProfileMain:
+ BR *= 1000; break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ BR *= 1000;
+ }
+ if (supported) {
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ }
+ maxBlocksPerSecond = std::max((int64_t)MBPS, maxBlocksPerSecond);
+ maxBlocks = std::max(FS, maxBlocks);
+ maxBps = std::max(BR, maxBps);
+ maxDPBBlocks = std::max(maxDPBBlocks, DPB);
+ }
+
+ int32_t maxLengthInBlocks = (int32_t)(std::sqrt(8 * maxBlocks));
+ applyMacroBlockLimits(
+ maxLengthInBlocks, maxLengthInBlocks,
+ maxBlocks, maxBlocksPerSecond,
+ 16 /* blockWidth */, 16 /* blockHeight */,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_MPEG2)) {
+ int32_t maxWidth = 11, maxHeight = 9, maxRate = 15;
+ maxBlocks = 99;
+ maxBlocksPerSecond = 1485;
+ maxBps = 64000;
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ int32_t MBPS = 0, FS = 0, BR = 0, FR = 0, W = 0, H = 0;
+ bool supported = true;
+ switch (profileLevel.mProfile) {
+ case MPEG2ProfileSimple:
+ switch (profileLevel.mLevel) {
+ case MPEG2LevelML:
+ FR = 30; W = 45; H = 36; MBPS = 40500; FS = 1620; BR = 15000; break;
+ default:
+ ALOGW("Unrecognized profile/level %d/%d for %s",
+ profileLevel.mProfile, profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ break;
+ case MPEG2ProfileMain:
+ switch (profileLevel.mLevel) {
+ case MPEG2LevelLL:
+ FR = 30; W = 22; H = 18; MBPS = 11880; FS = 396; BR = 4000; break;
+ case MPEG2LevelML:
+ FR = 30; W = 45; H = 36; MBPS = 40500; FS = 1620; BR = 15000; break;
+ case MPEG2LevelH14:
+ FR = 60; W = 90; H = 68; MBPS = 183600; FS = 6120; BR = 60000; break;
+ case MPEG2LevelHL:
+ FR = 60; W = 120; H = 68; MBPS = 244800; FS = 8160; BR = 80000; break;
+ case MPEG2LevelHP:
+ FR = 60; W = 120; H = 68; MBPS = 489600; FS = 8160; BR = 80000; break;
+ default:
+ ALOGW("Unrecognized profile/level %d / %d for %s",
+ profileLevel.mProfile, profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ break;
+ case MPEG2Profile422:
+ case MPEG2ProfileSNR:
+ case MPEG2ProfileSpatial:
+ case MPEG2ProfileHigh:
+ ALOGW("Unsupported profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNSUPPORTED;
+ supported = false;
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ if (supported) {
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ }
+ maxBlocksPerSecond = std::max((int64_t)MBPS, maxBlocksPerSecond);
+ maxBlocks = std::max(FS, maxBlocks);
+ maxBps = std::max(BR * 1000, maxBps);
+ maxWidth = std::max(W, maxWidth);
+ maxHeight = std::max(H, maxHeight);
+ maxRate = std::max(FR, maxRate);
+ }
+ applyMacroBlockLimits(maxWidth, maxHeight,
+ maxBlocks, maxBlocksPerSecond,
+ 16 /* blockWidth */, 16 /* blockHeight */,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ mFrameRateRange = mFrameRateRange.intersect(12, maxRate);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_MPEG4)) {
+ int32_t maxWidth = 11, maxHeight = 9, maxRate = 15;
+ maxBlocks = 99;
+ maxBlocksPerSecond = 1485;
+ maxBps = 64000;
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ int32_t MBPS = 0, FS = 0, BR = 0, FR = 0, W = 0, H = 0;
+ bool strict = false; // true: W, H and FR are individual max limits
+ bool supported = true;
+ switch (profileLevel.mProfile) {
+ case MPEG4ProfileSimple:
+ switch (profileLevel.mLevel) {
+ case MPEG4Level0:
+ strict = true;
+ FR = 15; W = 11; H = 9; MBPS = 1485; FS = 99; BR = 64; break;
+ case MPEG4Level1:
+ FR = 30; W = 11; H = 9; MBPS = 1485; FS = 99; BR = 64; break;
+ case MPEG4Level0b:
+ strict = true;
+ FR = 15; W = 11; H = 9; MBPS = 1485; FS = 99; BR = 128; break;
+ case MPEG4Level2:
+ FR = 30; W = 22; H = 18; MBPS = 5940; FS = 396; BR = 128; break;
+ case MPEG4Level3:
+ FR = 30; W = 22; H = 18; MBPS = 11880; FS = 396; BR = 384; break;
+ case MPEG4Level4a:
+ FR = 30; W = 40; H = 30; MBPS = 36000; FS = 1200; BR = 4000; break;
+ case MPEG4Level5:
+ FR = 30; W = 45; H = 36; MBPS = 40500; FS = 1620; BR = 8000; break;
+ case MPEG4Level6:
+ FR = 30; W = 80; H = 45; MBPS = 108000; FS = 3600; BR = 12000; break;
+ default:
+ ALOGW("Unrecognized profile/level %d/%d for %s",
+ profileLevel.mProfile, profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ break;
+ case MPEG4ProfileAdvancedSimple:
+ switch (profileLevel.mLevel) {
+ case MPEG4Level0:
+ case MPEG4Level1:
+ FR = 30; W = 11; H = 9; MBPS = 2970; FS = 99; BR = 128; break;
+ case MPEG4Level2:
+ FR = 30; W = 22; H = 18; MBPS = 5940; FS = 396; BR = 384; break;
+ case MPEG4Level3:
+ FR = 30; W = 22; H = 18; MBPS = 11880; FS = 396; BR = 768; break;
+ case MPEG4Level3b:
+ FR = 30; W = 22; H = 18; MBPS = 11880; FS = 396; BR = 1500; break;
+ case MPEG4Level4:
+ FR = 30; W = 44; H = 36; MBPS = 23760; FS = 792; BR = 3000; break;
+ case MPEG4Level5:
+ FR = 30; W = 45; H = 36; MBPS = 48600; FS = 1620; BR = 8000; break;
+ default:
+ ALOGW("Unrecognized profile/level %d/%d for %s",
+ profileLevel.mProfile, profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ break;
+ case MPEG4ProfileMain: // 2-4
+ case MPEG4ProfileNbit: // 2
+ case MPEG4ProfileAdvancedRealTime: // 1-4
+ case MPEG4ProfileCoreScalable: // 1-3
+ case MPEG4ProfileAdvancedCoding: // 1-4
+ case MPEG4ProfileCore: // 1-2
+ case MPEG4ProfileAdvancedCore: // 1-4
+ case MPEG4ProfileSimpleScalable: // 0-2
+ case MPEG4ProfileHybrid: // 1-2
+
+ // Studio profiles are not supported by our codecs.
+
+ // Only profiles that can decode simple object types are considered.
+ // The following profiles are not able to.
+ case MPEG4ProfileBasicAnimated: // 1-2
+ case MPEG4ProfileScalableTexture: // 1
+ case MPEG4ProfileSimpleFace: // 1-2
+ case MPEG4ProfileAdvancedScalable: // 1-3
+ case MPEG4ProfileSimpleFBA: // 1-2
+ ALOGV("Unsupported profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNSUPPORTED;
+ supported = false;
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ if (supported) {
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ }
+ maxBlocksPerSecond = std::max((int64_t)MBPS, maxBlocksPerSecond);
+ maxBlocks = std::max(FS, maxBlocks);
+ maxBps = std::max(BR * 1000, maxBps);
+ if (strict) {
+ maxWidth = std::max(W, maxWidth);
+ maxHeight = std::max(H, maxHeight);
+ maxRate = std::max(FR, maxRate);
+ } else {
+ // assuming max 60 fps frame rate and 1:2 aspect ratio
+ int32_t maxDim = (int32_t)std::sqrt(2 * FS);
+ maxWidth = std::max(maxDim, maxWidth);
+ maxHeight = std::max(maxDim, maxHeight);
+ maxRate = std::max(std::max(FR, 60), maxRate);
+ }
+ }
+ applyMacroBlockLimits(maxWidth, maxHeight,
+ maxBlocks, maxBlocksPerSecond,
+ 16 /* blockWidth */, 16 /* blockHeight */,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ mFrameRateRange = mFrameRateRange.intersect(12, maxRate);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_H263)) {
+ int32_t maxWidth = 11, maxHeight = 9, maxRate = 15;
+ int32_t minWidth = maxWidth, minHeight = maxHeight;
+ int32_t minAlignment = 16;
+ maxBlocks = 99;
+ maxBlocksPerSecond = 1485;
+ maxBps = 64000;
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ int32_t MBPS = 0, BR = 0, FR = 0, W = 0, H = 0, minW = minWidth, minH = minHeight;
+ bool strict = false; // true: support only sQCIF, QCIF (maybe CIF)
+ switch (profileLevel.mLevel) {
+ case H263Level10:
+ strict = true; // only supports sQCIF & QCIF
+ FR = 15; W = 11; H = 9; BR = 1; MBPS = W * H * FR; break;
+ case H263Level20:
+ strict = true; // only supports sQCIF, QCIF & CIF
+ FR = 30; W = 22; H = 18; BR = 2; MBPS = W * H * 15; break;
+ case H263Level30:
+ strict = true; // only supports sQCIF, QCIF & CIF
+ FR = 30; W = 22; H = 18; BR = 6; MBPS = W * H * FR; break;
+ case H263Level40:
+ strict = true; // only supports sQCIF, QCIF & CIF
+ FR = 30; W = 22; H = 18; BR = 32; MBPS = W * H * FR; break;
+ case H263Level45:
+ // only implies level 10 support
+ strict = profileLevel.mProfile == H263ProfileBaseline
+ || profileLevel.mProfile ==
+ H263ProfileBackwardCompatible;
+ if (!strict) {
+ minW = 1; minH = 1; minAlignment = 4;
+ }
+ FR = 15; W = 11; H = 9; BR = 2; MBPS = W * H * FR; break;
+ case H263Level50:
+ // only supports 50fps for H > 15
+ minW = 1; minH = 1; minAlignment = 4;
+ FR = 60; W = 22; H = 18; BR = 64; MBPS = W * H * 50; break;
+ case H263Level60:
+ // only supports 50fps for H > 15
+ minW = 1; minH = 1; minAlignment = 4;
+ FR = 60; W = 45; H = 18; BR = 128; MBPS = W * H * 50; break;
+ case H263Level70:
+ // only supports 50fps for H > 30
+ minW = 1; minH = 1; minAlignment = 4;
+ FR = 60; W = 45; H = 36; BR = 256; MBPS = W * H * 50; break;
+ default:
+ ALOGW("Unrecognized profile/level %d/%d for %s",
+ profileLevel.mProfile, profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ switch (profileLevel.mProfile) {
+ case H263ProfileBackwardCompatible:
+ case H263ProfileBaseline:
+ case H263ProfileH320Coding:
+ case H263ProfileHighCompression:
+ case H263ProfileHighLatency:
+ case H263ProfileInterlace:
+ case H263ProfileInternet:
+ case H263ProfileISWV2:
+ case H263ProfileISWV3:
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ if (strict) {
+ // Strict levels define sub-QCIF min size and enumerated sizes. We cannot
+ // express support for "only sQCIF & QCIF (& CIF)" using VideoCapabilities
+ // but we can express "only QCIF (& CIF)", so set minimume size at QCIF.
+ // minW = 8; minH = 6;
+ minW = 11; minH = 9;
+ } else {
+ // any support for non-strict levels (including unrecognized profiles or
+ // levels) allow custom frame size support beyond supported limits
+ // (other than bitrate)
+ mAllowMbOverride = true;
+ }
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ maxBlocksPerSecond = std::max((int64_t)MBPS, maxBlocksPerSecond);
+ maxBlocks = std::max(W * H, maxBlocks);
+ maxBps = std::max(BR * 64000, maxBps);
+ maxWidth = std::max(W, maxWidth);
+ maxHeight = std::max(H, maxHeight);
+ maxRate = std::max(FR, maxRate);
+ minWidth = std::min(minW, minWidth);
+ minHeight = std::min(minH, minHeight);
+ }
+ // unless we encountered custom frame size support, limit size to QCIF and CIF
+ // using aspect ratio.
+ if (!mAllowMbOverride) {
+ mBlockAspectRatioRange =
+ Range(Rational(11, 9), Rational(11, 9));
+ }
+ applyMacroBlockLimits(
+ minWidth, minHeight,
+ maxWidth, maxHeight,
+ maxBlocks, maxBlocksPerSecond,
+ 16 /* blockWidth */, 16 /* blockHeight */,
+ minAlignment /* widthAlignment */, minAlignment /* heightAlignment */);
+ mFrameRateRange = Range(1, maxRate);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_VP8)) {
+ maxBlocks = INT_MAX;
+ maxBlocksPerSecond = INT_MAX;
+
+ // TODO: set to 100Mbps for now, need a number for VP8
+ maxBps = 100000000;
+
+ // profile levels are not indicative for VPx, but verify
+ // them nonetheless
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ switch (profileLevel.mLevel) {
+ case VP8Level_Version0:
+ case VP8Level_Version1:
+ case VP8Level_Version2:
+ case VP8Level_Version3:
+ break;
+ default:
+ ALOGW("Unrecognized level %d for %s", profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ switch (profileLevel.mProfile) {
+ case VP8ProfileMain:
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ }
+
+ const int32_t blockSize = 16;
+ applyMacroBlockLimits(SHRT_MAX, SHRT_MAX,
+ maxBlocks, maxBlocksPerSecond, blockSize, blockSize,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_VP9)) {
+ maxBlocksPerSecond = 829440;
+ maxBlocks = 36864;
+ maxBps = 200000;
+ int32_t maxDim = 512;
+
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ int64_t SR = 0; // luma sample rate
+ int32_t FS = 0; // luma picture size
+ int32_t BR = 0; // bit rate kbps
+ int32_t D = 0; // luma dimension
+ switch (profileLevel.mLevel) {
+ case VP9Level1:
+ SR = 829440; FS = 36864; BR = 200; D = 512; break;
+ case VP9Level11:
+ SR = 2764800; FS = 73728; BR = 800; D = 768; break;
+ case VP9Level2:
+ SR = 4608000; FS = 122880; BR = 1800; D = 960; break;
+ case VP9Level21:
+ SR = 9216000; FS = 245760; BR = 3600; D = 1344; break;
+ case VP9Level3:
+ SR = 20736000; FS = 552960; BR = 7200; D = 2048; break;
+ case VP9Level31:
+ SR = 36864000; FS = 983040; BR = 12000; D = 2752; break;
+ case VP9Level4:
+ SR = 83558400; FS = 2228224; BR = 18000; D = 4160; break;
+ case VP9Level41:
+ SR = 160432128; FS = 2228224; BR = 30000; D = 4160; break;
+ case VP9Level5:
+ SR = 311951360; FS = 8912896; BR = 60000; D = 8384; break;
+ case VP9Level51:
+ SR = 588251136; FS = 8912896; BR = 120000; D = 8384; break;
+ case VP9Level52:
+ SR = 1176502272; FS = 8912896; BR = 180000; D = 8384; break;
+ case VP9Level6:
+ SR = 1176502272; FS = 35651584; BR = 180000; D = 16832; break;
+ case VP9Level61:
+ SR = 2353004544L; FS = 35651584; BR = 240000; D = 16832; break;
+ case VP9Level62:
+ SR = 4706009088L; FS = 35651584; BR = 480000; D = 16832; break;
+ default:
+ ALOGW("Unrecognized level %d for %s", profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ switch (profileLevel.mProfile) {
+ case VP9Profile0:
+ case VP9Profile1:
+ case VP9Profile2:
+ case VP9Profile3:
+ case VP9Profile2HDR:
+ case VP9Profile3HDR:
+ case VP9Profile2HDR10Plus:
+ case VP9Profile3HDR10Plus:
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ maxBlocksPerSecond = std::max(SR, maxBlocksPerSecond);
+ maxBlocks = std::max(FS, maxBlocks);
+ maxBps = std::max(BR * 1000, maxBps);
+ maxDim = std::max(D, maxDim);
+ }
+
+ const int32_t blockSize = 8;
+ int32_t maxLengthInBlocks = divUp(maxDim, blockSize);
+ maxBlocks = divUp(maxBlocks, blockSize * blockSize);
+ maxBlocksPerSecond = divUp(maxBlocksPerSecond, blockSize * (int64_t)blockSize);
+
+ applyMacroBlockLimits(
+ maxLengthInBlocks, maxLengthInBlocks,
+ maxBlocks, maxBlocksPerSecond,
+ blockSize, blockSize,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_HEVC)) {
+ // CTBs are at least 8x8 so use 8x8 block size
+ maxBlocks = 36864 >> 6; // 192x192 pixels == 576 8x8 blocks
+ maxBlocksPerSecond = maxBlocks * 15;
+ maxBps = 128000;
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ double FR = 0;
+ int32_t FS = 0, BR = 0;
+ switch (profileLevel.mLevel) {
+ /* The HEVC spec talks only in a very convoluted manner about the
+ existence of levels 1-3.1 for High tier, which could also be
+ understood as 'decoders and encoders should treat these levels
+ as if they were Main tier', so we do that. */
+ case HEVCMainTierLevel1:
+ case HEVCHighTierLevel1:
+ FR = 15; FS = 36864; BR = 128; break;
+ case HEVCMainTierLevel2:
+ case HEVCHighTierLevel2:
+ FR = 30; FS = 122880; BR = 1500; break;
+ case HEVCMainTierLevel21:
+ case HEVCHighTierLevel21:
+ FR = 30; FS = 245760; BR = 3000; break;
+ case HEVCMainTierLevel3:
+ case HEVCHighTierLevel3:
+ FR = 30; FS = 552960; BR = 6000; break;
+ case HEVCMainTierLevel31:
+ case HEVCHighTierLevel31:
+ FR = 33.75; FS = 983040; BR = 10000; break;
+ case HEVCMainTierLevel4:
+ FR = 30; FS = 2228224; BR = 12000; break;
+ case HEVCHighTierLevel4:
+ FR = 30; FS = 2228224; BR = 30000; break;
+ case HEVCMainTierLevel41:
+ FR = 60; FS = 2228224; BR = 20000; break;
+ case HEVCHighTierLevel41:
+ FR = 60; FS = 2228224; BR = 50000; break;
+ case HEVCMainTierLevel5:
+ FR = 30; FS = 8912896; BR = 25000; break;
+ case HEVCHighTierLevel5:
+ FR = 30; FS = 8912896; BR = 100000; break;
+ case HEVCMainTierLevel51:
+ FR = 60; FS = 8912896; BR = 40000; break;
+ case HEVCHighTierLevel51:
+ FR = 60; FS = 8912896; BR = 160000; break;
+ case HEVCMainTierLevel52:
+ FR = 120; FS = 8912896; BR = 60000; break;
+ case HEVCHighTierLevel52:
+ FR = 120; FS = 8912896; BR = 240000; break;
+ case HEVCMainTierLevel6:
+ FR = 30; FS = 35651584; BR = 60000; break;
+ case HEVCHighTierLevel6:
+ FR = 30; FS = 35651584; BR = 240000; break;
+ case HEVCMainTierLevel61:
+ FR = 60; FS = 35651584; BR = 120000; break;
+ case HEVCHighTierLevel61:
+ FR = 60; FS = 35651584; BR = 480000; break;
+ case HEVCMainTierLevel62:
+ FR = 120; FS = 35651584; BR = 240000; break;
+ case HEVCHighTierLevel62:
+ FR = 120; FS = 35651584; BR = 800000; break;
+ default:
+ ALOGW("Unrecognized level %d for %s", profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ switch (profileLevel.mProfile) {
+ case HEVCProfileMain:
+ case HEVCProfileMain10:
+ case HEVCProfileMainStill:
+ case HEVCProfileMain10HDR10:
+ case HEVCProfileMain10HDR10Plus:
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+
+ /* DPB logic:
+ if (width * height <= FS / 4) DPB = 16;
+ else if (width * height <= FS / 2) DPB = 12;
+ else if (width * height <= FS * 0.75) DPB = 8;
+ else DPB = 6;
+ */
+
+ FS >>= 6; // convert pixels to blocks
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ maxBlocksPerSecond = std::max((int64_t)(FR * FS), maxBlocksPerSecond);
+ maxBlocks = std::max(FS, maxBlocks);
+ maxBps = std::max(1000 * BR, maxBps);
+ }
+
+ int32_t maxLengthInBlocks = (int32_t)(std::sqrt(8 * maxBlocks));
+ applyMacroBlockLimits(
+ maxLengthInBlocks, maxLengthInBlocks,
+ maxBlocks, maxBlocksPerSecond,
+ 8 /* blockWidth */, 8 /* blockHeight */,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ } else if (base::EqualsIgnoreCase(mMediaType, MIMETYPE_VIDEO_AV1)) {
+ maxBlocksPerSecond = 829440;
+ maxBlocks = 36864;
+ maxBps = 200000;
+ int32_t maxDim = 512;
+
+ // Sample rate, Picture Size, Bit rate and luma dimension for AV1 Codec,
+ // corresponding to the definitions in
+ // "AV1 Bitstream & Decoding Process Specification", Annex A
+ // found at https://aomedia.org/av1-bitstream-and-decoding-process-specification/
+ for (ProfileLevel profileLevel: mProfileLevels) {
+ int64_t SR = 0; // luma sample rate
+ int32_t FS = 0; // luma picture size
+ int32_t BR = 0; // bit rate kbps
+ int32_t D = 0; // luma D
+ switch (profileLevel.mLevel) {
+ case AV1Level2:
+ SR = 5529600; FS = 147456; BR = 1500; D = 2048; break;
+ case AV1Level21:
+ case AV1Level22:
+ case AV1Level23:
+ SR = 10454400; FS = 278784; BR = 3000; D = 2816; break;
+
+ case AV1Level3:
+ SR = 24969600; FS = 665856; BR = 6000; D = 4352; break;
+ case AV1Level31:
+ case AV1Level32:
+ case AV1Level33:
+ SR = 39938400; FS = 1065024; BR = 10000; D = 5504; break;
+
+ case AV1Level4:
+ SR = 77856768; FS = 2359296; BR = 12000; D = 6144; break;
+ case AV1Level41:
+ case AV1Level42:
+ case AV1Level43:
+ SR = 155713536; FS = 2359296; BR = 20000; D = 6144; break;
+
+ case AV1Level5:
+ SR = 273715200; FS = 8912896; BR = 30000; D = 8192; break;
+ case AV1Level51:
+ SR = 547430400; FS = 8912896; BR = 40000; D = 8192; break;
+ case AV1Level52:
+ SR = 1094860800; FS = 8912896; BR = 60000; D = 8192; break;
+ case AV1Level53:
+ SR = 1176502272; FS = 8912896; BR = 60000; D = 8192; break;
+
+ case AV1Level6:
+ SR = 1176502272; FS = 35651584; BR = 60000; D = 16384; break;
+ case AV1Level61:
+ SR = 2189721600L; FS = 35651584; BR = 100000; D = 16384; break;
+ case AV1Level62:
+ SR = 4379443200L; FS = 35651584; BR = 160000; D = 16384; break;
+ case AV1Level63:
+ SR = 4706009088L; FS = 35651584; BR = 160000; D = 16384; break;
+
+ default:
+ ALOGW("Unrecognized level %d for %s", profileLevel.mLevel, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ switch (profileLevel.mProfile) {
+ case AV1ProfileMain8:
+ case AV1ProfileMain10:
+ case AV1ProfileMain10HDR10:
+ case AV1ProfileMain10HDR10Plus:
+ break;
+ default:
+ ALOGW("Unrecognized profile %d for %s", profileLevel.mProfile, mediaType);
+ errors |= ERROR_CAPABILITIES_UNRECOGNIZED;
+ }
+ errors &= ~ERROR_CAPABILITIES_NONE_SUPPORTED;
+ maxBlocksPerSecond = std::max(SR, maxBlocksPerSecond);
+ maxBlocks = std::max(FS, maxBlocks);
+ maxBps = std::max(BR * 1000, maxBps);
+ maxDim = std::max(D, maxDim);
+ }
+
+ const int32_t blockSize = 8;
+ int32_t maxLengthInBlocks = divUp(maxDim, blockSize);
+ maxBlocks = divUp(maxBlocks, blockSize * blockSize);
+ maxBlocksPerSecond = divUp(maxBlocksPerSecond, blockSize * (int64_t)blockSize);
+ applyMacroBlockLimits(
+ maxLengthInBlocks, maxLengthInBlocks,
+ maxBlocks, maxBlocksPerSecond,
+ blockSize, blockSize,
+ 1 /* widthAlignment */, 1 /* heightAlignment */);
+ } else {
+ ALOGW("Unsupported mime %s", mediaType);
+ // using minimal bitrate here. should be overridden by
+ // info from media_codecs.xml
+ maxBps = 64000;
+ errors |= ERROR_CAPABILITIES_UNSUPPORTED;
+ }
+ mBitrateRange = Range(1, maxBps);
+ mError |= errors;
+}
+
+} // namespace android
\ No newline at end of file
diff --git a/media/libmedia/include/media/AudioCapabilities.h b/media/libmedia/include/media/AudioCapabilities.h
index d2bd9d7..3e1c9df 100644
--- a/media/libmedia/include/media/AudioCapabilities.h
+++ b/media/libmedia/include/media/AudioCapabilities.h
@@ -44,14 +44,14 @@
* supports only discrete values. Otherwise, it returns an empty array.
* The array is sorted in ascending order.
*/
- const std::vector<int>& getSupportedSampleRates() const;
+ const std::vector<int32_t>& getSupportedSampleRates() const;
/**
* Returns the array of supported sample rate ranges. The
* array is sorted in ascending order, and the ranges are
* distinct.
*/
- const std::vector<Range<int>>& getSupportedSampleRateRanges() const;
+ const std::vector<Range<int32_t>>& getSupportedSampleRateRanges() const;
/**
* Returns the maximum number of input channels supported.
@@ -68,7 +68,7 @@
* The {@link #getMaxInputChannelCount} method will return the highest value
* in the ranges returned by {@link #getInputChannelCountRanges}
*/
- int getMaxInputChannelCount() const;
+ int32_t getMaxInputChannelCount() const;
/**
* Returns the minimum number of input channels supported.
@@ -77,7 +77,7 @@
* This returns the lowest channel count in the ranges returned by
* {@link #getInputChannelCountRanges}.
*/
- int getMinInputChannelCount() const;
+ int32_t getMinInputChannelCount() const;
/**
* Returns an array of ranges representing the number of input channels supported.
@@ -89,12 +89,12 @@
*
* The returned array cannot be empty.
*/
- const std::vector<Range<int>>& getInputChannelCountRanges() const;
+ const std::vector<Range<int32_t>>& getInputChannelCountRanges() const;
/**
* Query whether the sample rate is supported by the codec.
*/
- bool isSampleRateSupported(int sampleRate);
+ bool isSampleRateSupported(int32_t sampleRate);
/* For internal use only. Not exposed as a public API */
void getDefaultFormat(sp<AMessage> &format);
@@ -103,7 +103,7 @@
bool supportsFormat(const sp<AMessage> &format);
private:
- static constexpr int MAX_INPUT_CHANNEL_COUNT = 30;
+ static constexpr int32_t MAX_INPUT_CHANNEL_COUNT = 30;
static constexpr uint32_t MAX_NUM_CHANNELS = FCC_LIMIT;
int mError;
@@ -112,21 +112,21 @@
Range<int32_t> mBitrateRange;
- std::vector<int> mSampleRates;
- std::vector<Range<int>> mSampleRateRanges;
- std::vector<Range<int>> mInputChannelRanges;
+ std::vector<int32_t> mSampleRates;
+ std::vector<Range<int32_t>> mSampleRateRanges;
+ std::vector<Range<int32_t>> mInputChannelRanges;
/* no public constructor */
AudioCapabilities() {}
void init(std::string mediaType, std::vector<ProfileLevel> profLevs,
const sp<AMessage> &format);
void initWithPlatformLimits();
- bool supports(std::optional<int> sampleRate, std::optional<int> inputChannels);
- void limitSampleRates(std::vector<int> rates);
+ bool supports(std::optional<int32_t> sampleRate, std::optional<int32_t> inputChannels);
+ void limitSampleRates(std::vector<int32_t> rates);
void createDiscreteSampleRates();
- void limitSampleRates(std::vector<Range<int>> rateRanges);
+ void limitSampleRates(std::vector<Range<int32_t>> rateRanges);
void applyLevelLimits();
- void applyLimits(const std::vector<Range<int>> &inputChannels,
+ void applyLimits(const std::vector<Range<int32_t>> &inputChannels,
const std::optional<Range<int32_t>> &bitRates);
void parseFromInfo(const sp<AMessage> &format);
diff --git a/media/libmedia/include/media/CodecCapabilities.h b/media/libmedia/include/media/CodecCapabilities.h
index 570c8b5..0611d8c 100644
--- a/media/libmedia/include/media/CodecCapabilities.h
+++ b/media/libmedia/include/media/CodecCapabilities.h
@@ -20,6 +20,8 @@
#include <media/AudioCapabilities.h>
#include <media/CodecCapabilitiesUtils.h>
+#include <media/EncoderCapabilities.h>
+#include <media/VideoCapabilities.h>
#include <media/stagefright/foundation/ABase.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/foundation/AString.h>
@@ -38,6 +40,26 @@
const sp<AMessage> &format);
/**
+ * Retrieve the codec capabilities for a certain {@code mime type}, {@code
+ * profile} and {@code level}. If the type, or profile-level combination
+ * is not understood by the framework, it returns null.
+ * <p class=note> In {@link android.os.Build.VERSION_CODES#M}, calling this
+ * method without calling any method of the {@link MediaCodecList} class beforehand
+ * results in a {@link NullPointerException}.</p>
+ */
+ static std::shared_ptr<CodecCapabilities> CreateFromProfileLevel(std::string mediaType,
+ int32_t profile, int32_t level, int32_t maxConcurrentInstances = -1);
+
+ CodecCapabilities() {};
+
+ /**
+ * Init CodecCapabilities with settings.
+ */
+ void init(std::vector<ProfileLevel> profLevs, std::vector<uint32_t> colFmts, bool encoder,
+ sp<AMessage> &defaultFormat, sp<AMessage> &capabilitiesInfo,
+ int32_t maxConcurrentInstances = 0);
+
+ /**
* Returns the media type for which this codec-capability object was created.
*/
const std::string& getMediaType();
@@ -47,11 +69,209 @@
*/
const std::vector<ProfileLevel>& getProfileLevels();
+ /**
+ * Returns the supported color formats.
+ */
+ std::vector<uint32_t> getColorFormats() const;
+
+ /**
+ * Returns a media format with default values for configurations that have defaults.
+ */
+ sp<AMessage> getDefaultFormat() const;
+
+ /**
+ * Returns the max number of the supported concurrent codec instances.
+ * <p>
+ * This is a hint for an upper bound. Applications should not expect to successfully
+ * operate more instances than the returned value, but the actual number of
+ * concurrently operable instances may be less as it depends on the available
+ * resources at time of use.
+ */
+ int32_t getMaxSupportedInstances() const;
+
+ /**
+ * Returns the audio capabilities or {@code null} if this is not an audio codec.
+ */
+ std::shared_ptr<AudioCapabilities> getAudioCapabilities() const;
+
+ /**
+ * Returns the video capabilities or {@code null} if this is not a video codec.
+ */
+ std::shared_ptr<VideoCapabilities> getVideoCapabilities() const;
+
+ /**
+ * Returns the encoding capabilities or {@code null} if this is not an encoder.
+ */
+ std::shared_ptr<EncoderCapabilities> getEncoderCapabilities() const;
+
+ std::vector<std::string> validFeatures() const;
+
+ /**
+ * Query codec feature capabilities.
+ * <p>
+ * These features are supported to be used by the codec. These
+ * include optional features that can be turned on, as well as
+ * features that are always on.
+ */
+ bool isFeatureSupported(const std::string &name) const;
+
+ /**
+ * Query codec feature requirements.
+ * <p>
+ * These features are required to be used by the codec, and as such,
+ * they are always turned on.
+ */
+ bool isFeatureRequired(const std::string &name) const;
+
+ bool isRegular() const;
+
+ /**
+ * Query whether codec supports a given {@link MediaFormat}.
+ *
+ * <p class=note>
+ * <strong>Note:</strong> On {@link android.os.Build.VERSION_CODES#LOLLIPOP},
+ * {@code format} must not contain a {@linkplain MediaFormat#KEY_FRAME_RATE
+ * frame rate}. Use
+ * <code class=prettyprint>format.setString(MediaFormat.KEY_FRAME_RATE, null)</code>
+ * to clear any existing frame rate setting in the format.
+ * <p>
+ *
+ * The following table summarizes the format keys considered by this method.
+ * This is especially important to consider when targeting a higher SDK version than the
+ * minimum SDK version, as this method will disregard some keys on devices below the target
+ * SDK version.
+ *
+ * <table style="width: 0%">
+ * <thead>
+ * <tr>
+ * <th rowspan=3>OS Version(s)</th>
+ * <td colspan=3>{@code MediaFormat} keys considered for</th>
+ * </tr><tr>
+ * <th>Audio Codecs</th>
+ * <th>Video Codecs</th>
+ * <th>Encoders</th>
+ * </tr>
+ * </thead>
+ * <tbody>
+ * <tr>
+ * <td>{@link android.os.Build.VERSION_CODES#LOLLIPOP}</td>
+ * <td rowspan=3>{@link MediaFormat#KEY_MIME}<sup>*</sup>,<br>
+ * {@link MediaFormat#KEY_SAMPLE_RATE},<br>
+ * {@link MediaFormat#KEY_CHANNEL_COUNT},</td>
+ * <td>{@link MediaFormat#KEY_MIME}<sup>*</sup>,<br>
+ * {@link CodecCapabilities#FEATURE_AdaptivePlayback}<sup>D</sup>,<br>
+ * {@link CodecCapabilities#FEATURE_SecurePlayback}<sup>D</sup>,<br>
+ * {@link CodecCapabilities#FEATURE_TunneledPlayback}<sup>D</sup>,<br>
+ * {@link MediaFormat#KEY_WIDTH},<br>
+ * {@link MediaFormat#KEY_HEIGHT},<br>
+ * <strong>no</strong> {@code KEY_FRAME_RATE}</td>
+ * <td rowspan=10>as to the left, plus<br>
+ * {@link MediaFormat#KEY_BITRATE_MODE},<br>
+ * {@link MediaFormat#KEY_PROFILE}
+ * (and/or {@link MediaFormat#KEY_AAC_PROFILE}<sup>~</sup>),<br>
+ * <!-- {link MediaFormat#KEY_QUALITY},<br> -->
+ * {@link MediaFormat#KEY_COMPLEXITY}
+ * (and/or {@link MediaFormat#KEY_FLAC_COMPRESSION_LEVEL}<sup>~</sup>)</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#LOLLIPOP_MR1}</td>
+ * <td rowspan=2>as above, plus<br>
+ * {@link MediaFormat#KEY_FRAME_RATE}</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#M}</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#N}</td>
+ * <td rowspan=2>as above, plus<br>
+ * {@link MediaFormat#KEY_PROFILE},<br>
+ * <!-- {link MediaFormat#KEY_MAX_BIT_RATE},<br> -->
+ * {@link MediaFormat#KEY_BIT_RATE}</td>
+ * <td rowspan=2>as above, plus<br>
+ * {@link MediaFormat#KEY_PROFILE},<br>
+ * {@link MediaFormat#KEY_LEVEL}<sup>+</sup>,<br>
+ * <!-- {link MediaFormat#KEY_MAX_BIT_RATE},<br> -->
+ * {@link MediaFormat#KEY_BIT_RATE},<br>
+ * {@link CodecCapabilities#FEATURE_IntraRefresh}<sup>E</sup></td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#N_MR1}</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#O}</td>
+ * <td rowspan=3 colspan=2>as above, plus<br>
+ * {@link CodecCapabilities#FEATURE_PartialFrame}<sup>D</sup></td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#O_MR1}</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#P}</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#Q}</td>
+ * <td colspan=2>as above, plus<br>
+ * {@link CodecCapabilities#FEATURE_FrameParsing}<sup>D</sup>,<br>
+ * {@link CodecCapabilities#FEATURE_MultipleFrames},<br>
+ * {@link CodecCapabilities#FEATURE_DynamicTimestamp}</td>
+ * </tr><tr>
+ * <td>{@link android.os.Build.VERSION_CODES#R}</td>
+ * <td colspan=2>as above, plus<br>
+ * {@link CodecCapabilities#FEATURE_LowLatency}<sup>D</sup></td>
+ * </tr>
+ * <tr>
+ * <td colspan=4>
+ * <p class=note><strong>Notes:</strong><br>
+ * *: must be specified; otherwise, method returns {@code false}.<br>
+ * +: method does not verify that the format parameters are supported
+ * by the specified level.<br>
+ * D: decoders only<br>
+ * E: encoders only<br>
+ * ~: if both keys are provided values must match
+ * </td>
+ * </tr>
+ * </tbody>
+ * </table>
+ *
+ * @param format media format with optional feature directives.
+ * @return whether the codec capabilities support the given format
+ * and feature requests.
+ */
+ bool isFormatSupported(const sp<AMessage> &format) const;
+
+ /**
+ * If the CodecCapabilities contains an AudioCapabilities.
+ *
+ * Not a public API to users.
+ */
+ bool isAudio() const;
+
+ /**
+ * If the CodecCapabilities contains a VideoCapabilities.
+ *
+ * Not a public API to users.
+ */
+ bool isVideo() const;
+
+ /**
+ * If the CodecCapabilities contains an EncoderCapabilities.
+ *
+ * Not a public API to users.
+ */
+ bool isEncoder() const;
+
private:
std::string mMediaType;
std::vector<ProfileLevel> mProfileLevels;
+ std::vector<uint32_t> mColorFormats;
+ int32_t mMaxSupportedInstances;
+
+ sp<AMessage> mDefaultFormat;
+ sp<AMessage> mCapabilitiesInfo;
+
+ // Features
+ std::set<std::string> mFeaturesSupported;
+ std::set<std::string> mFeaturesRequired;
std::shared_ptr<AudioCapabilities> mAudioCaps;
+ std::shared_ptr<VideoCapabilities> mVideoCaps;
+ std::shared_ptr<EncoderCapabilities> mEncoderCaps;
+
+ bool supportsProfileLevel(int32_t profile, int32_t level) const;
+ std::vector<Feature> getValidFeatures() const;
+ int32_t getErrors() const;
};
} // namespace android
diff --git a/media/libmedia/include/media/CodecCapabilitiesUtils.h b/media/libmedia/include/media/CodecCapabilitiesUtils.h
index 89a452c..eb62bf9 100644
--- a/media/libmedia/include/media/CodecCapabilitiesUtils.h
+++ b/media/libmedia/include/media/CodecCapabilitiesUtils.h
@@ -19,8 +19,12 @@
#define CODEC_CAPABILITIES__UTILS_H_
#include <algorithm>
+#include <cerrno>
#include <cmath>
+#include <cstdlib>
+#include <numeric>
#include <optional>
+#include <regex>
#include <string>
#include <vector>
@@ -38,6 +42,21 @@
}
};
+struct Feature {
+ std::string mName;
+ int mValue;
+ bool mDefault;
+ bool mInternal;
+ Feature(std::string name, int value, bool def, bool internal) {
+ mName = name;
+ mValue = value;
+ mDefault = def;
+ mInternal = internal;
+ }
+ Feature(std::string name, int value, bool def) :
+ Feature(name, value, def, false /* internal */) {}
+};
+
/**
* Immutable class for describing the range of two numeric values.
*
@@ -113,6 +132,74 @@
return Range(std::max(lower_, lower), std::min(upper_, upper));
}
+ /**
+ * Returns the smallest range that includes this range and
+ * another range.
+ *
+ * E.g. if a < b < c < d, the
+ * extension of [a, c] and [b, d] ranges is [a, d].
+ * As the endpoints are object references, there is no guarantee
+ * which specific endpoint reference is used from the input ranges:
+ *
+ * E.g. if a == a' < b < c, the
+ * extension of [a, b] and [a', c] ranges could be either
+ * [a, c] or ['a, c], where ['a, c] could be either the exact
+ * input range, or a newly created range with the same endpoints.
+ *
+ * @param range a non-null Range<T> reference
+ * @return the extension of this range and the other range.
+ */
+ Range<T> extend(Range<T> range) {
+ return Range<T>(std::min(lower_, range.lower_), std::max(upper_, range.upper_));
+ }
+
+ Range<T> align(T align) {
+ return this->intersect(
+ divUp(lower_, align) * align, (upper_ / align) * align);
+ }
+
+ Range<T> factor(T factor) {
+ if (factor == 1) {
+ return *this;
+ }
+ return Range(divUp(this->lower(), factor), this->upper() / factor);
+ }
+
+ // parse a string into a range
+ static std::optional<Range<T>> Parse(const std::string &str) {
+ if (str.empty()) {
+ ALOGW("could not parse empty integer range");
+ return std::nullopt;
+ }
+ long long lower, upper;
+ std::regex regex("^([0-9]+)-([0-9]+)$");
+ std::smatch match;
+ errno = 0;
+ if (std::regex_match(str, match, regex)) {
+ lower = std::strtoll(match[1].str().c_str(), NULL, 10);
+ upper = std::strtoll(match[2].str().c_str(), NULL, 10);
+ } else {
+ char *end;
+ lower = upper = std::strtoll(str.c_str(), &end, 10);
+ if (*end != '\0') {
+ ALOGW("could not parse integer range: %s", str.c_str());
+ return std::nullopt;
+ }
+ }
+
+ if (errno == ERANGE || lower < std::numeric_limits<T>::min()
+ || std::numeric_limits<T>::max() < upper || upper < lower) {
+ ALOGW("could not parse integer range: %s", str.c_str());
+ return std::nullopt;
+ }
+
+ return std::make_optional<Range<T>>((T)lower, (T)upper);
+ }
+
+ static Range<T> RangeFor(double v) {
+ return Range((T)v, (T)ceil(v));
+ }
+
private:
T lower_;
T upper_;
@@ -125,7 +212,7 @@
// found profile/level for which we don't have capability estimates
constexpr int ERROR_CAPABILITIES_UNSUPPORTED = (1 << 1);
// have not found any profile/level for which we don't have capability estimate
-// constexpr int ERROR_NONE_SUPPORTED = (1 << 2);
+constexpr int ERROR_CAPABILITIES_NONE_SUPPORTED = (1 << 2);
/**
* Sorts distinct (non-intersecting) range array in ascending order.
@@ -176,8 +263,464 @@
return result;
}
-// parse string into int range
-std::optional<Range<int>> ParseIntRange(const std::string &str);
+/**
+ * Immutable class for describing width and height dimensions in pixels.
+ */
+struct VideoSize {
+ /**
+ * Create a new immutable VideoSize instance.
+ *
+ * @param width The width of the size, in pixels
+ * @param height The height of the size, in pixels
+ */
+ VideoSize(int32_t width, int32_t height);
+
+ // default constructor
+ VideoSize();
+
+ /**
+ * Get the width of the size (in pixels).
+ * @return width
+ */
+ int32_t getWidth() const;
+
+ /**
+ * Get the height of the size (in pixels).
+ * @return height
+ */
+ int32_t getHeight() const;
+
+ /**
+ * Check if this size is equal to another size.
+ *
+ * Two sizes are equal if and only if both their widths and heights are
+ * equal.
+ *
+ * A size object is never equal to any other type of object.
+ *
+ * @return true if the objects were equal, false otherwise
+ */
+ bool equals(VideoSize other) const;
+
+ bool empty() const;
+
+ std::string toString() const;
+
+ /**
+ * Parses the specified string as a size value.
+ *
+ * The ASCII characters {@code \}{@code u002a} ('*') and
+ * {@code \}{@code u0078} ('x') are recognized as separators between
+ * the width and height.
+ *
+ * For any {@code VideoSize s}: {@code VideoSize::ParseSize(s.toString()).equals(s)}.
+ * However, the method also handles sizes expressed in the
+ * following forms:
+ *
+ * "<i>width</i>{@code x}<i>height</i>" or
+ * "<i>width</i>{@code *}<i>height</i>" {@code => new VideoSize(width, height)},
+ * where <i>width</i> and <i>height</i> are string integers potentially
+ * containing a sign, such as "-10", "+7" or "5".
+ *
+ * <pre>{@code
+ * VideoSize::ParseSize("3*+6").equals(new VideoSize(3, 6)) == true
+ * VideoSize::ParseSize("-3x-6").equals(new VideoSize(-3, -6)) == true
+ * VideoSize::ParseSize("4 by 3") => throws NumberFormatException
+ * }</pre>
+ *
+ * @param string the string representation of a size value.
+ * @return the size value represented by {@code string}.
+ */
+ static std::optional<VideoSize> ParseSize(std::string str);
+
+ static std::optional<std::pair<VideoSize, VideoSize>> ParseSizeRange(const std::string str);
+
+ static Range<int32_t> GetAllowedDimensionRange();
+
+private:
+ int32_t mWidth;
+ int32_t mHeight;
+};
+
+// This is used for the std::map<VideoSize> in VideoCapabilities
+struct VideoSizeCompare {
+ bool operator() (const VideoSize& lhs, const VideoSize& rhs) const {
+ if (lhs.getWidth() == rhs.getWidth()) {
+ return lhs.getHeight() < rhs.getHeight();
+ } else {
+ return lhs.getWidth() < rhs.getWidth();
+ }
+ }
+};
+
+/**
+ * An immutable data type representation a rational number.
+ *
+ * Contains a pair of ints representing the numerator and denominator of a
+ * Rational number.
+ */
+struct Rational {
+ /**
+ * <p>Create a {@code Rational} with a given numerator and denominator.</p>
+ *
+ * <p>The signs of the numerator and the denominator may be flipped such that the denominator
+ * is always positive. Both the numerator and denominator will be converted to their reduced
+ * forms (see {@link #equals} for more details).</p>
+ *
+ * <p>For example,
+ * <ul>
+ * <li>a rational of {@code 2/4} will be reduced to {@code 1/2}.
+ * <li>a rational of {@code 1/-1} will be flipped to {@code -1/1}
+ * <li>a rational of {@code 5/0} will be reduced to {@code 1/0}
+ * <li>a rational of {@code 0/5} will be reduced to {@code 0/1}
+ * </ul>
+ * </p>
+ *
+ * @param numerator the numerator of the rational
+ * @param denominator the denominator of the rational
+ *
+ * @see #equals
+ */
+ Rational(int32_t numerator, int32_t denominator) {
+ if (denominator < 0) {
+ numerator = -numerator;
+ denominator = -denominator;
+ }
+
+ // Convert to reduced form
+ if (denominator == 0 && numerator > 0) {
+ mNumerator = 1; // +Inf
+ mDenominator = 0;
+ } else if (denominator == 0 && numerator < 0) {
+ mNumerator = -1; // -Inf
+ mDenominator = 0;
+ } else if (denominator == 0 && numerator == 0) {
+ mNumerator = 0; // NaN
+ mDenominator = 0;
+ } else if (numerator == 0) {
+ mNumerator = 0;
+ mDenominator = 1;
+ } else {
+ int gcd = std::gcd(numerator, denominator);
+
+ mNumerator = numerator / gcd;
+ mDenominator = denominator / gcd;
+ }
+ }
+
+ // default constructor;
+ Rational() {
+ Rational(0, 0);
+ }
+
+ /**
+ * Gets the numerator of the rational.
+ *
+ * <p>The numerator will always return {@code 1} if this rational represents
+ * infinity (that is, the denominator is {@code 0}).</p>
+ */
+ int32_t getNumerator() const {
+ return mNumerator;
+ }
+
+ /**
+ * Gets the denominator of the rational
+ *
+ * <p>The denominator may return {@code 0}, in which case the rational may represent
+ * positive infinity (if the numerator was positive), negative infinity (if the numerator
+ * was negative), or {@code NaN} (if the numerator was {@code 0}).</p>
+ *
+ * <p>The denominator will always return {@code 1} if the numerator is {@code 0}.
+ */
+ int32_t getDenominator() const {
+ return mDenominator;
+ }
+
+ /**
+ * Indicates whether this rational is a <em>Not-a-Number (NaN)</em> value.
+ *
+ * <p>A {@code NaN} value occurs when both the numerator and the denominator are {@code 0}.</p>
+ *
+ * @return {@code true} if this rational is a <em>Not-a-Number (NaN)</em> value;
+ * {@code false} if this is a (potentially infinite) number value
+ */
+ bool isNaN() const {
+ return mDenominator == 0 && mNumerator == 0;
+ }
+
+ /**
+ * Indicates whether this rational represents an infinite value.
+ *
+ * <p>An infinite value occurs when the denominator is {@code 0} (but the numerator is not).</p>
+ *
+ * @return {@code true} if this rational is a (positive or negative) infinite value;
+ * {@code false} if this is a finite number value (or {@code NaN})
+ */
+ bool isInfinite() const {
+ return mNumerator != 0 && mDenominator == 0;
+ }
+
+ /**
+ * Indicates whether this rational represents a finite value.
+ *
+ * <p>A finite value occurs when the denominator is not {@code 0}; in other words
+ * the rational is neither infinity or {@code NaN}.</p>
+ *
+ * @return {@code true} if this rational is a (positive or negative) infinite value;
+ * {@code false} if this is a finite number value (or {@code NaN})
+ */
+ bool isFinite() const {
+ return mDenominator != 0;
+ }
+
+ /**
+ * Indicates whether this rational represents a zero value.
+ *
+ * <p>A zero value is a {@link #isFinite finite} rational with a numerator of {@code 0}.</p>
+ *
+ * @return {@code true} if this rational is finite zero value;
+ * {@code false} otherwise
+ */
+ bool isZero() const {
+ return isFinite() && mNumerator == 0;
+ }
+
+ /**
+ * Return a string representation of this rational, e.g. {@code "1/2"}.
+ *
+ * <p>The following rules of conversion apply:
+ * <ul>
+ * <li>{@code NaN} values will return {@code "NaN"}
+ * <li>Positive infinity values will return {@code "Infinity"}
+ * <li>Negative infinity values will return {@code "-Infinity"}
+ * <li>All other values will return {@code "numerator/denominator"} where {@code numerator}
+ * and {@code denominator} are substituted with the appropriate numerator and denominator
+ * values.
+ * </ul></p>
+ */
+ std::string toString() const {
+ if (isNaN()) {
+ return "NaN";
+ } else if (isPosInf()) {
+ return "Infinity";
+ } else if (isNegInf()) {
+ return "-Infinity";
+ } else {
+ return std::to_string(mNumerator) + "/" + std::to_string(mDenominator);
+ }
+ }
+
+ /**
+ * Returns the value of the specified number as a {@code double}.
+ *
+ * <p>The {@code double} is calculated by converting both the numerator and denominator
+ * to a {@code double}; then returning the result of dividing the numerator by the
+ * denominator.</p>
+ *
+ * @return the divided value of the numerator and denominator as a {@code double}.
+ */
+ double asDouble() const {
+ double num = mNumerator;
+ double den = mDenominator;
+
+ return num / den;
+ }
+
+ /**
+ * Returns the value of the specified number as a {@code float}.
+ *
+ * <p>The {@code float} is calculated by converting both the numerator and denominator
+ * to a {@code float}; then returning the result of dividing the numerator by the
+ * denominator.</p>
+ *
+ * @return the divided value of the numerator and denominator as a {@code float}.
+ */
+ float asfloat() const {
+ float num = mNumerator;
+ float den = mDenominator;
+
+ return num / den;
+ }
+
+ /**
+ * Returns the value of the specified number as a {@code int}.
+ *
+ * <p>{@link #isInfinite Finite} rationals are converted to an {@code int} value
+ * by dividing the numerator by the denominator; conversion for non-finite values happens
+ * identically to casting a floating point value to an {@code int}, in particular:
+ *
+ * @return the divided value of the numerator and denominator as a {@code int}.
+ */
+ int32_t asInt32() const {
+ // Mimic float to int conversion rules from JLS 5.1.3
+
+ if (isPosInf()) {
+ return INT32_MAX;
+ } else if (isNegInf()) {
+ return INT32_MIN;
+ } else if (isNaN()) {
+ return 0;
+ } else { // finite
+ return mNumerator / mDenominator;
+ }
+ }
+
+ /**
+ * Returns the value of the specified number as a {@code long}.
+ *
+ * <p>{@link #isInfinite Finite} rationals are converted to an {@code long} value
+ * by dividing the numerator by the denominator; conversion for non-finite values happens
+ * identically to casting a floating point value to a {@code long}, in particular:
+ *
+ * @return the divided value of the numerator and denominator as a {@code long}.
+ */
+ int64_t asInt64() const {
+ // Mimic float to long conversion rules from JLS 5.1.3
+
+ if (isPosInf()) {
+ return INT64_MAX;
+ } else if (isNegInf()) {
+ return INT64_MIN;
+ } else if (isNaN()) {
+ return 0;
+ } else { // finite
+ return mNumerator / mDenominator;
+ }
+ }
+
+ /**
+ * Returns the value of the specified number as a {@code short}.
+ *
+ * <p>{@link #isInfinite Finite} rationals are converted to a {@code short} value
+ * identically to {@link #intValue}; the {@code int} result is then truncated to a
+ * {@code short} before returning the value.</p>
+ *
+ * @return the divided value of the numerator and denominator as a {@code short}.
+ */
+ int16_t asInt16() const {
+ return (int16_t) asInt32();
+ }
+
+ /**
+ * Compare this rational to the specified rational to determine their natural order.
+ *
+ * Nan is considered to be equal to itself and greater than all other
+ * Rational values. Otherwise, if the objects are not equal, then
+ * the following rules apply:
+ *
+ * Positive infinity is greater than any other finite number (or negative infinity)
+ * Negative infinity is less than any other finite number (or positive infinity)
+ * The finite number represented by this rational is checked numerically
+ * against the other finite number by converting both rationals to a common denominator multiple
+ * and comparing their numerators.
+ *
+ * @param another the rational to be compared
+ *
+ * @return a negative integer, zero, or a positive integer as this object is less than,
+ * equal to, or greater than the specified rational.
+ */
+ // bool operator> (const Rational& another) {
+ int compareTo(Rational another) const {
+ if (equals(another)) {
+ return 0;
+ } else if (isNaN()) { // NaN is greater than the other non-NaN value
+ return 1;
+ } else if (another.isNaN()) { // the other NaN is greater than this non-NaN value
+ return -1;
+ } else if (isPosInf() || another.isNegInf()) {
+ return 1; // positive infinity is greater than any non-NaN/non-posInf value
+ } else if (isNegInf() || another.isPosInf()) {
+ return -1; // negative infinity is less than any non-NaN/non-negInf value
+ }
+
+ // else both this and another are finite numbers
+
+ // make the denominators the same, then compare numerators. int64_t to avoid overflow
+ int64_t thisNumerator = ((int64_t)mNumerator) * another.mDenominator;
+ int64_t otherNumerator = ((int64_t)another.mNumerator) * mDenominator;
+
+ // avoid underflow from subtraction by doing comparisons
+ if (thisNumerator < otherNumerator) {
+ return -1;
+ } else if (thisNumerator > otherNumerator) {
+ return 1;
+ } else {
+ // This should be covered by #equals, but have this code path just in case
+ return 0;
+ }
+ }
+
+ bool operator > (const Rational& another) const {
+ return compareTo(another) > 0;
+ }
+
+ bool operator >= (const Rational& another) const {
+ return compareTo(another) >= 0;
+ }
+
+ bool operator < (const Rational& another) const {
+ return compareTo(another) < 0;
+ }
+
+ bool operator <= (const Rational& another) const {
+ return compareTo(another) <= 0;
+ }
+
+ bool operator == (const Rational& another) const {
+ return equals(another);
+ }
+
+ static std::optional<Range<Rational>> ParseRange(const std::string str);
+
+ static Range<Rational> ScaleRange(Range<Rational> range, int32_t num, int32_t den);
+
+private:
+ int32_t mNumerator;
+ int32_t mDenominator;
+
+ bool isPosInf() const {
+ return mDenominator == 0 && mNumerator > 0;
+ }
+
+ bool isNegInf() const {
+ return mDenominator == 0 && mNumerator < 0;
+ }
+
+ bool equals(Rational other) const {
+ return (mNumerator == other.mNumerator && mDenominator == other.mDenominator);
+ }
+
+ Rational scale(int32_t num, int32_t den);
+
+ /**
+ * Parses the specified string as a rational value.
+ * The ASCII characters {@code \}{@code u003a} (':') and
+ * {@code \}{@code u002f} ('/') are recognized as separators between
+ * the numerator and denominator.
+ *
+ * For any {@code Rational r}: {@code Rational::parseRational(r.toString()).equals(r)}.
+ * However, the method also handles rational numbers expressed in the
+ * following forms:
+ *
+ * "<i>num</i>{@code /}<i>den</i>" or
+ * "<i>num</i>{@code :}<i>den</i>" {@code => new Rational(num, den);},
+ * where <i>num</i> and <i>den</i> are string integers potentially
+ * containing a sign, such as "-10", "+7" or "5".
+ *
+ * Rational::Parse("3:+6").equals(new Rational(1, 2)) == true
+ * Rational::Parse("-3/-6").equals(new Rational(1, 2)) == true
+ * Rational::Parse("4.56") => return std::nullopt
+ *
+ * @param str the string representation of a rational value.
+ * @return the rational value wrapped by std::optional represented by str.
+ */
+ static std::optional<Rational> Parse(std::string str);
+};
+
+static const Rational NaN = Rational(0, 0);
+static const Rational POSITIVE_INFINITY = Rational(1, 0);
+static const Rational NEGATIVE_INFINITY = Rational(-1, 0);
+static const Rational ZERO = Rational(0, 1);
} // namespace android
diff --git a/media/libmedia/include/media/EncoderCapabilities.h b/media/libmedia/include/media/EncoderCapabilities.h
new file mode 100644
index 0000000..a9654bb
--- /dev/null
+++ b/media/libmedia/include/media/EncoderCapabilities.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2024, The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ENCODER_CAPABILITIES_H_
+
+#define ENCODER_CAPABILITIES_H_
+
+#include <media/CodecCapabilitiesUtils.h>
+#include <media/stagefright/foundation/AMessage.h>
+
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+/**
+ * A class that supports querying the encoding capabilities of a codec.
+ */
+struct EncoderCapabilities {
+ /**
+ * Returns the supported range of quality values.
+ *
+ * Quality is implementation-specific. As a general rule, a higher quality
+ * setting results in a better image quality and a lower compression ratio.
+ */
+ const Range<int>& getQualityRange();
+
+ /**
+ * Returns the supported range of encoder complexity values.
+ * <p>
+ * Some codecs may support multiple complexity levels, where higher
+ * complexity values use more encoder tools (e.g. perform more
+ * intensive calculations) to improve the quality or the compression
+ * ratio. Use a lower value to save power and/or time.
+ */
+ const Range<int>& getComplexityRange();
+
+ /** Constant quality mode */
+ inline static constexpr int BITRATE_MODE_CQ = 0;
+ /** Variable bitrate mode */
+ inline static constexpr int BITRATE_MODE_VBR = 1;
+ /** Constant bitrate mode */
+ inline static constexpr int BITRATE_MODE_CBR = 2;
+ /** Constant bitrate mode with frame drops */
+ inline static constexpr int BITRATE_MODE_CBR_FD = 3;
+
+ /**
+ * Query whether a bitrate mode is supported.
+ */
+ bool isBitrateModeSupported(int mode);
+
+ /** @hide */
+ static std::shared_ptr<EncoderCapabilities> Create(std::string mediaType,
+ std::vector<ProfileLevel> profLevs, const sp<AMessage> &format);
+
+ /** @hide */
+ void getDefaultFormat(sp<AMessage> &format);
+
+ /** @hide */
+ bool supportsFormat(const sp<AMessage> &format);
+
+private:
+ inline static const Feature sBitrateModes[] = {
+ Feature("VBR", BITRATE_MODE_VBR, true),
+ Feature("CBR", BITRATE_MODE_CBR, false),
+ Feature("CQ", BITRATE_MODE_CQ, false),
+ Feature("CBR-FD", BITRATE_MODE_CBR_FD, false)
+ };
+ static int ParseBitrateMode(std::string mode);
+
+ std::string mMediaType;
+ std::vector<ProfileLevel> mProfileLevels;
+
+ Range<int> mQualityRange;
+ Range<int> mComplexityRange;
+ int mBitControl;
+ int mDefaultComplexity;
+ int mDefaultQuality;
+ std::string mQualityScale;
+
+ /* no public constructor */
+ EncoderCapabilities() {}
+ void init(std::string mediaType, std::vector<ProfileLevel> profLevs,
+ const sp<AMessage> &format);
+ void applyLevelLimits();
+ void parseFromInfo(const sp<AMessage> &format);
+ bool supports(std::optional<int> complexity, std::optional<int> quality,
+ std::optional<int> profile);
+};
+
+} // namespace android
+
+#endif // ENCODER_CAPABILITIES_H_
\ No newline at end of file
diff --git a/media/libmedia/include/media/VideoCapabilities.h b/media/libmedia/include/media/VideoCapabilities.h
new file mode 100644
index 0000000..5671375
--- /dev/null
+++ b/media/libmedia/include/media/VideoCapabilities.h
@@ -0,0 +1,457 @@
+/*
+ * Copyright 2024, The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef VIDEO_CAPABILITIES_H_
+
+#define VIDEO_CAPABILITIES_H_
+
+#include <media/CodecCapabilitiesUtils.h>
+#include <media/stagefright/foundation/AMessage.h>
+
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+struct VideoCapabilities {
+ struct PerformancePoint {
+ /**
+ * Maximum number of macroblocks in the frame.
+ *
+ * Video frames are conceptually divided into 16-by-16 pixel blocks called macroblocks.
+ * Most coding standards operate on these 16-by-16 pixel blocks; thus, codec performance
+ * is characterized using such blocks.
+ *
+ * Test API
+ */
+ int32_t getMaxMacroBlocks() const;
+
+ /**
+ * Return the width.
+ *
+ * For internal use only.
+ */
+ int32_t getWidth() const;
+
+ /**
+ * Return the height.
+ *
+ * For internal use only.
+ */
+ int32_t getHeight() const;
+
+ /**
+ * Maximum frame rate in frames per second.
+ *
+ * Test API
+ */
+ int32_t getMaxFrameRate() const;
+
+ /**
+ * Maximum number of macroblocks processed per second.
+ *
+ * Test API
+ */
+ int64_t getMaxMacroBlockRate() const;
+
+ /**
+ * Return the block size.
+ *
+ * For internal use only.
+ */
+ VideoSize getBlockSize() const;
+
+ /**
+ * convert to a debug string
+ *
+ * Be careful about the serializable compatibility across API revisions.
+ */
+ std::string toString() const;
+
+ /**
+ * Create a detailed performance point with custom max frame rate and macroblock size.
+ *
+ * @param width frame width in pixels
+ * @param height frame height in pixels
+ * @param frameRate frames per second for frame width and height
+ * @param maxFrameRate maximum frames per second for any frame size
+ * @param blockSize block size for codec implementation. Must be powers of two in both
+ * width and height.
+ *
+ * Test API
+ */
+ PerformancePoint(int32_t width, int32_t height, int32_t frameRate, int32_t maxFrameRate,
+ VideoSize blockSize);
+
+ /**
+ * Create a detailed performance point with custom max frame rate and macroblock size.
+ *
+ * @param width frame width in pixels
+ * @param height frame height in pixels
+ * @param maxFrameRate maximum frames per second for any frame size
+ * @param maxMacroBlockRate maximum number of macroblocks processed per second.
+ * @param blockSize block size for codec implementation. Must be powers of two in both
+ * width and height.
+ *
+ * Test API
+ */
+ PerformancePoint(VideoSize blockSize, int32_t width, int32_t height, int maxFrameRate,
+ int64_t maxMacroBlockRate);
+
+ /**
+ * Convert a performance point to a larger blocksize.
+ *
+ * @param pp performance point. NonNull
+ * @param blockSize block size for codec implementation. NonNull.
+ *
+ * Test API
+ */
+ PerformancePoint(const PerformancePoint &pp, VideoSize newBlockSize);
+
+ /**
+ * Create a performance point for a given frame size and frame rate.
+ *
+ * @param width width of the frame in pixels
+ * @param height height of the frame in pixels
+ * @param frameRate frame rate in frames per second
+ */
+ PerformancePoint(int32_t width, int32_t height, int32_t frameRate);
+
+ /**
+ * Checks whether the performance point covers a media format.
+ *
+ * @param format Stream format considered
+ *
+ * @return {@code true} if the performance point covers the format.
+ */
+ bool covers(const sp<AMessage> &format) const;
+
+ /**
+ * Checks whether the performance point covers another performance point. Use this
+ * method to determine if a performance point advertised by a codec covers the
+ * performance point required. This method can also be used for loose ordering as this
+ * method is transitive.
+ *
+ * @param other other performance point considered
+ *
+ * @return {@code true} if the performance point covers the other.
+ */
+ bool covers(const PerformancePoint &other) const;
+
+ /**
+ * Check if two PerformancePoint instances are equal.
+ *
+ * @param other other PerformancePoint instance for comparison.
+ *
+ * @return true if two PerformancePoint are equal.
+ */
+ bool equals(const PerformancePoint &other) const;
+
+ private:
+ VideoSize mBlockSize; // codec block size in macroblocks
+ int32_t mWidth; // width in macroblocks
+ int32_t mHeight; // height in macroblocks
+ int32_t mMaxFrameRate; // max frames per second
+ int64_t mMaxMacroBlockRate; // max macro block rate
+
+ void init(int32_t width, int32_t height, int32_t frameRate, int32_t maxFrameRate,
+ VideoSize blockSize);
+
+ /** Saturates a 64 bit integer value to a 32 bit integer */
+ int32_t saturateInt64ToInt32(int64_t value) const;
+
+ /** This method may overflow */
+ int32_t align(int32_t value, int32_t alignment) const;
+
+ /** @return NonNull */
+ VideoSize getCommonBlockSize(const PerformancePoint &other) const;
+ };
+
+ /**
+ * Find the equivalent VP9 profile level.
+ *
+ * Not a public API to developers.
+ */
+ static int32_t EquivalentVP9Level(const sp<AMessage> &format);
+
+ /**
+ * Returns the range of supported bitrates in bits/second.
+ */
+ const Range<int32_t>& getBitrateRange() const;
+
+ /**
+ * Returns the range of supported video widths.
+ * 32-bit processes will not support resolutions larger than 4096x4096 due to
+ * the limited address space.
+ */
+ const Range<int32_t>& getSupportedWidths() const;
+
+ /**
+ * Returns the range of supported video heights.
+ * 32-bit processes will not support resolutions larger than 4096x4096 due to
+ * the limited address space.
+ */
+ const Range<int32_t>& getSupportedHeights() const;
+
+ /**
+ * Returns the alignment requirement for video width (in pixels).
+ *
+ * This is a power-of-2 value that video width must be a
+ * multiple of.
+ */
+ int32_t getWidthAlignment() const;
+
+ /**
+ * Returns the alignment requirement for video height (in pixels).
+ *
+ * This is a power-of-2 value that video height must be a
+ * multiple of.
+ */
+ int32_t getHeightAlignment() const;
+
+ /**
+ * Return the upper limit on the smaller dimension of width or height.
+ *
+ * Some codecs have a limit on the smaller dimension, whether it be
+ * the width or the height. E.g. a codec may only be able to handle
+ * up to 1920x1080 both in landscape and portrait mode (1080x1920).
+ * In this case the maximum width and height are both 1920, but the
+ * smaller dimension limit will be 1080. For other codecs, this is
+ * {@code Math.min(getSupportedWidths().getUpper(),
+ * getSupportedHeights().getUpper())}.
+ */
+ int32_t getSmallerDimensionUpperLimit() const;
+
+ /**
+ * Returns the range of supported frame rates.
+ *
+ * This is not a performance indicator. Rather, it expresses the
+ * limits specified in the coding standard, based on the complexities
+ * of encoding material for later playback at a certain frame rate,
+ * or the decoding of such material in non-realtime.
+ */
+ const Range<int32_t>& getSupportedFrameRates() const;
+
+ /**
+ * Returns the range of supported video widths for a video height.
+ * @param height the height of the video
+ */
+ std::optional<Range<int32_t>> getSupportedWidthsFor(int32_t height) const;
+
+ /**
+ * Returns the range of supported video heights for a video width
+ * @param width the width of the video
+ */
+ std::optional<Range<int32_t>> getSupportedHeightsFor(int32_t width) const;
+
+ /**
+ * Returns the range of supported video frame rates for a video size.
+ *
+ * This is not a performance indicator. Rather, it expresses the limits specified in
+ * the coding standard, based on the complexities of encoding material of a given
+ * size for later playback at a certain frame rate, or the decoding of such material
+ * in non-realtime.
+
+ * @param width the width of the video
+ * @param height the height of the video
+ */
+ std::optional<Range<double>> getSupportedFrameRatesFor(int32_t width, int32_t height) const;
+
+ /**
+ * Returns the range of achievable video frame rates for a video size.
+ * May return {@code null}, if the codec did not publish any measurement
+ * data.
+ * <p>
+ * This is a performance estimate provided by the device manufacturer based on statistical
+ * sampling of full-speed decoding and encoding measurements in various configurations
+ * of common video sizes supported by the codec. As such it should only be used to
+ * compare individual codecs on the device. The value is not suitable for comparing
+ * different devices or even different android releases for the same device.
+ * <p>
+ * <em>On {@link android.os.Build.VERSION_CODES#M} release</em> the returned range
+ * corresponds to the fastest frame rates achieved in the tested configurations. As
+ * such, it should not be used to gauge guaranteed or even average codec performance
+ * on the device.
+ * <p>
+ * <em>On {@link android.os.Build.VERSION_CODES#N} release</em> the returned range
+ * corresponds closer to sustained performance <em>in tested configurations</em>.
+ * One can expect to achieve sustained performance higher than the lower limit more than
+ * 50% of the time, and higher than half of the lower limit at least 90% of the time
+ * <em>in tested configurations</em>.
+ * Conversely, one can expect performance lower than twice the upper limit at least
+ * 90% of the time.
+ * <p class=note>
+ * Tested configurations use a single active codec. For use cases where multiple
+ * codecs are active, applications can expect lower and in most cases significantly lower
+ * performance.
+ * <p class=note>
+ * The returned range value is interpolated from the nearest frame size(s) tested.
+ * Codec performance is severely impacted by other activity on the device as well
+ * as environmental factors (such as battery level, temperature or power source), and can
+ * vary significantly even in a steady environment.
+ * <p class=note>
+ * Use this method in cases where only codec performance matters, e.g. to evaluate if
+ * a codec has any chance of meeting a performance target. Codecs are listed
+ * in {@link MediaCodecList} in the preferred order as defined by the device
+ * manufacturer. As such, applications should use the first suitable codec in the
+ * list to achieve the best balance between power use and performance.
+ *
+ * @param width the width of the video
+ * @param height the height of the video
+ */
+ std::optional<Range<double>> getAchievableFrameRatesFor(int32_t width, int32_t height) const;
+
+ /**
+ * Returns the supported performance points. May return {@code null} if the codec did not
+ * publish any performance point information (e.g. the vendor codecs have not been updated
+ * to the latest android release). May return an empty list if the codec published that
+ * if does not guarantee any performance points.
+ * <p>
+ * This is a performance guarantee provided by the device manufacturer for hardware codecs
+ * based on hardware capabilities of the device.
+ * <p>
+ * The returned list is sorted first by decreasing number of pixels, then by decreasing
+ * width, and finally by decreasing frame rate.
+ * Performance points assume a single active codec. For use cases where multiple
+ * codecs are active, should use that highest pixel count, and add the frame rates of
+ * each individual codec.
+ * <p class=note>
+ * 32-bit processes will not support resolutions larger than 4096x4096 due to
+ * the limited address space, but performance points will be presented as is.
+ * In other words, even though a component publishes a performance point for
+ * a resolution higher than 4096x4096, it does not mean that the resolution is supported
+ * for 32-bit processes.
+ */
+ const std::vector<PerformancePoint>& getSupportedPerformancePoints() const;
+
+ /**
+ * Returns whether a given video size ({@code width} and
+ * {@code height}) and {@code frameRate} combination is supported.
+ */
+ bool areSizeAndRateSupported(int32_t width, int32_t height, double frameRate) const;
+
+ /**
+ * Returns whether a given video size ({@code width} and
+ * {@code height}) is supported.
+ */
+ bool isSizeSupported(int32_t width, int32_t height) const;
+
+ /**
+ * Returns if a media format is supported.
+ *
+ * Not exposed to public
+ */
+ bool supportsFormat(const sp<AMessage> &format) const;
+
+ /**
+ * Create VideoCapabilities.
+ */
+ static std::shared_ptr<VideoCapabilities> Create(std::string mediaType,
+ std::vector<ProfileLevel> profLevs, const sp<AMessage> &format);
+
+ /**
+ * Get the block size.
+ *
+ * Not a public API to developers
+ */
+ VideoSize getBlockSize() const;
+
+ /**
+ * Get the block count range.
+ *
+ * Not a public API to developers
+ */
+ const Range<int32_t>& getBlockCountRange() const;
+
+ /**
+ * Get the blocks per second range.
+ *
+ * Not a public API to developers
+ */
+ const Range<int64_t>& getBlocksPerSecondRange() const;
+
+ /**
+ * Get the aspect ratio range.
+ *
+ * Not a public API to developers
+ */
+ Range<Rational> getAspectRatioRange(bool blocks) const;
+
+private:
+ std::string mMediaType;
+ std::vector<ProfileLevel> mProfileLevels;
+ int mError;
+
+ Range<int32_t> mBitrateRange;
+ Range<int32_t> mHeightRange;
+ Range<int32_t> mWidthRange;
+ Range<int32_t> mBlockCountRange;
+ Range<int32_t> mHorizontalBlockRange;
+ Range<int32_t> mVerticalBlockRange;
+ Range<Rational> mAspectRatioRange;
+ Range<Rational> mBlockAspectRatioRange;
+ Range<int64_t> mBlocksPerSecondRange;
+ std::map<VideoSize, Range<int64_t>, VideoSizeCompare> mMeasuredFrameRates;
+ std::vector<PerformancePoint> mPerformancePoints;
+ Range<int32_t> mFrameRateRange;
+
+ int32_t mBlockWidth;
+ int32_t mBlockHeight;
+ int32_t mWidthAlignment;
+ int32_t mHeightAlignment;
+ int mSmallerDimensionUpperLimit;
+
+ bool mAllowMbOverride; // allow XML to override calculated limits
+
+ int32_t getBlockCount(int32_t width, int32_t height) const;
+ std::optional<VideoSize> findClosestSize(int32_t width, int32_t height) const;
+ std::optional<Range<double>> estimateFrameRatesFor(int32_t width, int32_t height) const;
+ bool supports(std::optional<int32_t> width, std::optional<int32_t> height,
+ std::optional<double> rate) const;
+ /* no public constructor */
+ VideoCapabilities() {}
+ void init(std::string mediaType, std::vector<ProfileLevel> profLevs,
+ const sp<AMessage> &format);
+ void initWithPlatformLimits();
+ std::vector<PerformancePoint> getPerformancePoints(const sp<AMessage> &format) const;
+ std::map<VideoSize, Range<int64_t>, VideoSizeCompare>
+ getMeasuredFrameRates(const sp<AMessage> &format) const;
+
+ static std::optional<std::pair<Range<int32_t>, Range<int32_t>>> ParseWidthHeightRanges(
+ const std::string &str);
+ void parseFromInfo(const sp<AMessage> &format);
+ void applyBlockLimits(int32_t blockWidth, int32_t blockHeight,
+ Range<int32_t> counts, Range<int64_t> rates, Range<Rational> ratios);
+ void applyAlignment(int32_t widthAlignment, int32_t heightAlignment);
+ void updateLimits();
+ void applyMacroBlockLimits(
+ int32_t maxHorizontalBlocks, int32_t maxVerticalBlocks,
+ int32_t maxBlocks, int64_t maxBlocksPerSecond,
+ int32_t blockWidth, int32_t blockHeight,
+ int32_t widthAlignment, int32_t heightAlignment);
+ void applyMacroBlockLimits(
+ int32_t minHorizontalBlocks, int32_t minVerticalBlocks,
+ int32_t maxHorizontalBlocks, int32_t maxVerticalBlocks,
+ int32_t maxBlocks, int64_t maxBlocksPerSecond,
+ int32_t blockWidth, int32_t blockHeight,
+ int32_t widthAlignment, int32_t heightAlignment);
+ void applyLevelLimits();
+
+ friend struct CodecCapabilities;
+};
+
+} // namespace android
+
+#endif // VIDEO_CAPABILITIES_H_
\ No newline at end of file
diff --git a/media/libmedia/tests/codeccapabilities/CodecCapabilitiesTest.cpp b/media/libmedia/tests/codeccapabilities/CodecCapabilitiesTest.cpp
index 02e43a4..e59d4d6 100644
--- a/media/libmedia/tests/codeccapabilities/CodecCapabilitiesTest.cpp
+++ b/media/libmedia/tests/codeccapabilities/CodecCapabilitiesTest.cpp
@@ -72,15 +72,15 @@
}
TEST_F(AudioCapsAacTest, AudioCaps_Aac_InputChannelCount) {
- int maxInputChannelCount = audioCaps->getMaxInputChannelCount();
+ int32_t maxInputChannelCount = audioCaps->getMaxInputChannelCount();
EXPECT_EQ(maxInputChannelCount, 8);
- int minInputChannelCount = audioCaps->getMinInputChannelCount();
+ int32_t minInputChannelCount = audioCaps->getMinInputChannelCount();
EXPECT_EQ(minInputChannelCount, 1);
}
TEST_F(AudioCapsAacTest, AudioCaps_Aac_SupportedSampleRates) {
- const std::vector<int>& sampleRates = audioCaps->getSupportedSampleRates();
- EXPECT_EQ(sampleRates, std::vector<int>({7350, 8000, 11025, 12000, 16000, 22050,
+ const std::vector<int32_t>& sampleRates = audioCaps->getSupportedSampleRates();
+ EXPECT_EQ(sampleRates, std::vector<int32_t>({7350, 8000, 11025, 12000, 16000, 22050,
24000, 32000, 44100, 48000}));
EXPECT_FALSE(audioCaps->isSampleRateSupported(6000))
@@ -120,16 +120,16 @@
}
TEST_F(AudioCapsRawTest, AudioCaps_Raw_InputChannelCount) {
- int maxInputChannelCount = audioCaps->getMaxInputChannelCount();
+ int32_t maxInputChannelCount = audioCaps->getMaxInputChannelCount();
EXPECT_EQ(maxInputChannelCount, 12);
- int minInputChannelCount = audioCaps->getMinInputChannelCount();
+ int32_t minInputChannelCount = audioCaps->getMinInputChannelCount();
EXPECT_EQ(minInputChannelCount, 1);
}
TEST_F(AudioCapsRawTest, AudioCaps_Raw_InputChannelCountRanges) {
- const std::vector<Range<int>>& inputChannelCountRanges
+ const std::vector<Range<int32_t>>& inputChannelCountRanges
= audioCaps->getInputChannelCountRanges();
- std::vector<Range<int>> expectedOutput({{1,1}, {2,2}, {3,3}, {4,4}, {5,5},
+ std::vector<Range<int32_t>> expectedOutput({{1,1}, {2,2}, {3,3}, {4,4}, {5,5},
{6,6}, {7,7}, {8,8}, {9,9}, {10,10}, {11,11}, {12,12}});
ASSERT_EQ(inputChannelCountRanges.size(), expectedOutput.size());
for (int i = 0; i < inputChannelCountRanges.size(); i++) {
@@ -139,7 +139,7 @@
}
TEST_F(AudioCapsRawTest, AudioCaps_Raw_SupportedSampleRates) {
- const std::vector<Range<int>>& sampleRateRanges = audioCaps->getSupportedSampleRateRanges();
+ const std::vector<Range<int32_t>>& sampleRateRanges = audioCaps->getSupportedSampleRateRanges();
EXPECT_EQ(sampleRateRanges.size(), 1);
EXPECT_EQ(sampleRateRanges.at(0).lower(), 8000);
EXPECT_EQ(sampleRateRanges.at(0).upper(), 192000);
@@ -148,3 +148,226 @@
EXPECT_EQ(audioCaps->isSampleRateSupported(10000), true);
EXPECT_EQ(audioCaps->isSampleRateSupported(193000), false);
}
+
+class VideoCapsHevcTest : public testing::Test {
+protected:
+ VideoCapsHevcTest() {
+ std::string mediaType = MIMETYPE_VIDEO_HEVC;
+
+ sp<AMessage> details = new AMessage;
+ details->setString("alignment", "2x2");
+ details->setString("bitrate-range", "1-120000000");
+ details->setString("block-count-range", "1-32640");
+ details->setString("block-size", "16x16");
+ details->setString("blocks-per-second-range", "1-3916800");
+ details->setInt32("feature-adaptive-playback", 0);
+ details->setInt32("feature-can-swap-width-height", 1);
+ details->setString("max-concurrent-instances", "16");
+ details->setString("measured-frame-rate-1280x720-range", "547-553");
+ details->setString("measured-frame-rate-1920x1080-range", "569-572");
+ details->setString("measured-frame-rate-352x288-range", "1150-1250");
+ details->setString("measured-frame-rate-3840x2160-range", "159-159");
+ details->setString("measured-frame-rate-640x360-range", "528-529");
+ details->setString("measured-frame-rate-720x480-range", "546-548");
+ details->setString("performance-point-1280x720-range", "240");
+ details->setString("performance-point-3840x2160-range", "120");
+ details->setString("size-range", "64x64-3840x2176");
+
+ std::vector<ProfileLevel> profileLevel{
+ ProfileLevel(1, 8388608),
+ ProfileLevel(2, 8388608),
+ ProfileLevel(4096, 8388608),
+ ProfileLevel(8192, 8388608),
+ };
+
+ videoCaps = VideoCapabilities::Create(mediaType, profileLevel, details);
+ }
+
+ std::shared_ptr<VideoCapabilities> videoCaps;
+};
+
+TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_Alignment) {
+ int32_t widthAlignment = videoCaps->getWidthAlignment();
+ EXPECT_EQ(widthAlignment, 2);
+ int32_t heightAlignment = videoCaps->getHeightAlignment();
+ EXPECT_EQ(heightAlignment, 2);
+}
+
+TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_BitrateRange) {
+ const Range<int32_t>& bitrateRange = videoCaps->getBitrateRange();
+ EXPECT_EQ(bitrateRange.lower(), 1);
+ EXPECT_EQ(bitrateRange.upper(), 120000000);
+}
+
+TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_SupportedWidthsAndHeights) {
+ const Range<int32_t>& supportedWidths = videoCaps->getSupportedWidths();
+ EXPECT_EQ(supportedWidths.upper(), 3840);
+ const Range<int32_t>& supportedHeights = videoCaps->getSupportedHeights();
+ EXPECT_EQ(supportedHeights.upper(), 3840);
+}
+
+TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_SupportedFrameRates) {
+ const Range<int32_t>& supportedFrameRates = videoCaps->getSupportedFrameRates();
+ EXPECT_EQ(supportedFrameRates.lower(), 0);
+ EXPECT_EQ(supportedFrameRates.upper(), 960);
+
+ std::optional<Range<double>> supportedFR720p = videoCaps->getSupportedFrameRatesFor(1280, 720);
+ EXPECT_EQ(supportedFR720p.value().upper(), 960.0);
+ std::optional<Range<double>> supportedFR1080p
+ = videoCaps->getSupportedFrameRatesFor(1920, 1080);
+ EXPECT_EQ(supportedFR1080p.value().upper(), 480.0);
+ std::optional<Range<double>> supportedFR4k = videoCaps->getSupportedFrameRatesFor(3840, 2160);
+ EXPECT_EQ(std::round(supportedFR4k.value().upper()), 121);
+}
+
+TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_AchievableFrameRates) {
+ std::optional<Range<double>> achievableFR1080p
+ = videoCaps->getAchievableFrameRatesFor(1920, 1080);
+ ASSERT_NE(achievableFR1080p, std::nullopt) << "resolution not supported";
+ EXPECT_EQ(achievableFR1080p.value().lower(), 569);
+ EXPECT_EQ(achievableFR1080p.value().upper(), 572);
+}
+
+class EncoderCapsAacTest : public testing::Test {
+protected:
+ EncoderCapsAacTest() {
+ std::string mediaType = MIMETYPE_AUDIO_AAC;
+
+ sp<AMessage> details = new AMessage;
+ details->setString("bitrate-range", "8000-960000");
+ details->setString("max-channel-count", "6");
+ details->setString("sample-rate-ranges",
+ "8000,11025,12000,16000,22050,24000,32000,44100,48000");
+
+ std::vector<ProfileLevel> profileLevel{
+ ProfileLevel(2, 0),
+ ProfileLevel(5, 0),
+ ProfileLevel(29, 0),
+ ProfileLevel(23, 0),
+ ProfileLevel(39, 0),
+ };
+
+ encoderCaps = EncoderCapabilities::Create(mediaType, profileLevel, details);
+ }
+
+ std::shared_ptr<EncoderCapabilities> encoderCaps;
+};
+
+
+TEST_F(EncoderCapsAacTest, EncoderCaps_AAC_ComplexityRange) {
+ const Range<int>& complexityRange = encoderCaps->getComplexityRange();
+ EXPECT_EQ(complexityRange.lower(), 0);
+ EXPECT_EQ(complexityRange.upper(), 0);
+}
+
+TEST_F(EncoderCapsAacTest, EncoderCaps_AAC_QualityRange) {
+ const Range<int>& qualityRange = encoderCaps->getQualityRange();
+ EXPECT_EQ(qualityRange.lower(), 0);
+ EXPECT_EQ(qualityRange.upper(), 0);
+}
+
+TEST_F(EncoderCapsAacTest, EncoderCaps_AAC_SupportedBitrateMode) {
+ EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR));
+ EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_VBR));
+ EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CQ));
+ EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR_FD));
+}
+
+class EncoderCapsFlacTest : public testing::Test {
+protected:
+ EncoderCapsFlacTest() {
+ std::string mediaType = MIMETYPE_AUDIO_FLAC;
+
+ sp<AMessage> details = new AMessage;
+ details->setString("bitrate-range", "1-21000000");
+ details->setString("complexity-default", "5");
+ details->setString("complexity-range", "0-8");
+ details->setString("feature-bitrate-modes", "CQ");
+ details->setString("max-channel-count", "2");
+ details->setString("sample-rate-ranges", "1-655350");
+
+ std::vector<ProfileLevel> profileLevel;
+
+ encoderCaps = EncoderCapabilities::Create(mediaType, profileLevel, details);
+ }
+
+ std::shared_ptr<EncoderCapabilities> encoderCaps;
+};
+
+TEST_F(EncoderCapsFlacTest, EncoderCaps_FLAC_ComplexityRange) {
+ const Range<int>& complexityRange = encoderCaps->getComplexityRange();
+ EXPECT_EQ(complexityRange.lower(), 0);
+ EXPECT_EQ(complexityRange.upper(), 8);
+}
+
+TEST_F(EncoderCapsFlacTest, EncoderCaps_FLAC_QualityRange) {
+ const Range<int>& qualityRange = encoderCaps->getQualityRange();
+ EXPECT_EQ(qualityRange.lower(), 0);
+ EXPECT_EQ(qualityRange.upper(), 0);
+}
+
+TEST_F(EncoderCapsFlacTest, EncoderCaps_FLAC_SupportedBitrateMode) {
+ EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR));
+ EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_VBR));
+ EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CQ));
+ EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR_FD));
+}
+
+class EncoderCapsHevcTest : public testing::Test {
+protected:
+ EncoderCapsHevcTest() {
+ std::string mediaType = MIMETYPE_VIDEO_HEVC;
+
+ sp<AMessage> details = new AMessage;
+ details->setString("alignment", "2x2");
+ details->setString("bitrate-range", "1-120000000");
+ details->setString("block-count-range", "1-8160");
+ details->setString("block-size", "32x32");
+ details->setString("blocks-per-second-range", "1-979200");
+ details->setString("feature-bitrate-modes", "VBR,CBR,CQ,CBR-FD");
+ details->setInt32("feature-can-swap-width-height", 1);
+ details->setInt32("feature-qp-bounds", 0);
+ details->setInt32("feature-vq-minimum-quality", 0);
+ details->setString("max-concurrent-instances", "16");
+ details->setString("measured-frame-rate-1280x720-range", "154-198");
+ details->setString("measured-frame-rate-1920x1080-range", "46-97");
+ details->setString("measured-frame-rate-320x240-range", "371-553");
+ details->setString("measured-frame-rate-720x480-range", "214-305");
+ details->setString("performance-point-1280x720-range", "240");
+ details->setString("performance-point-3840x2160-range", "120");
+ details->setString("quality-default", "57");
+ details->setString("quality-range", "0-100");
+ details->setString("quality-scale", "linear");
+ details->setString("size-range", "64x64-3840x2176");
+
+ std::vector<ProfileLevel> profileLevel{
+ ProfileLevel(1, 2097152),
+ ProfileLevel(2, 2097152),
+ ProfileLevel(4096, 2097152),
+ ProfileLevel(8192, 2097152),
+ };
+
+ encoderCaps = EncoderCapabilities::Create(mediaType, profileLevel, details);
+ }
+
+ std::shared_ptr<EncoderCapabilities> encoderCaps;
+};
+
+TEST_F(EncoderCapsHevcTest, EncoderCaps_HEVC_ComplexityRange) {
+ const Range<int>& complexityRange = encoderCaps->getComplexityRange();
+ EXPECT_EQ(complexityRange.lower(), 0);
+ EXPECT_EQ(complexityRange.upper(), 0);
+}
+
+TEST_F(EncoderCapsHevcTest, EncoderCaps_HEVC_QualityRange) {
+ const Range<int>& qualityRange = encoderCaps->getQualityRange();
+ EXPECT_EQ(qualityRange.lower(), 0);
+ EXPECT_EQ(qualityRange.upper(), 100);
+}
+
+TEST_F(EncoderCapsHevcTest, EncoderCaps_HEVC_SupportedBitrateMode) {
+ EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR));
+ EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_VBR));
+ EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CQ));
+ EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR_FD));
+}
diff --git a/media/libstagefright/Android.bp b/media/libstagefright/Android.bp
index d084f10..9ed5343 100644
--- a/media/libstagefright/Android.bp
+++ b/media/libstagefright/Android.bp
@@ -99,6 +99,7 @@
static_libs: [
"libstagefright_esds",
+ "android.media.extractor.flags-aconfig-cc",
],
export_include_dirs: [
@@ -321,6 +322,7 @@
static_libs: [
"android.media.codec-aconfig-cc",
+ "android.media.extractor.flags-aconfig-cc",
"com.android.media.flags.editing-aconfig-cc",
"libstagefright_esds",
"libstagefright_color_conversion",
diff --git a/media/libstagefright/MediaCodec.cpp b/media/libstagefright/MediaCodec.cpp
index 7d47837..8cb1674 100644
--- a/media/libstagefright/MediaCodec.cpp
+++ b/media/libstagefright/MediaCodec.cpp
@@ -1189,6 +1189,19 @@
return new PersistentSurface(bufferProducer, bufferSource);
}
+//static
+status_t MediaCodec::getGloballyAvailableResources(std::vector<GlobalResourceInfo>& resources) {
+ resources.clear();
+ // Make sure codec availability feature is on.
+ if (!android::media::codec::codec_availability()) {
+ return ERROR_UNSUPPORTED;
+ }
+ // TODO: For now this is just an empty function.
+ // The actual implementation should use component store to query the
+ // available resources from hal, and fill in resources with the same.
+ return ERROR_UNSUPPORTED;
+}
+
// GenerateCodecId generates a 64bit Random ID for each codec that is created.
// The Codec ID is generated as:
// - A process-unique random high 32bits
@@ -1295,7 +1308,12 @@
CHECK_EQ(mState, UNINITIALIZED);
mResourceManagerProxy->removeClient();
- flushMediametrics();
+ flushMediametrics(); // this deletes mMetricsHandle
+ // don't keep the last metrics handle around
+ if (mLastMetricsHandle != 0) {
+ mediametrics_delete(mLastMetricsHandle);
+ mLastMetricsHandle = 0;
+ }
// clean any saved metrics info we stored as part of configure()
if (mConfigureMsg != nullptr) {
@@ -1306,7 +1324,7 @@
}
}
-// except for in constructor, called from the looper thread (and therefore mutexed)
+// except for in constructor, called from the looper thread (and therefore not mutexed)
void MediaCodec::initMediametrics() {
if (mMetricsHandle == 0) {
mMetricsHandle = mediametrics_create(kCodecKeyName);
@@ -1332,6 +1350,7 @@
mInputBufferCounter = 0;
}
+ mSubsessionCount = 0;
mLifetimeStartNs = systemTime(SYSTEM_TIME_MONOTONIC);
resetMetricsFields();
}
@@ -1343,6 +1362,17 @@
mReliabilityContextMetrics = ReliabilityContextMetrics();
}
+// always called from the looper thread (and therefore not mutexed)
+void MediaCodec::resetSubsessionMetricsFields() {
+ mBytesEncoded = 0;
+ mFramesEncoded = 0;
+ mFramesInput = 0;
+ mBytesInput = 0;
+ mEarliestEncodedPtsUs = INT64_MAX;
+ mLatestEncodedPtsUs = INT64_MIN;
+}
+
+// always called from the looper thread
void MediaCodec::updateMediametrics() {
if (mMetricsHandle == 0) {
ALOGV("no metrics handle found");
@@ -1707,6 +1737,7 @@
}
}
+// except for in destructor, called from the looper thread
void MediaCodec::flushMediametrics() {
ALOGV("flushMediametrics");
@@ -1720,7 +1751,14 @@
if (mMetricsToUpload && mediametrics_count(mMetricsHandle) > 0) {
mediametrics_selfRecord(mMetricsHandle);
}
- mediametrics_delete(mMetricsHandle);
+ // keep previous metrics handle for subsequent getMetrics() calls.
+ // NOTE: There could be multiple error events, each flushing the metrics.
+ // We keep the last non-empty metrics handle, so getMetrics() in the
+ // next call will get the latest metrics prior to the errors.
+ if (mLastMetricsHandle != 0) {
+ mediametrics_delete(mLastMetricsHandle);
+ }
+ mLastMetricsHandle = mMetricsHandle;
mMetricsHandle = 0;
}
// we no longer have anything pending upload
@@ -1885,7 +1923,10 @@
});
}
- if (mDomain == DOMAIN_VIDEO && (mFlags & kFlagIsEncoder)) {
+ // NOTE: these were erroneously restricted to video encoders, but we want them for all
+ // codecs.
+ if (android::media::codec::provider_->subsession_metrics()
+ || (mDomain == DOMAIN_VIDEO && (mFlags & kFlagIsEncoder))) {
mBytesInput += buffer->size();
mFramesInput++;
}
@@ -1907,12 +1948,15 @@
++mInputBufferCounter;
}
-// when we get a buffer back from the codec
+// when we get a buffer back from the codec, always called from the looper thread
void MediaCodec::statsBufferReceived(int64_t presentationUs, const sp<MediaCodecBuffer> &buffer) {
CHECK_NE(mState, UNINITIALIZED);
- if (mDomain == DOMAIN_VIDEO && (mFlags & kFlagIsEncoder)) {
+ // NOTE: these were erroneously restricted to video encoders, but we want them for all
+ // codecs.
+ if (android::media::codec::provider_->subsession_metrics()
+ || (mDomain == DOMAIN_VIDEO && (mFlags & kFlagIsEncoder))) {
int32_t flags = 0;
(void) buffer->meta()->findInt32("flags", &flags);
@@ -2460,12 +2504,8 @@
mediametrics_setInt32(nextMetricsHandle, kCodecCrypto, 1);
}
} else if (mFlags & kFlagIsSecure) {
- if (android::media::codec::provider_->secure_codecs_require_crypto()) {
- mErrorLog.log(LOG_TAG, "Crypto or descrambler must be given for secure codec");
- return INVALID_OPERATION;
- } else {
- ALOGW("Crypto or descrambler should be given for secure codec");
- }
+ // We'll catch this later when we process the buffers.
+ ALOGW("Crypto or descrambler should be given for secure codec");
}
if (mConfigureMsg != nullptr) {
@@ -2526,6 +2566,31 @@
return err;
}
+status_t MediaCodec::getRequiredResources(std::vector<InstanceResourceInfo>& resources) {
+ resources.clear();
+ // Make sure codec availability feature is on.
+ if (!android::media::codec::codec_availability()) {
+ return ERROR_UNSUPPORTED;
+ }
+ // Make sure that the codec was configured already.
+ if (mState != CONFIGURED && mState != STARTING && mState != STARTED &&
+ mState != FLUSHING && mState != FLUSHED) {
+ ALOGE("Codec wasn't configured yet!");
+ return INVALID_OPERATION;
+ }
+
+ if (!mRequiredResourceInfo.empty()) {
+ resources = mRequiredResourceInfo;
+ return OK;
+ }
+
+ // TODO: For now this is just an empty function.
+ // The actual implementation should use component interface
+ // (for example, through mCodec->getRequiredDeviceResources) to query the
+ // the required resources for this configuration, and fill in resources with the same.
+ return ERROR_UNSUPPORTED;
+}
+
// Media Format Shaping support
//
@@ -3614,6 +3679,10 @@
updateMediametrics();
results = mediametrics_dup(mMetricsHandle);
updateEphemeralMediametrics(results);
+ } else if (mLastMetricsHandle != 0) {
+ // After error, mMetricsHandle is cleared, but we keep the last
+ // metrics around so that it can be queried by getMetrics().
+ results = mediametrics_dup(mLastMetricsHandle);
} else {
results = mediametrics_dup(mMetricsHandle);
}
@@ -3883,6 +3952,7 @@
return true;
}
+// always called from the looper thread
MediaCodec::DequeueOutputResult MediaCodec::handleDequeueOutputBuffer(
const sp<AReplyToken> &replyID, bool newRequest) {
if (!isExecuting()) {
@@ -3938,6 +4008,9 @@
response->setInt32("flags", flags);
+ // NOTE: we must account the stats for an output buffer only after we
+ // already handled a potential output format change that could have
+ // started a new subsession.
statsBufferReceived(timeUs, buffer);
response->postReply(replyID);
@@ -5842,6 +5915,7 @@
}
}
+// always called from the looper thread
void MediaCodec::handleOutputFormatChangeIfNeeded(const sp<MediaCodecBuffer> &buffer) {
sp<AMessage> format = buffer->format();
if (mOutputFormat == format) {
@@ -5925,6 +5999,24 @@
}
}
}
+
+ // Update the width and the height.
+ int32_t left = 0, top = 0, right = 0, bottom = 0, width = 0, height = 0;
+ bool newSubsession = false;
+ if (android::media::codec::provider_->subsession_metrics()
+ && mOutputFormat->findInt32("width", &width)
+ && mOutputFormat->findInt32("height", &height)
+ && (width != mWidth || height != mHeight)) {
+ // consider a new subsession if the width or height changes.
+ newSubsession = true;
+ }
+ // TODO: properly detect new audio subsession
+
+ // Only consider a new subsession if we already have output (from a previous subsession).
+ if (newSubsession && mMetricsToUpload && mBytesEncoded > 0) {
+ handleStartingANewSubsession();
+ }
+
if (mFlags & kFlagIsAsync) {
onOutputFormatChanged();
} else {
@@ -5932,8 +6024,6 @@
postActivityNotificationIfPossible();
}
- // Update the width and the height.
- int32_t left = 0, top = 0, right = 0, bottom = 0, width = 0, height = 0;
bool resolutionChanged = false;
if (mOutputFormat->findRect("crop", &left, &top, &right, &bottom)) {
mWidth = right - left + 1;
@@ -5960,6 +6050,35 @@
updateHdrMetrics(false /* isConfig */);
}
+// always called from the looper thread (and therefore not mutexed)
+void MediaCodec::handleStartingANewSubsession() {
+ // create a new metrics item for the subsession with the new resolution.
+ // TODO: properly account input counts for the previous and the new
+ // subsessions. We only find out that a new subsession started from the
+ // output format, but by that time we already accounted the input counts
+ // to the previous subsession.
+ flushMediametrics(); // this deletes mMetricsHandle, but stores it in mLastMetricsHandle
+
+ // hence mLastMetricsHandle has the metrics item for the previous subsession.
+ if ((mFlags & kFlagIsAsync) && mCallback != nullptr) {
+ sp<AMessage> msg = mCallback->dup();
+ msg->setInt32("callbackID", CB_METRICS_FLUSHED);
+ std::unique_ptr<mediametrics::Item> flushedMetrics(
+ mediametrics::Item::convert(mediametrics_dup(mLastMetricsHandle)));
+ msg->setObject("metrics", new WrapperObject<std::unique_ptr<mediametrics::Item>>(
+ std::move(flushedMetrics)));
+ msg->post();
+ }
+
+ // reuse/continue old metrics item for the new subsession.
+ mMetricsHandle = mediametrics_dup(mLastMetricsHandle);
+ mMetricsToUpload = true;
+ // TODO: configured width/height for the new subsession should be the
+ // previous width/height.
+ mSubsessionCount++;
+ resetSubsessionMetricsFields();
+}
+
void MediaCodec::extractCSD(const sp<AMessage> &format) {
mCSD.clear();
@@ -6210,6 +6329,12 @@
CryptoPlugin::SubSample ss;
CryptoPlugin::Pattern pattern;
+ if (android::media::codec::provider_->secure_codecs_require_crypto()
+ && (mFlags & kFlagIsSecure) && !hasCryptoOrDescrambler()) {
+ mErrorLog.log(LOG_TAG, "Crypto or descrambler must be given for secure codec");
+ return INVALID_OPERATION;
+ }
+
if (msg->findSize("size", &size)) {
if (hasCryptoOrDescrambler()) {
ss.mNumBytesOfClearData = size;
@@ -6954,6 +7079,18 @@
}
}
+void MediaCodec::onRequiredResourcesChanged(
+ const std::vector<InstanceResourceInfo>& resourceInfo) {
+ mRequiredResourceInfo = resourceInfo;
+ // Make sure codec availability feature is on.
+ if (mCallback != nullptr && android::media::codec::codec_availability()) {
+ // Post the callback
+ sp<AMessage> msg = mCallback->dup();
+ msg->setInt32("callbackID", CB_REQUIRED_RESOURCES_CHANGED);
+ msg->post();
+ }
+}
+
void MediaCodec::postActivityNotificationIfPossible() {
if (mActivityNotify == NULL) {
return;
diff --git a/media/libstagefright/Utils.cpp b/media/libstagefright/Utils.cpp
index 86741a6..50eeb62 100644
--- a/media/libstagefright/Utils.cpp
+++ b/media/libstagefright/Utils.cpp
@@ -44,6 +44,8 @@
#include <media/AudioParameter.h>
#include <system/audio.h>
+#include <com_android_media_extractor_flags.h>
+
// TODO : Remove the defines once mainline media is built against NDK >= 31.
// The mp4 extractor is part of mainline and builds against NDK 29 as of
// writing. These keys are available only from NDK 31:
@@ -1443,6 +1445,17 @@
buffer->meta()->setInt64("timeUs", 0);
msg->setBuffer("csd-0", buffer);
parseAV1ProfileLevelFromCsd(buffer, msg);
+ } else if (com::android::media::extractor::flags::extractor_mp4_enable_apv() &&
+ meta->findData(kKeyAPVC, &type, &data, &size)) {
+ sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
+ if (buffer.get() == NULL || buffer->base() == NULL) {
+ return NO_MEMORY;
+ }
+ memcpy(buffer->data(), data, size);
+
+ buffer->meta()->setInt32("csd", true);
+ buffer->meta()->setInt64("timeUs", 0);
+ msg->setBuffer("csd-0", buffer);
} else if (meta->findData(kKeyESDS, &type, &data, &size)) {
ESDS esds((const char *)data, size);
if (esds.InitCheck() != (status_t)OK) {
@@ -2091,6 +2104,9 @@
} else if (mime == MEDIA_MIMETYPE_VIDEO_AV1 ||
mime == MEDIA_MIMETYPE_IMAGE_AVIF) {
meta->setData(kKeyAV1C, 0, csd0->data(), csd0->size());
+ } else if (com::android::media::extractor::flags::extractor_mp4_enable_apv() &&
+ mime == MEDIA_MIMETYPE_VIDEO_APV) {
+ meta->setData(kKeyAPVC, 0, csd0->data(), csd0->size());
} else if (mime == MEDIA_MIMETYPE_VIDEO_DOLBY_VISION) {
int32_t profile = -1;
uint8_t blCompatibilityId = -1;
diff --git a/media/libstagefright/data/media_codecs_google_c2_video.xml b/media/libstagefright/data/media_codecs_google_c2_video.xml
index fc0a5e9..72a2551 100644
--- a/media/libstagefright/data/media_codecs_google_c2_video.xml
+++ b/media/libstagefright/data/media_codecs_google_c2_video.xml
@@ -95,7 +95,7 @@
<Feature name="adaptive-playback" />
<Attribute name="software-codec" />
</MediaCodec>
- <MediaCodec name="c2.android.apv.decoder" type="video/apv">
+ <MediaCodec name="c2.android.apv.decoder" type="video/apv" enabled="false" minsdk="36" variant="!slow-cpu">
<Limit name="size" min="16x16" max="1920x1920"/>
<Limit name="alignment" value="2x2"/>
<Limit name="bitrate" range="1-240000000"/>
@@ -168,7 +168,7 @@
<Limit name="bitrate" range="1-40000000" />
<Feature name="bitrate-modes" value="VBR,CBR" />
</MediaCodec>
- <MediaCodec name="c2.android.apv.encoder" type="video/apv">
+ <MediaCodec name="c2.android.apv.encoder" type="video/apv" enabled="false" minsdk="36" variant="!slow-cpu">
<Limit name="size" min="2x2" max="1920x1920" />
<Limit name="alignment" value="2x2" />
<Limit name="block-size" value="16x16" />
diff --git a/media/libstagefright/data/media_codecs_sw.xml b/media/libstagefright/data/media_codecs_sw.xml
index 61b7198..20c97dc 100644
--- a/media/libstagefright/data/media_codecs_sw.xml
+++ b/media/libstagefright/data/media_codecs_sw.xml
@@ -255,12 +255,13 @@
<Feature name="adaptive-playback" />
<Attribute name="software-codec" />
</MediaCodec>
- <MediaCodec name="c2.android.apv.decoder" type="video/apv">
+ <MediaCodec name="c2.android.apv.decoder" type="video/apv" enabled="false" minsdk="36" variant="!slow-cpu">
<Limit name="size" min="16x16" max="1920x1920"/>
<Limit name="alignment" value="2x2"/>
<Limit name="bitrate" range="1-240000000"/>
<Limit name="block-size" value="16x16" />
<Limit name="block-count" range="1-32768" /> <!-- max 4096x2048 equivalent -->
+ <Feature name="adaptive-playback" />
<Attribute name="software-codec"/>
</MediaCodec>
</Decoders>
@@ -417,7 +418,7 @@
<Feature name="qp-bounds" />
<Attribute name="software-codec" />
</MediaCodec>
- <MediaCodec name="c2.android.apv.encoder" type="video/apv" variant="!slow-cpu">
+ <MediaCodec name="c2.android.apv.encoder" type="video/apv" enabled="false" minsdk="36" variant="!slow-cpu">
<Limit name="size" min="2x2" max="1920x1920" />
<Limit name="alignment" value="2x2" />
<Limit name="block-size" value="16x16" />
diff --git a/media/libstagefright/include/media/stagefright/MediaCodec.h b/media/libstagefright/include/media/stagefright/MediaCodec.h
index 7169b1e..df1ebd7 100644
--- a/media/libstagefright/include/media/stagefright/MediaCodec.h
+++ b/media/libstagefright/include/media/stagefright/MediaCodec.h
@@ -123,6 +123,18 @@
CB_RESOURCE_RECLAIMED = 5,
CB_CRYPTO_ERROR = 6,
CB_LARGE_FRAME_OUTPUT_AVAILABLE = 7,
+
+ /** Callback ID for when the metrics for this codec have been flushed
+ * due to the start of a new subsession. The associated AMessage will
+ * contain an sp<WrapperObject<std::unique_ptr<mediametrics::Item>>>
+ * Object at the "metrics" key.
+ */
+ CB_METRICS_FLUSHED = 8,
+
+ /** Callback ID to notify the change in resource requirement
+ * for the codec component.
+ */
+ CB_REQUIRED_RESOURCES_CHANGED = 9,
};
static const pid_t kNoPid = -1;
@@ -142,6 +154,73 @@
static sp<PersistentSurface> CreatePersistentInputSurface();
+ /**
+ * Abstraction for the Global Codec resources.
+ * This encapsulates all the available codec resources on the device.
+ */
+ struct GlobalResourceInfo {
+ /**
+ * Name of the Resource type.
+ */
+ std::string mName;
+ /**
+ * Total count/capacity of resources of this type.
+ */
+ int mCapacity;
+ /**
+ * Available count of this resource type.
+ */
+ int mAvailable;
+
+ GlobalResourceInfo(const std::string& name, int capacity, int available) :
+ mName(name),
+ mCapacity(capacity),
+ mAvailable(available) {}
+
+ GlobalResourceInfo(const GlobalResourceInfo& info) :
+ mName(info.mName),
+ mCapacity(info.mCapacity),
+ mAvailable(info.mAvailable) {}
+ };
+
+ /**
+ * Abstraction for the resources associated with a codec instance.
+ * This encapsulates the required codec resources for a configured codec instance.
+ */
+ struct InstanceResourceInfo {
+ /**
+ * Name of the Resource type.
+ */
+ std::string mName;
+ /**
+ * Required resource count of this type.
+ */
+ int mStaticCount;
+ /**
+ * Per frame resource requirement of this resource type.
+ */
+ int mPerFrameCount;
+
+ InstanceResourceInfo(const std::string& name, int staticCount, int perFrameCount) :
+ mName(name),
+ mStaticCount(staticCount),
+ mPerFrameCount(perFrameCount) {}
+
+ InstanceResourceInfo(const InstanceResourceInfo& info) :
+ mName(info.mName),
+ mStaticCount(info.mStaticCount),
+ mPerFrameCount(info.mPerFrameCount) {}
+ };
+
+ /**
+ * Get a list of Globally available device codec resources.
+ *
+ * It will return INVALID_OPERATION if:
+ * - HAL does not implement codec availability API
+ * - codec_availability feature flag isn't defined.
+ */
+ static status_t getGloballyAvailableResources(std::vector<GlobalResourceInfo>& resources);
+
status_t configure(
const sp<AMessage> &format,
const sp<Surface> &nativeWindow,
@@ -155,6 +234,19 @@
const sp<IDescrambler> &descrambler,
uint32_t flags);
+ /**
+ * Get a list of required codec resources.
+ *
+ * This may only be called after configuring the codec.
+ *
+ * Calling this while the codec wasn't configured, will result in
+ * returning INVALID_OPERATION error code.
+ * It will also return INVALID_OPERATION if:
+ * - HAL does not implement codec availability API
+ * - codec_availability feature flag isn't defined.
+ */
+ status_t getRequiredResources(std::vector<InstanceResourceInfo>& resources);
+
status_t releaseCrypto();
status_t setCallback(const sp<AMessage> &callback);
@@ -484,12 +576,21 @@
Mutex mMetricsLock;
mediametrics_handle_t mMetricsHandle = 0;
+ mediametrics_handle_t mLastMetricsHandle = 0; // only accessed from the looper or destructor
bool mMetricsToUpload = false;
nsecs_t mLifetimeStartNs = 0;
void initMediametrics();
void updateMediametrics();
void flushMediametrics();
void resetMetricsFields();
+
+ // Reset the metrics fields for a new subsession.
+ void resetSubsessionMetricsFields();
+
+ // Start a new subsession (for metrics). This includes flushing the current
+ // metrics, notifying the client and resetting the session fields.
+ void handleStartingANewSubsession();
+
void updateEphemeralMediametrics(mediametrics_handle_t item);
void updateLowLatency(const sp<AMessage> &msg);
void updateCodecImportance(const sp<AMessage>& msg);
@@ -551,6 +652,7 @@
int32_t setOutputSurfaceCount;
int32_t resolutionChangeCount;
} mReliabilityContextMetrics;
+ int32_t mSubsessionCount;
// initial create parameters
AString mInitName;
@@ -671,6 +773,7 @@
void onCryptoError(const sp<AMessage> &msg);
void onError(status_t err, int32_t actionCode, const char *detail = NULL);
void onOutputFormatChanged();
+ void onRequiredResourcesChanged(const std::vector<InstanceResourceInfo>& resourceInfo);
status_t onSetParameters(const sp<AMessage> ¶ms);
@@ -770,6 +873,8 @@
friend class MediaTestHelper;
CodecErrorLog mErrorLog;
+ // Required resource info for this codec.
+ std::vector<InstanceResourceInfo> mRequiredResourceInfo;
DISALLOW_EVIL_CONSTRUCTORS(MediaCodec);
};
diff --git a/media/libstagefright/include/media/stagefright/MediaCodecConstants.h b/media/libstagefright/include/media/stagefright/MediaCodecConstants.h
index 8f2f162..b0f671d 100644
--- a/media/libstagefright/include/media/stagefright/MediaCodecConstants.h
+++ b/media/libstagefright/include/media/stagefright/MediaCodecConstants.h
@@ -854,12 +854,17 @@
}
inline constexpr char FEATURE_AdaptivePlayback[] = "adaptive-playback";
+inline constexpr char FEATURE_DynamicTimestamp[] = "dynamic-timestamp";
inline constexpr char FEATURE_EncodingStatistics[] = "encoding-statistics";
+inline constexpr char FEATURE_FrameParsing[] = "frame-parsing";
+inline constexpr char FEATURE_HdrEditing[] = "hdr-editing";
inline constexpr char FEATURE_IntraRefresh[] = "intra-refresh";
+inline constexpr char FEATURE_LowLatency[] = "low-latency";
inline constexpr char FEATURE_MultipleFrames[] = "multiple-frames";
inline constexpr char FEATURE_PartialFrame[] = "partial-frame";
inline constexpr char FEATURE_QpBounds[] = "qp-bounds";
inline constexpr char FEATURE_SecurePlayback[] = "secure-playback";
+inline constexpr char FEATURE_SpecialCodec[] = "special-codec";
inline constexpr char FEATURE_TunneledPlayback[] = "tunneled-playback";
// from MediaFormat.java
diff --git a/media/module/extractors/mpeg2/Android.bp b/media/module/extractors/mpeg2/Android.bp
index aa59a0c..63dbcda 100644
--- a/media/module/extractors/mpeg2/Android.bp
+++ b/media/module/extractors/mpeg2/Android.bp
@@ -44,7 +44,6 @@
shared_libs: [
"libbase",
- "libcgrouprc#29",
],
header_libs: [
diff --git a/media/module/foundation/include/media/stagefright/foundation/AUtils.h b/media/module/foundation/include/media/stagefright/foundation/AUtils.h
index 3b646dc..eb605a7 100644
--- a/media/module/foundation/include/media/stagefright/foundation/AUtils.h
+++ b/media/module/foundation/include/media/stagefright/foundation/AUtils.h
@@ -92,4 +92,13 @@
return (err < (period / 2)) ? err : (period - err);
}
+inline static bool IsPowerOfTwo(int32_t value) {
+ return (value & (value - 1)) == 0;
+}
+
+/** Checks if the value is a power of two and not zero. */
+inline static bool IsPowerOfTwoStrict(int32_t value) {
+ return value != 0 && (value & (value - 1)) == 0;
+}
+
#endif // A_UTILS_H_
diff --git a/media/module/libapexcodecs/Android.bp b/media/module/libapexcodecs/Android.bp
new file mode 100644
index 0000000..790b749
--- /dev/null
+++ b/media/module/libapexcodecs/Android.bp
@@ -0,0 +1,71 @@
+//
+// Copyright (C) 2024 The Android Open Source Project
+//
+// 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.
+//
+
+package {
+ default_applicable_licenses: ["frameworks_av_license"],
+}
+
+cc_defaults {
+ name: "libapexcodecs-defaults",
+ header_libs: [
+ "libbase_headers",
+ ],
+
+ srcs: ["ApexCodecs.cpp"],
+
+ shared_libs: [
+ "libbase",
+ "libnativewindow",
+ ],
+
+ export_include_dirs: ["include"],
+
+ export_shared_lib_headers: [
+ "libbase",
+ "libnativewindow",
+ ],
+
+}
+
+cc_library {
+ name: "libapexcodecs-testing",
+ defaults: ["libapexcodecs-defaults"],
+
+ visibility: [
+ ":__subpackages__",
+ ],
+}
+
+cc_library {
+ name: "libapexcodecs",
+ defaults: ["libapexcodecs-defaults"],
+
+ visibility: [
+ "//frameworks/av/apex:__subpackages__",
+ "//frameworks/av/media/codec2/hal/client",
+ ],
+
+ min_sdk_version: "apex_inherit",
+ version_script: "libapexcodecs.map.txt",
+ stubs: {
+ symbol_file: "libapexcodecs.map.txt",
+ versions: ["36"],
+ },
+
+ apex_available: [
+ "com.android.media.swcodec",
+ ],
+}
diff --git a/media/module/libapexcodecs/ApexCodecs.cpp b/media/module/libapexcodecs/ApexCodecs.cpp
new file mode 100644
index 0000000..7101677
--- /dev/null
+++ b/media/module/libapexcodecs/ApexCodecs.cpp
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * 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 <new>
+
+#include <android-base/no_destructor.h>
+#include <apex/ApexCodecs.h>
+
+// TODO: remove when we have real implementations
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+
+struct ApexCodec_ComponentStore {
+ ApexCodec_ComponentStore() = default;
+};
+
+ApexCodec_ComponentStore *ApexCodec_GetComponentStore() {
+ ::android::base::NoDestructor<ApexCodec_ComponentStore> store;
+ return store.get();
+}
+
+ApexCodec_ComponentTraits *ApexCodec_Traits_get(
+ ApexCodec_ComponentStore *store, size_t index) {
+ return nullptr;
+}
+
+ApexCodec_Status ApexCodec_Component_create(
+ ApexCodec_ComponentStore *store, const char *name, ApexCodec_Component **comp) {
+ *comp = nullptr;
+ return APEXCODEC_STATUS_NOT_FOUND;
+}
+
+void ApexCodec_Component_destroy(ApexCodec_Component *comp) {}
+
+ApexCodec_Status ApexCodec_Component_start(ApexCodec_Component *comp) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_Component_flush(ApexCodec_Component *comp) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_Component_reset(ApexCodec_Component *comp) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Configurable *ApexCodec_Component_getConfigurable(
+ ApexCodec_Component *comp) {
+ return nullptr;
+}
+
+ApexCodec_Status ApexCodec_SupportedValues_getTypeAndValues(
+ ApexCodec_SupportedValues *supportedValues,
+ ApexCodec_SupportedValuesType *type,
+ ApexCodec_SupportedValuesNumberType *numberType,
+ ApexCodec_Value **values,
+ uint32_t *numValues) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+void ApexCodec_SupportedValues_release(ApexCodec_SupportedValues *values) {}
+
+ApexCodec_Status ApexCodec_SettingResults_getResultAtIndex(
+ ApexCodec_SettingResults *results,
+ size_t index,
+ ApexCodec_SettingResultFailure *failure,
+ ApexCodec_ParamFieldValues *field,
+ ApexCodec_ParamFieldValues **conflicts,
+ size_t *numConflicts) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+void ApexCodec_SettingResults_release(ApexCodec_SettingResults *results) {}
+
+ApexCodec_Status ApexCodec_Component_process(
+ ApexCodec_Component *comp,
+ const ApexCodec_Buffer *input,
+ ApexCodec_Buffer *output,
+ size_t *consumed,
+ size_t *produced) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_Configurable_config(
+ ApexCodec_Configurable *comp,
+ ApexCodec_LinearBuffer *config,
+ ApexCodec_SettingResults **results) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_Configurable_query(
+ ApexCodec_Configurable *comp,
+ uint32_t indices[],
+ size_t numIndices,
+ ApexCodec_LinearBuffer *config,
+ size_t *written) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_ParamDescriptors_getIndices(
+ ApexCodec_ParamDescriptors *descriptors,
+ uint32_t **indices,
+ size_t *numIndices) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_ParamDescriptors_getDescriptor(
+ ApexCodec_ParamDescriptors *descriptors,
+ uint32_t index,
+ ApexCodec_ParamAttribute *attr,
+ const char **name,
+ uint32_t **dependencies,
+ size_t *numDependencies) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_ParamDescriptors_release(
+ ApexCodec_ParamDescriptors *descriptors) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_Configurable_querySupportedParams(
+ ApexCodec_Configurable *comp,
+ ApexCodec_ParamDescriptors **descriptors) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+ApexCodec_Status ApexCodec_Configurable_querySupportedValues(
+ ApexCodec_Configurable *comp,
+ ApexCodec_SupportedValuesQuery *queries,
+ size_t numQueries) {
+ return APEXCODEC_STATUS_OMITTED;
+}
+
+#pragma clang diagnostic pop
\ No newline at end of file
diff --git a/media/module/libapexcodecs/include/apex/ApexCodecs.h b/media/module/libapexcodecs/include/apex/ApexCodecs.h
new file mode 100644
index 0000000..b9f2e83
--- /dev/null
+++ b/media/module/libapexcodecs/include/apex/ApexCodecs.h
@@ -0,0 +1,768 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <sys/cdefs.h>
+#include <errno.h>
+#include <stdint.h>
+
+#include <android/api-level.h>
+#include <android/hardware_buffer.h>
+#include <android/versioning.h>
+
+__BEGIN_DECLS
+
+/**
+ * An API to access and operate codecs implemented within an APEX module,
+ * used only by the OS when using the codecs within a client process
+ * (instead of via a HAL).
+ *
+ * NOTE: Many of the constants and types mirror the ones in the Codec 2.0 API.
+ */
+
+/**
+ * Error code for ApexCodec APIs.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_Status : int32_t {
+ APEXCODEC_STATUS_OK = 0,
+
+ /* bad input */
+ APEXCODEC_STATUS_BAD_VALUE = EINVAL,
+ APEXCODEC_STATUS_BAD_INDEX = ENXIO,
+ APEXCODEC_STATUS_CANNOT_DO = ENOTSUP,
+
+ /* bad sequencing of events */
+ APEXCODEC_STATUS_DUPLICATE = EEXIST,
+ APEXCODEC_STATUS_NOT_FOUND = ENOENT,
+ APEXCODEC_STATUS_BAD_STATE = EPERM,
+ APEXCODEC_STATUS_BLOCKING = EWOULDBLOCK,
+ APEXCODEC_STATUS_CANCELED = EINTR,
+
+ /* bad environment */
+ APEXCODEC_STATUS_NO_MEMORY = ENOMEM,
+ APEXCODEC_STATUS_REFUSED = EACCES,
+
+ APEXCODEC_STATUS_TIMED_OUT = ETIMEDOUT,
+
+ /* bad versioning */
+ APEXCODEC_STATUS_OMITTED = ENOSYS,
+
+ /* unknown fatal */
+ APEXCODEC_STATUS_CORRUPTED = EFAULT,
+ APEXCODEC_STATUS_NO_INIT = ENODEV,
+} ApexCodec_Status;
+
+/**
+ * Enum that represents the kind of component
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_Kind : uint32_t {
+ /**
+ * The component is of a kind that is not listed below.
+ */
+ APEXCODEC_KIND_OTHER = 0x0,
+ /**
+ * The component is a decoder, which decodes coded bitstream
+ * into raw buffers.
+ *
+ * Introduced in API 36.
+ */
+ APEXCODEC_KIND_DECODER = 0x1,
+ /**
+ * The component is an encoder, which encodes raw buffers
+ * into coded bitstream.
+ *
+ * Introduced in API 36.
+ */
+ APEXCODEC_KIND_ENCODER = 0x2,
+} ApexCodec_Kind;
+
+typedef enum ApexCodec_Domain : uint32_t {
+ /**
+ * A component domain that is not listed below.
+ *
+ * Introduced in API 36.
+ */
+ APEXCODEC_DOMAIN_OTHER = 0x0,
+ /**
+ * A component domain that operates on video.
+ *
+ * Introduced in API 36.
+ */
+ APEXCODEC_DOMAIN_VIDEO = 0x1,
+ /**
+ * A component domain that operates on audio.
+ *
+ * Introduced in API 36.
+ */
+ APEXCODEC_DOMAIN_AUDIO = 0x2,
+ /**
+ * A component domain that operates on image.
+ *
+ * Introduced in API 36.
+ */
+ APEXCODEC_DOMAIN_IMAGE = 0x3,
+} ApexCodec_Domain;
+
+/**
+ * Handle for component traits such as name, media type, kind (decoder/encoder),
+ * domain (audio/video/image), etc.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_ComponentTraits {
+ /**
+ * The name of the component.
+ */
+ const char *name;
+ /**
+ * The supported media type of the component.
+ */
+ const char *mediaType;
+ /**
+ * The kind of the component.
+ */
+ ApexCodec_Kind kind;
+ /**
+ * The domain on which the component operates.
+ */
+ ApexCodec_Domain domain;
+} ApexCodec_ComponentTraits;
+
+/**
+ * An opaque struct that represents a component store.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_ComponentStore ApexCodec_ComponentStore;
+
+/**
+ * Get the component store object. This function never fails.
+ *
+ * \return component store object.
+ */
+ApexCodec_ComponentStore *ApexCodec_GetComponentStore()
+ __INTRODUCED_IN(36);
+
+/**
+ * Get the traits object of a component at given index. ApexCodecs_Traits_*
+ * functions are used to extract information from the traits object.
+ *
+ * Returns nullptr if index is out of bounds. The returned object is owned by
+ * ApexCodec_ComponentStore object and the client should not delete it.
+ *
+ * The client can iterate through the traits objects by calling this function
+ * with an index incrementing from 0 until it gets a nullptr.
+ *
+ * \param index index of the traits object to query
+ * \return traits object at the index, or nullptr if the index is out of bounds.
+ */
+ApexCodec_ComponentTraits *ApexCodec_Traits_get(
+ ApexCodec_ComponentStore *store, size_t index) __INTRODUCED_IN(36);
+
+/**
+ * An opaque struct that represents a codec.
+ */
+typedef struct ApexCodec_Component ApexCodec_Component;
+
+/**
+ * Create a component by the name.
+ *
+ * \param store the component store
+ * \param name the name of the component
+ * \param component out-param to be filled with the component; must not be null
+ * \return APEXCODEC_STATUS_OK if successful
+ * APEXCODEC_STATUS_NOT_FOUND if the name is not found
+ */
+ApexCodec_Status ApexCodec_Component_create(
+ ApexCodec_ComponentStore *store, const char *name, ApexCodec_Component **comp)
+ __INTRODUCED_IN(36);
+
+/**
+ * Destroy the component by the handle. It is invalid to call component methods on the handle
+ * after calling this method. It is no-op to call this method with |comp| == nullptr.
+ *
+ * \param comp the handle for the component
+ */
+void ApexCodec_Component_destroy(ApexCodec_Component *comp) __INTRODUCED_IN(36);
+
+/**
+ * Start the component. The component is ready to process buffers after this call.
+ *
+ * \param comp the handle for the component
+ */
+ApexCodec_Status ApexCodec_Component_start(
+ ApexCodec_Component *comp) __INTRODUCED_IN(36);
+
+/**
+ * Flush the component's internal states. This operation preserves the existing configurations.
+ *
+ * \param comp the handle for the component
+ */
+ApexCodec_Status ApexCodec_Component_flush(
+ ApexCodec_Component *comp) __INTRODUCED_IN(36);
+
+/**
+ * Resets the component to the initial state, right after creation. Note that the configuration
+ * will also revert to the initial state, so if there are configurations required those should be
+ * set again to use the component.
+ *
+ * \param comp the handle for the component
+ */
+ApexCodec_Status ApexCodec_Component_reset(
+ ApexCodec_Component *comp) __INTRODUCED_IN(36);
+
+/**
+ * An opaque struct that represents a configurable part of the component.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_Configurable ApexCodec_Configurable;
+
+/**
+ * Return the configurable object for the given ApexCodec_Component.
+ * The returned object has the same lifecycle as |comp|.
+ *
+ * \param comp the handle for the component
+ * \return the configurable object handle
+ */
+ApexCodec_Configurable *ApexCodec_Component_getConfigurable(
+ ApexCodec_Component *comp) __INTRODUCED_IN(36);
+
+/**
+ * Enum that represents the flags for ApexCodec_Buffer.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_BufferFlags : uint32_t {
+ APEXCODEC_FLAG_DROP_FRAME = (1 << 0),
+ APEXCODEC_FLAG_END_OF_STREAM = (1 << 1),
+ APEXCODEC_FLAG_DISCARD_FRAME = (1 << 2),
+ APEXCODEC_FLAG_INCOMPLETE = (1 << 3),
+ APEXCODEC_FLAG_CORRECTED = (1 << 4),
+ APEXCODEC_FLAG_CORRUPT = (1 << 5),
+ APEXCODEC_FLAG_CODEC_CONFIG = (1u << 31),
+} ApexCodec_BufferFlags;
+
+/**
+ * Enum that represents the type of buffer.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_BufferType : uint32_t {
+ APEXCODEC_BUFFER_TYPE_INVALID,
+ APEXCODEC_BUFFER_TYPE_LINEAR,
+ APEXCODEC_BUFFER_TYPE_LINEAR_CHUNKS,
+ APEXCODEC_BUFFER_TYPE_GRAPHIC,
+ APEXCODEC_BUFFER_TYPE_GRAPHIC_CHUNKS,
+} ApexCodec_BufferType;
+
+/**
+ * Struct that represents the memory for ApexCodec_Buffer.
+ *
+ * All memory regions have the simple 1D representation.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_LinearBuffer {
+ /**
+ * A pointer to the start of the buffer. This is not aligned.
+ */
+ uint8_t *data;
+ /**
+ * Size of the buffer. The memory region between |data| (inclusive) and
+ * |data + size| (exclusive) is assumed to be valid for read/write.
+ */
+ size_t size;
+} ApexCodec_LinearBuffer;
+
+/**
+ * Struct that represents a buffer for ApexCodec_Component.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_Buffer {
+ /**
+ * Flags associated with the buffer.
+ */
+ ApexCodec_BufferFlags flags;
+ /**
+ * For input buffers client assign a unique sequential index for each buffer. For output buffers
+ * it is the same as the associated input buffer's frame index.
+ */
+ uint64_t frameIndex;
+ /**
+ * A timestamp associated with the buffer in microseconds.
+ */
+ uint64_t timestampUs;
+ /**
+ * The type of the buffer. The component may reject request to process a buffer with the wrong
+ * type. For example, a video decoder will reject an input buffer with type BUFFER_TYPE_GRAPHIC,
+ * or an output buffer with type BUFFER_TYPE_LINEAR.
+ */
+ ApexCodec_BufferType type;
+ /**
+ * The actual memory for the buffer.
+ */
+ union {
+ ApexCodec_LinearBuffer linear;
+ AHardwareBuffer *graphic;
+ } memory;
+ /**
+ * Config updates associated with the buffer. For input buffers these are sent to the component
+ * at the specific input frame. For output buffers these are config updates as a result of
+ * processing the buffer.
+ */
+ ApexCodec_LinearBuffer configUpdates;
+} ApexCodec_Buffer;
+
+/**
+ * Enum that represents the query type for the supported values.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_SupportedValuesQueryType : uint32_t {
+ /** Query all possible supported values regardless of current configuration */
+ APEXCODEC_SUPPORTED_VALUES_QUERY_POSSIBLE,
+ /** Query supported values at current configuration */
+ APEXCODEC_SUPPORTED_VALUES_QUERY_CURRENT,
+} ApexCodec_SupportedValuesQueryType;
+
+/**
+ * Enum that represents the type of the supported values.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_SupportedValuesType : uint32_t {
+ /** The supported values are empty. */
+ APEXCODEC_SUPPORTED_VALUES_EMPTY,
+ /**
+ * The supported values are represented by a range defined with {min, max, step, num, den}.
+ *
+ * If step is 0 and num and denom are both 1, the supported values are any value, for which
+ * min <= value <= max.
+ *
+ * Otherwise, the range represents a geometric/arithmetic/multiply-accumulate series, where
+ * successive supported values can be derived from previous values (starting at min), using the
+ * following formula:
+ * v[0] = min
+ * v[i] = v[i-1] * num / denom + step for i >= 1, while min < v[i] <= max.
+ */
+ APEXCODEC_SUPPORTED_VALUES_RANGE,
+ /** The supported values are represented by a list of values. */
+ APEXCODEC_SUPPORTED_VALUES_VALUES,
+ /** The supported values are represented by a list of flags. */
+ APEXCODEC_SUPPORTED_VALUES_FLAGS,
+} ApexCodec_SupportedValuesType;
+
+/**
+ * Enum that represents numeric types of the supported values.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_SupportedValuesNumberType : uint32_t {
+ APEXCODEC_SUPPORTED_VALUES_TYPE_NONE = 0,
+ APEXCODEC_SUPPORTED_VALUES_TYPE_INT32 = 1,
+ APEXCODEC_SUPPORTED_VALUES_TYPE_UINT32 = 2,
+ // RESERVED = 3,
+ APEXCODEC_SUPPORTED_VALUES_TYPE_INT64 = 4,
+ APEXCODEC_SUPPORTED_VALUES_TYPE_UINT64 = 5,
+ // RESERVED = 6,
+ APEXCODEC_SUPPORTED_VALUES_TYPE_FLOAT = 7,
+} ApexCodec_SupportedValuesNumberType;
+
+/**
+ * Union of primitive types.
+ *
+ * Introduced in API 36.
+ */
+typedef union {
+ int32_t i32;
+ uint32_t u32;
+ int64_t i64;
+ uint64_t u64;
+ float f;
+} ApexCodec_Value;
+
+/**
+ * An opaque struct that represents the supported values of a parameter.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_SupportedValues ApexCodec_SupportedValues;
+
+/**
+ * Extract information from ApexCodec_SupportedValues object.
+ *
+ * \param [in] supportedValues the supported values object
+ * \param [out] type pointer to be filled with the type of the supported values
+ * \param [out] numberType pointer to be filled with the numeric type of the supported values
+ * \param [out] values pointer to be filled with the array of the actual supported values.
+ * if type == APEXCODEC_SUPPORTED_VALUES_EMPTY: nullptr
+ * if type == APEXCODEC_SUPPORTED_VALUES_RANGE: {min, max, step, num, den}
+ * if type == APEXCODEC_SUPPORTED_VALUES_VALUES/_FLAGS:
+ * the array of supported values/flags
+ * the array is owned by the |supportedValues| object and the client
+ * should not free it.
+ * \param [out] numValues pointer to be filled with the number of values.
+ * if type == APEXCODEC_SUPPORTED_VALUES_EMPTY: 0
+ * if type == APEXCODEC_SUPPORTED_VALUES_RANGE: 5
+ * if type == APEXCODEC_SUPPORTED_VALUES_VALUES/_FLAGS: varies
+ */
+ApexCodec_Status ApexCodec_SupportedValues_getTypeAndValues(
+ ApexCodec_SupportedValues *supportedValues,
+ ApexCodec_SupportedValuesType *type,
+ ApexCodec_SupportedValuesNumberType *numberType,
+ ApexCodec_Value **values,
+ uint32_t *numValues) __INTRODUCED_IN(36);
+
+/**
+ * Release the supported values object.
+ *
+ * \param values the supported values object
+ */
+void ApexCodec_SupportedValues_release(
+ ApexCodec_SupportedValues *values) __INTRODUCED_IN(36);
+
+/**
+ * Struct that represents the result of ApexCodec_Configurable_config.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_SettingResults ApexCodec_SettingResults;
+
+/**
+ * Enum that represents the failure code of ApexCodec_SettingResults.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_SettingResultFailure : uint32_t {
+ /** parameter type is not supported */
+ APEXCODEC_SETTING_RESULT_BAD_TYPE,
+ /** parameter is not supported on the specific port */
+ APEXCODEC_SETTING_RESULT_BAD_PORT,
+ /** parameter is not supported on the specific stream */
+ APEXCODEC_SETTING_RESULT_BAD_INDEX,
+ /** parameter is read-only */
+ APEXCODEC_SETTING_RESULT_READ_ONLY,
+ /** parameter mismatches input data */
+ APEXCODEC_SETTING_RESULT_MISMATCH,
+ /** strict parameter does not accept value for the field at all */
+ APEXCODEC_SETTING_RESULT_BAD_VALUE,
+ /** strict parameter field value conflicts with another settings */
+ APEXCODEC_SETTING_RESULT_CONFLICT,
+ /** strict parameter field is out of range due to other settings */
+ APEXCODEC_SETTING_RESULT_UNSUPPORTED,
+ /**
+ * field does not accept the requested parameter value at all. It has been corrected to
+ * the closest supported value. This failure mode is provided to give guidance as to what
+ * are the currently supported values for this field (which may be a subset of the at-all-
+ * potential values)
+ */
+ APEXCODEC_SETTING_RESULT_INFO_BAD_VALUE,
+ /**
+ * requested parameter value is in conflict with an/other setting(s)
+ * and has been corrected to the closest supported value. This failure
+ * mode is given to provide guidance as to what are the currently supported values as well
+ * as to optionally provide suggestion to the client as to how to enable the requested
+ * parameter value.
+ */
+ APEXCODEC_SETTING_RESULT_INFO_CONFLICT,
+} ApexCodec_SettingResultFailure;
+
+/**
+ * Struct that represents a field and its supported values of a parameter.
+ *
+ * The offset and size of the field are where the field is located in the blob representation of
+ * the parameter, as used in the ApexCodec_Configurable_query() and ApexCodec_Configurable_config(),
+ * for example.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_ParamFieldValues {
+ /** index of the param */
+ uint32_t index;
+ /** offset of the param field */
+ uint32_t offset;
+ /** size of the param field */
+ uint32_t size;
+ /** currently supported values of the param field */
+ ApexCodec_SupportedValues *values;
+} ApexCodec_ParamFieldValues;
+
+/**
+ * Extract the result of ApexCodec_Configurable_config.
+ * The client can iterate through the results with index starting from 0 until this function returns
+ * APEXCODEC_STATUS_NOT_FOUND.
+ *
+ * \param [in] result the result object
+ * \param [in] index the index of the result to extract, starts from 0.
+ * \param [out] failure pointer to be filled with the failure code
+ * \param [out] field pointer to be filled with the field that failed.
+ * |field->value| is owned by the |result| object and the client should not
+ * free it.
+ * \param [out] conflicts pointer to be filled with the array of conflicts.
+ * nullptr if |numConflicts| is 0.
+ * the array and its content is owned by the |result| object and the client
+ * should not free it.
+ * \param [out] numConflicts pointer to be filled with the number of conflicts
+ * may be 0 if there are no conflicts
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_NOT_FOUND if index is out of range
+ */
+ApexCodec_Status ApexCodec_SettingResults_getResultAtIndex(
+ ApexCodec_SettingResults *results,
+ size_t index,
+ ApexCodec_SettingResultFailure *failure,
+ ApexCodec_ParamFieldValues *field,
+ ApexCodec_ParamFieldValues **conflicts,
+ size_t *numConflicts) __INTRODUCED_IN(36);
+
+/**
+ * Release the setting result object.
+ *
+ * \param result the setting result object
+ */
+void ApexCodec_SettingResults_release(
+ ApexCodec_SettingResults *results) __INTRODUCED_IN(36);
+
+/**
+ * Process one frame from |input|, and produce one frame to |output| if possible.
+ * When successfully filled, |output->memory.linear| has the size adjusted to the produced
+ * output size, in case of linear buffers. |input->configUpdates| is applied with the input
+ * buffer; |output->configUpdates| contains config updates as a result of processing the frame.
+ *
+ * \param comp the component to process the buffers
+ * \param input the input buffer; when nullptr, the component should fill |output| if there are
+ * any pending output buffers.
+ * \param output the output buffer, should not be nullptr.
+ * \param consumed the number of consumed bytes from the input buffer
+ * set to 0 if no input buffer has been consumed, including |input| is nullptr.
+ * for graphic buffers, any non-zero value means that the input buffer is consumed.
+ * \param produced the number of bytes produced on the output buffer
+ * set to 0 if no output buffer has been produced.
+ * for graphic buffers, any non-zero value means that the output buffer is filled.
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_NO_MEMORY if the output buffer is not suitable to hold the output frame
+ * the client should retry with a new output buffer;
+ * configUpdates should have the information to update
+ * the buffer size.
+ * \return APEXCODEC_STATUS_BAD_VALUE if the parameters are bad
+ * \return APEXCODEC_STATUS_BAD_STATE if the component is not in the right state
+ * to process the frame
+ * \return APEXCODEC_STATUS_CORRUPTED if unexpected error has occurred
+ */
+ApexCodec_Status ApexCodec_Component_process(
+ ApexCodec_Component *comp,
+ const ApexCodec_Buffer *input,
+ ApexCodec_Buffer *output,
+ size_t *consumed,
+ size_t *produced) __INTRODUCED_IN(36);
+
+/**
+ * Configure the component with the given config.
+ *
+ * Configurations are Codec 2.0 configs in binary blobs,
+ * concatenated if there are multiple configs.
+ *
+ * frameworks/av/media/codec2/core/include/C2Param.h contains more details about the configuration
+ * blob layout.
+ *
+ * The component may correct the configured parameters to the closest supported values, and could
+ * fail in case there are no values that the component can auto-correct to. |result| contains the
+ * information about the failures. See ApexCodec_SettingResultFailure and ApexCodec_SettingResults
+ * for more details.
+ *
+ * \param [in] comp the handle for the component
+ * \param [inout] config the config blob; after the call, the config blob is updated to the actual
+ * config by the component.
+ * \param [out] result the result of the configuration.
+ * the client should call ApexCodec_SettingResult_getResultAtIndex()
+ * to extract the result. The result object is owned by the client and should
+ * be released with ApexCodec_SettingResult_release().
+ * |result| may be nullptr if empty.
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_BAD_VALUE if the config is invalid
+ * \return APEXCODEC_STATUS_BAD_STATE if the component is not in the right state to be configured
+ * \return APEXCODEC_STATUS_CORRUPTED if unexpected error has occurred
+ */
+ApexCodec_Status ApexCodec_Configurable_config(
+ ApexCodec_Configurable *comp,
+ ApexCodec_LinearBuffer *config,
+ ApexCodec_SettingResults **results) __INTRODUCED_IN(36);
+
+/**
+ * Query the component for the given indices.
+ *
+ * Parameter indices are defined in frameworks/av/media/codec2/core/include/C2Config.h.
+ *
+ * \param [in] comp the handle for the component
+ * \param [in] indices the array of indices to query
+ * \param [in] numIndices the size of the indices array
+ * \param [inout] config the output buffer for the config blob, allocated by the client.
+ * if the |config->size| was insufficient, it is set to the required size
+ * and |config->data| remains unchanged.
+ * \param [out] written the number of bytes written to |config|.
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_NO_MEMORY if |config.size| is too small; |config.size| is updated to the
+ * requested buffer size.
+ * \return APEXCODEC_STATUS_BAD_VALUE if the parameters are bad. e.g. |indices|, |config|,
+ * |config->data| or |written| is nullptr.
+ */
+ApexCodec_Status ApexCodec_Configurable_query(
+ ApexCodec_Configurable *comp,
+ uint32_t indices[],
+ size_t numIndices,
+ ApexCodec_LinearBuffer *config,
+ size_t *written) __INTRODUCED_IN(36);
+
+/**
+ * Struct that represents a parameter descriptor.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_ParamDescriptors ApexCodec_ParamDescriptors;
+
+/**
+ * Enum that represents the attributes of a parameter.
+ *
+ * Introduced in API 36.
+ */
+typedef enum ApexCodec_ParamAttribute : uint32_t {
+ /** parameter is required to be specified */
+ APEXCODEC_PARAM_IS_REQUIRED = 1u << 0,
+ /** parameter retains its value */
+ APEXCODEC_PARAM_IS_PERSISTENT = 1u << 1,
+ /** parameter is strict */
+ APEXCODEC_PARAM_IS_STRICT = 1u << 2,
+ /** parameter is read-only */
+ APEXCODEC_PARAM_IS_READ_ONLY = 1u << 3,
+ /** parameter shall not be visible to clients */
+ APEXCODEC_PARAM_IS_HIDDEN = 1u << 4,
+ /** parameter shall not be used by framework (other than testing) */
+ APEXCODEC_PARAM_IS_INTERNAL = 1u << 5,
+ /** parameter is publicly const (hence read-only) */
+ APEXCODEC_PARAM_IS_CONST = 1u << 6 | APEXCODEC_PARAM_IS_READ_ONLY,
+} ApexCodec_ParamAttribute;
+
+/**
+ * Get the parameter indices of the param descriptors.
+ *
+ * \param [in] descriptors the param descriptors object
+ * \param [out] indices the pointer to be filled with the array of the indices;
+ * the array is owned by |descriptors| and should not be freed by the client.
+ * \param [out] numIndices the size of the indices array
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_BAD_VALUE if parameters are bad. e.g. |descriptors|, |indices| or
+ * |numIndices| is nullptr.
+ */
+ApexCodec_Status ApexCodec_ParamDescriptors_getIndices(
+ ApexCodec_ParamDescriptors *descriptors,
+ uint32_t **indices,
+ size_t *numIndices) __INTRODUCED_IN(36);
+
+/**
+ * Get the descriptor of the param.
+ *
+ * \param [in] descriptors the param descriptors object
+ * \param [in] index the index of the param
+ * \param [out] attr the attribute of the param
+ * \param [out] name the pointer to be filled with the name of the param
+ * the string is owned by |descriptors| and should not be freed by the client.
+ * \param [out] dependencies the pointer to be filled with an array of the parameter indices
+ * that the parameter with |index| depends on.
+ * may be null if empty.
+ * the array is owned by |descriptors| and should not be freed by the client.
+ * \param [out] numDependencies the number of dependencies
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_BAD_VALUE if parameters are bad. e.g. |descriptors|, |attr|, |name|,
+ * |dependencies| or |numDependencies| is nullptr.
+ * \return APEXCODEC_STATUS_BAD_INDEX if the index is not included in the param descriptors.
+ */
+ApexCodec_Status ApexCodec_ParamDescriptors_getDescriptor(
+ ApexCodec_ParamDescriptors *descriptors,
+ uint32_t index,
+ ApexCodec_ParamAttribute *attr,
+ const char **name,
+ uint32_t **dependencies,
+ size_t *numDependencies) __INTRODUCED_IN(36);
+
+/**
+ * Release the param descriptors object.
+ *
+ * \param descriptors the param descriptors object
+ */
+ApexCodec_Status ApexCodec_ParamDescriptors_release(
+ ApexCodec_ParamDescriptors *descriptors) __INTRODUCED_IN(36);
+
+/**
+ * Query the component for the supported parameters.
+ *
+ * \param comp the handle for the component
+ * \param descriptors the pointer to be filled with the param descriptors object
+ * the object should be released with ApexCodec_ParamDescriptors_release().
+ * \return APEXCODEC_STATUS_OK if successful
+ * \return APEXCODEC_STATUS_BAD_VALUE if parameters are bad. e.g. |descriptors| is nullptr.
+ */
+ApexCodec_Status ApexCodec_Configurable_querySupportedParams(
+ ApexCodec_Configurable *comp,
+ ApexCodec_ParamDescriptors **descriptors) __INTRODUCED_IN(36);
+
+/**
+ * Struct that represents the query for the supported values of a parameter.
+ *
+ * The offset of the field can be found in the layout of the parameter blob.
+ *
+ * Introduced in API 36.
+ */
+typedef struct ApexCodec_SupportedValuesQuery {
+ /* in-params */
+
+ /** index of the param */
+ uint32_t index;
+ /** offset to the param field */
+ size_t offset;
+ /** query type */
+ ApexCodec_SupportedValuesQueryType type;
+
+ /* out-params */
+
+ /** status of the query */
+ ApexCodec_Status status;
+
+ /** supported values. must be released with ApexCodec_SupportedValues_release(). */
+ ApexCodec_SupportedValues *values;
+} ApexCodec_SupportedValuesQuery;
+
+/**
+ * Query the component for the supported values of the given indices.
+ *
+ * \param comp the handle for the component
+ * \param queries the array of queries
+ * \param numQueries the size of the queries array
+ * \return APEXCODEC_STATUS_OK if successful
+ * APEXCODEC_STATUS_CORRUPTED if unexpected error has occurred
+ */
+ApexCodec_Status ApexCodec_Configurable_querySupportedValues(
+ ApexCodec_Configurable *comp,
+ ApexCodec_SupportedValuesQuery *queries,
+ size_t numQueries) __INTRODUCED_IN(36);
+
+__END_DECLS
\ No newline at end of file
diff --git a/media/module/libapexcodecs/libapexcodecs.map.txt b/media/module/libapexcodecs/libapexcodecs.map.txt
new file mode 100644
index 0000000..672cf89
--- /dev/null
+++ b/media/module/libapexcodecs/libapexcodecs.map.txt
@@ -0,0 +1,26 @@
+LIBAPEXCODECS_36 { # introduced=36
+ global:
+ ApexCodec_Component_create; # apex
+ ApexCodec_Component_destroy; # apex
+ ApexCodec_Component_flush; # apex
+ ApexCodec_Component_getConfigurable; # apex
+ ApexCodec_Component_process; # apex
+ ApexCodec_Component_start; # apex
+ ApexCodec_Component_reset; # apex
+ ApexCodec_Configurable_config; # apex
+ ApexCodec_Configurable_query; # apex
+ ApexCodec_Configurable_querySupportedParams; # apex
+ ApexCodec_Configurable_querySupportedValues; # apex
+ ApexCodec_GetComponentStore; # apex
+ ApexCodec_ParamDescriptors_getDescriptor; # apex
+ ApexCodec_ParamDescriptors_getIndices; # apex
+ ApexCodec_ParamDescriptors_release; # apex
+ ApexCodec_SettingResults_getResultAtIndex; # apex
+ ApexCodec_SettingResults_release; # apex
+ ApexCodec_SupportedValues_getTypeAndValues; # apex
+ ApexCodec_SupportedValues_release; # apex
+ ApexCodec_Traits_get; # apex
+
+ local:
+ *;
+};
\ No newline at end of file
diff --git a/media/module/libapexcodecs/tests/Android.bp b/media/module/libapexcodecs/tests/Android.bp
new file mode 100644
index 0000000..162d12c
--- /dev/null
+++ b/media/module/libapexcodecs/tests/Android.bp
@@ -0,0 +1,30 @@
+//
+// Copyright (C) 2024 The Android Open Source Project
+//
+// 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.
+//
+
+package {
+ default_team: "trendy_team_android_media_codec_framework",
+ default_applicable_licenses: ["frameworks_av_license"],
+}
+
+cc_test {
+ name: "libapexcodecs_tests",
+ shared_libs: [
+ "libapexcodecs-testing",
+ "libcodec2",
+ ],
+
+ srcs: ["ApexCodecsTest.cpp"],
+}
diff --git a/media/module/libapexcodecs/tests/ApexCodecsTest.cpp b/media/module/libapexcodecs/tests/ApexCodecsTest.cpp
new file mode 100644
index 0000000..cd5ebba
--- /dev/null
+++ b/media/module/libapexcodecs/tests/ApexCodecsTest.cpp
@@ -0,0 +1,100 @@
+#include <C2.h>
+#include <C2Component.h>
+
+#include <apex/ApexCodecs.h>
+
+// static_asserts for enum values match
+static_assert((uint32_t)APEXCODEC_STATUS_OK == (uint32_t)C2_OK);
+static_assert((uint32_t)APEXCODEC_STATUS_BAD_VALUE == (uint32_t)C2_BAD_VALUE);
+static_assert((uint32_t)APEXCODEC_STATUS_BAD_INDEX == (uint32_t)C2_BAD_INDEX);
+static_assert((uint32_t)APEXCODEC_STATUS_CANNOT_DO == (uint32_t)C2_CANNOT_DO);
+static_assert((uint32_t)APEXCODEC_STATUS_DUPLICATE == (uint32_t)C2_DUPLICATE);
+static_assert((uint32_t)APEXCODEC_STATUS_NOT_FOUND == (uint32_t)C2_NOT_FOUND);
+static_assert((uint32_t)APEXCODEC_STATUS_BAD_STATE == (uint32_t)C2_BAD_STATE);
+static_assert((uint32_t)APEXCODEC_STATUS_BLOCKING == (uint32_t)C2_BLOCKING);
+static_assert((uint32_t)APEXCODEC_STATUS_CANCELED == (uint32_t)C2_CANCELED);
+static_assert((uint32_t)APEXCODEC_STATUS_NO_MEMORY == (uint32_t)C2_NO_MEMORY);
+static_assert((uint32_t)APEXCODEC_STATUS_REFUSED == (uint32_t)C2_REFUSED);
+static_assert((uint32_t)APEXCODEC_STATUS_TIMED_OUT == (uint32_t)C2_TIMED_OUT);
+static_assert((uint32_t)APEXCODEC_STATUS_OMITTED == (uint32_t)C2_OMITTED);
+static_assert((uint32_t)APEXCODEC_STATUS_CORRUPTED == (uint32_t)C2_CORRUPTED);
+static_assert((uint32_t)APEXCODEC_STATUS_NO_INIT == (uint32_t)C2_NO_INIT);
+
+static_assert((uint32_t)APEXCODEC_KIND_OTHER == (uint32_t)C2Component::KIND_OTHER);
+static_assert((uint32_t)APEXCODEC_KIND_DECODER == (uint32_t)C2Component::KIND_DECODER);
+static_assert((uint32_t)APEXCODEC_KIND_ENCODER == (uint32_t)C2Component::KIND_ENCODER);
+
+static_assert((uint32_t)APEXCODEC_DOMAIN_OTHER == (uint32_t)C2Component::DOMAIN_OTHER);
+static_assert((uint32_t)APEXCODEC_DOMAIN_VIDEO == (uint32_t)C2Component::DOMAIN_VIDEO);
+static_assert((uint32_t)APEXCODEC_DOMAIN_AUDIO == (uint32_t)C2Component::DOMAIN_AUDIO);
+static_assert((uint32_t)APEXCODEC_DOMAIN_IMAGE == (uint32_t)C2Component::DOMAIN_IMAGE);
+
+static_assert((uint32_t)APEXCODEC_FLAG_DROP_FRAME == (uint32_t)C2FrameData::FLAG_DROP_FRAME);
+static_assert((uint32_t)APEXCODEC_FLAG_END_OF_STREAM == (uint32_t)C2FrameData::FLAG_END_OF_STREAM);
+static_assert((uint32_t)APEXCODEC_FLAG_DISCARD_FRAME == (uint32_t)C2FrameData::FLAG_DISCARD_FRAME);
+static_assert((uint32_t)APEXCODEC_FLAG_INCOMPLETE == (uint32_t)C2FrameData::FLAG_INCOMPLETE);
+static_assert((uint32_t)APEXCODEC_FLAG_CORRECTED == (uint32_t)C2FrameData::FLAG_CORRECTED);
+static_assert((uint32_t)APEXCODEC_FLAG_CORRUPT == (uint32_t)C2FrameData::FLAG_CORRUPT);
+static_assert((uint32_t)APEXCODEC_FLAG_CODEC_CONFIG == (uint32_t)C2FrameData::FLAG_CODEC_CONFIG);
+
+static_assert((uint32_t)APEXCODEC_BUFFER_TYPE_INVALID ==
+ (uint32_t)C2BufferData::INVALID);
+static_assert((uint32_t)APEXCODEC_BUFFER_TYPE_LINEAR ==
+ (uint32_t)C2BufferData::LINEAR);
+static_assert((uint32_t)APEXCODEC_BUFFER_TYPE_LINEAR_CHUNKS ==
+ (uint32_t)C2BufferData::LINEAR_CHUNKS);
+static_assert((uint32_t)APEXCODEC_BUFFER_TYPE_GRAPHIC ==
+ (uint32_t)C2BufferData::GRAPHIC);
+static_assert((uint32_t)APEXCODEC_BUFFER_TYPE_GRAPHIC_CHUNKS ==
+ (uint32_t)C2BufferData::GRAPHIC_CHUNKS);
+
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_QUERY_CURRENT ==
+ (uint32_t)C2FieldSupportedValuesQuery::CURRENT);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_QUERY_POSSIBLE ==
+ (uint32_t)C2FieldSupportedValuesQuery::POSSIBLE);
+
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_EMPTY ==
+ (uint32_t)C2FieldSupportedValues::EMPTY);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_RANGE ==
+ (uint32_t)C2FieldSupportedValues::RANGE);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_VALUES ==
+ (uint32_t)C2FieldSupportedValues::VALUES);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_FLAGS ==
+ (uint32_t)C2FieldSupportedValues::FLAGS);
+
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_TYPE_NONE == (uint32_t)C2Value::NO_INIT);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_TYPE_INT32 == (uint32_t)C2Value::INT32);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_TYPE_UINT32 == (uint32_t)C2Value::UINT32);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_TYPE_INT64 == (uint32_t)C2Value::INT64);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_TYPE_UINT64 == (uint32_t)C2Value::UINT64);
+static_assert((uint32_t)APEXCODEC_SUPPORTED_VALUES_TYPE_FLOAT == (uint32_t)C2Value::FLOAT);
+
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_BAD_TYPE ==
+ (uint32_t)C2SettingResult::BAD_TYPE);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_BAD_PORT ==
+ (uint32_t)C2SettingResult::BAD_PORT);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_BAD_INDEX ==
+ (uint32_t)C2SettingResult::BAD_INDEX);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_READ_ONLY ==
+ (uint32_t)C2SettingResult::READ_ONLY);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_MISMATCH ==
+ (uint32_t)C2SettingResult::MISMATCH);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_BAD_VALUE ==
+ (uint32_t)C2SettingResult::BAD_VALUE);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_CONFLICT ==
+ (uint32_t)C2SettingResult::CONFLICT);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_UNSUPPORTED ==
+ (uint32_t)C2SettingResult::UNSUPPORTED);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_INFO_BAD_VALUE ==
+ (uint32_t)C2SettingResult::INFO_BAD_VALUE);
+static_assert((uint32_t)APEXCODEC_SETTING_RESULT_INFO_CONFLICT ==
+ (uint32_t)C2SettingResult::INFO_CONFLICT);
+
+static_assert((uint32_t)APEXCODEC_PARAM_IS_REQUIRED == (uint32_t)C2ParamDescriptor::IS_REQUIRED);
+static_assert((uint32_t)APEXCODEC_PARAM_IS_PERSISTENT ==
+ (uint32_t)C2ParamDescriptor::IS_PERSISTENT);
+static_assert((uint32_t)APEXCODEC_PARAM_IS_STRICT == (uint32_t)C2ParamDescriptor::IS_STRICT);
+static_assert((uint32_t)APEXCODEC_PARAM_IS_READ_ONLY == (uint32_t)C2ParamDescriptor::IS_READ_ONLY);
+static_assert((uint32_t)APEXCODEC_PARAM_IS_HIDDEN == (uint32_t)C2ParamDescriptor::IS_HIDDEN);
+static_assert((uint32_t)APEXCODEC_PARAM_IS_INTERNAL == (uint32_t)C2ParamDescriptor::IS_INTERNAL);
+static_assert((uint32_t)APEXCODEC_PARAM_IS_CONST == (uint32_t)C2ParamDescriptor::IS_CONST);
\ No newline at end of file
diff --git a/services/audioparameterparser/Android.bp b/services/audioparameterparser/Android.bp
index 1c1c1e1..0b2c1ba 100644
--- a/services/audioparameterparser/Android.bp
+++ b/services/audioparameterparser/Android.bp
@@ -35,10 +35,10 @@
name: "android.hardware.audio.parameter_parser.example_defaults",
defaults: [
"latest_android_hardware_audio_core_ndk_shared",
- "latest_av_audio_types_aidl_ndk_shared",
],
shared_libs: [
+ "av-audio-types-aidl-ndk",
"libbase",
"libbinder_ndk",
],