Merge "C2SoftFlacDec: add support to receive multiple CSDs"
diff --git a/drm/mediadrm/plugins/clearkey/default/DrmPlugin.cpp b/drm/mediadrm/plugins/clearkey/default/DrmPlugin.cpp
index 1b8b8c1..6ac3510 100644
--- a/drm/mediadrm/plugins/clearkey/default/DrmPlugin.cpp
+++ b/drm/mediadrm/plugins/clearkey/default/DrmPlugin.cpp
@@ -109,6 +109,7 @@
}
void DrmPlugin::setPlayPolicy() {
+ android::Mutex::Autolock lock(mPlayPolicyLock);
mPlayPolicy.clear();
mPlayPolicy.add(kQueryKeyLicenseType, kStreaming);
mPlayPolicy.add(kQueryKeyPlayAllowed, kTrue);
diff --git a/drm/mediadrm/plugins/clearkey/default/include/DrmPlugin.h b/drm/mediadrm/plugins/clearkey/default/include/DrmPlugin.h
index 4fa42e5..aa9b59d 100644
--- a/drm/mediadrm/plugins/clearkey/default/include/DrmPlugin.h
+++ b/drm/mediadrm/plugins/clearkey/default/include/DrmPlugin.h
@@ -262,6 +262,7 @@
void initProperties();
void setPlayPolicy();
+ android::Mutex mPlayPolicyLock;
android::KeyedVector<String8, String8> mPlayPolicy;
android::KeyedVector<String8, String8> mStringProperties;
android::KeyedVector<String8, Vector<uint8_t>> mByteArrayProperties;
diff --git a/drm/mediadrm/plugins/clearkey/hidl/CryptoPlugin.cpp b/drm/mediadrm/plugins/clearkey/hidl/CryptoPlugin.cpp
index 1495703..d278633 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/CryptoPlugin.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/CryptoPlugin.cpp
@@ -119,7 +119,11 @@
return Void();
}
- if (source.offset + offset + source.size > sourceBase->getSize()) {
+ size_t totalSize = 0;
+ if (__builtin_add_overflow(source.offset, offset, &totalSize) ||
+ __builtin_add_overflow(totalSize, source.size, &totalSize) ||
+ totalSize > sourceBase->getSize()) {
+ android_errorWriteLog(0x534e4554, "176496160");
_hidl_cb(Status_V1_2::ERROR_DRM_CANNOT_HANDLE, 0, "invalid buffer size");
return Void();
}
diff --git a/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp b/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
index f87f830..a77759e 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
@@ -304,6 +304,7 @@
}
void DrmPlugin::setPlayPolicy() {
+ android::Mutex::Autolock lock(mPlayPolicyLock);
mPlayPolicy.clear();
KeyValue policy;
diff --git a/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h b/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
index 3de7589..076beb8 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
+++ b/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
@@ -406,6 +406,7 @@
int64_t mCloseSessionOkCount;
int64_t mCloseSessionNotOpenedCount;
uint32_t mNextSecureStopId;
+ android::Mutex mPlayPolicyLock;
// set by property to mock error scenarios
Status_V1_2 mMockError;
diff --git a/media/bufferpool/2.0/BufferPoolClient.cpp b/media/bufferpool/2.0/BufferPoolClient.cpp
index 9308b81..cda23ff 100644
--- a/media/bufferpool/2.0/BufferPoolClient.cpp
+++ b/media/bufferpool/2.0/BufferPoolClient.cpp
@@ -29,7 +29,7 @@
namespace V2_0 {
namespace implementation {
-static constexpr int64_t kReceiveTimeoutUs = 1000000; // 100ms
+static constexpr int64_t kReceiveTimeoutUs = 2000000; // 2s
static constexpr int kPostMaxRetry = 3;
static constexpr int kCacheTtlUs = 1000000; // TODO: tune
static constexpr size_t kMaxCachedBufferCount = 64;
diff --git a/media/codec2/components/aac/C2SoftAacEnc.cpp b/media/codec2/components/aac/C2SoftAacEnc.cpp
index ea76cbb..d865ab2 100644
--- a/media/codec2/components/aac/C2SoftAacEnc.cpp
+++ b/media/codec2/components/aac/C2SoftAacEnc.cpp
@@ -272,8 +272,9 @@
return UNKNOWN_ERROR;
}
- if (sbrMode != -1 && aacProfile == C2Config::PROFILE_AAC_ELD) {
- if (AACENC_OK != aacEncoder_SetParam(mAACEncoder, AACENC_SBR_MODE, sbrMode)) {
+ if (sbrMode != C2Config::AAC_SBR_AUTO && aacProfile == C2Config::PROFILE_AAC_ELD) {
+ int aacSbrMode = sbrMode != C2Config::AAC_SBR_OFF;
+ if (AACENC_OK != aacEncoder_SetParam(mAACEncoder, AACENC_SBR_MODE, aacSbrMode)) {
ALOGE("Failed to set AAC encoder parameters");
return UNKNOWN_ERROR;
}
diff --git a/media/codec2/components/avc/C2SoftAvcDec.cpp b/media/codec2/components/avc/C2SoftAvcDec.cpp
index f4a6e17..e8287f9 100644
--- a/media/codec2/components/avc/C2SoftAvcDec.cpp
+++ b/media/codec2/components/avc/C2SoftAvcDec.cpp
@@ -22,7 +22,6 @@
#include <C2Debug.h>
#include <C2PlatformSupport.h>
-#include <Codec2BufferUtils.h>
#include <Codec2Mapper.h>
#include <SimpleC2Interface.h>
@@ -332,14 +331,6 @@
free(mem);
}
-static IV_COLOR_FORMAT_T GetIvColorFormat() {
- static IV_COLOR_FORMAT_T sColorFormat =
- (GetYuv420FlexibleLayout() == FLEX_LAYOUT_SEMIPLANAR_UV) ? IV_YUV_420SP_UV :
- (GetYuv420FlexibleLayout() == FLEX_LAYOUT_SEMIPLANAR_VU) ? IV_YUV_420SP_VU :
- IV_YUV_420P;
- return sColorFormat;
-}
-
C2SoftAvcDec::C2SoftAvcDec(
const char *name,
c2_node_id_t id,
@@ -348,6 +339,7 @@
mIntf(intfImpl),
mDecHandle(nullptr),
mOutBufferFlush(nullptr),
+ mIvColorFormat(IV_YUV_420P),
mOutputDelay(kDefaultOutputDelay),
mWidth(320),
mHeight(240),
@@ -426,13 +418,7 @@
s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ivdext_create_ip_t);
s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
- s_create_ip.s_ivd_create_ip_t.e_output_format = GetIvColorFormat();
- switch (s_create_ip.s_ivd_create_ip_t.e_output_format) {
- case IV_YUV_420P: ALOGD("Flex Planar"); break;
- case IV_YUV_420SP_UV: ALOGD("Flex Semi-planar UV"); break;
- case IV_YUV_420SP_VU: ALOGD("Flex Semi-planar VU"); break;
- default: ALOGD("Unknown"); break;
- }
+ s_create_ip.s_ivd_create_ip_t.e_output_format = mIvColorFormat;
s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = nullptr;
@@ -569,12 +555,8 @@
ps_decode_ip->u4_num_Bytes = 0;
}
ps_decode_ip->s_out_buffer.u4_min_out_buf_size[0] = lumaSize;
- if (GetIvColorFormat() == IV_YUV_420P) {
- ps_decode_ip->s_out_buffer.u4_min_out_buf_size[1] = chromaSize;
- ps_decode_ip->s_out_buffer.u4_min_out_buf_size[2] = chromaSize;
- } else {
- ps_decode_ip->s_out_buffer.u4_min_out_buf_size[1] = chromaSize * 2;
- }
+ ps_decode_ip->s_out_buffer.u4_min_out_buf_size[1] = chromaSize;
+ ps_decode_ip->s_out_buffer.u4_min_out_buf_size[2] = chromaSize;
if (outBuffer) {
if (outBuffer->height() < displayHeight) {
ALOGE("Output buffer too small: provided (%dx%d) required (%ux%u)",
@@ -583,23 +565,13 @@
}
ps_decode_ip->s_out_buffer.pu1_bufs[0] = outBuffer->data()[C2PlanarLayout::PLANE_Y];
ps_decode_ip->s_out_buffer.pu1_bufs[1] = outBuffer->data()[C2PlanarLayout::PLANE_U];
- if (GetIvColorFormat() == IV_YUV_420P) {
- ps_decode_ip->s_out_buffer.pu1_bufs[2] = outBuffer->data()[C2PlanarLayout::PLANE_V];
- } else if (GetIvColorFormat() == IV_YUV_420SP_VU) {
- ps_decode_ip->s_out_buffer.pu1_bufs[1] = outBuffer->data()[C2PlanarLayout::PLANE_V];
- }
+ ps_decode_ip->s_out_buffer.pu1_bufs[2] = outBuffer->data()[C2PlanarLayout::PLANE_V];
} else {
ps_decode_ip->s_out_buffer.pu1_bufs[0] = mOutBufferFlush;
ps_decode_ip->s_out_buffer.pu1_bufs[1] = mOutBufferFlush + lumaSize;
- if (GetIvColorFormat() == IV_YUV_420P) {
- ps_decode_ip->s_out_buffer.pu1_bufs[2] = mOutBufferFlush + lumaSize + chromaSize;
- }
+ ps_decode_ip->s_out_buffer.pu1_bufs[2] = mOutBufferFlush + lumaSize + chromaSize;
}
- if (GetIvColorFormat() == IV_YUV_420P) {
- ps_decode_ip->s_out_buffer.u4_num_bufs = 3;
- } else {
- ps_decode_ip->s_out_buffer.u4_num_bufs = 2;
- }
+ ps_decode_ip->s_out_buffer.u4_num_bufs = 3;
ps_decode_op->u4_size = sizeof(ih264d_video_decode_op_t);
return true;
@@ -809,7 +781,7 @@
mOutBlock.reset();
}
if (!mOutBlock) {
- uint32_t format = HAL_PIXEL_FORMAT_YCBCR_420_888;
+ uint32_t format = HAL_PIXEL_FORMAT_YV12;
C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
c2_status_t err =
pool->fetchGraphicBlock(ALIGN32(mWidth), mHeight, format, usage, &mOutBlock);
@@ -825,6 +797,8 @@
}
// TODO: can overall error checking be improved?
+// TODO: allow configuration of color format and usage for graphic buffers instead
+// of hard coding them to HAL_PIXEL_FORMAT_YV12
// TODO: pass coloraspects information to surface
// TODO: test support for dynamic change in resolution
// TODO: verify if the decoder sent back all frames
diff --git a/media/codec2/components/avc/C2SoftAvcDec.h b/media/codec2/components/avc/C2SoftAvcDec.h
index ed99ad1..5c07d29 100644
--- a/media/codec2/components/avc/C2SoftAvcDec.h
+++ b/media/codec2/components/avc/C2SoftAvcDec.h
@@ -155,6 +155,7 @@
uint8_t *mOutBufferFlush;
size_t mNumCores;
+ IV_COLOR_FORMAT_T mIvColorFormat;
uint32_t mOutputDelay;
uint32_t mWidth;
uint32_t mHeight;
diff --git a/media/codec2/components/avc/C2SoftAvcEnc.cpp b/media/codec2/components/avc/C2SoftAvcEnc.cpp
index fc5b75d..0b121ad 100644
--- a/media/codec2/components/avc/C2SoftAvcEnc.cpp
+++ b/media/codec2/components/avc/C2SoftAvcEnc.cpp
@@ -28,6 +28,7 @@
#include <media/stagefright/foundation/AUtils.h>
#include <C2Debug.h>
+#include <Codec2Mapper.h>
#include <C2PlatformSupport.h>
#include <Codec2BufferUtils.h>
#include <SimpleC2Interface.h>
@@ -213,6 +214,42 @@
.withFields({C2F(mSyncFramePeriod, value).any()})
.withSetter(Setter<decltype(*mSyncFramePeriod)>::StrictValueWithNoDeps)
.build());
+
+ addParameter(
+ DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
+ .withDefault(new C2StreamColorAspectsInfo::input(
+ 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
+ .withFields({
+ C2F(mColorAspects, range).inRange(
+ C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
+ C2F(mColorAspects, primaries).inRange(
+ C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
+ C2F(mColorAspects, transfer).inRange(
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
+ C2F(mColorAspects, matrix).inRange(
+ C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
+ })
+ .withSetter(ColorAspectsSetter)
+ .build());
+
+ addParameter(
+ DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
+ .withDefault(new C2StreamColorAspectsInfo::output(
+ 0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
+ .withFields({
+ C2F(mCodedColorAspects, range).inRange(
+ C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
+ C2F(mCodedColorAspects, primaries).inRange(
+ C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
+ C2F(mCodedColorAspects, transfer).inRange(
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
+ C2F(mCodedColorAspects, matrix).inRange(
+ C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
+ })
+ .withSetter(CodedColorAspectsSetter, mColorAspects)
+ .build());
}
static C2R InputDelaySetter(
@@ -359,6 +396,33 @@
return C2R::Ok();
}
+ static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::input> &me) {
+ (void)mayBlock;
+ if (me.v.range > C2Color::RANGE_OTHER) {
+ me.set().range = C2Color::RANGE_OTHER;
+ }
+ if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
+ me.set().primaries = C2Color::PRIMARIES_OTHER;
+ }
+ if (me.v.transfer > C2Color::TRANSFER_OTHER) {
+ me.set().transfer = C2Color::TRANSFER_OTHER;
+ }
+ if (me.v.matrix > C2Color::MATRIX_OTHER) {
+ me.set().matrix = C2Color::MATRIX_OTHER;
+ }
+ return C2R::Ok();
+ }
+
+ static C2R CodedColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output> &me,
+ const C2P<C2StreamColorAspectsInfo::input> &coded) {
+ (void)mayBlock;
+ me.set().range = coded.v.range;
+ me.set().primaries = coded.v.primaries;
+ me.set().transfer = coded.v.transfer;
+ me.set().matrix = coded.v.matrix;
+ return C2R::Ok();
+ }
+
IV_PROFILE_T getProfile_l() const {
switch (mProfileLevel->profile) {
case PROFILE_AVC_CONSTRAINED_BASELINE: [[fallthrough]];
@@ -418,6 +482,9 @@
std::shared_ptr<C2StreamGopTuning::output> getGop_l() const { return mGop; }
std::shared_ptr<C2StreamPictureQuantizationTuning::output> getPictureQuantization_l() const
{ return mPictureQuantization; }
+ std::shared_ptr<C2StreamColorAspectsInfo::output> getCodedColorAspects_l() const {
+ return mCodedColorAspects;
+ }
private:
std::shared_ptr<C2StreamUsageTuning::input> mUsage;
@@ -430,6 +497,8 @@
std::shared_ptr<C2StreamSyncFrameIntervalTuning::output> mSyncFramePeriod;
std::shared_ptr<C2StreamGopTuning::output> mGop;
std::shared_ptr<C2StreamPictureQuantizationTuning::output> mPictureQuantization;
+ std::shared_ptr<C2StreamColorAspectsInfo::input> mColorAspects;
+ std::shared_ptr<C2StreamColorAspectsInfo::output> mCodedColorAspects;
};
#define ive_api_function ih264e_api_function
@@ -454,19 +523,11 @@
} // namespace
-static IV_COLOR_FORMAT_T GetIvColorFormat() {
- static IV_COLOR_FORMAT_T sColorFormat =
- (GetYuv420FlexibleLayout() == FLEX_LAYOUT_SEMIPLANAR_UV) ? IV_YUV_420SP_UV :
- (GetYuv420FlexibleLayout() == FLEX_LAYOUT_SEMIPLANAR_VU) ? IV_YUV_420SP_VU :
- IV_YUV_420P;
- return sColorFormat;
-}
-
C2SoftAvcEnc::C2SoftAvcEnc(
const char *name, c2_node_id_t id, const std::shared_ptr<IntfImpl> &intfImpl)
: SimpleC2Component(std::make_shared<SimpleInterface<IntfImpl>>(name, id, intfImpl)),
mIntf(intfImpl),
- mIvVideoColorFormat(GetIvColorFormat()),
+ mIvVideoColorFormat(IV_YUV_420P),
mAVCEncProfile(IV_PROFILE_BASE),
mAVCEncLevel(41),
mStarted(false),
@@ -988,6 +1049,55 @@
return;
}
+c2_status_t C2SoftAvcEnc::setVuiParams()
+{
+ ColorAspects sfAspects;
+ if (!C2Mapper::map(mColorAspects->primaries, &sfAspects.mPrimaries)) {
+ sfAspects.mPrimaries = android::ColorAspects::PrimariesUnspecified;
+ }
+ if (!C2Mapper::map(mColorAspects->range, &sfAspects.mRange)) {
+ sfAspects.mRange = android::ColorAspects::RangeUnspecified;
+ }
+ if (!C2Mapper::map(mColorAspects->matrix, &sfAspects.mMatrixCoeffs)) {
+ sfAspects.mMatrixCoeffs = android::ColorAspects::MatrixUnspecified;
+ }
+ if (!C2Mapper::map(mColorAspects->transfer, &sfAspects.mTransfer)) {
+ sfAspects.mTransfer = android::ColorAspects::TransferUnspecified;
+ }
+ int32_t primaries, transfer, matrixCoeffs;
+ bool range;
+ ColorUtils::convertCodecColorAspectsToIsoAspects(sfAspects,
+ &primaries,
+ &transfer,
+ &matrixCoeffs,
+ &range);
+ ih264e_vui_ip_t s_vui_params_ip {};
+ ih264e_vui_op_t s_vui_params_op {};
+
+ s_vui_params_ip.e_cmd = IVE_CMD_VIDEO_CTL;
+ s_vui_params_ip.e_sub_cmd = IVE_CMD_CTL_SET_VUI_PARAMS;
+
+ s_vui_params_ip.u1_video_signal_type_present_flag = 1;
+ s_vui_params_ip.u1_colour_description_present_flag = 1;
+ s_vui_params_ip.u1_colour_primaries = primaries;
+ s_vui_params_ip.u1_transfer_characteristics = transfer;
+ s_vui_params_ip.u1_matrix_coefficients = matrixCoeffs;
+ s_vui_params_ip.u1_video_full_range_flag = range;
+
+ s_vui_params_ip.u4_size = sizeof(ih264e_vui_ip_t);
+ s_vui_params_op.u4_size = sizeof(ih264e_vui_op_t);
+
+ IV_STATUS_T status = ih264e_api_function(mCodecCtx, &s_vui_params_ip,
+ &s_vui_params_op);
+ if(status != IV_SUCCESS)
+ {
+ ALOGE("Unable to set vui params = 0x%x\n",
+ s_vui_params_op.u4_error_code);
+ return C2_CORRUPTED;
+ }
+ return C2_OK;
+}
+
c2_status_t C2SoftAvcEnc::initEncoder() {
IV_STATUS_T status;
WORD32 level;
@@ -1007,6 +1117,7 @@
mIInterval = mIntf->getSyncFramePeriod_l();
mIDRInterval = mIntf->getSyncFramePeriod_l();
gop = mIntf->getGop_l();
+ mColorAspects = mIntf->getCodedColorAspects_l();
}
if (gop && gop->flexCount() > 0) {
uint32_t syncInterval = 1;
@@ -1034,7 +1145,8 @@
// Assume worst case output buffer size to be equal to number of bytes in input
mOutBufferSize = std::max(width * height * 3 / 2, kMinOutBufferSize);
- mIvVideoColorFormat = GetIvColorFormat();
+ // TODO
+ mIvVideoColorFormat = IV_YUV_420P;
ALOGD("Params width %d height %d level %d colorFormat %d bframes %d", width,
height, mAVCEncLevel, mIvVideoColorFormat, mBframes);
@@ -1230,6 +1342,9 @@
/* Video control Set Profile params */
setProfileParams();
+ /* Video control Set VUI params */
+ setVuiParams();
+
/* Video control Set in Encode header mode */
setEncMode(IVE_ENC_MODE_HEADER);
@@ -1332,6 +1447,7 @@
mSize->width, input->height(), mSize->height);
return C2_BAD_VALUE;
}
+ ALOGV("width = %d, height = %d", input->width(), input->height());
const C2PlanarLayout &layout = input->layout();
uint8_t *yPlane = const_cast<uint8_t *>(input->data()[C2PlanarLayout::PLANE_Y]);
uint8_t *uPlane = const_cast<uint8_t *>(input->data()[C2PlanarLayout::PLANE_U]);
@@ -1368,8 +1484,7 @@
return C2_BAD_VALUE;
}
- if (mIvVideoColorFormat == IV_YUV_420P
- && layout.planes[layout.PLANE_Y].colInc == 1
+ if (layout.planes[layout.PLANE_Y].colInc == 1
&& layout.planes[layout.PLANE_U].colInc == 1
&& layout.planes[layout.PLANE_V].colInc == 1
&& uStride == vStride
@@ -1377,61 +1492,21 @@
// I420 compatible - already set up above
break;
}
- if (mIvVideoColorFormat == IV_YUV_420SP_UV
- && layout.planes[layout.PLANE_Y].colInc == 1
- && layout.planes[layout.PLANE_U].colInc == 2
- && layout.planes[layout.PLANE_V].colInc == 2
- && uStride == vStride
- && yStride == vStride
- && uPlane + 1 == vPlane) {
- // NV12 compatible - already set up above
- break;
- }
- if (mIvVideoColorFormat == IV_YUV_420SP_VU
- && layout.planes[layout.PLANE_Y].colInc == 1
- && layout.planes[layout.PLANE_U].colInc == 2
- && layout.planes[layout.PLANE_V].colInc == 2
- && uStride == vStride
- && yStride == vStride
- && uPlane == vPlane + 1) {
- // NV21 compatible - already set up above
- break;
- }
// copy to I420
yStride = width;
uStride = vStride = yStride / 2;
MemoryBlock conversionBuffer = mConversionBuffers.fetch(yPlaneSize * 3 / 2);
mConversionBuffersInUse.emplace(conversionBuffer.data(), conversionBuffer);
- MediaImage2 img;
- switch (mIvVideoColorFormat) {
- case IV_YUV_420P:
- img = CreateYUV420PlanarMediaImage2(width, height, yStride, height);
- yPlane = conversionBuffer.data();
- uPlane = yPlane + yPlaneSize;
- vPlane = uPlane + yPlaneSize / 4;
- break;
- case IV_YUV_420SP_VU:
- img = CreateYUV420SemiPlanarMediaImage2(width, height, yStride, height);
- img.mPlane[MediaImage2::U].mOffset++;
- img.mPlane[MediaImage2::V].mOffset--;
- yPlane = conversionBuffer.data();
- vPlane = yPlane + yPlaneSize;
- uPlane = vPlane + 1;
- break;
- case IV_YUV_420SP_UV:
- default:
- img = CreateYUV420SemiPlanarMediaImage2(width, height, yStride, height);
- yPlane = conversionBuffer.data();
- uPlane = yPlane + yPlaneSize;
- vPlane = uPlane + 1;
- break;
- }
+ MediaImage2 img = CreateYUV420PlanarMediaImage2(width, height, yStride, height);
status_t err = ImageCopy(conversionBuffer.data(), &img, *input);
if (err != OK) {
ALOGE("Buffer conversion failed: %d", err);
return C2_BAD_VALUE;
}
+ yPlane = conversionBuffer.data();
+ uPlane = yPlane + yPlaneSize;
+ vPlane = uPlane + yPlaneSize / 4;
break;
}
@@ -1477,17 +1552,15 @@
break;
}
- case IV_YUV_420SP_VU:
- uPlane = vPlane;
- [[fallthrough]];
case IV_YUV_420SP_UV:
+ case IV_YUV_420SP_VU:
default:
{
ps_inp_raw_buf->apv_bufs[0] = yPlane;
ps_inp_raw_buf->apv_bufs[1] = uPlane;
ps_inp_raw_buf->au4_wd[0] = mSize->width;
- ps_inp_raw_buf->au4_wd[1] = mSize->width / 2;
+ ps_inp_raw_buf->au4_wd[1] = mSize->width;
ps_inp_raw_buf->au4_ht[0] = mSize->height;
ps_inp_raw_buf->au4_ht[1] = mSize->height / 2;
diff --git a/media/codec2/components/avc/C2SoftAvcEnc.h b/media/codec2/components/avc/C2SoftAvcEnc.h
index 673a282..baf33e2 100644
--- a/media/codec2/components/avc/C2SoftAvcEnc.h
+++ b/media/codec2/components/avc/C2SoftAvcEnc.h
@@ -196,6 +196,7 @@
std::shared_ptr<C2StreamFrameRateInfo::output> mFrameRate;
std::shared_ptr<C2StreamBitrateInfo::output> mBitrate;
std::shared_ptr<C2StreamRequestSyncFrameTuning::output> mRequestSync;
+ std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects;
uint32_t mOutBufferSize;
UWORD32 mHeaderGenerated;
@@ -229,6 +230,7 @@
c2_status_t setProfileParams();
c2_status_t setDeblockParams();
c2_status_t setVbvParams();
+ c2_status_t setVuiParams();
void logVersion();
c2_status_t setEncodeArgs(
ive_video_encode_ip_t *ps_encode_ip,
diff --git a/media/codec2/components/base/SimpleC2Component.cpp b/media/codec2/components/base/SimpleC2Component.cpp
index fb3fbd0..dfad226 100644
--- a/media/codec2/components/base/SimpleC2Component.cpp
+++ b/media/codec2/components/base/SimpleC2Component.cpp
@@ -110,17 +110,20 @@
}
case kWhatStop: {
int32_t err = thiz->onStop();
+ thiz->mOutputBlockPool.reset();
Reply(msg, &err);
break;
}
case kWhatReset: {
thiz->onReset();
+ thiz->mOutputBlockPool.reset();
mRunning = false;
Reply(msg);
break;
}
case kWhatRelease: {
thiz->onRelease();
+ thiz->mOutputBlockPool.reset();
mRunning = false;
Reply(msg);
break;
diff --git a/media/codec2/components/hevc/C2SoftHevcEnc.cpp b/media/codec2/components/hevc/C2SoftHevcEnc.cpp
index 436a2c4..4bc1777 100644
--- a/media/codec2/components/hevc/C2SoftHevcEnc.cpp
+++ b/media/codec2/components/hevc/C2SoftHevcEnc.cpp
@@ -25,6 +25,7 @@
#include <media/stagefright/foundation/AUtils.h>
#include <C2Debug.h>
+#include <Codec2Mapper.h>
#include <C2PlatformSupport.h>
#include <Codec2BufferUtils.h>
#include <SimpleC2Interface.h>
@@ -208,6 +209,42 @@
.withSetter(
Setter<decltype(*mSyncFramePeriod)>::StrictValueWithNoDeps)
.build());
+
+ addParameter(
+ DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
+ .withDefault(new C2StreamColorAspectsInfo::input(
+ 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
+ .withFields({
+ C2F(mColorAspects, range).inRange(
+ C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
+ C2F(mColorAspects, primaries).inRange(
+ C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
+ C2F(mColorAspects, transfer).inRange(
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
+ C2F(mColorAspects, matrix).inRange(
+ C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
+ })
+ .withSetter(ColorAspectsSetter)
+ .build());
+
+ addParameter(
+ DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
+ .withDefault(new C2StreamColorAspectsInfo::output(
+ 0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
+ .withFields({
+ C2F(mCodedColorAspects, range).inRange(
+ C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
+ C2F(mCodedColorAspects, primaries).inRange(
+ C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
+ C2F(mCodedColorAspects, transfer).inRange(
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
+ C2F(mCodedColorAspects, matrix).inRange(
+ C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
+ })
+ .withSetter(CodedColorAspectsSetter, mColorAspects)
+ .build());
}
static C2R InputDelaySetter(
@@ -402,6 +439,34 @@
std::shared_ptr<C2StreamGopTuning::output> getGop_l() const {
return mGop;
}
+ static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::input> &me) {
+ (void)mayBlock;
+ if (me.v.range > C2Color::RANGE_OTHER) {
+ me.set().range = C2Color::RANGE_OTHER;
+ }
+ if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
+ me.set().primaries = C2Color::PRIMARIES_OTHER;
+ }
+ if (me.v.transfer > C2Color::TRANSFER_OTHER) {
+ me.set().transfer = C2Color::TRANSFER_OTHER;
+ }
+ if (me.v.matrix > C2Color::MATRIX_OTHER) {
+ me.set().matrix = C2Color::MATRIX_OTHER;
+ }
+ return C2R::Ok();
+ }
+ static C2R CodedColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output> &me,
+ const C2P<C2StreamColorAspectsInfo::input> &coded) {
+ (void)mayBlock;
+ me.set().range = coded.v.range;
+ me.set().primaries = coded.v.primaries;
+ me.set().transfer = coded.v.transfer;
+ me.set().matrix = coded.v.matrix;
+ return C2R::Ok();
+ }
+ std::shared_ptr<C2StreamColorAspectsInfo::output> getCodedColorAspects_l() {
+ return mCodedColorAspects;
+ }
private:
std::shared_ptr<C2StreamUsageTuning::input> mUsage;
@@ -415,6 +480,8 @@
std::shared_ptr<C2StreamProfileLevelInfo::output> mProfileLevel;
std::shared_ptr<C2StreamSyncFrameIntervalTuning::output> mSyncFramePeriod;
std::shared_ptr<C2StreamGopTuning::output> mGop;
+ std::shared_ptr<C2StreamColorAspectsInfo::input> mColorAspects;
+ std::shared_ptr<C2StreamColorAspectsInfo::output> mCodedColorAspects;
};
static size_t GetCPUCoreCount() {
@@ -533,6 +600,32 @@
mBframes = maxBframes;
}
}
+ ColorAspects sfAspects;
+ if (!C2Mapper::map(mColorAspects->primaries, &sfAspects.mPrimaries)) {
+ sfAspects.mPrimaries = android::ColorAspects::PrimariesUnspecified;
+ }
+ if (!C2Mapper::map(mColorAspects->range, &sfAspects.mRange)) {
+ sfAspects.mRange = android::ColorAspects::RangeUnspecified;
+ }
+ if (!C2Mapper::map(mColorAspects->matrix, &sfAspects.mMatrixCoeffs)) {
+ sfAspects.mMatrixCoeffs = android::ColorAspects::MatrixUnspecified;
+ }
+ if (!C2Mapper::map(mColorAspects->transfer, &sfAspects.mTransfer)) {
+ sfAspects.mTransfer = android::ColorAspects::TransferUnspecified;
+ }
+ int32_t primaries, transfer, matrixCoeffs;
+ bool range;
+ ColorUtils::convertCodecColorAspectsToIsoAspects(sfAspects,
+ &primaries,
+ &transfer,
+ &matrixCoeffs,
+ &range);
+ mEncParams.s_out_strm_prms.i4_vui_enable = 1;
+ mEncParams.s_vui_sei_prms.u1_colour_description_present_flag = 1;
+ mEncParams.s_vui_sei_prms.u1_colour_primaries = primaries;
+ mEncParams.s_vui_sei_prms.u1_transfer_characteristics = transfer;
+ mEncParams.s_vui_sei_prms.u1_matrix_coefficients = matrixCoeffs;
+ mEncParams.s_vui_sei_prms.u1_video_full_range_flag = range;
// update configuration
mEncParams.s_src_prms.i4_width = mSize->width;
mEncParams.s_src_prms.i4_height = mSize->height;
@@ -629,6 +722,7 @@
mQuality = mIntf->getQuality_l();
mGop = mIntf->getGop_l();
mRequestSync = mIntf->getRequestSync_l();
+ mColorAspects = mIntf->getCodedColorAspects_l();
}
c2_status_t status = initEncParams();
diff --git a/media/codec2/components/hevc/C2SoftHevcEnc.h b/media/codec2/components/hevc/C2SoftHevcEnc.h
index 5ea4602..9dbf682 100644
--- a/media/codec2/components/hevc/C2SoftHevcEnc.h
+++ b/media/codec2/components/hevc/C2SoftHevcEnc.h
@@ -89,6 +89,7 @@
std::shared_ptr<C2StreamQualityTuning::output> mQuality;
std::shared_ptr<C2StreamGopTuning::output> mGop;
std::shared_ptr<C2StreamRequestSyncFrameTuning::output> mRequestSync;
+ std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects;
#ifdef FILE_DUMP_ENABLE
char mInFile[200];
char mOutFile[200];
diff --git a/media/codec2/components/raw/C2SoftRawDec.cpp b/media/codec2/components/raw/C2SoftRawDec.cpp
index 31ca705..a03d4e2 100644
--- a/media/codec2/components/raw/C2SoftRawDec.cpp
+++ b/media/codec2/components/raw/C2SoftRawDec.cpp
@@ -87,7 +87,9 @@
.withFields({C2F(mPcmEncodingInfo, value).oneOf({
C2Config::PCM_16,
C2Config::PCM_8,
- C2Config::PCM_FLOAT})
+ C2Config::PCM_FLOAT,
+ C2Config::PCM_24,
+ C2Config::PCM_32})
})
.withSetter((Setter<decltype(*mPcmEncodingInfo)>::StrictValueWithNoDeps))
.build());
diff --git a/media/codec2/components/vpx/C2SoftVpxEnc.h b/media/codec2/components/vpx/C2SoftVpxEnc.h
index 5e34b8a..c98b802 100644
--- a/media/codec2/components/vpx/C2SoftVpxEnc.h
+++ b/media/codec2/components/vpx/C2SoftVpxEnc.h
@@ -345,6 +345,42 @@
.withFields({C2F(mRequestSync, value).oneOf({ C2_FALSE, C2_TRUE }) })
.withSetter(Setter<decltype(*mRequestSync)>::NonStrictValueWithNoDeps)
.build());
+
+ addParameter(
+ DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
+ .withDefault(new C2StreamColorAspectsInfo::input(
+ 0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
+ .withFields({
+ C2F(mColorAspects, range).inRange(
+ C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
+ C2F(mColorAspects, primaries).inRange(
+ C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
+ C2F(mColorAspects, transfer).inRange(
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
+ C2F(mColorAspects, matrix).inRange(
+ C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
+ })
+ .withSetter(ColorAspectsSetter)
+ .build());
+
+ addParameter(
+ DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
+ .withDefault(new C2StreamColorAspectsInfo::output(
+ 0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
+ .withFields({
+ C2F(mCodedColorAspects, range).inRange(
+ C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
+ C2F(mCodedColorAspects, primaries).inRange(
+ C2Color::PRIMARIES_UNSPECIFIED, C2Color::PRIMARIES_OTHER),
+ C2F(mCodedColorAspects, transfer).inRange(
+ C2Color::TRANSFER_UNSPECIFIED, C2Color::TRANSFER_OTHER),
+ C2F(mCodedColorAspects, matrix).inRange(
+ C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)
+ })
+ .withSetter(CodedColorAspectsSetter, mColorAspects)
+ .build());
}
static C2R BitrateSetter(bool mayBlock, C2P<C2StreamBitrateInfo::output> &me) {
@@ -415,6 +451,31 @@
double period = mSyncFramePeriod->value / 1e6 * mFrameRate->value;
return (uint32_t)c2_max(c2_min(period + 0.5, double(UINT32_MAX)), 1.);
}
+ static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::input> &me) {
+ (void)mayBlock;
+ if (me.v.range > C2Color::RANGE_OTHER) {
+ me.set().range = C2Color::RANGE_OTHER;
+ }
+ if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
+ me.set().primaries = C2Color::PRIMARIES_OTHER;
+ }
+ if (me.v.transfer > C2Color::TRANSFER_OTHER) {
+ me.set().transfer = C2Color::TRANSFER_OTHER;
+ }
+ if (me.v.matrix > C2Color::MATRIX_OTHER) {
+ me.set().matrix = C2Color::MATRIX_OTHER;
+ }
+ return C2R::Ok();
+ }
+ static C2R CodedColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output> &me,
+ const C2P<C2StreamColorAspectsInfo::input> &coded) {
+ (void)mayBlock;
+ me.set().range = coded.v.range;
+ me.set().primaries = coded.v.primaries;
+ me.set().transfer = coded.v.transfer;
+ me.set().matrix = coded.v.matrix;
+ return C2R::Ok();
+ }
private:
std::shared_ptr<C2StreamUsageTuning::input> mUsage;
@@ -427,6 +488,8 @@
std::shared_ptr<C2StreamBitrateInfo::output> mBitrate;
std::shared_ptr<C2StreamBitrateModeTuning::output> mBitrateMode;
std::shared_ptr<C2StreamProfileLevelInfo::output> mProfileLevel;
+ std::shared_ptr<C2StreamColorAspectsInfo::input> mColorAspects;
+ std::shared_ptr<C2StreamColorAspectsInfo::output> mCodedColorAspects;
};
} // namespace android
diff --git a/media/codec2/core/include/C2Config.h b/media/codec2/core/include/C2Config.h
index f8aa672..9d9ed70 100644
--- a/media/codec2/core/include/C2Config.h
+++ b/media/codec2/core/include/C2Config.h
@@ -75,6 +75,10 @@
enum tiling_mode_t : uint32_t; ///< tiling modes
};
+struct C2PlatformConfig {
+ enum encoding_quality_level_t : uint32_t; ///< encoding quality level
+};
+
namespace {
enum C2ParamIndexKind : C2Param::type_index_t {
@@ -259,7 +263,11 @@
kParamIndexTunnelHandle, // int32[]
kParamIndexTunnelSystemTime, // int64
+ // dmabuf allocator
kParamIndexStoreDmaBufUsage, // store, struct
+
+ // encoding quality requirements
+ kParamIndexEncodingQualityLevel, // encoders, enum
};
}
@@ -384,6 +392,7 @@
namespace {
+// Codec bases are ordered by their date of introduction to the code base.
enum : uint32_t {
_C2_PL_MP2V_BASE = 0x1000,
_C2_PL_AAC_BASE = 0x2000,
@@ -394,12 +403,16 @@
_C2_PL_VP9_BASE = 0x7000,
_C2_PL_DV_BASE = 0x8000,
_C2_PL_AV1_BASE = 0x9000,
+ _C2_PL_VP8_BASE = 0xA000,
+ _C2_PL_MPEGH_BASE = 0xB000, // MPEG-H 3D Audio
C2_PROFILE_LEVEL_VENDOR_START = 0x70000000,
};
}
+// Profiles and levels for each codec are ordered based on how they are ordered in the
+// corresponding standard documents at introduction, and chronologically afterwards.
enum C2Config::profile_t : uint32_t {
PROFILE_UNUSED = 0, ///< profile is not used by this media type
@@ -547,6 +560,19 @@
PROFILE_AV1_0 = _C2_PL_AV1_BASE, ///< AV1 Profile 0 (4:2:0, 8 to 10 bit)
PROFILE_AV1_1, ///< AV1 Profile 1 (8 to 10 bit)
PROFILE_AV1_2, ///< AV1 Profile 2 (8 to 12 bit)
+
+ // VP8 profiles
+ PROFILE_VP8_0 = _C2_PL_VP8_BASE, ///< VP8 Profile 0
+ PROFILE_VP8_1, ///< VP8 Profile 1
+ PROFILE_VP8_2, ///< VP8 Profile 2
+ PROFILE_VP8_3, ///< VP8 Profile 3
+
+ // MPEG-H 3D Audio profiles
+ PROFILE_MPEGH_MAIN = _C2_PL_MPEGH_BASE, ///< MPEG-H Main
+ PROFILE_MPEGH_HIGH, ///< MPEG-H High
+ PROFILE_MPEGH_LC, ///< MPEG-H Low-complexity
+ PROFILE_MPEGH_BASELINE, ///< MPEG-H Baseline
+
};
enum C2Config::level_t : uint32_t {
@@ -689,6 +715,13 @@
LEVEL_AV1_7_1, ///< AV1 Level 7.1
LEVEL_AV1_7_2, ///< AV1 Level 7.2
LEVEL_AV1_7_3, ///< AV1 Level 7.3
+
+ // MPEG-H 3D Audio levels
+ LEVEL_MPEGH_1 = _C2_PL_MPEGH_BASE, ///< MPEG-H L1
+ LEVEL_MPEGH_2, ///< MPEG-H L2
+ LEVEL_MPEGH_3, ///< MPEG-H L3
+ LEVEL_MPEGH_4, ///< MPEG-H L4
+ LEVEL_MPEGH_5, ///< MPEG-H L5
};
struct C2ProfileLevelStruct {
@@ -1901,7 +1934,9 @@
C2ENUM(C2Config::pcm_encoding_t, uint32_t,
PCM_16,
PCM_8,
- PCM_FLOAT
+ PCM_FLOAT,
+ PCM_24,
+ PCM_32
)
typedef C2StreamParam<C2Info, C2SimpleValueStruct<C2Config::pcm_encoding_t>, kParamIndexPcmEncoding>
@@ -2331,6 +2366,23 @@
C2PortTunnelSystemTime;
constexpr char C2_PARAMKEY_OUTPUT_RENDER_TIME[] = "output.render-time";
+C2ENUM(C2PlatformConfig::encoding_quality_level_t, uint32_t,
+ NONE,
+ S_HANDHELD,
+ S_HANDHELD_PC
+);
+
+namespace android {
+
+/**
+ * Encoding quality level signaling.
+ */
+typedef C2GlobalParam<C2Setting,
+ C2SimpleValueStruct<C2EasyEnum<C2PlatformConfig::encoding_quality_level_t>>,
+ kParamIndexEncodingQualityLevel> C2EncodingQualityLevel;
+
+}
+
/// @}
#endif // C2CONFIG_H_
diff --git a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp
index efc5813..58a568e 100644
--- a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp
@@ -23,21 +23,18 @@
#include <stdio.h>
#include <algorithm>
-#include <C2AllocatorIon.h>
#include <C2Buffer.h>
#include <C2BufferPriv.h>
#include <C2Config.h>
#include <C2Debug.h>
#include <codec2/hidl/client.h>
-using android::C2AllocatorIon;
-
#include "media_c2_hidl_test_common.h"
using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;
-static std::vector<DecodeTestParameters> kDecodeTestParameters;
+static std::vector<DecodeTestParameters> gDecodeTestParameters;
using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;
-static std::vector<CsdFlushTestParameters> kCsdFlushTestParameters;
+static std::vector<CsdFlushTestParameters> gCsdFlushTestParameters;
struct CompToURL {
std::string mime;
@@ -45,7 +42,7 @@
std::string info;
};
-std::vector<CompToURL> kCompToURL = {
+std::vector<CompToURL> gCompToURL = {
{"mp4a-latm", "bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.info"},
{"mp4a-latm", "bbb_aac_stereo_128kbps_48000hz.aac",
"bbb_aac_stereo_128kbps_48000hz_multi_frame.info"},
@@ -290,11 +287,11 @@
// LookUpTable of clips and metadata for component testing
void Codec2AudioDecHidlTestBase::GetURLForComponent(char* mURL, char* info, size_t streamIndex) {
int streamCount = 0;
- for (size_t i = 0; i < kCompToURL.size(); ++i) {
- if (mMime.find(kCompToURL[i].mime) != std::string::npos) {
+ for (size_t i = 0; i < gCompToURL.size(); ++i) {
+ if (mMime.find(gCompToURL[i].mime) != std::string::npos) {
if (streamCount == streamIndex) {
- strcat(mURL, kCompToURL[i].mURL.c_str());
- strcat(info, kCompToURL[i].info.c_str());
+ strcat(mURL, gCompToURL[i].mURL.c_str());
+ strcat(info, gCompToURL[i].info.c_str());
return;
}
streamCount++;
@@ -859,36 +856,36 @@
ASSERT_EQ(mComponent->stop(), C2_OK);
}
-INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioDecHidlTest, testing::ValuesIn(kTestParameters),
+INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioDecHidlTest, testing::ValuesIn(gTestParameters),
PrintInstanceTupleNameToString<>);
// DecodeTest with StreamIndex and EOS / No EOS
INSTANTIATE_TEST_SUITE_P(StreamIndexAndEOS, Codec2AudioDecDecodeTest,
- testing::ValuesIn(kDecodeTestParameters),
+ testing::ValuesIn(gDecodeTestParameters),
PrintInstanceTupleNameToString<>);
INSTANTIATE_TEST_SUITE_P(CsdInputs, Codec2AudioDecCsdInputTests,
- testing::ValuesIn(kCsdFlushTestParameters),
+ testing::ValuesIn(gCsdFlushTestParameters),
PrintInstanceTupleNameToString<>);
} // anonymous namespace
int main(int argc, char** argv) {
parseArgs(argc, argv);
- kTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_DECODER);
- for (auto params : kTestParameters) {
- kDecodeTestParameters.push_back(
+ gTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_DECODER);
+ for (auto params : gTestParameters) {
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true));
- kCsdFlushTestParameters.push_back(
+ gCsdFlushTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), true));
- kCsdFlushTestParameters.push_back(
+ gCsdFlushTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), false));
}
diff --git a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp
index 562c77f..92b53a0 100644
--- a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp
@@ -24,20 +24,17 @@
#include <algorithm>
#include <fstream>
-#include <C2AllocatorIon.h>
#include <C2Buffer.h>
#include <C2BufferPriv.h>
#include <C2Config.h>
#include <C2Debug.h>
#include <codec2/hidl/client.h>
-using android::C2AllocatorIon;
-
#include "media_c2_hidl_test_common.h"
using EncodeTestParameters = std::tuple<std::string, std::string, bool, int32_t>;
-static std::vector<EncodeTestParameters> kEncodeTestParameters;
+static std::vector<EncodeTestParameters> gEncodeTestParameters;
class LinearBuffer : public C2Buffer {
public:
@@ -45,6 +42,8 @@
: C2Buffer({block->share(block->offset(), block->size(), ::C2Fence())}) {}
};
+constexpr uint32_t kMaxSamplesPerFrame = 256;
+
namespace {
class Codec2AudioEncHidlTestBase : public ::testing::Test {
@@ -98,7 +97,7 @@
// Get the test parameters from GetParam call.
virtual void getParams() {}
- void GetURLForComponent(char* mURL);
+ void GetURLForComponent(char* mURL, int32_t channelCount, int32_t sampleRate);
// callback function to process onWorkDone received by Listener
void handleWorkDone(std::list<std::unique_ptr<C2Work>>& workItems) {
@@ -223,53 +222,105 @@
return false;
}
+c2_status_t getChannelCount(const std::shared_ptr<android::Codec2Client::Component>& component,
+ int32_t* nChannels) {
+ std::unique_ptr<C2StreamChannelCountInfo::input> channelCount =
+ std::make_unique<C2StreamChannelCountInfo::input>();
+ std::vector<C2FieldSupportedValuesQuery> validValueInfos = {
+ C2FieldSupportedValuesQuery::Current(
+ C2ParamField(channelCount.get(), &C2StreamChannelCountInfo::value))};
+ c2_status_t c2err = component->querySupportedValues(validValueInfos, C2_DONT_BLOCK);
+ if (c2err != C2_OK || validValueInfos.size() != 1u) {
+ ALOGE("querySupportedValues_vb failed for channelCount");
+ return c2err;
+ }
+
+ // setting default value of channelCount
+ *nChannels = 1;
+ const auto& c2FSV = validValueInfos[0].values;
+ switch (c2FSV.type) {
+ case C2FieldSupportedValues::type_t::RANGE: {
+ const auto& range = c2FSV.range;
+ uint32_t rmax = (uint32_t)(range.max).ref<uint32_t>();
+ if (rmax >= 2) {
+ *nChannels = 2;
+ } else {
+ *nChannels = 1;
+ }
+ break;
+ }
+ case C2FieldSupportedValues::type_t::VALUES: {
+ for (const C2Value::Primitive& prim : c2FSV.values) {
+ if ((uint32_t)prim.ref<uint32_t>() == 2) {
+ *nChannels = 2;
+ } else if ((uint32_t)prim.ref<uint32_t>() == 1) {
+ *nChannels = 1;
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ return C2_OK;
+}
+
+c2_status_t getSampleRate(const std::shared_ptr<android::Codec2Client::Component>& component,
+ int32_t* nSampleRate) {
+ // Use the default sample rate for components
+ std::vector<std::unique_ptr<C2Param>> queried;
+ c2_status_t c2err = component->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},
+ C2_DONT_BLOCK, &queried);
+ if (c2err != C2_OK || queried.size() == 0) return c2err;
+
+ size_t offset = sizeof(C2Param);
+ C2Param* param = queried[0].get();
+ *nSampleRate = *(int32_t*)((uint8_t*)param + offset);
+
+ return C2_OK;
+}
+
+c2_status_t getSamplesPerFrame(const std::shared_ptr<android::Codec2Client::Component>& component,
+ int32_t nChannels, int32_t* samplesPerFrame) {
+ std::vector<std::unique_ptr<C2Param>> queried;
+ c2_status_t c2err = component->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE},
+ C2_DONT_BLOCK, &queried);
+ if (c2err != C2_OK || queried.size() == 0) return c2err;
+
+ size_t offset = sizeof(C2Param);
+ C2Param* param = queried[0].get();
+ uint32_t maxInputSize = *(uint32_t*)((uint8_t*)param + offset);
+ *samplesPerFrame = std::min((maxInputSize / (nChannels * 2)), kMaxSamplesPerFrame);
+
+ return C2_OK;
+}
+
// Get config params for a component
-bool getConfigParams(std::string mime, int32_t* nChannels, int32_t* nSampleRate,
- int32_t* samplesPerFrame) {
- if (mime.find("mp4a-latm") != std::string::npos) {
- *nChannels = 2;
- *nSampleRate = 48000;
- *samplesPerFrame = 1024;
- } else if (mime.find("flac") != std::string::npos) {
- *nChannels = 2;
- *nSampleRate = 48000;
- *samplesPerFrame = 1152;
- } else if (mime.find("opus") != std::string::npos) {
- *nChannels = 2;
- *nSampleRate = 48000;
- *samplesPerFrame = 960;
- } else if (mime.find("3gpp") != std::string::npos) {
- *nChannels = 1;
- *nSampleRate = 8000;
- *samplesPerFrame = 160;
- } else if (mime.find("amr-wb") != std::string::npos) {
- *nChannels = 1;
- *nSampleRate = 16000;
- *samplesPerFrame = 160;
- } else
- return false;
+bool getConfigParams(const std::shared_ptr<android::Codec2Client::Component>& component,
+ int32_t* nChannels, int32_t* nSampleRate, int32_t* samplesPerFrame) {
+ c2_status_t status = getChannelCount(component, nChannels);
+ if (status != C2_OK) return false;
+
+ status = getSampleRate(component, nSampleRate);
+ if (status != C2_OK) return false;
+
+ status = getSamplesPerFrame(component, *nChannels, samplesPerFrame);
+ if (status != C2_OK) return false;
return true;
}
// LookUpTable of clips and metadata for component testing
-void Codec2AudioEncHidlTestBase::GetURLForComponent(char* mURL) {
- struct CompToURL {
- std::string mime;
- const char* mURL;
- };
- static const CompToURL kCompToURL[] = {
- {"mp4a-latm", "bbb_raw_2ch_48khz_s16le.raw"}, {"3gpp", "bbb_raw_1ch_8khz_s16le.raw"},
- {"amr-wb", "bbb_raw_1ch_16khz_s16le.raw"}, {"flac", "bbb_raw_2ch_48khz_s16le.raw"},
- {"opus", "bbb_raw_2ch_48khz_s16le.raw"},
- };
-
- for (size_t i = 0; i < sizeof(kCompToURL) / sizeof(kCompToURL[0]); ++i) {
- if (mMime.find(kCompToURL[i].mime) != std::string::npos) {
- strcat(mURL, kCompToURL[i].mURL);
- return;
- }
+void Codec2AudioEncHidlTestBase::GetURLForComponent(char* mURL, int32_t channelCount,
+ int32_t sampleRate) {
+ std::string rawInput = "bbb_raw_1ch_8khz_s16le.raw";
+ if (channelCount == 1 && sampleRate == 16000) {
+ rawInput = "bbb_raw_1ch_16khz_s16le.raw";
+ } else if (channelCount == 2) {
+ rawInput = "bbb_raw_2ch_48khz_s16le.raw";
}
+
+ strcat(mURL, rawInput.c_str());
}
void encodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& component,
@@ -283,9 +334,17 @@
uint32_t frameID = 0;
uint32_t maxRetry = 0;
- int bytesCount = samplesPerFrame * nChannels * 2;
+ uint32_t bytesCount = samplesPerFrame * nChannels * 2;
int32_t timestampIncr = (int)(((float)samplesPerFrame / nSampleRate) * 1000000);
uint64_t timestamp = 0;
+
+ // get length of file:
+ int32_t currPos = eleStream.tellg();
+ eleStream.seekg(0, eleStream.end);
+ uint32_t remainingBytes = (uint32_t)eleStream.tellg() - currPos;
+ eleStream.seekg(currPos, eleStream.beg);
+
+ nFrames = std::min(nFrames, remainingBytes / bytesCount);
while (1) {
if (nFrames == 0) break;
uint32_t flags = 0;
@@ -319,7 +378,12 @@
char* data = (char*)malloc(bytesCount);
ASSERT_NE(data, nullptr);
eleStream.read(data, bytesCount);
- ASSERT_EQ(eleStream.gcount(), bytesCount);
+ // if we have reached at the end of input stream, signal eos
+ if (eleStream.gcount() < bytesCount) {
+ bytesCount = eleStream.gcount();
+ if (signalEOS) flags |= C2FrameData::FLAG_END_OF_STREAM;
+ }
+
std::shared_ptr<C2LinearBlock> block;
ASSERT_EQ(C2_OK,
linearPool->fetchLinearBlock(
@@ -373,9 +437,6 @@
TEST_P(Codec2AudioEncEncodeTest, EncodeTest) {
ALOGV("EncodeTest");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- char mURL[512];
- strcpy(mURL, sResourceDir.c_str());
- GetURLForComponent(mURL);
bool signalEOS = std::get<2>(GetParam());
// Ratio w.r.t to mInputMaxBufSize
int32_t inputMaxBufRatio = std::get<3>(GetParam());
@@ -384,7 +445,7 @@
int32_t nSampleRate;
int32_t samplesPerFrame;
- if (!getConfigParams(mMime, &nChannels, &nSampleRate, &samplesPerFrame)) {
+ if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {
std::cout << "Failed to get the config params for " << mComponentName << "\n";
std::cout << "[ WARN ] Test Skipped \n";
return;
@@ -398,6 +459,10 @@
std::cout << "[ WARN ] Test Skipped \n";
return;
}
+ char mURL[512];
+ strcpy(mURL, sResourceDir.c_str());
+ GetURLForComponent(mURL, nChannels, nSampleRate);
+
ASSERT_EQ(mComponent->start(), C2_OK);
std::ifstream eleStream;
uint32_t numFrames = 16;
@@ -479,16 +544,12 @@
description("Test Request for flush");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- char mURL[512];
- strcpy(mURL, sResourceDir.c_str());
- GetURLForComponent(mURL);
-
mFlushedIndices.clear();
int32_t nChannels;
int32_t nSampleRate;
int32_t samplesPerFrame;
- if (!getConfigParams(mMime, &nChannels, &nSampleRate, &samplesPerFrame)) {
+ if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {
std::cout << "Failed to get the config params for " << mComponentName << "\n";
std::cout << "[ WARN ] Test Skipped \n";
return;
@@ -498,6 +559,10 @@
std::cout << "[ WARN ] Test Skipped \n";
return;
}
+ char mURL[512];
+ strcpy(mURL, sResourceDir.c_str());
+ GetURLForComponent(mURL, nChannels, nSampleRate);
+
ASSERT_EQ(mComponent->start(), C2_OK);
std::ifstream eleStream;
@@ -544,26 +609,25 @@
description("Encodes input file for different channel count");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- char mURL[512];
- strcpy(mURL, sResourceDir.c_str());
- GetURLForComponent(mURL);
-
- std::ifstream eleStream;
- eleStream.open(mURL, std::ifstream::binary);
- ASSERT_EQ(eleStream.is_open(), true) << mURL << " file not found";
- ALOGV("mURL : %s", mURL);
-
int32_t nSampleRate;
int32_t samplesPerFrame;
int32_t nChannels;
int32_t numFrames = 16;
int32_t maxChannelCount = 8;
- if (!getConfigParams(mMime, &nChannels, &nSampleRate, &samplesPerFrame)) {
+ if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {
std::cout << "Failed to get the config params for " << mComponentName << "\n";
std::cout << "[ WARN ] Test Skipped \n";
return;
}
+ char mURL[512];
+ strcpy(mURL, sResourceDir.c_str());
+ GetURLForComponent(mURL, nChannels, nSampleRate);
+
+ std::ifstream eleStream;
+ eleStream.open(mURL, std::ifstream::binary);
+ ASSERT_EQ(eleStream.is_open(), true) << mURL << " file not found";
+ ALOGV("mURL : %s", mURL);
uint64_t prevOutputSize = 0u;
uint32_t prevChannelCount = 0u;
@@ -591,8 +655,11 @@
}
// To check if the input stream is sufficient to encode for the higher channel count
+ struct stat buf;
+ stat(mURL, &buf);
+ size_t fileSize = buf.st_size;
int32_t bytesCount = (samplesPerFrame * nChannels * 2) * numFrames;
- if (eleStream.gcount() < bytesCount) {
+ if (fileSize < bytesCount) {
std::cout << "[ WARN ] Test Skipped for ChannelCount " << nChannels
<< " because of insufficient input data\n";
continue;
@@ -616,9 +683,6 @@
// blocking call to ensures application to Wait till all the inputs are consumed
waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
- // Validate output size based on chosen ChannelCount
- EXPECT_GE(mOutputSize, prevOutputSize);
-
prevChannelCount = nChannels;
prevOutputSize = mOutputSize;
@@ -633,7 +697,8 @@
ASSERT_TRUE(mCsd) << "CSD buffer missing";
}
ASSERT_TRUE(mEos);
- ASSERT_EQ(mComponent->stop(), C2_OK);
+ // TODO(b/147348711) Use reset instead of stop when using the same instance of codec.
+ ASSERT_EQ(mComponent->reset(), C2_OK);
mFramesReceived = 0;
mOutputSize = 0;
mEos = false;
@@ -646,25 +711,24 @@
description("Encodes input file for different SampleRate");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- char mURL[512];
- strcpy(mURL, sResourceDir.c_str());
- GetURLForComponent(mURL);
-
- std::ifstream eleStream;
- eleStream.open(mURL, std::ifstream::binary);
- ASSERT_EQ(eleStream.is_open(), true) << mURL << " file not found";
- ALOGV("mURL : %s", mURL);
-
int32_t nSampleRate;
int32_t samplesPerFrame;
int32_t nChannels;
int32_t numFrames = 16;
- if (!getConfigParams(mMime, &nChannels, &nSampleRate, &samplesPerFrame)) {
+ if (!getConfigParams(mComponent, &nChannels, &nSampleRate, &samplesPerFrame)) {
std::cout << "Failed to get the config params for " << mComponentName << "\n";
std::cout << "[ WARN ] Test Skipped \n";
return;
}
+ char mURL[512];
+ strcpy(mURL, sResourceDir.c_str());
+ GetURLForComponent(mURL, nChannels, nSampleRate);
+
+ std::ifstream eleStream;
+ eleStream.open(mURL, std::ifstream::binary);
+ ASSERT_EQ(eleStream.is_open(), true) << mURL << " file not found";
+ ALOGV("mURL : %s", mURL);
int32_t sampleRateValues[] = {1000, 8000, 16000, 24000, 48000, 96000, 192000};
@@ -694,8 +758,11 @@
}
// To check if the input stream is sufficient to encode for the higher SampleRate
+ struct stat buf;
+ stat(mURL, &buf);
+ size_t fileSize = buf.st_size;
int32_t bytesCount = (samplesPerFrame * nChannels * 2) * numFrames;
- if (eleStream.gcount() < bytesCount) {
+ if (fileSize < bytesCount) {
std::cout << "[ WARN ] Test Skipped for SampleRate " << nSampleRate
<< " because of insufficient input data\n";
continue;
@@ -719,12 +786,6 @@
// blocking call to ensures application to Wait till all the inputs are consumed
waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
- // Validate output size based on chosen samplerate
- if (prevSampleRate >= nSampleRate) {
- EXPECT_LE(mOutputSize, prevOutputSize);
- } else {
- EXPECT_GT(mOutputSize, prevOutputSize);
- }
prevSampleRate = nSampleRate;
prevOutputSize = mOutputSize;
@@ -739,7 +800,8 @@
ASSERT_TRUE(mCsd) << "CSD buffer missing";
}
ASSERT_TRUE(mEos);
- ASSERT_EQ(mComponent->stop(), C2_OK);
+ // TODO(b/147348711) Use reset instead of stop when using the same instance of codec.
+ ASSERT_EQ(mComponent->reset(), C2_OK);
mFramesReceived = 0;
mOutputSize = 0;
mEos = false;
@@ -748,28 +810,28 @@
}
}
-INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioEncHidlTest, testing::ValuesIn(kTestParameters),
+INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2AudioEncHidlTest, testing::ValuesIn(gTestParameters),
PrintInstanceTupleNameToString<>);
// EncodeTest with EOS / No EOS and inputMaxBufRatio
// inputMaxBufRatio is ratio w.r.t. to mInputMaxBufSize
INSTANTIATE_TEST_SUITE_P(EncodeTest, Codec2AudioEncEncodeTest,
- testing::ValuesIn(kEncodeTestParameters),
+ testing::ValuesIn(gEncodeTestParameters),
PrintInstanceTupleNameToString<>);
} // anonymous namespace
int main(int argc, char** argv) {
parseArgs(argc, argv);
- kTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_ENCODER);
- for (auto params : kTestParameters) {
- kEncodeTestParameters.push_back(
+ gTestParameters = getTestParameters(C2Component::DOMAIN_AUDIO, C2Component::KIND_ENCODER);
+ for (auto params : gTestParameters) {
+ gEncodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), false, 1));
- kEncodeTestParameters.push_back(
+ gEncodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), false, 2));
- kEncodeTestParameters.push_back(
+ gEncodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), true, 1));
- kEncodeTestParameters.push_back(
+ gEncodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), true, 2));
}
diff --git a/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h b/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h
index e74f247..2222aaf 100644
--- a/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h
+++ b/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h
@@ -41,7 +41,7 @@
using namespace ::std::chrono;
using TestParameters = std::tuple<std::string, std::string>;
-static std::vector<TestParameters> kTestParameters;
+static std::vector<TestParameters> gTestParameters;
// Resource directory
extern std::string sResourceDir;
diff --git a/media/codec2/hidl/1.0/vts/functional/component/VtsHalMediaC2V1_0TargetComponentTest.cpp b/media/codec2/hidl/1.0/vts/functional/component/VtsHalMediaC2V1_0TargetComponentTest.cpp
index 29acd33..ffec897 100644
--- a/media/codec2/hidl/1.0/vts/functional/component/VtsHalMediaC2V1_0TargetComponentTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/component/VtsHalMediaC2V1_0TargetComponentTest.cpp
@@ -54,7 +54,7 @@
namespace {
using InputTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;
-static std::vector<InputTestParameters> kInputTestParameters;
+static std::vector<InputTestParameters> gInputTestParameters;
// google.codec2 Component test setup
class Codec2ComponentHidlTestBase : public ::testing::Test {
@@ -345,28 +345,28 @@
ASSERT_EQ(mComponent->reset(), C2_OK);
}
-INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2ComponentHidlTest, testing::ValuesIn(kTestParameters),
+INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2ComponentHidlTest, testing::ValuesIn(gTestParameters),
PrintInstanceTupleNameToString<>);
INSTANTIATE_TEST_CASE_P(NonStdInputs, Codec2ComponentInputTests,
- testing::ValuesIn(kInputTestParameters), PrintInstanceTupleNameToString<>);
+ testing::ValuesIn(gInputTestParameters), PrintInstanceTupleNameToString<>);
} // anonymous namespace
// TODO: Add test for Invalid work,
// TODO: Add test for Invalid states
int main(int argc, char** argv) {
parseArgs(argc, argv);
- kTestParameters = getTestParameters();
- for (auto params : kTestParameters) {
- kInputTestParameters.push_back(
+ gTestParameters = getTestParameters();
+ for (auto params : gTestParameters) {
+ gInputTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));
- kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),
+ gInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),
C2FrameData::FLAG_END_OF_STREAM, true));
- kInputTestParameters.push_back(
+ gInputTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));
- kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),
+ gInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),
C2FrameData::FLAG_CODEC_CONFIG, false));
- kInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),
+ gInputTestParameters.push_back(std::make_tuple(std::get<0>(params), std::get<1>(params),
C2FrameData::FLAG_END_OF_STREAM, false));
}
diff --git a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp
index d0a1c31..8d917b3 100644
--- a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp
@@ -24,7 +24,6 @@
#include <openssl/md5.h>
-#include <C2AllocatorIon.h>
#include <C2Buffer.h>
#include <C2BufferPriv.h>
#include <C2Config.h>
@@ -35,16 +34,14 @@
#include <gui/IProducerListener.h>
#include <system/window.h>
-using android::C2AllocatorIon;
-
#include "media_c2_hidl_test_common.h"
#include "media_c2_video_hidl_test_common.h"
using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;
-static std::vector<DecodeTestParameters> kDecodeTestParameters;
+static std::vector<DecodeTestParameters> gDecodeTestParameters;
using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;
-static std::vector<CsdFlushTestParameters> kCsdFlushTestParameters;
+static std::vector<CsdFlushTestParameters> gCsdFlushTestParameters;
struct CompToURL {
std::string mime;
@@ -52,7 +49,7 @@
std::string info;
std::string chksum;
};
-std::vector<CompToURL> kCompToURL = {
+std::vector<CompToURL> gCompToURL = {
{"avc", "bbb_avc_176x144_300kbps_60fps.h264", "bbb_avc_176x144_300kbps_60fps.info",
"bbb_avc_176x144_300kbps_60fps_chksum.md5"},
{"avc", "bbb_avc_640x360_768kbps_30fps.h264", "bbb_avc_640x360_768kbps_30fps.info",
@@ -365,12 +362,12 @@
void Codec2VideoDecHidlTestBase::GetURLChksmForComponent(char* mURL, char* info, char* chksum,
size_t streamIndex) {
int streamCount = 0;
- for (size_t i = 0; i < kCompToURL.size(); ++i) {
- if (mMime.find(kCompToURL[i].mime) != std::string::npos) {
+ for (size_t i = 0; i < gCompToURL.size(); ++i) {
+ if (mMime.find(gCompToURL[i].mime) != std::string::npos) {
if (streamCount == streamIndex) {
- strcat(mURL, kCompToURL[i].mURL.c_str());
- strcat(info, kCompToURL[i].info.c_str());
- strcat(chksum, kCompToURL[i].chksum.c_str());
+ strcat(mURL, gCompToURL[i].mURL.c_str());
+ strcat(info, gCompToURL[i].info.c_str());
+ strcat(chksum, gCompToURL[i].chksum.c_str());
return;
}
streamCount++;
@@ -1074,16 +1071,16 @@
ASSERT_EQ(mComponent->stop(), C2_OK);
}
-INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2VideoDecHidlTest, testing::ValuesIn(kTestParameters),
+INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2VideoDecHidlTest, testing::ValuesIn(gTestParameters),
PrintInstanceTupleNameToString<>);
// DecodeTest with StreamIndex and EOS / No EOS
INSTANTIATE_TEST_SUITE_P(StreamIndexAndEOS, Codec2VideoDecDecodeTest,
- testing::ValuesIn(kDecodeTestParameters),
+ testing::ValuesIn(gDecodeTestParameters),
PrintInstanceTupleNameToString<>);
INSTANTIATE_TEST_SUITE_P(CsdInputs, Codec2VideoDecCsdInputTests,
- testing::ValuesIn(kCsdFlushTestParameters),
+ testing::ValuesIn(gCsdFlushTestParameters),
PrintInstanceTupleNameToString<>);
} // anonymous namespace
@@ -1091,24 +1088,24 @@
// TODO : Video specific configuration Test
int main(int argc, char** argv) {
parseArgs(argc, argv);
- kTestParameters = getTestParameters(C2Component::DOMAIN_VIDEO, C2Component::KIND_DECODER);
- for (auto params : kTestParameters) {
- kDecodeTestParameters.push_back(
+ gTestParameters = getTestParameters(C2Component::DOMAIN_VIDEO, C2Component::KIND_DECODER);
+ for (auto params : gTestParameters) {
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 2, false));
- kDecodeTestParameters.push_back(
+ gDecodeTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 2, true));
- kCsdFlushTestParameters.push_back(
+ gCsdFlushTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), true));
- kCsdFlushTestParameters.push_back(
+ gCsdFlushTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), false));
}
diff --git a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp
index 23ceff4..dfd649d 100644
--- a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp
@@ -23,15 +23,12 @@
#include <stdio.h>
#include <fstream>
-#include <C2AllocatorIon.h>
#include <C2Buffer.h>
#include <C2BufferPriv.h>
#include <C2Config.h>
#include <C2Debug.h>
#include <codec2/hidl/client.h>
-using android::C2AllocatorIon;
-
#include "media_c2_hidl_test_common.h"
#include "media_c2_video_hidl_test_common.h"
@@ -42,10 +39,10 @@
};
using EncodeTestParameters = std::tuple<std::string, std::string, bool, bool, bool>;
-static std::vector<EncodeTestParameters> kEncodeTestParameters;
+static std::vector<EncodeTestParameters> gEncodeTestParameters;
using EncodeResolutionTestParameters = std::tuple<std::string, std::string, int32_t, int32_t>;
-static std::vector<EncodeResolutionTestParameters> kEncodeResolutionTestParameters;
+static std::vector<EncodeResolutionTestParameters> gEncodeResolutionTestParameters;
namespace {
@@ -706,16 +703,16 @@
ASSERT_EQ(mComponent->reset(), C2_OK);
}
-INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2VideoEncHidlTest, testing::ValuesIn(kTestParameters),
+INSTANTIATE_TEST_SUITE_P(PerInstance, Codec2VideoEncHidlTest, testing::ValuesIn(gTestParameters),
PrintInstanceTupleNameToString<>);
INSTANTIATE_TEST_SUITE_P(NonStdSizes, Codec2VideoEncResolutionTest,
- ::testing::ValuesIn(kEncodeResolutionTestParameters),
+ ::testing::ValuesIn(gEncodeResolutionTestParameters),
PrintInstanceTupleNameToString<>);
// EncodeTest with EOS / No EOS
INSTANTIATE_TEST_SUITE_P(EncodeTestwithEOS, Codec2VideoEncEncodeTest,
- ::testing::ValuesIn(kEncodeTestParameters),
+ ::testing::ValuesIn(gEncodeTestParameters),
PrintInstanceTupleNameToString<>);
TEST_P(Codec2VideoEncHidlTest, AdaptiveBitrateTest) {
@@ -808,24 +805,24 @@
int main(int argc, char** argv) {
parseArgs(argc, argv);
- kTestParameters = getTestParameters(C2Component::DOMAIN_VIDEO, C2Component::KIND_ENCODER);
- for (auto params : kTestParameters) {
+ gTestParameters = getTestParameters(C2Component::DOMAIN_VIDEO, C2Component::KIND_ENCODER);
+ for (auto params : gTestParameters) {
for (size_t i = 0; i < 1 << 3; ++i) {
- kEncodeTestParameters.push_back(std::make_tuple(
+ gEncodeTestParameters.push_back(std::make_tuple(
std::get<0>(params), std::get<1>(params), i & 1, (i >> 1) & 1, (i >> 2) & 1));
}
- kEncodeResolutionTestParameters.push_back(
+ gEncodeResolutionTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 52, 18));
- kEncodeResolutionTestParameters.push_back(
+ gEncodeResolutionTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 365, 365));
- kEncodeResolutionTestParameters.push_back(
+ gEncodeResolutionTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 484, 362));
- kEncodeResolutionTestParameters.push_back(
+ gEncodeResolutionTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 244, 488));
- kEncodeResolutionTestParameters.push_back(
+ gEncodeResolutionTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 852, 608));
- kEncodeResolutionTestParameters.push_back(
+ gEncodeResolutionTestParameters.push_back(
std::make_tuple(std::get<0>(params), std::get<1>(params), 1400, 442));
}
diff --git a/media/codec2/hidl/plugin/FilterWrapperStub.cpp b/media/codec2/hidl/plugin/FilterWrapperStub.cpp
index 1b94a1a..01ca596 100644
--- a/media/codec2/hidl/plugin/FilterWrapperStub.cpp
+++ b/media/codec2/hidl/plugin/FilterWrapperStub.cpp
@@ -42,10 +42,10 @@
}
c2_status_t FilterWrapper::createBlockPool(
- C2PlatformAllocatorStore::id_t,
- std::shared_ptr<const C2Component>,
- std::shared_ptr<C2BlockPool> *) {
- return C2_OMITTED;
+ C2PlatformAllocatorStore::id_t allocatorId,
+ std::shared_ptr<const C2Component> component,
+ std::shared_ptr<C2BlockPool> *pool) {
+ return CreateCodec2BlockPool(allocatorId, component, pool);
}
} // namespace android
diff --git a/media/codec2/hidl/services/seccomp_policy/android.hardware.media.c2@1.1-default-arm64.policy b/media/codec2/hidl/services/seccomp_policy/android.hardware.media.c2@1.1-default-arm64.policy
index 4faf8b2..85fd28d 100644
--- a/media/codec2/hidl/services/seccomp_policy/android.hardware.media.c2@1.1-default-arm64.policy
+++ b/media/codec2/hidl/services/seccomp_policy/android.hardware.media.c2@1.1-default-arm64.policy
@@ -35,7 +35,7 @@
# on ARM is statically loaded at 0xffff 0000. See
# http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0211h/Babfeega.html
# for more details.
-mremap: arg3 == 3
+mremap: arg3 == 3 || arg3 == MREMAP_MAYMOVE
munmap: 1
prctl: 1
writev: 1
diff --git a/media/codec2/sfplugin/CCodec.cpp b/media/codec2/sfplugin/CCodec.cpp
index 5c387b3..343cf29 100644
--- a/media/codec2/sfplugin/CCodec.cpp
+++ b/media/codec2/sfplugin/CCodec.cpp
@@ -1796,17 +1796,19 @@
}
status_t CCodec::setSurface(const sp<Surface> &surface) {
- Mutexed<std::unique_ptr<Config>>::Locked configLocked(mConfig);
- const std::unique_ptr<Config> &config = *configLocked;
- if (config->mTunneled && config->mSidebandHandle != nullptr) {
- sp<ANativeWindow> nativeWindow = static_cast<ANativeWindow *>(surface.get());
- status_t err = native_window_set_sideband_stream(
- nativeWindow.get(),
- const_cast<native_handle_t *>(config->mSidebandHandle->handle()));
- if (err != OK) {
- ALOGE("NativeWindow(%p) native_window_set_sideband_stream(%p) failed! (err %d).",
- nativeWindow.get(), config->mSidebandHandle->handle(), err);
- return err;
+ {
+ Mutexed<std::unique_ptr<Config>>::Locked configLocked(mConfig);
+ const std::unique_ptr<Config> &config = *configLocked;
+ if (config->mTunneled && config->mSidebandHandle != nullptr) {
+ sp<ANativeWindow> nativeWindow = static_cast<ANativeWindow *>(surface.get());
+ status_t err = native_window_set_sideband_stream(
+ nativeWindow.get(),
+ const_cast<native_handle_t *>(config->mSidebandHandle->handle()));
+ if (err != OK) {
+ ALOGE("NativeWindow(%p) native_window_set_sideband_stream(%p) failed! (err %d).",
+ nativeWindow.get(), config->mSidebandHandle->handle(), err);
+ return err;
+ }
}
}
return mChannel->setSurface(surface);
@@ -2147,80 +2149,92 @@
}
// handle configuration changes in work done
- Mutexed<std::unique_ptr<Config>>::Locked configLocked(mConfig);
- const std::unique_ptr<Config> &config = *configLocked;
- Config::Watcher<C2StreamInitDataInfo::output> initData =
- config->watch<C2StreamInitDataInfo::output>();
- if (!work->worklets.empty()
- && (work->worklets.front()->output.flags
- & C2FrameData::FLAG_DISCARD_FRAME) == 0) {
+ std::unique_ptr<C2Param> initData;
+ sp<AMessage> outputFormat = nullptr;
+ {
+ Mutexed<std::unique_ptr<Config>>::Locked configLocked(mConfig);
+ const std::unique_ptr<Config> &config = *configLocked;
+ Config::Watcher<C2StreamInitDataInfo::output> initDataWatcher =
+ config->watch<C2StreamInitDataInfo::output>();
+ if (!work->worklets.empty()
+ && (work->worklets.front()->output.flags
+ & C2FrameData::FLAG_DISCARD_FRAME) == 0) {
- // copy buffer info to config
- std::vector<std::unique_ptr<C2Param>> updates;
- for (const std::unique_ptr<C2Param> ¶m
- : work->worklets.front()->output.configUpdate) {
- updates.push_back(C2Param::Copy(*param));
- }
- unsigned stream = 0;
- for (const std::shared_ptr<C2Buffer> &buf : work->worklets.front()->output.buffers) {
- for (const std::shared_ptr<const C2Info> &info : buf->info()) {
- // move all info into output-stream #0 domain
- updates.emplace_back(C2Param::CopyAsStream(*info, true /* output */, stream));
+ // copy buffer info to config
+ std::vector<std::unique_ptr<C2Param>> updates;
+ for (const std::unique_ptr<C2Param> ¶m
+ : work->worklets.front()->output.configUpdate) {
+ updates.push_back(C2Param::Copy(*param));
+ }
+ unsigned stream = 0;
+ std::vector<std::shared_ptr<C2Buffer>> &outputBuffers =
+ work->worklets.front()->output.buffers;
+ for (const std::shared_ptr<C2Buffer> &buf : outputBuffers) {
+ for (const std::shared_ptr<const C2Info> &info : buf->info()) {
+ // move all info into output-stream #0 domain
+ updates.emplace_back(
+ C2Param::CopyAsStream(*info, true /* output */, stream));
+ }
+
+ const std::vector<C2ConstGraphicBlock> blocks = buf->data().graphicBlocks();
+ // for now only do the first block
+ if (!blocks.empty()) {
+ // ALOGV("got output buffer with crop %u,%u+%u,%u and size %u,%u",
+ // block.crop().left, block.crop().top,
+ // block.crop().width, block.crop().height,
+ // block.width(), block.height());
+ const C2ConstGraphicBlock &block = blocks[0];
+ updates.emplace_back(new C2StreamCropRectInfo::output(
+ stream, block.crop()));
+ updates.emplace_back(new C2StreamPictureSizeInfo::output(
+ stream, block.crop().width, block.crop().height));
+ }
+ ++stream;
}
- const std::vector<C2ConstGraphicBlock> blocks = buf->data().graphicBlocks();
- // for now only do the first block
- if (!blocks.empty()) {
- // ALOGV("got output buffer with crop %u,%u+%u,%u and size %u,%u",
- // block.crop().left, block.crop().top,
- // block.crop().width, block.crop().height,
- // block.width(), block.height());
- const C2ConstGraphicBlock &block = blocks[0];
- updates.emplace_back(new C2StreamCropRectInfo::output(stream, block.crop()));
- updates.emplace_back(new C2StreamPictureSizeInfo::output(
- stream, block.crop().width, block.crop().height));
- }
- ++stream;
- }
+ sp<AMessage> oldFormat = config->mOutputFormat;
+ config->updateConfiguration(updates, config->mOutputDomain);
+ RevertOutputFormatIfNeeded(oldFormat, config->mOutputFormat);
- sp<AMessage> outputFormat = config->mOutputFormat;
- config->updateConfiguration(updates, config->mOutputDomain);
- RevertOutputFormatIfNeeded(outputFormat, config->mOutputFormat);
-
- // copy standard infos to graphic buffers if not already present (otherwise, we
- // may overwrite the actual intermediate value with a final value)
- stream = 0;
- const static C2Param::Index stdGfxInfos[] = {
- C2StreamRotationInfo::output::PARAM_TYPE,
- C2StreamColorAspectsInfo::output::PARAM_TYPE,
- C2StreamDataSpaceInfo::output::PARAM_TYPE,
- C2StreamHdrStaticInfo::output::PARAM_TYPE,
- C2StreamHdr10PlusInfo::output::PARAM_TYPE,
- C2StreamPixelAspectRatioInfo::output::PARAM_TYPE,
- C2StreamSurfaceScalingInfo::output::PARAM_TYPE
- };
- for (const std::shared_ptr<C2Buffer> &buf : work->worklets.front()->output.buffers) {
- if (buf->data().graphicBlocks().size()) {
- for (C2Param::Index ix : stdGfxInfos) {
- if (!buf->hasInfo(ix)) {
- const C2Param *param =
- config->getConfigParameterValue(ix.withStream(stream));
- if (param) {
- std::shared_ptr<C2Param> info(C2Param::Copy(*param));
- buf->setInfo(std::static_pointer_cast<C2Info>(info));
+ // copy standard infos to graphic buffers if not already present (otherwise, we
+ // may overwrite the actual intermediate value with a final value)
+ stream = 0;
+ const static C2Param::Index stdGfxInfos[] = {
+ C2StreamRotationInfo::output::PARAM_TYPE,
+ C2StreamColorAspectsInfo::output::PARAM_TYPE,
+ C2StreamDataSpaceInfo::output::PARAM_TYPE,
+ C2StreamHdrStaticInfo::output::PARAM_TYPE,
+ C2StreamHdr10PlusInfo::output::PARAM_TYPE,
+ C2StreamPixelAspectRatioInfo::output::PARAM_TYPE,
+ C2StreamSurfaceScalingInfo::output::PARAM_TYPE
+ };
+ for (const std::shared_ptr<C2Buffer> &buf : outputBuffers) {
+ if (buf->data().graphicBlocks().size()) {
+ for (C2Param::Index ix : stdGfxInfos) {
+ if (!buf->hasInfo(ix)) {
+ const C2Param *param =
+ config->getConfigParameterValue(ix.withStream(stream));
+ if (param) {
+ std::shared_ptr<C2Param> info(C2Param::Copy(*param));
+ buf->setInfo(std::static_pointer_cast<C2Info>(info));
+ }
}
}
}
+ ++stream;
}
- ++stream;
}
- }
- if (config->mInputSurface) {
- config->mInputSurface->onInputBufferDone(work->input.ordinal.frameIndex);
+ if (config->mInputSurface) {
+ config->mInputSurface->onInputBufferDone(work->input.ordinal.frameIndex);
+ }
+ if (initDataWatcher.hasChanged()) {
+ initData = C2Param::Copy(*initDataWatcher.update().get());
+ }
+ outputFormat = config->mOutputFormat;
}
mChannel->onWorkDone(
- std::move(work), config->mOutputFormat,
- initData.hasChanged() ? initData.update().get() : nullptr);
+ std::move(work), outputFormat,
+ initData ? (C2StreamInitDataInfo::output *)initData.get() : nullptr);
break;
}
case kWhatWatch: {
@@ -2305,9 +2319,44 @@
pendingDeadline = true;
}
}
- Mutexed<std::unique_ptr<Config>>::Locked configLocked(mConfig);
- const std::unique_ptr<Config> &config = *configLocked;
- if (config->mTunneled == false && name.empty()) {
+ bool tunneled = false;
+ bool isMediaTypeKnown = false;
+ {
+ static const std::set<std::string> kKnownMediaTypes{
+ MIMETYPE_VIDEO_VP8,
+ MIMETYPE_VIDEO_VP9,
+ MIMETYPE_VIDEO_AV1,
+ MIMETYPE_VIDEO_AVC,
+ MIMETYPE_VIDEO_HEVC,
+ MIMETYPE_VIDEO_MPEG4,
+ MIMETYPE_VIDEO_H263,
+ MIMETYPE_VIDEO_MPEG2,
+ MIMETYPE_VIDEO_RAW,
+ MIMETYPE_VIDEO_DOLBY_VISION,
+
+ MIMETYPE_AUDIO_AMR_NB,
+ MIMETYPE_AUDIO_AMR_WB,
+ MIMETYPE_AUDIO_MPEG,
+ MIMETYPE_AUDIO_AAC,
+ MIMETYPE_AUDIO_QCELP,
+ MIMETYPE_AUDIO_VORBIS,
+ MIMETYPE_AUDIO_OPUS,
+ MIMETYPE_AUDIO_G711_ALAW,
+ MIMETYPE_AUDIO_G711_MLAW,
+ MIMETYPE_AUDIO_RAW,
+ MIMETYPE_AUDIO_FLAC,
+ MIMETYPE_AUDIO_MSGSM,
+ MIMETYPE_AUDIO_AC3,
+ MIMETYPE_AUDIO_EAC3,
+
+ MIMETYPE_IMAGE_ANDROID_HEIC,
+ };
+ Mutexed<std::unique_ptr<Config>>::Locked configLocked(mConfig);
+ const std::unique_ptr<Config> &config = *configLocked;
+ tunneled = config->mTunneled;
+ isMediaTypeKnown = (kKnownMediaTypes.count(config->mCodingMediaType) != 0);
+ }
+ if (!tunneled && isMediaTypeKnown && name.empty()) {
constexpr std::chrono::steady_clock::duration kWorkDurationThreshold = 3s;
std::chrono::steady_clock::duration elapsed = mChannel->elapsed();
if (elapsed >= kWorkDurationThreshold) {
diff --git a/media/codec2/sfplugin/CCodecBufferChannel.cpp b/media/codec2/sfplugin/CCodecBufferChannel.cpp
index ad02edb..5a58fd8 100644
--- a/media/codec2/sfplugin/CCodecBufferChannel.cpp
+++ b/media/codec2/sfplugin/CCodecBufferChannel.cpp
@@ -1348,7 +1348,7 @@
// about buffers from the previous generation do not interfere with the
// newly initialized pipeline capacity.
- {
+ if (inputFormat || outputFormat) {
Mutexed<PipelineWatcher>::Locked watcher(mPipelineWatcher);
watcher->inputDelay(inputDelayValue)
.pipelineDelay(pipelineDelayValue)
@@ -1448,14 +1448,14 @@
void CCodecBufferChannel::stop() {
mSync.stop();
mFirstValidFrameIndex = mFrameIndex.load(std::memory_order_relaxed);
- if (mInputSurface != nullptr) {
- mInputSurface.reset();
- }
- mPipelineWatcher.lock()->flush();
}
void CCodecBufferChannel::reset() {
stop();
+ if (mInputSurface != nullptr) {
+ mInputSurface.reset();
+ }
+ mPipelineWatcher.lock()->flush();
{
Mutexed<Input>::Locked input(mInput);
input->buffers.reset(new DummyInputBuffers(""));
@@ -1483,8 +1483,10 @@
void CCodecBufferChannel::flush(const std::list<std::unique_ptr<C2Work>> &flushedWork) {
ALOGV("[%s] flush", mName);
+ std::vector<uint64_t> indices;
std::list<std::unique_ptr<C2Work>> configs;
for (const std::unique_ptr<C2Work> &work : flushedWork) {
+ indices.push_back(work->input.ordinal.frameIndex.peeku());
if (!(work->input.flags & C2FrameData::FLAG_CODEC_CONFIG)) {
continue;
}
@@ -1497,6 +1499,7 @@
std::unique_ptr<C2Work> copy(new C2Work);
copy->input.flags = C2FrameData::flags_t(work->input.flags | C2FrameData::FLAG_DROP_FRAME);
copy->input.ordinal = work->input.ordinal;
+ copy->input.ordinal.frameIndex = mFrameIndex++;
copy->input.buffers.insert(
copy->input.buffers.begin(),
work->input.buffers.begin(),
@@ -1525,7 +1528,12 @@
output->buffers->flushStash();
}
}
- mPipelineWatcher.lock()->flush();
+ {
+ Mutexed<PipelineWatcher>::Locked watcher(mPipelineWatcher);
+ for (uint64_t index : indices) {
+ watcher->onWorkDone(index);
+ }
+ }
}
void CCodecBufferChannel::onWorkDone(
@@ -1621,7 +1629,8 @@
}
}
- std::optional<uint32_t> newInputDelay, newPipelineDelay;
+ std::optional<uint32_t> newInputDelay, newPipelineDelay, newOutputDelay, newReorderDepth;
+ std::optional<C2Config::ordinal_key_t> newReorderKey;
bool needMaxDequeueBufferCountUpdate = false;
while (!worklet->output.configUpdate.empty()) {
std::unique_ptr<C2Param> param;
@@ -1633,7 +1642,7 @@
if (reorderDepth.updateFrom(*param)) {
ALOGV("[%s] onWorkDone: updated reorder depth to %u",
mName, reorderDepth.value);
- mOutput.lock()->buffers->setReorderDepth(reorderDepth.value);
+ newReorderDepth = reorderDepth.value;
needMaxDequeueBufferCountUpdate = true;
} else {
ALOGD("[%s] onWorkDone: failed to read reorder depth",
@@ -1644,7 +1653,7 @@
case C2PortReorderKeySetting::CORE_INDEX: {
C2PortReorderKeySetting::output reorderKey;
if (reorderKey.updateFrom(*param)) {
- mOutput.lock()->buffers->setReorderKey(reorderKey.value);
+ newReorderKey = reorderKey.value;
ALOGV("[%s] onWorkDone: updated reorder key to %u",
mName, reorderKey.value);
} else {
@@ -1679,35 +1688,9 @@
ALOGV("[%s] onWorkDone: updating output delay %u",
mName, outputDelay.value);
(void)mPipelineWatcher.lock()->outputDelay(outputDelay.value);
+ newOutputDelay = outputDelay.value;
needMaxDequeueBufferCountUpdate = true;
- bool outputBuffersChanged = false;
- size_t numOutputSlots = 0;
- {
- Mutexed<Output>::Locked output(mOutput);
- if (!output->buffers) {
- return false;
- }
- output->outputDelay = outputDelay.value;
- numOutputSlots = outputDelay.value +
- kSmoothnessFactor;
- if (output->numSlots < numOutputSlots) {
- output->numSlots = numOutputSlots;
- if (output->buffers->isArrayMode()) {
- OutputBuffersArray *array =
- (OutputBuffersArray *)output->buffers.get();
- ALOGV("[%s] onWorkDone: growing output buffer array to %zu",
- mName, numOutputSlots);
- array->grow(numOutputSlots);
- outputBuffersChanged = true;
- }
- }
- numOutputSlots = output->numSlots;
- }
-
- if (outputBuffersChanged) {
- mCCodecCallback->onOutputBuffersChanged();
- }
}
}
break;
@@ -1747,14 +1730,43 @@
input->numSlots = newNumSlots;
}
}
- if (needMaxDequeueBufferCountUpdate) {
- size_t numOutputSlots = 0;
- uint32_t reorderDepth = 0;
- {
- Mutexed<Output>::Locked output(mOutput);
- numOutputSlots = output->numSlots;
- reorderDepth = output->buffers->getReorderDepth();
+ size_t numOutputSlots = 0;
+ uint32_t reorderDepth = 0;
+ bool outputBuffersChanged = false;
+ if (newReorderKey || newReorderDepth || needMaxDequeueBufferCountUpdate) {
+ Mutexed<Output>::Locked output(mOutput);
+ if (!output->buffers) {
+ return false;
}
+ numOutputSlots = output->numSlots;
+ if (newReorderKey) {
+ output->buffers->setReorderKey(newReorderKey.value());
+ }
+ if (newReorderDepth) {
+ output->buffers->setReorderDepth(newReorderDepth.value());
+ }
+ reorderDepth = output->buffers->getReorderDepth();
+ if (newOutputDelay) {
+ output->outputDelay = newOutputDelay.value();
+ numOutputSlots = newOutputDelay.value() + kSmoothnessFactor;
+ if (output->numSlots < numOutputSlots) {
+ output->numSlots = numOutputSlots;
+ if (output->buffers->isArrayMode()) {
+ OutputBuffersArray *array =
+ (OutputBuffersArray *)output->buffers.get();
+ ALOGV("[%s] onWorkDone: growing output buffer array to %zu",
+ mName, numOutputSlots);
+ array->grow(numOutputSlots);
+ outputBuffersChanged = true;
+ }
+ }
+ }
+ numOutputSlots = output->numSlots;
+ }
+ if (outputBuffersChanged) {
+ mCCodecCallback->onOutputBuffersChanged();
+ }
+ if (needMaxDequeueBufferCountUpdate) {
Mutexed<OutputSurface>::Locked output(mOutputSurface);
output->maxDequeueBuffers = numOutputSlots + reorderDepth + kRenderingDepth;
if (output->surface) {
diff --git a/media/codec2/sfplugin/CCodecConfig.cpp b/media/codec2/sfplugin/CCodecConfig.cpp
index ad28545..727b1ff 100644
--- a/media/codec2/sfplugin/CCodecConfig.cpp
+++ b/media/codec2/sfplugin/CCodecConfig.cpp
@@ -362,7 +362,10 @@
.limitTo(D::OUTPUT & D::READ));
add(ConfigMapper(KEY_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
- .limitTo(D::ENCODER & D::OUTPUT));
+ .limitTo(D::ENCODER & D::CODED));
+ // Some audio decoders require bitrate information to be set
+ add(ConfigMapper(KEY_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
+ .limitTo(D::AUDIO & D::DECODER & D::CODED));
// we also need to put the bitrate in the max bitrate field
add(ConfigMapper(KEY_MAX_BIT_RATE, C2_PARAMKEY_BITRATE, "value")
.limitTo(D::ENCODER & D::READ & D::OUTPUT));
@@ -730,6 +733,17 @@
return C2Value();
}));
+ add(ConfigMapper(KEY_AAC_PROFILE, C2_PARAMKEY_PROFILE_LEVEL, "profile")
+ .limitTo(D::AUDIO & D::ENCODER & (D::CONFIG | D::PARAM))
+ .withMapper([mapper](C2Value v) -> C2Value {
+ C2Config::profile_t c2 = PROFILE_UNUSED;
+ int32_t sdk;
+ if (mapper && v.get(&sdk) && mapper->mapProfile(sdk, &c2)) {
+ return c2;
+ }
+ return PROFILE_UNUSED;
+ }));
+
// convert to dBFS and add default
add(ConfigMapper(KEY_AAC_DRC_TARGET_REFERENCE_LEVEL, C2_PARAMKEY_DRC_TARGET_REFERENCE_LEVEL, "value")
.limitTo(D::AUDIO & D::DECODER & (D::CONFIG | D::PARAM | D::READ))
@@ -1319,6 +1333,14 @@
}
}
+ // Remove KEY_AAC_SBR_MODE from SDK message if it is outside supported range
+ // as SDK doesn't have a way to signal default sbr mode based on profile and
+ // requires that the key isn't present in format to signal that
+ int sbrMode;
+ if (msg->findInt32(KEY_AAC_SBR_MODE, &sbrMode) && (sbrMode < 0 || sbrMode > 2)) {
+ msg->removeEntryAt(msg->findEntryByName(KEY_AAC_SBR_MODE));
+ }
+
{ // convert color info
// move default color to color aspect if not read from the component
int32_t tmp;
diff --git a/media/codec2/sfplugin/PipelineWatcher.cpp b/media/codec2/sfplugin/PipelineWatcher.cpp
index 0ee9056..bc9197c 100644
--- a/media/codec2/sfplugin/PipelineWatcher.cpp
+++ b/media/codec2/sfplugin/PipelineWatcher.cpp
@@ -95,6 +95,7 @@
}
void PipelineWatcher::flush() {
+ ALOGV("flush");
mFramesInPipeline.clear();
}
diff --git a/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp b/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp
index a78d811..0966988 100644
--- a/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp
+++ b/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp
@@ -346,7 +346,7 @@
}
return (img->mPlane[1].mColInc == 2
&& img->mPlane[2].mColInc == 2
- && (img->mPlane[2].mOffset - img->mPlane[1].mOffset == 1));
+ && (img->mPlane[2].mOffset == img->mPlane[1].mOffset + 1));
}
bool IsNV21(const MediaImage2 *img) {
@@ -355,7 +355,7 @@
}
return (img->mPlane[1].mColInc == 2
&& img->mPlane[2].mColInc == 2
- && (img->mPlane[1].mOffset - img->mPlane[2].mOffset == 1));
+ && (img->mPlane[1].mOffset == img->mPlane[2].mOffset + 1));
}
bool IsI420(const MediaImage2 *img) {
diff --git a/media/codec2/sfplugin/utils/Codec2Mapper.cpp b/media/codec2/sfplugin/utils/Codec2Mapper.cpp
index 1390642..00bf84f 100644
--- a/media/codec2/sfplugin/utils/Codec2Mapper.cpp
+++ b/media/codec2/sfplugin/utils/Codec2Mapper.cpp
@@ -311,6 +311,8 @@
{ C2Config::PCM_8, kAudioEncodingPcm8bit },
{ C2Config::PCM_16, kAudioEncodingPcm16bit },
{ C2Config::PCM_FLOAT, kAudioEncodingPcmFloat },
+ { C2Config::PCM_24, kAudioEncodingPcm24bitPacked },
+ { C2Config::PCM_32, kAudioEncodingPcm32bit },
};
ALookup<C2Config::level_t, int32_t> sVp9Levels = {
diff --git a/media/codec2/vndk/C2Config.cpp b/media/codec2/vndk/C2Config.cpp
index 34680a7..e9223fb 100644
--- a/media/codec2/vndk/C2Config.cpp
+++ b/media/codec2/vndk/C2Config.cpp
@@ -142,6 +142,14 @@
{ "av1-0", C2Config::PROFILE_AV1_0 },
{ "av1-1", C2Config::PROFILE_AV1_1 },
{ "av1-2", C2Config::PROFILE_AV1_2 },
+ { "vp8-0", C2Config::PROFILE_VP8_0 },
+ { "vp8-1", C2Config::PROFILE_VP8_1 },
+ { "vp8-2", C2Config::PROFILE_VP8_2 },
+ { "vp8-3", C2Config::PROFILE_VP8_3 },
+ { "mpegh-main", C2Config::PROFILE_MPEGH_MAIN },
+ { "mpegh-high", C2Config::PROFILE_MPEGH_HIGH },
+ { "mpegh-lc", C2Config::PROFILE_MPEGH_LC },
+ { "mpegh-baseline", C2Config::PROFILE_MPEGH_BASELINE },
}))
DEFINE_C2_ENUM_VALUE_CUSTOM_HELPER(C2Config::level_t, ({
@@ -248,6 +256,11 @@
{ "av1-7.1", C2Config::LEVEL_AV1_7_1 },
{ "av1-7.2", C2Config::LEVEL_AV1_7_2 },
{ "av1-7.3", C2Config::LEVEL_AV1_7_3 },
+ { "mpegh-1", C2Config::LEVEL_MPEGH_1 },
+ { "mpegh-2", C2Config::LEVEL_MPEGH_2 },
+ { "mpegh-3", C2Config::LEVEL_MPEGH_3 },
+ { "mpegh-4", C2Config::LEVEL_MPEGH_4 },
+ { "mpegh-5", C2Config::LEVEL_MPEGH_5 },
}))
DEFINE_C2_ENUM_VALUE_CUSTOM_HELPER(C2BufferData::type_t, ({
diff --git a/media/codecs/amrnb/dec/test/Android.bp b/media/codecs/amrnb/dec/test/Android.bp
index b882481..74258e0 100644
--- a/media/codecs/amrnb/dec/test/Android.bp
+++ b/media/codecs/amrnb/dec/test/Android.bp
@@ -29,6 +29,7 @@
cc_test {
name: "AmrnbDecoderTest",
gtest: true,
+ test_suites: ["device-tests"],
srcs: [
"AmrnbDecoderTest.cpp",
diff --git a/media/codecs/amrnb/enc/test/Android.bp b/media/codecs/amrnb/enc/test/Android.bp
index a94ffd4..7e393e3 100644
--- a/media/codecs/amrnb/enc/test/Android.bp
+++ b/media/codecs/amrnb/enc/test/Android.bp
@@ -29,6 +29,7 @@
cc_test {
name: "AmrnbEncoderTest",
gtest: true,
+ test_suites: ["device-tests"],
srcs: [
"AmrnbEncoderTest.cpp",
diff --git a/media/codecs/m4v_h263/dec/test/Android.bp b/media/codecs/m4v_h263/dec/test/Android.bp
index 4ae5e73..6eed66f 100644
--- a/media/codecs/m4v_h263/dec/test/Android.bp
+++ b/media/codecs/m4v_h263/dec/test/Android.bp
@@ -29,6 +29,24 @@
name: "Mpeg4H263DecoderTest",
gtest: true,
+ test_suites: [
+ "device-tests",
+ "mts",
+ ],
+
+ // Support multilib variants (using different suffix per sub-architecture), which is needed on
+ // build targets with secondary architectures, as the MTS test suite packaging logic flattens
+ // all test artifacts into a single `testcases` directory.
+ compile_multilib: "both",
+ multilib: {
+ lib32: {
+ suffix: "32",
+ },
+ lib64: {
+ suffix: "64",
+ },
+ },
+
srcs: [
"Mpeg4H263DecoderTest.cpp",
],
diff --git a/media/codecs/m4v_h263/dec/test/AndroidTest.xml b/media/codecs/m4v_h263/dec/test/AndroidTest.xml
index f572b0c..8bb4d1c 100755
--- a/media/codecs/m4v_h263/dec/test/AndroidTest.xml
+++ b/media/codecs/m4v_h263/dec/test/AndroidTest.xml
@@ -15,9 +15,10 @@
-->
<configuration description="Test module config for Mpeg4H263 Decoder unit tests">
<option name="test-suite-tag" value="Mpeg4H263DecoderTest" />
- <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">
+ <target_preparer class="com.android.compatibility.common.tradefed.targetprep.FilePusher">
<option name="cleanup" value="true" />
<option name="push" value="Mpeg4H263DecoderTest->/data/local/tmp/Mpeg4H263DecoderTest" />
+ <option name="append-bitness" value="true" />
<option name="push-file"
key="https://storage.googleapis.com/android_media/frameworks/av/media/libstagefright/codecs/m4v_h263/dec/test/Mpeg4H263Decoder-1.1.zip?unzip=true"
value="/data/local/tmp/Mpeg4H263DecoderTestRes/" />
diff --git a/media/codecs/m4v_h263/enc/test/Android.bp b/media/codecs/m4v_h263/enc/test/Android.bp
index e1ce4aa..2b5e49c 100644
--- a/media/codecs/m4v_h263/enc/test/Android.bp
+++ b/media/codecs/m4v_h263/enc/test/Android.bp
@@ -29,6 +29,7 @@
cc_test {
name: "Mpeg4H263EncoderTest",
gtest: true,
+ test_suites: ["device-tests"],
srcs : [ "Mpeg4H263EncoderTest.cpp" ],
diff --git a/media/codecs/mp3dec/test/Android.bp b/media/codecs/mp3dec/test/Android.bp
index 8003068..f10b6ae 100644
--- a/media/codecs/mp3dec/test/Android.bp
+++ b/media/codecs/mp3dec/test/Android.bp
@@ -27,6 +27,7 @@
cc_test {
name: "Mp3DecoderTest",
gtest: true,
+ test_suites: ["device-tests"],
srcs: [
"mp3reader.cpp",
diff --git a/media/extractors/mp4/MPEG4Extractor.cpp b/media/extractors/mp4/MPEG4Extractor.cpp
index 1bc8c63..f725a8c 100644
--- a/media/extractors/mp4/MPEG4Extractor.cpp
+++ b/media/extractors/mp4/MPEG4Extractor.cpp
@@ -62,6 +62,16 @@
#define ALAC_SPECIFIC_INFO_SIZE (36)
+// 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:
+#define AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION \
+ "mpegh-profile-level-indication"
+#define AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT \
+ "mpegh-reference-channel-layout"
+#define AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS \
+ "mpegh-compatible-sets"
+
namespace android {
enum {
@@ -139,6 +149,7 @@
bool mIsHEVC;
bool mIsDolbyVision;
bool mIsAC4;
+ bool mIsMpegH = false;
bool mIsPcm;
size_t mNALLengthSize;
@@ -377,6 +388,10 @@
case FOURCC(".mp3"):
case 0x6D730055: // "ms U" mp3 audio
return MEDIA_MIMETYPE_AUDIO_MPEG;
+ case FOURCC("mha1"):
+ return MEDIA_MIMETYPE_AUDIO_MPEGH_MHA1;
+ case FOURCC("mhm1"):
+ return MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1;
default:
ALOGW("Unknown fourcc: %c%c%c%c",
(fourcc >> 24) & 0xff,
@@ -1760,6 +1775,8 @@
case FOURCC("fLaC"):
case FOURCC(".mp3"):
case 0x6D730055: // "ms U" mp3 audio
+ case FOURCC("mha1"):
+ case FOURCC("mhm1"):
{
if (mIsQT && depth >= 1 && mPath[depth - 1] == FOURCC("wave")) {
@@ -1959,7 +1976,94 @@
}
break;
}
+ case FOURCC("mhaC"):
+ {
+ // See ISO_IEC_23008-3;2019 MHADecoderConfigurationRecord
+ constexpr uint32_t mhac_header_size = 4 /* size */ + 4 /* boxtype 'mhaC' */
+ + 1 /* configurationVersion */ + 1 /* mpegh3daProfileLevelIndication */
+ + 1 /* referenceChannelLayout */ + 2 /* mpegh3daConfigLength */;
+ uint8_t mhac_header[mhac_header_size];
+ off64_t data_offset = *offset;
+ if (chunk_size < sizeof(mhac_header)) {
+ return ERROR_MALFORMED;
+ }
+
+ if (mDataSource->readAt(data_offset, mhac_header, sizeof(mhac_header))
+ < (ssize_t)sizeof(mhac_header)) {
+ return ERROR_IO;
+ }
+
+ //get mpegh3daProfileLevelIndication
+ const uint32_t mpegh3daProfileLevelIndication = mhac_header[9];
+ AMediaFormat_setInt32(mLastTrack->meta,
+ AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION,
+ mpegh3daProfileLevelIndication);
+
+ //get referenceChannelLayout
+ const uint32_t referenceChannelLayout = mhac_header[10];
+ AMediaFormat_setInt32(mLastTrack->meta,
+ AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT,
+ referenceChannelLayout);
+
+ // get mpegh3daConfigLength
+ const uint32_t mhac_config_size = U16_AT(&mhac_header[11]);
+ if (chunk_size != sizeof(mhac_header) + mhac_config_size) {
+ return ERROR_MALFORMED;
+ }
+
+ data_offset += sizeof(mhac_header);
+ uint8_t mhac_config[mhac_config_size];
+ if (mDataSource->readAt(data_offset, mhac_config, sizeof(mhac_config))
+ < (ssize_t)sizeof(mhac_config)) {
+ return ERROR_IO;
+ }
+
+ AMediaFormat_setBuffer(mLastTrack->meta,
+ AMEDIAFORMAT_KEY_CSD_0, mhac_config, sizeof(mhac_config));
+ data_offset += sizeof(mhac_config);
+ *offset = data_offset;
+ break;
+ }
+ case FOURCC("mhaP"):
+ {
+ // FDAmd_2 of ISO_IEC_23008-3;2019 MHAProfileAndLevelCompatibilitySetBox
+ constexpr uint32_t mhap_header_size = 4 /* size */ + 4 /* boxtype 'mhaP' */
+ + 1 /* numCompatibleSets */;
+
+ uint8_t mhap_header[mhap_header_size];
+ off64_t data_offset = *offset;
+
+ if (chunk_size < (ssize_t)mhap_header_size) {
+ return ERROR_MALFORMED;
+ }
+
+ if (mDataSource->readAt(data_offset, mhap_header, sizeof(mhap_header))
+ < (ssize_t)sizeof(mhap_header)) {
+ return ERROR_IO;
+ }
+
+ // mhap_compatible_sets_size = numCompatibleSets * sizeof(uint8_t)
+ const uint32_t mhap_compatible_sets_size = mhap_header[8];
+ if (chunk_size != sizeof(mhap_header) + mhap_compatible_sets_size) {
+ return ERROR_MALFORMED;
+ }
+
+ data_offset += sizeof(mhap_header);
+ uint8_t mhap_compatible_sets[mhap_compatible_sets_size];
+ if (mDataSource->readAt(
+ data_offset, mhap_compatible_sets, sizeof(mhap_compatible_sets))
+ < (ssize_t)sizeof(mhap_compatible_sets)) {
+ return ERROR_IO;
+ }
+
+ AMediaFormat_setBuffer(mLastTrack->meta,
+ AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS,
+ mhap_compatible_sets, sizeof(mhap_compatible_sets));
+ data_offset += sizeof(mhap_compatible_sets);
+ *offset = data_offset;
+ break;
+ }
case FOURCC("mp4v"):
case FOURCC("encv"):
case FOURCC("s263"):
@@ -4939,6 +5043,8 @@
bool success = AMediaFormat_getString(mFormat, AMEDIAFORMAT_KEY_MIME, &mime);
CHECK(success);
+ mIsMpegH = !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEGH_MHA1) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1);
mIsAVC = !strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC);
mIsHEVC = !strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_HEVC) ||
!strcasecmp(mime, MEDIA_MIMETYPE_IMAGE_ANDROID_HEIC);
@@ -6008,10 +6114,11 @@
}
uint32_t syncSampleIndex = sampleIndex;
- // assume every non-USAC audio sample is a sync sample. This works around
+ // assume every non-USAC/non-MPEGH audio sample is a sync sample.
+ // This works around
// seek issues with files that were incorrectly written with an
// empty or single-sample stss block for the audio track
- if (err == OK && (!mIsAudio || mIsUsac)) {
+ if (err == OK && (!mIsAudio || mIsUsac || mIsMpegH)) {
err = mSampleTable->findSyncSampleNear(
sampleIndex, &syncSampleIndex, findFlags);
}
diff --git a/media/libaudiohal/impl/StreamHalLocal.cpp b/media/libaudiohal/impl/StreamHalLocal.cpp
index d0c375e..34bd5df 100644
--- a/media/libaudiohal/impl/StreamHalLocal.cpp
+++ b/media/libaudiohal/impl/StreamHalLocal.cpp
@@ -17,6 +17,7 @@
#define LOG_TAG "StreamHalLocal"
//#define LOG_NDEBUG 0
+#include <audio_utils/Metadata.h>
#include <hardware/audio.h>
#include <media/AudioParameter.h>
#include <utils/Log.h>
@@ -353,7 +354,11 @@
if (callback.get() == nullptr) return 0;
switch (event) {
case STREAM_EVENT_CBK_TYPE_CODEC_FORMAT_CHANGED:
- callback->onCodecFormatChanged(std::basic_string<uint8_t>((uint8_t*)param));
+ // void* param is the byte string buffer from byte_string_from_audio_metadata().
+ // As the byte string buffer may have embedded zeroes, we cannot use strlen()
+ callback->onCodecFormatChanged(std::basic_string<uint8_t>(
+ (const uint8_t*)param,
+ audio_utils::metadata::dataByteStringLen((const uint8_t*)param)));
break;
default:
ALOGW("%s unknown event %d", __func__, event);
diff --git a/media/libdatasource/DataSourceFactory.cpp b/media/libdatasource/DataSourceFactory.cpp
index bb6a08c..f91e3ea 100644
--- a/media/libdatasource/DataSourceFactory.cpp
+++ b/media/libdatasource/DataSourceFactory.cpp
@@ -65,6 +65,9 @@
sp<HTTPBase> mediaHTTP = httpSource;
if (mediaHTTP == NULL) {
mediaHTTP = static_cast<HTTPBase *>(CreateMediaHTTP(httpService).get());
+ if (mediaHTTP == NULL) {
+ return NULL;
+ }
}
String8 cacheConfig;
diff --git a/media/libeffects/lvm/lib/Android.bp b/media/libeffects/lvm/lib/Android.bp
index 5d75055..7998879 100644
--- a/media/libeffects/lvm/lib/Android.bp
+++ b/media/libeffects/lvm/lib/Android.bp
@@ -63,7 +63,6 @@
"Common/src/DC_2I_D16_TRC_WRA_01_Init.cpp",
"Common/src/Copy_16.cpp",
"Common/src/MonoTo2I_32.cpp",
- "Common/src/LoadConst_32.cpp",
"Common/src/dB_to_Lin32.cpp",
"Common/src/Shift_Sat_v16xv16.cpp",
"Common/src/Shift_Sat_v32xv32.cpp",
@@ -148,7 +147,6 @@
"Reverb/src/LVREV_Process.cpp",
"Reverb/src/LVREV_SetControlParameters.cpp",
"Reverb/src/LVREV_Tables.cpp",
- "Common/src/LoadConst_32.cpp",
"Common/src/From2iToMono_32.cpp",
"Common/src/Mult3s_32x16.cpp",
"Common/src/Copy_16.cpp",
diff --git a/media/libeffects/lvm/lib/Bundle/src/LVM_Init.cpp b/media/libeffects/lvm/lib/Bundle/src/LVM_Init.cpp
index 9f5f448..12b86f3 100644
--- a/media/libeffects/lvm/lib/Bundle/src/LVM_Init.cpp
+++ b/media/libeffects/lvm/lib/Bundle/src/LVM_Init.cpp
@@ -137,9 +137,9 @@
pInstance->pBufferManagement->pScratch = (LVM_FLOAT*)pInstance->pScratch;
- LoadConst_Float(0, /* Clear the input delay buffer */
- (LVM_FLOAT*)&pInstance->pBufferManagement->InDelayBuffer,
- (LVM_INT16)(LVM_MAX_CHANNELS * MIN_INTERNAL_BLOCKSIZE));
+ memset(pInstance->pBufferManagement->InDelayBuffer, 0,
+ LVM_MAX_CHANNELS * MIN_INTERNAL_BLOCKSIZE *
+ sizeof(pInstance->pBufferManagement->InDelayBuffer[0]));
pInstance->pBufferManagement->InDelaySamples =
MIN_INTERNAL_BLOCKSIZE; /* Set the number of delay samples */
pInstance->pBufferManagement->OutDelaySamples = 0; /* No samples in the output buffer */
diff --git a/media/libeffects/lvm/lib/Common/lib/VectorArithmetic.h b/media/libeffects/lvm/lib/Common/lib/VectorArithmetic.h
index 18de85b..10f351e 100644
--- a/media/libeffects/lvm/lib/Common/lib/VectorArithmetic.h
+++ b/media/libeffects/lvm/lib/Common/lib/VectorArithmetic.h
@@ -24,8 +24,6 @@
VARIOUS FUNCTIONS
***********************************************************************************/
-void LoadConst_Float(const LVM_FLOAT val, LVM_FLOAT* dst, LVM_INT16 n);
-
void Copy_Float(const LVM_FLOAT* src, LVM_FLOAT* dst, LVM_INT16 n);
void Copy_Float_Mc_Stereo(const LVM_FLOAT* src, LVM_FLOAT* dst, LVM_INT16 NrFrames,
LVM_INT32 NrChannels);
diff --git a/media/libeffects/lvm/lib/Common/src/LVC_MixSoft_1St_D16C31_SAT.cpp b/media/libeffects/lvm/lib/Common/src/LVC_MixSoft_1St_D16C31_SAT.cpp
index be19fa0..5a67bda 100644
--- a/media/libeffects/lvm/lib/Common/src/LVC_MixSoft_1St_D16C31_SAT.cpp
+++ b/media/libeffects/lvm/lib/Common/src/LVC_MixSoft_1St_D16C31_SAT.cpp
@@ -19,6 +19,7 @@
INCLUDE FILES
***********************************************************************************/
+#include <string.h>
#include "LVC_Mixer_Private.h"
#include "VectorArithmetic.h"
#include "ScalarArithmetic.h"
@@ -68,7 +69,7 @@
if (HardMixing) {
if (pInstance->Target == 0)
- LoadConst_Float(0.0, dst, n);
+ memset(dst, 0, n * sizeof(*dst));
else {
if ((pInstance->Target) != 1.0f)
Mult3s_Float(src, (pInstance->Target), dst, n);
@@ -150,7 +151,7 @@
if (HardMixing) {
if (pInstance->Target == 0)
- LoadConst_Float(0.0, dst, NrFrames * NrChannels);
+ memset(dst, 0, NrFrames * NrChannels * sizeof(*dst));
else {
if ((pInstance->Target) != 1.0f)
Mult3s_Float(src, (pInstance->Target), dst, NrFrames * NrChannels);
diff --git a/media/libeffects/lvm/lib/Common/src/LoadConst_32.cpp b/media/libeffects/lvm/lib/Common/src/LoadConst_32.cpp
deleted file mode 100644
index df7a558..0000000
--- a/media/libeffects/lvm/lib/Common/src/LoadConst_32.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2004-2010 NXP Software
- * Copyright (C) 2010 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 FILES
-***********************************************************************************/
-
-#include "VectorArithmetic.h"
-
-/**********************************************************************************
- FUNCTION LoadConst_32
-***********************************************************************************/
-void LoadConst_Float(const LVM_FLOAT val, LVM_FLOAT* dst, LVM_INT16 n) {
- LVM_INT16 ii;
-
- for (ii = n; ii != 0; ii--) {
- *dst = val;
- dst++;
- }
-
- return;
-}
-
-/**********************************************************************************/
diff --git a/media/libeffects/lvm/lib/Common/src/MixSoft_1St_D32C31_WRA.cpp b/media/libeffects/lvm/lib/Common/src/MixSoft_1St_D32C31_WRA.cpp
index 8408962..58a9102 100644
--- a/media/libeffects/lvm/lib/Common/src/MixSoft_1St_D32C31_WRA.cpp
+++ b/media/libeffects/lvm/lib/Common/src/MixSoft_1St_D32C31_WRA.cpp
@@ -19,6 +19,7 @@
INCLUDE FILES
***********************************************************************************/
+#include <string.h>
#include "Mixer_private.h"
#include "VectorArithmetic.h"
@@ -61,7 +62,7 @@
if (HardMixing) {
if (pInstance->Target == 0)
- LoadConst_Float(0, dst, n);
+ memset(dst, 0, n * sizeof(*dst));
else if ((pInstance->Target) == 1.0f) {
if (src != dst) Copy_Float((LVM_FLOAT*)src, (LVM_FLOAT*)dst, (LVM_INT16)(n));
} else
diff --git a/media/libeffects/lvm/lib/Reverb/src/LVREV_ClearAudioBuffers.cpp b/media/libeffects/lvm/lib/Reverb/src/LVREV_ClearAudioBuffers.cpp
index d4b321f..be3505f 100644
--- a/media/libeffects/lvm/lib/Reverb/src/LVREV_ClearAudioBuffers.cpp
+++ b/media/libeffects/lvm/lib/Reverb/src/LVREV_ClearAudioBuffers.cpp
@@ -60,7 +60,8 @@
pLVREV_Private->pRevLPFBiquad->clear();
for (size_t i = 0; i < pLVREV_Private->InstanceParams.NumDelays; i++) {
pLVREV_Private->revLPFBiquad[i]->clear();
- LoadConst_Float(0, pLVREV_Private->pDelay_T[i], LVREV_MAX_T_DELAY[i]);
+ memset(pLVREV_Private->pDelay_T[i], 0, LVREV_MAX_T_DELAY[i] *
+ sizeof(pLVREV_Private->pDelay_T[i][0]));
}
return LVREV_SUCCESS;
}
diff --git a/media/libeffects/lvm/lib/StereoWidening/src/LVCS_ReverbGenerator.cpp b/media/libeffects/lvm/lib/StereoWidening/src/LVCS_ReverbGenerator.cpp
index c5b6598..de23d07 100644
--- a/media/libeffects/lvm/lib/StereoWidening/src/LVCS_ReverbGenerator.cpp
+++ b/media/libeffects/lvm/lib/StereoWidening/src/LVCS_ReverbGenerator.cpp
@@ -81,10 +81,7 @@
pConfig->DelaySize =
(pParams->NrChannels == FCC_1) ? (LVM_INT16)Delay : (LVM_INT16)(FCC_2 * Delay);
pConfig->DelayOffset = 0;
- LoadConst_Float(0, /* Value */
- (LVM_FLOAT*)&pConfig->StereoSamples[0], /* Destination */
- /* Number of words */
- (LVM_UINT16)(sizeof(pConfig->StereoSamples) / sizeof(LVM_FLOAT)));
+ memset(pConfig->StereoSamples, 0, sizeof(pConfig->StereoSamples));
/*
* Setup the filters
*/
diff --git a/media/libmedia/Android.bp b/media/libmedia/Android.bp
index 48b5391..6214f5e 100644
--- a/media/libmedia/Android.bp
+++ b/media/libmedia/Android.bp
@@ -43,6 +43,12 @@
enabled: false,
},
},
+ header_libs: [
+ "libbinder_headers",
+ ],
+ export_header_lib_headers: [
+ "libbinder_headers",
+ ],
apex_available: [
"//apex_available:platform",
"com.android.media",
diff --git a/media/libmedia/MediaProfiles.cpp b/media/libmedia/MediaProfiles.cpp
index 8be961c..bd17f4d 100644
--- a/media/libmedia/MediaProfiles.cpp
+++ b/media/libmedia/MediaProfiles.cpp
@@ -168,6 +168,7 @@
ALOGV("frame width: %d", codec.mFrameWidth);
ALOGV("frame height: %d", codec.mFrameHeight);
ALOGV("frame rate: %d", codec.mFrameRate);
+ ALOGV("profile: %d", codec.mProfile);
}
/*static*/ void
@@ -178,6 +179,7 @@
ALOGV("bit rate: %d", codec.mBitRate);
ALOGV("sample rate: %d", codec.mSampleRate);
ALOGV("number of channels: %d", codec.mChannels);
+ ALOGV("profile: %d", codec.mProfile);
}
/*static*/ void
@@ -229,10 +231,11 @@
return tag;
}
-/*static*/ MediaProfiles::VideoCodec*
-MediaProfiles::createVideoCodec(const char **atts, MediaProfiles *profiles)
+/*static*/ void
+MediaProfiles::createVideoCodec(const char **atts, size_t natts, MediaProfiles *profiles)
{
- CHECK(!strcmp("codec", atts[0]) &&
+ CHECK(natts >= 10 &&
+ !strcmp("codec", atts[0]) &&
!strcmp("bitRate", atts[2]) &&
!strcmp("width", atts[4]) &&
!strcmp("height", atts[6]) &&
@@ -241,49 +244,60 @@
const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]);
const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]);
if (codec == -1) {
- ALOGE("MediaProfiles::createVideoCodec failed to locate codec %s", atts[1]);
- return nullptr;
+ ALOGE("MediaProfiles::createVideoCodec failed to locate codec %s", atts[1]);
+ return;
}
- MediaProfiles::VideoCodec *videoCodec =
- new MediaProfiles::VideoCodec(static_cast<video_encoder>(codec),
- atoi(atts[3]), atoi(atts[5]), atoi(atts[7]), atoi(atts[9]));
- logVideoCodec(*videoCodec);
+ int profile = -1;
+ if (natts >= 12 && !strcmp("profile", atts[10])) {
+ profile = atoi(atts[11]);
+ }
+
+ VideoCodec videoCodec {
+ static_cast<video_encoder>(codec),
+ atoi(atts[3]), atoi(atts[5]), atoi(atts[7]), atoi(atts[9]), profile };
+ logVideoCodec(videoCodec);
size_t nCamcorderProfiles;
CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1);
- profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mVideoCodec = videoCodec;
- return videoCodec;
+ profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mVideoCodecs.emplace_back(videoCodec);
}
-/*static*/ MediaProfiles::AudioCodec*
-MediaProfiles::createAudioCodec(const char **atts, MediaProfiles *profiles)
+/*static*/ void
+MediaProfiles::createAudioCodec(const char **atts, size_t natts, MediaProfiles *profiles)
{
- CHECK(!strcmp("codec", atts[0]) &&
+ CHECK(natts >= 8 &&
+ !strcmp("codec", atts[0]) &&
!strcmp("bitRate", atts[2]) &&
!strcmp("sampleRate", atts[4]) &&
!strcmp("channels", atts[6]));
const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]);
const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]);
if (codec == -1) {
- ALOGE("MediaProfiles::createAudioCodec failed to locate codec %s", atts[1]);
- return nullptr;
+ ALOGE("MediaProfiles::createAudioCodec failed to locate codec %s", atts[1]);
+ return;
}
- MediaProfiles::AudioCodec *audioCodec =
- new MediaProfiles::AudioCodec(static_cast<audio_encoder>(codec),
- atoi(atts[3]), atoi(atts[5]), atoi(atts[7]));
- logAudioCodec(*audioCodec);
+ int profile = -1;
+ if (natts >= 10 && !strcmp("profile", atts[8])) {
+ profile = atoi(atts[9]);
+ }
+
+ AudioCodec audioCodec{
+ static_cast<audio_encoder>(codec),
+ atoi(atts[3]), atoi(atts[5]), atoi(atts[7]), profile };
+ logAudioCodec(audioCodec);
size_t nCamcorderProfiles;
CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1);
- profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mAudioCodec = audioCodec;
- return audioCodec;
+ profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mAudioCodecs.emplace_back(audioCodec);
}
+
/*static*/ MediaProfiles::AudioDecoderCap*
-MediaProfiles::createAudioDecoderCap(const char **atts)
+MediaProfiles::createAudioDecoderCap(const char **atts, size_t natts)
{
- CHECK(!strcmp("name", atts[0]) &&
+ CHECK(natts >= 4 &&
+ !strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]));
const size_t nMappings = sizeof(sAudioDecoderNameMap)/sizeof(sAudioDecoderNameMap[0]);
@@ -300,9 +314,10 @@
}
/*static*/ MediaProfiles::VideoDecoderCap*
-MediaProfiles::createVideoDecoderCap(const char **atts)
+MediaProfiles::createVideoDecoderCap(const char **atts, size_t natts)
{
- CHECK(!strcmp("name", atts[0]) &&
+ CHECK(natts >= 4 &&
+ !strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]));
const size_t nMappings = sizeof(sVideoDecoderNameMap)/sizeof(sVideoDecoderNameMap[0]);
@@ -319,9 +334,10 @@
}
/*static*/ MediaProfiles::VideoEncoderCap*
-MediaProfiles::createVideoEncoderCap(const char **atts)
+MediaProfiles::createVideoEncoderCap(const char **atts, size_t natts)
{
- CHECK(!strcmp("name", atts[0]) &&
+ CHECK(natts >= 20 &&
+ !strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]) &&
!strcmp("minBitRate", atts[4]) &&
!strcmp("maxBitRate", atts[6]) &&
@@ -348,9 +364,10 @@
}
/*static*/ MediaProfiles::AudioEncoderCap*
-MediaProfiles::createAudioEncoderCap(const char **atts)
+MediaProfiles::createAudioEncoderCap(const char **atts, size_t natts)
{
- CHECK(!strcmp("name", atts[0]) &&
+ CHECK(natts >= 16 &&
+ !strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]) &&
!strcmp("minBitRate", atts[4]) &&
!strcmp("maxBitRate", atts[6]) &&
@@ -374,9 +391,10 @@
}
/*static*/ output_format
-MediaProfiles::createEncoderOutputFileFormat(const char **atts)
+MediaProfiles::createEncoderOutputFileFormat(const char **atts, size_t natts)
{
- CHECK(!strcmp("name", atts[0]));
+ CHECK(natts >= 2 &&
+ !strcmp("name", atts[0]));
const size_t nMappings =sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]);
const int format = findTagForName(sFileFormatMap, nMappings, atts[1]);
@@ -395,9 +413,11 @@
}
/*static*/ MediaProfiles::CamcorderProfile*
-MediaProfiles::createCamcorderProfile(int cameraId, const char **atts, Vector<int>& cameraIds)
+MediaProfiles::createCamcorderProfile(
+ int cameraId, const char **atts, size_t natts, Vector<int>& cameraIds)
{
- CHECK(!strcmp("quality", atts[0]) &&
+ CHECK(natts >= 6 &&
+ !strcmp("quality", atts[0]) &&
!strcmp("fileFormat", atts[2]) &&
!strcmp("duration", atts[4]));
@@ -440,9 +460,10 @@
return NULL;
}
-void MediaProfiles::addImageEncodingQualityLevel(int cameraId, const char** atts)
+void MediaProfiles::addImageEncodingQualityLevel(int cameraId, const char** atts, size_t natts)
{
- CHECK(!strcmp("quality", atts[0]));
+ CHECK(natts >= 2 &&
+ !strcmp("quality", atts[0]));
int quality = atoi(atts[1]);
ALOGV("%s: cameraId=%d, quality=%d", __func__, cameraId, quality);
ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId);
@@ -457,18 +478,19 @@
}
/*static*/ int
-MediaProfiles::getCameraId(const char** atts)
+MediaProfiles::getCameraId(const char** atts, size_t natts)
{
if (!atts[0]) return 0; // default cameraId = 0
- CHECK(!strcmp("cameraId", atts[0]));
+ CHECK(natts >= 2 &&
+ !strcmp("cameraId", atts[0]));
return atoi(atts[1]);
}
-void MediaProfiles::addStartTimeOffset(int cameraId, const char** atts)
+void MediaProfiles::addStartTimeOffset(int cameraId, const char** atts, size_t natts)
{
int offsetTimeMs = 1000;
- if (atts[2]) {
- CHECK(!strcmp("startOffsetMs", atts[2]));
+ if (natts >= 3 && atts[2]) {
+ CHECK(natts >= 4 && !strcmp("startOffsetMs", atts[2]));
offsetTimeMs = atoi(atts[3]);
}
@@ -479,48 +501,58 @@
/*static*/ void
MediaProfiles::startElementHandler(void *userData, const char *name, const char **atts)
{
- MediaProfiles *profiles = (MediaProfiles *) userData;
+ // determine number of attributes
+ size_t natts = 0;
+ while (atts[natts]) {
+ ++natts;
+ }
+
+ MediaProfiles *profiles = (MediaProfiles *)userData;
if (strcmp("Video", name) == 0) {
- createVideoCodec(atts, profiles);
+ createVideoCodec(atts, natts, profiles);
} else if (strcmp("Audio", name) == 0) {
- createAudioCodec(atts, profiles);
+ createAudioCodec(atts, natts, profiles);
} else if (strcmp("VideoEncoderCap", name) == 0 &&
+ natts >= 4 &&
strcmp("true", atts[3]) == 0) {
- MediaProfiles::VideoEncoderCap* cap = createVideoEncoderCap(atts);
+ MediaProfiles::VideoEncoderCap* cap = createVideoEncoderCap(atts, natts);
if (cap != nullptr) {
profiles->mVideoEncoders.add(cap);
}
} else if (strcmp("AudioEncoderCap", name) == 0 &&
+ natts >= 4 &&
strcmp("true", atts[3]) == 0) {
- MediaProfiles::AudioEncoderCap* cap = createAudioEncoderCap(atts);
+ MediaProfiles::AudioEncoderCap* cap = createAudioEncoderCap(atts, natts);
if (cap != nullptr) {
profiles->mAudioEncoders.add(cap);
}
} else if (strcmp("VideoDecoderCap", name) == 0 &&
+ natts >= 4 &&
strcmp("true", atts[3]) == 0) {
- MediaProfiles::VideoDecoderCap* cap = createVideoDecoderCap(atts);
+ MediaProfiles::VideoDecoderCap* cap = createVideoDecoderCap(atts, natts);
if (cap != nullptr) {
profiles->mVideoDecoders.add(cap);
}
} else if (strcmp("AudioDecoderCap", name) == 0 &&
+ natts >= 4 &&
strcmp("true", atts[3]) == 0) {
- MediaProfiles::AudioDecoderCap* cap = createAudioDecoderCap(atts);
+ MediaProfiles::AudioDecoderCap* cap = createAudioDecoderCap(atts, natts);
if (cap != nullptr) {
profiles->mAudioDecoders.add(cap);
}
} else if (strcmp("EncoderOutputFileFormat", name) == 0) {
- profiles->mEncoderOutputFileFormats.add(createEncoderOutputFileFormat(atts));
+ profiles->mEncoderOutputFileFormats.add(createEncoderOutputFileFormat(atts, natts));
} else if (strcmp("CamcorderProfiles", name) == 0) {
- profiles->mCurrentCameraId = getCameraId(atts);
- profiles->addStartTimeOffset(profiles->mCurrentCameraId, atts);
+ profiles->mCurrentCameraId = getCameraId(atts, natts);
+ profiles->addStartTimeOffset(profiles->mCurrentCameraId, atts, natts);
} else if (strcmp("EncoderProfile", name) == 0) {
MediaProfiles::CamcorderProfile* profile = createCamcorderProfile(
- profiles->mCurrentCameraId, atts, profiles->mCameraIds);
+ profiles->mCurrentCameraId, atts, natts, profiles->mCameraIds);
if (profile != nullptr) {
profiles->mCamcorderProfiles.add(profile);
}
} else if (strcmp("ImageEncoding", name) == 0) {
- profiles->addImageEncodingQualityLevel(profiles->mCurrentCameraId, atts);
+ profiles->addImageEncodingQualityLevel(profiles->mCurrentCameraId, atts, natts);
}
}
@@ -574,8 +606,20 @@
initRequiredProfileRefs(mCameraIds);
for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) {
- int product = mCamcorderProfiles[i]->mVideoCodec->mFrameWidth *
- mCamcorderProfiles[i]->mVideoCodec->mFrameHeight;
+ // ensure at least one video and audio profile is added
+ if (mCamcorderProfiles[i]->mVideoCodecs.empty()) {
+ mCamcorderProfiles[i]->mVideoCodecs.emplace_back(
+ VIDEO_ENCODER_H263, 192000 /* bitrate */,
+ 176 /* width */, 144 /* height */, 20 /* frameRate */);
+ }
+ if (mCamcorderProfiles[i]->mAudioCodecs.empty()) {
+ mCamcorderProfiles[i]->mAudioCodecs.emplace_back(
+ AUDIO_ENCODER_AMR_NB, 12200 /* bitrate */,
+ 8000 /* sampleRate */, 1 /* channels */);
+ }
+
+ int product = mCamcorderProfiles[i]->mVideoCodecs[0].mFrameWidth *
+ mCamcorderProfiles[i]->mVideoCodecs[0].mFrameHeight;
camcorder_quality quality = mCamcorderProfiles[i]->mQuality;
int cameraId = mCamcorderProfiles[i]->mCameraId;
@@ -744,34 +788,35 @@
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality)
{
- MediaProfiles::VideoCodec *videoCodec =
- new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 1000000, 176, 144, 20);
-
- AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 60;
- profile->mVideoCodec = videoCodec;
- profile->mAudioCodec = audioCodec;
+ profile->mVideoCodecs.emplace_back(
+ VIDEO_ENCODER_H263, 1000000 /* bitrate */,
+ 176 /* width */, 144 /* height */, 20 /* frameRate */);
+ profile->mAudioCodecs.emplace_back(
+ AUDIO_ENCODER_AMR_NB, 12200 /* bitrate */,
+ 8000 /* sampleRate */, 1 /* channels */);
+
return profile;
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality)
{
- MediaProfiles::VideoCodec *videoCodec =
- new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 20000000, 720, 480, 20);
-
- AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 60;
- profile->mVideoCodec = videoCodec;
- profile->mAudioCodec = audioCodec;
+ profile->mVideoCodecs.emplace_back(
+ VIDEO_ENCODER_H263, 20000000 /* bitrate */,
+ 720 /* width */, 480 /* height */, 20 /* frameRate */);
+ profile->mAudioCodecs.emplace_back(
+ AUDIO_ENCODER_AMR_NB, 12200 /* bitrate */,
+ 8000 /* sampleRate */, 1 /* channels */);
return profile;
}
@@ -798,36 +843,34 @@
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderQcifProfile(camcorder_quality quality)
{
- MediaProfiles::VideoCodec *videoCodec =
- new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 192000, 176, 144, 20);
-
- MediaProfiles::AudioCodec *audioCodec =
- new MediaProfiles::AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
-
- MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
+ CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 30;
- profile->mVideoCodec = videoCodec;
- profile->mAudioCodec = audioCodec;
+ profile->mVideoCodecs.emplace_back(
+ VIDEO_ENCODER_H263, 192000 /* bitrate */,
+ 176 /* width */, 144 /* height */, 20 /* frameRate */);
+ profile->mAudioCodecs.emplace_back(
+ AUDIO_ENCODER_AMR_NB, 12200 /* bitrate */,
+ 8000 /* sampleRate */, 1 /* channels */);
return profile;
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderCifProfile(camcorder_quality quality)
{
- MediaProfiles::VideoCodec *videoCodec =
- new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 360000, 352, 288, 20);
-
- AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 60;
- profile->mVideoCodec = videoCodec;
- profile->mAudioCodec = audioCodec;
+ profile->mVideoCodecs.emplace_back(
+ VIDEO_ENCODER_H263, 360000 /* bitrate */,
+ 352 /* width */, 288 /* height */, 20 /* frameRate */);
+ profile->mAudioCodecs.emplace_back(
+ AUDIO_ENCODER_AMR_NB, 12200 /* bitrate */,
+ 8000 /* sampleRate */, 1 /* channels */);
return profile;
}
@@ -1111,6 +1154,36 @@
return index;
}
+const MediaProfiles::CamcorderProfile *MediaProfiles::getCamcorderProfile(
+ int cameraId, camcorder_quality quality) const {
+ int index = getCamcorderProfileIndex(cameraId, quality);
+ if (index == -1) {
+ ALOGE("The given camcorder profile camera %d quality %d is not found",
+ cameraId, quality);
+ return nullptr;
+ }
+
+ return mCamcorderProfiles[index];
+}
+
+std::vector<const MediaProfiles::AudioCodec *>
+MediaProfiles::CamcorderProfile::getAudioCodecs() const {
+ std::vector<const MediaProfiles::AudioCodec *> res;
+ for (const MediaProfiles::AudioCodec &ac : mAudioCodecs) {
+ res.push_back(&ac);
+ }
+ return res;
+}
+
+std::vector<const MediaProfiles::VideoCodec *>
+MediaProfiles::CamcorderProfile::getVideoCodecs() const {
+ std::vector<const MediaProfiles::VideoCodec *> res;
+ for (const MediaProfiles::VideoCodec &vc : mVideoCodecs) {
+ res.push_back(&vc);
+ }
+ return res;
+}
+
int MediaProfiles::getCamcorderProfileParamByName(const char *name,
int cameraId,
camcorder_quality quality) const
@@ -1127,15 +1200,15 @@
if (!strcmp("duration", name)) return mCamcorderProfiles[index]->mDuration;
if (!strcmp("file.format", name)) return mCamcorderProfiles[index]->mFileFormat;
- if (!strcmp("vid.codec", name)) return mCamcorderProfiles[index]->mVideoCodec->mCodec;
- if (!strcmp("vid.width", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameWidth;
- if (!strcmp("vid.height", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameHeight;
- if (!strcmp("vid.bps", name)) return mCamcorderProfiles[index]->mVideoCodec->mBitRate;
- if (!strcmp("vid.fps", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameRate;
- if (!strcmp("aud.codec", name)) return mCamcorderProfiles[index]->mAudioCodec->mCodec;
- if (!strcmp("aud.bps", name)) return mCamcorderProfiles[index]->mAudioCodec->mBitRate;
- if (!strcmp("aud.ch", name)) return mCamcorderProfiles[index]->mAudioCodec->mChannels;
- if (!strcmp("aud.hz", name)) return mCamcorderProfiles[index]->mAudioCodec->mSampleRate;
+ if (!strcmp("vid.codec", name)) return mCamcorderProfiles[index]->mVideoCodecs[0].mCodec;
+ if (!strcmp("vid.width", name)) return mCamcorderProfiles[index]->mVideoCodecs[0].mFrameWidth;
+ if (!strcmp("vid.height", name)) return mCamcorderProfiles[index]->mVideoCodecs[0].mFrameHeight;
+ if (!strcmp("vid.bps", name)) return mCamcorderProfiles[index]->mVideoCodecs[0].mBitRate;
+ if (!strcmp("vid.fps", name)) return mCamcorderProfiles[index]->mVideoCodecs[0].mFrameRate;
+ if (!strcmp("aud.codec", name)) return mCamcorderProfiles[index]->mAudioCodecs[0].mCodec;
+ if (!strcmp("aud.bps", name)) return mCamcorderProfiles[index]->mAudioCodecs[0].mBitRate;
+ if (!strcmp("aud.ch", name)) return mCamcorderProfiles[index]->mAudioCodecs[0].mChannels;
+ if (!strcmp("aud.hz", name)) return mCamcorderProfiles[index]->mAudioCodecs[0].mSampleRate;
ALOGE("The given camcorder profile param id %d name %s is not found", cameraId, name);
return -1;
diff --git a/media/libmedia/include/media/MediaProfiles.h b/media/libmedia/include/media/MediaProfiles.h
index 4cc5b95..3f4fd19 100644
--- a/media/libmedia/include/media/MediaProfiles.h
+++ b/media/libmedia/include/media/MediaProfiles.h
@@ -21,6 +21,8 @@
#include <utils/threads.h>
#include <media/mediarecorder.h>
+#include <vector>
+
namespace android {
enum camcorder_quality {
@@ -98,6 +100,193 @@
static MediaProfiles* getInstance();
/**
+ * Configuration for a video encoder.
+ */
+ struct VideoCodec {
+ public:
+ /**
+ * Constructs a video encoder configuration.
+ *
+ * @param codec codec type
+ * @param bitrate bitrate in bps
+ * @param frameWidth frame width in pixels
+ * @param frameHeight frame height in pixels
+ * @param frameRate frame rate in fps
+ * @param profile codec profile (for MediaCodec) or -1 for none
+ */
+ VideoCodec(video_encoder codec, int bitrate, int frameWidth, int frameHeight, int frameRate,
+ int profile = -1)
+ : mCodec(codec),
+ mBitRate(bitrate),
+ mFrameWidth(frameWidth),
+ mFrameHeight(frameHeight),
+ mFrameRate(frameRate),
+ mProfile(profile) {
+ }
+
+ VideoCodec(const VideoCodec&) = default;
+
+ ~VideoCodec() {}
+
+ /** Returns the codec type. */
+ video_encoder getCodec() const {
+ return mCodec;
+ }
+
+ /** Returns the bitrate in bps. */
+ int getBitrate() const {
+ return mBitRate;
+ }
+
+ /** Returns the frame width in pixels. */
+ int getFrameWidth() const {
+ return mFrameWidth;
+ }
+
+ /** Returns the frame height in pixels. */
+ int getFrameHeight() const {
+ return mFrameHeight;
+ }
+
+ /** Returns the frame rate in fps. */
+ int getFrameRate() const {
+ return mFrameRate;
+ }
+
+ /** Returns the codec profile (or -1 for no profile). */
+ int getProfile() const {
+ return mProfile;
+ }
+
+ private:
+ video_encoder mCodec;
+ int mBitRate;
+ int mFrameWidth;
+ int mFrameHeight;
+ int mFrameRate;
+ int mProfile;
+ friend class MediaProfiles;
+ };
+
+ /**
+ * Configuration for an audio encoder.
+ */
+ struct AudioCodec {
+ public:
+ /**
+ * Constructs an audio encoder configuration.
+ *
+ * @param codec codec type
+ * @param bitrate bitrate in bps
+ * @param sampleRate sample rate in Hz
+ * @param channels number of channels
+ * @param profile codec profile (for MediaCodec) or -1 for none
+ */
+ AudioCodec(audio_encoder codec, int bitrate, int sampleRate, int channels, int profile = -1)
+ : mCodec(codec),
+ mBitRate(bitrate),
+ mSampleRate(sampleRate),
+ mChannels(channels),
+ mProfile(profile) {
+ }
+
+ AudioCodec(const AudioCodec&) = default;
+
+ ~AudioCodec() {}
+
+ /** Returns the codec type. */
+ audio_encoder getCodec() const {
+ return mCodec;
+ }
+
+ /** Returns the bitrate in bps. */
+ int getBitrate() const {
+ return mBitRate;
+ }
+
+ /** Returns the sample rate in Hz. */
+ int getSampleRate() const {
+ return mSampleRate;
+ }
+
+ /** Returns the number of channels. */
+ int getChannels() const {
+ return mChannels;
+ }
+
+ /** Returns the codec profile (or -1 for no profile). */
+ int getProfile() const {
+ return mProfile;
+ }
+
+ private:
+ audio_encoder mCodec;
+ int mBitRate;
+ int mSampleRate;
+ int mChannels;
+ int mProfile;
+ friend class MediaProfiles;
+ };
+
+ /**
+ * Configuration for a camcorder profile/encoder profiles object.
+ */
+ struct CamcorderProfile {
+ /**
+ * Returns on ordered list of the video codec configurations in
+ * decreasing preference. The returned object is only valid
+ * during the lifetime of this object.
+ */
+ std::vector<const VideoCodec *> getVideoCodecs() const;
+
+ /**
+ * Returns on ordered list of the audio codec configurations in
+ * decreasing preference. The returned object is only valid
+ * during the lifetime of this object.
+ */
+ std::vector<const AudioCodec *> getAudioCodecs() const;
+
+ /** Returns the default duration in seconds. */
+ int getDuration() const {
+ return mDuration;
+ }
+
+ /** Returns the preferred file format. */
+ int getFileFormat() const {
+ return mFileFormat;
+ }
+
+ CamcorderProfile(const CamcorderProfile& copy) = default;
+
+ ~CamcorderProfile() = default;
+
+ private:
+ /**
+ * Constructs an empty object with no audio/video profiles.
+ */
+ CamcorderProfile()
+ : mCameraId(0),
+ mFileFormat(OUTPUT_FORMAT_THREE_GPP),
+ mQuality(CAMCORDER_QUALITY_HIGH),
+ mDuration(0) {}
+
+ int mCameraId;
+ output_format mFileFormat;
+ camcorder_quality mQuality;
+ int mDuration;
+ std::vector<VideoCodec> mVideoCodecs;
+ std::vector<AudioCodec> mAudioCodecs;
+ friend class MediaProfiles;
+ };
+
+ /**
+ * Returns the CamcorderProfile object for the given camera at
+ * the given quality level, or null if it does not exist.
+ */
+ const CamcorderProfile *getCamcorderProfile(
+ int cameraId, camcorder_quality quality) const;
+
+ /**
* Returns the value for the given param name for the given camera at
* the given quality level, or -1 if error.
*
@@ -200,84 +389,6 @@
MediaProfiles() {} // Dummy default constructor
~MediaProfiles(); // Don't delete me
- struct VideoCodec {
- VideoCodec(video_encoder codec, int bitRate, int frameWidth, int frameHeight, int frameRate)
- : mCodec(codec),
- mBitRate(bitRate),
- mFrameWidth(frameWidth),
- mFrameHeight(frameHeight),
- mFrameRate(frameRate) {}
-
- VideoCodec(const VideoCodec& copy) {
- mCodec = copy.mCodec;
- mBitRate = copy.mBitRate;
- mFrameWidth = copy.mFrameWidth;
- mFrameHeight = copy.mFrameHeight;
- mFrameRate = copy.mFrameRate;
- }
-
- ~VideoCodec() {}
-
- video_encoder mCodec;
- int mBitRate;
- int mFrameWidth;
- int mFrameHeight;
- int mFrameRate;
- };
-
- struct AudioCodec {
- AudioCodec(audio_encoder codec, int bitRate, int sampleRate, int channels)
- : mCodec(codec),
- mBitRate(bitRate),
- mSampleRate(sampleRate),
- mChannels(channels) {}
-
- AudioCodec(const AudioCodec& copy) {
- mCodec = copy.mCodec;
- mBitRate = copy.mBitRate;
- mSampleRate = copy.mSampleRate;
- mChannels = copy.mChannels;
- }
-
- ~AudioCodec() {}
-
- audio_encoder mCodec;
- int mBitRate;
- int mSampleRate;
- int mChannels;
- };
-
- struct CamcorderProfile {
- CamcorderProfile()
- : mCameraId(0),
- mFileFormat(OUTPUT_FORMAT_THREE_GPP),
- mQuality(CAMCORDER_QUALITY_HIGH),
- mDuration(0),
- mVideoCodec(0),
- mAudioCodec(0) {}
-
- CamcorderProfile(const CamcorderProfile& copy) {
- mCameraId = copy.mCameraId;
- mFileFormat = copy.mFileFormat;
- mQuality = copy.mQuality;
- mDuration = copy.mDuration;
- mVideoCodec = new VideoCodec(*copy.mVideoCodec);
- mAudioCodec = new AudioCodec(*copy.mAudioCodec);
- }
-
- ~CamcorderProfile() {
- delete mVideoCodec;
- delete mAudioCodec;
- }
-
- int mCameraId;
- output_format mFileFormat;
- camcorder_quality mQuality;
- int mDuration;
- VideoCodec *mVideoCodec;
- AudioCodec *mAudioCodec;
- };
-
struct VideoEncoderCap {
// Ugly constructor
VideoEncoderCap(video_encoder codec,
@@ -362,23 +473,23 @@
// If the xml configuration file does exist, use the settings
// from the xml
static MediaProfiles* createInstanceFromXmlFile(const char *xml);
- static output_format createEncoderOutputFileFormat(const char **atts);
- static VideoCodec* createVideoCodec(const char **atts, MediaProfiles *profiles);
- static AudioCodec* createAudioCodec(const char **atts, MediaProfiles *profiles);
- static AudioDecoderCap* createAudioDecoderCap(const char **atts);
- static VideoDecoderCap* createVideoDecoderCap(const char **atts);
- static VideoEncoderCap* createVideoEncoderCap(const char **atts);
- static AudioEncoderCap* createAudioEncoderCap(const char **atts);
+ static output_format createEncoderOutputFileFormat(const char **atts, size_t natts);
+ static void createVideoCodec(const char **atts, size_t natts, MediaProfiles *profiles);
+ static void createAudioCodec(const char **atts, size_t natts, MediaProfiles *profiles);
+ static AudioDecoderCap* createAudioDecoderCap(const char **atts, size_t natts);
+ static VideoDecoderCap* createVideoDecoderCap(const char **atts, size_t natts);
+ static VideoEncoderCap* createVideoEncoderCap(const char **atts, size_t natts);
+ static AudioEncoderCap* createAudioEncoderCap(const char **atts, size_t natts);
static CamcorderProfile* createCamcorderProfile(
- int cameraId, const char **atts, Vector<int>& cameraIds);
+ int cameraId, const char **atts, size_t natts, Vector<int>& cameraIds);
- static int getCameraId(const char **atts);
+ static int getCameraId(const char **atts, size_t natts);
- void addStartTimeOffset(int cameraId, const char **atts);
+ void addStartTimeOffset(int cameraId, const char **atts, size_t natts);
ImageEncodingQualityLevels* findImageEncodingQualityLevels(int cameraId) const;
- void addImageEncodingQualityLevel(int cameraId, const char** atts);
+ void addImageEncodingQualityLevel(int cameraId, const char** atts, size_t natts);
// Customized element tag handler for parsing the xml configuration file.
static void startElementHandler(void *userData, const char *name, const char **atts);
diff --git a/media/libstagefright/MediaCodec.cpp b/media/libstagefright/MediaCodec.cpp
index 8e721d4..a35932a 100644
--- a/media/libstagefright/MediaCodec.cpp
+++ b/media/libstagefright/MediaCodec.cpp
@@ -1333,16 +1333,12 @@
// the reclaimResource call doesn't consider the requester's buffer size for now.
resources.push_back(MediaResource::GraphicMemoryResource(1));
for (int i = 0; i <= kMaxRetry; ++i) {
- if (i > 0) {
- // Don't try to reclaim resource for the first time.
- if (!mResourceManagerProxy->reclaimResource(resources)) {
- break;
- }
- }
-
sp<AMessage> response;
err = PostAndAwaitResponse(msg, &response);
if (err != OK && err != INVALID_OPERATION) {
+ if (isResourceError(err) && !mResourceManagerProxy->reclaimResource(resources)) {
+ break;
+ }
// MediaCodec now set state to UNINITIALIZED upon any fatal error.
// To maintain backward-compatibility, do a reset() to put codec
// back into INITIALIZED state.
@@ -2247,6 +2243,11 @@
case STOPPING:
{
if (mFlags & kFlagSawMediaServerDie) {
+ bool postPendingReplies = true;
+ if (mState == RELEASING && !mReplyID) {
+ ALOGD("Releasing asynchronously, so nothing to reply here.");
+ postPendingReplies = false;
+ }
// MediaServer died, there definitely won't
// be a shutdown complete notification after
// all.
@@ -2258,7 +2259,9 @@
if (mState == RELEASING) {
mComponentName.clear();
}
- postPendingRepliesAndDeferredMessages(origin + ":dead");
+ if (postPendingReplies) {
+ postPendingRepliesAndDeferredMessages(origin + ":dead");
+ }
sendErrorResponse = false;
} else if (!mReplyID) {
sendErrorResponse = false;
diff --git a/media/libstagefright/Utils.cpp b/media/libstagefright/Utils.cpp
index 1c4f5ac..bd9a694 100644
--- a/media/libstagefright/Utils.cpp
+++ b/media/libstagefright/Utils.cpp
@@ -47,6 +47,16 @@
#include <media/AudioParameter.h>
#include <system/audio.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:
+#define AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION \
+ "mpegh-profile-level-indication"
+#define AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT \
+ "mpegh-reference-channel-layout"
+#define AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS \
+ "mpegh-compatible-sets"
+
namespace android {
static status_t copyNALUToABuffer(sp<ABuffer> *buffer, const uint8_t *ptr, size_t length) {
@@ -1078,6 +1088,25 @@
msg->setInt32("is-adts", isADTS);
}
+ int32_t mpeghProfileLevelIndication;
+ if (meta->findInt32(kKeyMpeghProfileLevelIndication, &mpeghProfileLevelIndication)) {
+ msg->setInt32(AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION,
+ mpeghProfileLevelIndication);
+ }
+ int32_t mpeghReferenceChannelLayout;
+ if (meta->findInt32(kKeyMpeghReferenceChannelLayout, &mpeghReferenceChannelLayout)) {
+ msg->setInt32(AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT,
+ mpeghReferenceChannelLayout);
+ }
+ if (meta->findData(kKeyMpeghCompatibleSets, &type, &data, &size)) {
+ sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
+ if (buffer.get() == NULL || buffer->base() == NULL) {
+ return NO_MEMORY;
+ }
+ msg->setBuffer(AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS, buffer);
+ memcpy(buffer->data(), data, size);
+ }
+
int32_t aacProfile = -1;
if (meta->findInt32(kKeyAACAOT, &aacProfile)) {
msg->setInt32("aac-profile", aacProfile);
@@ -1837,6 +1866,23 @@
meta->setInt32(kKeyIsADTS, isADTS);
}
+ int32_t mpeghProfileLevelIndication = -1;
+ if (msg->findInt32(AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION,
+ &mpeghProfileLevelIndication)) {
+ meta->setInt32(kKeyMpeghProfileLevelIndication, mpeghProfileLevelIndication);
+ }
+ int32_t mpeghReferenceChannelLayout = -1;
+ if (msg->findInt32(AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT,
+ &mpeghReferenceChannelLayout)) {
+ meta->setInt32(kKeyMpeghReferenceChannelLayout, mpeghReferenceChannelLayout);
+ }
+ sp<ABuffer> mpeghCompatibleSets;
+ if (msg->findBuffer(AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS,
+ &mpeghCompatibleSets)) {
+ meta->setData(kKeyMpeghCompatibleSets, kTypeHCOS,
+ mpeghCompatibleSets->data(), mpeghCompatibleSets->size());
+ }
+
int32_t aacProfile = -1;
if (msg->findInt32("aac-profile", &aacProfile)) {
meta->setInt32(kKeyAACAOT, aacProfile);
diff --git a/media/libstagefright/foundation/Android.bp b/media/libstagefright/foundation/Android.bp
index 407f609..db87a33 100644
--- a/media/libstagefright/foundation/Android.bp
+++ b/media/libstagefright/foundation/Android.bp
@@ -45,6 +45,9 @@
],
header_libs: [
+ // this is only needed for the vendor variant that removes libbinder, but vendor
+ // target below does not allow adding header_libs.
+ "libbinder_headers",
"libstagefright_foundation_headers",
"media_ndk_headers",
"media_plugin_headers",
@@ -98,6 +101,7 @@
target: {
vendor: {
+ // TODO: add libbinder_headers here instead of above when it becomes supported
exclude_shared_libs: [
"libbinder",
],
diff --git a/media/libstagefright/foundation/MediaDefs.cpp b/media/libstagefright/foundation/MediaDefs.cpp
index a08fed1..1493406 100644
--- a/media/libstagefright/foundation/MediaDefs.cpp
+++ b/media/libstagefright/foundation/MediaDefs.cpp
@@ -57,6 +57,8 @@
const char *MEDIA_MIMETYPE_AUDIO_EAC3 = "audio/eac3";
const char *MEDIA_MIMETYPE_AUDIO_EAC3_JOC = "audio/eac3-joc";
const char *MEDIA_MIMETYPE_AUDIO_AC4 = "audio/ac4";
+const char *MEDIA_MIMETYPE_AUDIO_MPEGH_MHA1 = "audio/mha1";
+const char *MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1 = "audio/mhm1";
const char *MEDIA_MIMETYPE_AUDIO_SCRAMBLED = "audio/scrambled";
const char *MEDIA_MIMETYPE_AUDIO_ALAC = "audio/alac";
const char *MEDIA_MIMETYPE_AUDIO_WMA = "audio/x-ms-wma";
diff --git a/media/libstagefright/foundation/include/media/stagefright/foundation/MediaDefs.h b/media/libstagefright/foundation/include/media/stagefright/foundation/MediaDefs.h
index 1f9e636..97458c3 100644
--- a/media/libstagefright/foundation/include/media/stagefright/foundation/MediaDefs.h
+++ b/media/libstagefright/foundation/include/media/stagefright/foundation/MediaDefs.h
@@ -59,6 +59,8 @@
extern const char *MEDIA_MIMETYPE_AUDIO_EAC3;
extern const char *MEDIA_MIMETYPE_AUDIO_EAC3_JOC;
extern const char *MEDIA_MIMETYPE_AUDIO_AC4;
+extern const char *MEDIA_MIMETYPE_AUDIO_MPEGH_MHA1;
+extern const char *MEDIA_MIMETYPE_AUDIO_MPEGH_MHM1;
extern const char *MEDIA_MIMETYPE_AUDIO_SCRAMBLED;
extern const char *MEDIA_MIMETYPE_AUDIO_ALAC;
extern const char *MEDIA_MIMETYPE_AUDIO_WMA;
@@ -89,6 +91,8 @@
kAudioEncodingPcm16bit = 2,
kAudioEncodingPcm8bit = 3,
kAudioEncodingPcmFloat = 4,
+ kAudioEncodingPcm24bitPacked = 21,
+ kAudioEncodingPcm32bit = 22,
};
} // namespace android
diff --git a/media/libstagefright/id3/ID3.cpp b/media/libstagefright/id3/ID3.cpp
index e97f6eb..1f3cad9 100644
--- a/media/libstagefright/id3/ID3.cpp
+++ b/media/libstagefright/id3/ID3.cpp
@@ -234,10 +234,20 @@
}
// first handle global unsynchronization
+ bool hasGlobalUnsync = false;
if (header.flags & 0x80) {
- ALOGV("removing unsynchronization");
+ ALOGV("has Global unsynchronization");
+ hasGlobalUnsync = true;
+ // we have to wait on applying global unsynchronization to V2.4 frames
+ // if we apply it now, the length information within any V2.4 frames goes bad
+ // Removing unsynchronization shrinks the buffer, but lengths (stored in safesync
+ // format) stored within the frame reflect "pre-shrinking" totals.
- removeUnsynchronization();
+ // we can (and should) apply the non-2.4 synch now.
+ if ( header.version_major != 4) {
+ ALOGV("Apply global unsync for non V2.4 frames");
+ removeUnsynchronization();
+ }
}
// handle extended header, if present
@@ -327,9 +337,10 @@
// Handle any v2.4 per-frame unsynchronization
// The id3 spec isn't clear about what should happen if the global
// unsynchronization flag is combined with per-frame unsynchronization,
- // or whether that's even allowed, so this code assumes id3 writing
- // tools do the right thing and not apply double-unsynchronization,
- // but will honor the flags if they are set.
+ // or whether that's even allowed. We choose a "no more than 1 unsynchronization"
+ // semantic; the V2_4 unsynchronizer gets a copy of the global flag so it can handle
+ // this possible ambiquity.
+ //
if (header.version_major == 4) {
void *copy = malloc(size);
if (copy == NULL) {
@@ -341,12 +352,12 @@
memcpy(copy, mData, size);
- bool success = removeUnsynchronizationV2_4(false /* iTunesHack */);
+ bool success = removeUnsynchronizationV2_4(false /* iTunesHack */, hasGlobalUnsync);
if (!success) {
memcpy(mData, copy, size);
mSize = size;
- success = removeUnsynchronizationV2_4(true /* iTunesHack */);
+ success = removeUnsynchronizationV2_4(true /* iTunesHack */, hasGlobalUnsync);
if (success) {
ALOGV("Had to apply the iTunes hack to parse this ID3 tag");
@@ -365,7 +376,6 @@
}
-
if (header.version_major == 2) {
mVersion = ID3_V2_2;
} else if (header.version_major == 3) {
@@ -407,7 +417,7 @@
}
}
-bool ID3::removeUnsynchronizationV2_4(bool iTunesHack) {
+bool ID3::removeUnsynchronizationV2_4(bool iTunesHack, bool hasGlobalUnsync) {
size_t oldSize = mSize;
size_t offset = mFirstFrameOffset;
@@ -443,7 +453,11 @@
flags &= ~1;
}
- if ((flags & 2) && (dataSize >= 2)) {
+ ALOGV("hasglobal %d flags&2 %d", hasGlobalUnsync, flags&2);
+ if (hasGlobalUnsync && !(flags & 2)) {
+ ALOGV("OOPS: global unsync set, but per-frame NOT set; removing unsync anyway");
+ }
+ if ((hasGlobalUnsync || (flags & 2)) && (dataSize >= 2)) {
// This frame has "unsynchronization", so we have to replace occurrences
// of 0xff 0x00 with just 0xff in order to get the real data.
@@ -470,7 +484,6 @@
ALOGE("b/34618607 (%zu %zu %zu %zu)", readOffset, writeOffset, oldSize, mSize);
android_errorWriteLog(0x534e4554, "34618607");
}
-
}
flags &= ~2;
if (flags != prevFlags || iTunesHack) {
diff --git a/media/libstagefright/id3/test/AndroidTest.xml b/media/libstagefright/id3/test/AndroidTest.xml
index d6ea470..50f9253 100644
--- a/media/libstagefright/id3/test/AndroidTest.xml
+++ b/media/libstagefright/id3/test/AndroidTest.xml
@@ -19,7 +19,7 @@
<option name="cleanup" value="true" />
<option name="push" value="ID3Test->/data/local/tmp/ID3Test" />
<option name="push-file"
- key="https://storage.googleapis.com/android_media/frameworks/av/media/libstagefright/id3/test/ID3Test-1.1.zip?unzip=true"
+ key="https://storage.googleapis.com/android_media/frameworks/av/media/libstagefright/id3/test/ID3Test-1.2.zip?unzip=true"
value="/data/local/tmp/ID3TestRes/" />
</target_preparer>
diff --git a/media/libstagefright/id3/test/ID3Test.cpp b/media/libstagefright/id3/test/ID3Test.cpp
index 8db83cb..a0a84ec 100644
--- a/media/libstagefright/id3/test/ID3Test.cpp
+++ b/media/libstagefright/id3/test/ID3Test.cpp
@@ -29,6 +29,7 @@
#include "ID3TestEnvironment.h"
+
using namespace android;
static ID3TestEnvironment *gEnv = nullptr;
@@ -41,6 +42,7 @@
TEST_P(ID3tagTest, TagTest) {
string path = gEnv->getRes() + GetParam();
+ ALOGV(" ===== TagTest for %s", path.c_str());
sp<FileSource> file = new FileSource(path.c_str());
ASSERT_EQ(file->initCheck(), (status_t)OK) << "File initialization failed! \n";
DataSourceHelper helper(file->wrap());
@@ -60,6 +62,7 @@
TEST_P(ID3versionTest, VersionTest) {
int versionNumber = GetParam().second;
string path = gEnv->getRes() + GetParam().first;
+ ALOGV(" ===== VersionTest for %s", path.c_str());
sp<android::FileSource> file = new FileSource(path.c_str());
ASSERT_EQ(file->initCheck(), (status_t)OK) << "File initialization failed! \n";
@@ -73,6 +76,7 @@
TEST_P(ID3textTagTest, TextTagTest) {
int numTextFrames = GetParam().second;
string path = gEnv->getRes() + GetParam().first;
+ ALOGV(" ===== TextTagTest for %s", path.c_str());
sp<android::FileSource> file = new FileSource(path.c_str());
ASSERT_EQ(file->initCheck(), (status_t)OK) << "File initialization failed! \n";
@@ -117,6 +121,7 @@
TEST_P(ID3albumArtTest, AlbumArtTest) {
bool albumArtPresent = GetParam().second;
string path = gEnv->getRes() + GetParam().first;
+ ALOGV(" ===== AlbumArt for %s", path.c_str());
sp<android::FileSource> file = new FileSource(path.c_str());
ASSERT_EQ(file->initCheck(), (status_t)OK) << "File initialization failed! \n";
@@ -135,6 +140,7 @@
} else {
ASSERT_EQ(data, nullptr) << "Found album art when expected none!";
}
+
#if (LOG_NDEBUG == 0)
hexdump(data, dataSize > 128 ? 128 : dataSize);
#endif
@@ -175,6 +181,17 @@
<< " album arts! \n";
}
+// we have a test asset with large album art -- which is larger than our 3M cap
+// that we inserted intentionally in the ID3 parsing routine.
+// Rather than have it fail all the time, we have wrapped it under an #ifdef
+// so that the tests will pass.
+#undef TEST_LARGE
+
+
+// it appears that bbb_2sec_v24_unsynchronizedAllFrames.mp3 is not a legal file,
+// so we've commented it out of the list of files to be tested
+//
+
INSTANTIATE_TEST_SUITE_P(id3TestAll, ID3tagTest,
::testing::Values("bbb_1sec_v23.mp3",
"bbb_1sec_1_image.mp3",
@@ -186,7 +203,7 @@
"bbb_1sec_v23_3tags.mp3",
"bbb_1sec_v1_5tags.mp3",
"bbb_2sec_v24_unsynchronizedOneFrame.mp3",
- "bbb_2sec_v24_unsynchronizedAllFrames.mp3"));
+ "idv24_unsynchronized.mp3"));
INSTANTIATE_TEST_SUITE_P(
id3TestAll, ID3versionTest,
@@ -196,12 +213,14 @@
make_pair("bbb_2sec_v24.mp3", ID3::ID3_V2_4),
make_pair("bbb_2sec_1_image.mp3", ID3::ID3_V2_4),
make_pair("bbb_2sec_2_image.mp3", ID3::ID3_V2_4),
- make_pair("bbb_2sec_largeSize.mp3", ID3::ID3_V2_4),
+#if TEST_LARGE
+ make_pair("bbb_2sec_largeSize.mp3", ID3::ID3_V2_4), // FAIL
+#endif
make_pair("bbb_1sec_v23_3tags.mp3", ID3::ID3_V2_3),
make_pair("bbb_1sec_v1_5tags.mp3", ID3::ID3_V1_1),
make_pair("bbb_1sec_v1_3tags.mp3", ID3::ID3_V1_1),
make_pair("bbb_2sec_v24_unsynchronizedOneFrame.mp3", ID3::ID3_V2_4),
- make_pair("bbb_2sec_v24_unsynchronizedAllFrames.mp3", ID3::ID3_V2_4)));
+ make_pair("idv24_unsynchronized.mp3", ID3::ID3_V2_4)));
INSTANTIATE_TEST_SUITE_P(
id3TestAll, ID3textTagTest,
@@ -212,12 +231,14 @@
make_pair("bbb_2sec_v24.mp3", 1),
make_pair("bbb_2sec_1_image.mp3", 1),
make_pair("bbb_2sec_2_image.mp3", 1),
- make_pair("bbb_2sec_largeSize.mp3", 1),
+#if TEST_LARGE
+ make_pair("bbb_2sec_largeSize.mp3", 1), // FAIL
+#endif
make_pair("bbb_1sec_v23_3tags.mp3", 3),
make_pair("bbb_1sec_v1_5tags.mp3", 5),
make_pair("bbb_1sec_v1_3tags.mp3", 3),
- make_pair("bbb_2sec_v24_unsynchronizedOneFrame.mp3", 3),
- make_pair("bbb_2sec_v24_unsynchronizedAllFrames.mp3", 3)));
+ make_pair("bbb_2sec_v24_unsynchronizedOneFrame.mp3", 3)
+ ));
INSTANTIATE_TEST_SUITE_P(id3TestAll, ID3albumArtTest,
::testing::Values(make_pair("bbb_1sec_v23.mp3", false),
@@ -226,17 +247,24 @@
make_pair("bbb_2sec_v24.mp3", false),
make_pair("bbb_2sec_1_image.mp3", true),
make_pair("bbb_2sec_2_image.mp3", true),
- make_pair("bbb_2sec_largeSize.mp3", true),
- make_pair("bbb_1sec_v1_5tags.mp3", false)));
+#if TEST_LARGE
+ make_pair("bbb_2sec_largeSize.mp3", true), // FAIL
+#endif
+ make_pair("bbb_1sec_v1_5tags.mp3", false),
+ make_pair("idv24_unsynchronized.mp3", true)
+ ));
INSTANTIATE_TEST_SUITE_P(id3TestAll, ID3multiAlbumArtTest,
::testing::Values(make_pair("bbb_1sec_v23.mp3", 0),
make_pair("bbb_2sec_v24.mp3", 0),
+#if TEST_LARGE
+ make_pair("bbb_2sec_largeSize.mp3", 3), // FAIL
+#endif
make_pair("bbb_1sec_1_image.mp3", 1),
make_pair("bbb_2sec_1_image.mp3", 1),
make_pair("bbb_1sec_2_image.mp3", 2),
- make_pair("bbb_2sec_2_image.mp3", 2),
- make_pair("bbb_2sec_largeSize.mp3", 3)));
+ make_pair("bbb_2sec_2_image.mp3", 2)
+ ));
int main(int argc, char **argv) {
gEnv = new ID3TestEnvironment();
diff --git a/media/libstagefright/include/ID3.h b/media/libstagefright/include/ID3.h
index 0be5896..bd0d27c 100644
--- a/media/libstagefright/include/ID3.h
+++ b/media/libstagefright/include/ID3.h
@@ -91,7 +91,7 @@
bool parseV1(DataSourceBase *source);
bool parseV2(DataSourceBase *source, off64_t offset);
void removeUnsynchronization();
- bool removeUnsynchronizationV2_4(bool iTunesHack);
+ bool removeUnsynchronizationV2_4(bool iTunesHack, bool hasGlobalUnsync);
static bool ParseSyncsafeInteger(const uint8_t encoded[4], size_t *x);
diff --git a/media/libstagefright/include/media/stagefright/MetaDataBase.h b/media/libstagefright/include/media/stagefright/MetaDataBase.h
index 6f21a80..aae5ef9 100644
--- a/media/libstagefright/include/media/stagefright/MetaDataBase.h
+++ b/media/libstagefright/include/media/stagefright/MetaDataBase.h
@@ -152,6 +152,10 @@
kKeyIsADTS = 'adts', // bool (int32_t)
kKeyAACAOT = 'aaot', // int32_t
+ kKeyMpeghProfileLevelIndication = 'hpli', // int32_t
+ kKeyMpeghReferenceChannelLayout = 'hrcl', // int32_t
+ kKeyMpeghCompatibleSets = 'hcos', // raw data
+
// If a MediaBuffer's data represents (at least partially) encrypted
// data, the following fields aid in decryption.
// The data can be thought of as pairs of plain and encrypted data
@@ -265,6 +269,7 @@
kTypeAV1C = 'av1c',
kTypeDVCC = 'dvcc',
kTypeD263 = 'd263',
+ kTypeHCOS = 'hcos',
};
enum {
diff --git a/media/libstagefright/tests/mediacodec/MediaCodecTest.cpp b/media/libstagefright/tests/mediacodec/MediaCodecTest.cpp
index 06e36ad..ac1e9b1 100644
--- a/media/libstagefright/tests/mediacodec/MediaCodecTest.cpp
+++ b/media/libstagefright/tests/mediacodec/MediaCodecTest.cpp
@@ -349,3 +349,47 @@
codec->release();
looper->stop();
}
+
+TEST(MediaCodecTest, DeadWhileAsyncReleasing) {
+ // Test scenario:
+ //
+ // 1) Client thread calls release(); MediaCodec looper thread calls
+ // initiateShutdown(); shutdown is being handled at the component thread.
+ // 2) Codec service died during the shutdown operation.
+ // 3) MediaCodec looper thread handles the death.
+
+ static const AString kCodecName{"test.codec"};
+ static const AString kCodecOwner{"nobody"};
+ static const AString kMediaType{"video/x-test"};
+
+ sp<MockCodec> mockCodec;
+ std::function<sp<CodecBase>(const AString &name, const char *owner)> getCodecBase =
+ [&mockCodec](const AString &, const char *) {
+ mockCodec = new MockCodec([](const std::shared_ptr<MockBufferChannel> &) {
+ // No mock setup, as we don't expect any buffer operations
+ // in this scenario.
+ });
+ ON_CALL(*mockCodec, initiateAllocateComponent(_))
+ .WillByDefault([mockCodec](const sp<AMessage> &) {
+ mockCodec->callback()->onComponentAllocated(kCodecName.c_str());
+ });
+ ON_CALL(*mockCodec, initiateShutdown(_))
+ .WillByDefault([mockCodec](bool) {
+ // 2)
+ mockCodec->callback()->onError(DEAD_OBJECT, ACTION_CODE_FATAL);
+ // Codec service has died, no callback.
+ });
+ return mockCodec;
+ };
+
+ sp<ALooper> looper{new ALooper};
+ sp<MediaCodec> codec = SetupMediaCodec(
+ kCodecOwner, kCodecName, kMediaType, looper, getCodecBase);
+ ASSERT_NE(nullptr, codec) << "Codec must not be null";
+ ASSERT_NE(nullptr, mockCodec) << "MockCodec must not be null";
+
+ codec->releaseAsync(new AMessage);
+ // sleep here so that the looper thread can handle the error
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ looper->stop();
+}
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index e9ea386..05f6efa 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -85,7 +85,9 @@
cc_library_shared {
name: "libmediandk",
- llndk_stubs: "libmediandk.llndk",
+ llndk: {
+ symbol_file: "libmediandk.map.txt",
+ },
srcs: [
"NdkJavaVMHelper.cpp",
@@ -165,14 +167,6 @@
},
}
-llndk_library {
- name: "libmediandk.llndk",
- symbol_file: "libmediandk.map.txt",
- export_include_dirs: [
- "include",
- ],
-}
-
cc_library {
name: "libmediandk_utils",
diff --git a/media/utils/Android.bp b/media/utils/Android.bp
index 12179db..59c2e65 100644
--- a/media/utils/Android.bp
+++ b/media/utils/Android.bp
@@ -45,6 +45,7 @@
"libbinder",
"libcutils",
"liblog",
+ "libpermission",
"libutils",
"libhidlbase",
"android.hardware.graphics.bufferqueue@1.0",
diff --git a/services/audioflinger/Android.bp b/services/audioflinger/Android.bp
index 3c9897d..ff3bfd2 100644
--- a/services/audioflinger/Android.bp
+++ b/services/audioflinger/Android.bp
@@ -69,6 +69,7 @@
"libmediautils",
"libnbaio",
"libnblog",
+ "libpermission",
"libpowermanager",
"libmediautils",
"libmemunreachable",
@@ -86,6 +87,10 @@
"libmedia_headers",
],
+ export_shared_lib_headers: [
+ "libpermission",
+ ],
+
cflags: [
"-DSTATE_QUEUE_INSTANTIATIONS=\"StateQueueInstantiations.cpp\"",
"-fvisibility=hidden",
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index 37aa13e..030c929 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -111,7 +111,8 @@
/* Connect a patch between several source and sink ports */
status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle)
+ audio_patch_handle_t *handle,
+ bool endpointPatch)
{
if (handle == NULL || patch == NULL) {
return BAD_VALUE;
@@ -174,7 +175,7 @@
}
}
- Patch newPatch{*patch};
+ Patch newPatch{*patch, endpointPatch};
audio_module_handle_t insertedModule = AUDIO_MODULE_HANDLE_NONE;
switch (patch->sources[0].type) {
@@ -396,10 +397,15 @@
}
// remove stale audio patch with same output as source if any
- for (auto& iter : mPatches) {
- if (iter.second.mAudioPatch.sources[0].ext.mix.handle == thread->id()) {
- erasePatch(iter.first);
- break;
+ // Prevent to remove endpoint patches (involved in a SwBridge)
+ // Prevent to remove AudioPatch used to route an output involved in an endpoint.
+ if (!endpointPatch) {
+ for (auto& iter : mPatches) {
+ if (iter.second.mAudioPatch.sources[0].ext.mix.handle == thread->id() &&
+ !iter.second.mIsEndpointPatch) {
+ erasePatch(iter.first);
+ break;
+ }
}
}
} break;
@@ -435,7 +441,8 @@
status_t status = panel->createAudioPatch(
PatchBuilder().addSource(mAudioPatch.sources[0]).
addSink(mRecord.thread(), { .source = AUDIO_SOURCE_MIC }).patch(),
- mRecord.handlePtr());
+ mRecord.handlePtr(),
+ true /*endpointPatch*/);
if (status != NO_ERROR) {
*mRecord.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
return status;
@@ -445,7 +452,8 @@
if (mAudioPatch.num_sinks != 0) {
status = panel->createAudioPatch(
PatchBuilder().addSource(mPlayback.thread()).addSink(mAudioPatch.sinks[0]).patch(),
- mPlayback.handlePtr());
+ mPlayback.handlePtr(),
+ true /*endpointPatch*/);
if (status != NO_ERROR) {
*mPlayback.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
return status;
diff --git a/services/audioflinger/PatchPanel.h b/services/audioflinger/PatchPanel.h
index ea38559..38f0615 100644
--- a/services/audioflinger/PatchPanel.h
+++ b/services/audioflinger/PatchPanel.h
@@ -56,7 +56,8 @@
/* Create a patch between several source and sink ports */
status_t createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle);
+ audio_patch_handle_t *handle,
+ bool endpointPatch = false);
/* Release a patch */
status_t releaseAudioPatch(audio_patch_handle_t handle);
@@ -161,7 +162,8 @@
class Patch final {
public:
- explicit Patch(const struct audio_patch &patch) : mAudioPatch(patch) {}
+ Patch(const struct audio_patch &patch, bool endpointPatch) :
+ mAudioPatch(patch), mIsEndpointPatch(endpointPatch) {}
Patch() = default;
~Patch();
Patch(const Patch& other) noexcept {
@@ -170,6 +172,7 @@
mPlayback = other.mPlayback;
mRecord = other.mRecord;
mThread = other.mThread;
+ mIsEndpointPatch = other.mIsEndpointPatch;
}
Patch(Patch&& other) noexcept { swap(other); }
Patch& operator=(Patch&& other) noexcept {
@@ -184,6 +187,7 @@
swap(mPlayback, other.mPlayback);
swap(mRecord, other.mRecord);
swap(mThread, other.mThread);
+ swap(mIsEndpointPatch, other.mIsEndpointPatch);
}
friend void swap(Patch &a, Patch &b) noexcept {
@@ -218,6 +222,7 @@
Endpoint<RecordThread, RecordThread::PatchRecord> mRecord;
wp<ThreadBase> mThread;
+ bool mIsEndpointPatch;
};
// Call with AudioFlinger mLock held
diff --git a/services/audioflinger/PlaybackTracks.h b/services/audioflinger/PlaybackTracks.h
index 472c359..9770054 100644
--- a/services/audioflinger/PlaybackTracks.h
+++ b/services/audioflinger/PlaybackTracks.h
@@ -217,6 +217,10 @@
void flushAck();
bool isResumePending();
void resumeAck();
+ // For direct or offloaded tracks ensure that the pause state is acknowledged
+ // by the playback thread in case of an immediate flush.
+ bool isPausePending() const { return mPauseHwPending; }
+ void pauseAck();
void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
uint32_t halSampleRate, const ExtendedTimestamp &timeStamp);
@@ -312,6 +316,7 @@
sp<AudioTrackServerProxy> mAudioTrackServerProxy;
bool mResumeToStopping; // track was paused in stopping state.
bool mFlushHwPending; // track requests for thread flush
+ bool mPauseHwPending = false; // direct/offload track request for thread pause
audio_output_flags_t mFlags;
// If the last track change was notified to the client with readAndClearHasChanged
std::atomic_flag mChangeNotified = ATOMIC_FLAG_INIT;
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 0c66301..1522746 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -120,12 +120,26 @@
// 50 * ~20msecs = 1 second
static const int8_t kMaxTrackRetries = 50;
static const int8_t kMaxTrackStartupRetries = 50;
+
// allow less retry attempts on direct output thread.
// direct outputs can be a scarce resource in audio hardware and should
// be released as quickly as possible.
-static const int8_t kMaxTrackRetriesDirect = 2;
-
-
+// Notes:
+// 1) The retry duration kMaxTrackRetriesDirectMs may be increased
+// in case the data write is bursty for the AudioTrack. The application
+// should endeavor to write at least once every kMaxTrackRetriesDirectMs
+// to prevent an underrun situation. If the data is bursty, then
+// the application can also throttle the data sent to be even.
+// 2) For compressed audio data, any data present in the AudioTrack buffer
+// will be sent and reset the retry count. This delivers data as
+// it arrives, with approximately kDirectMinSleepTimeUs = 10ms checking interval.
+// 3) For linear PCM or proportional PCM, we wait one period for a period's worth
+// of data to be available, then any remaining data is delivered.
+// This is required to ensure the last bit of data is delivered before underrun.
+//
+// Sleep time per cycle is kDirectMinSleepTimeUs for compressed tracks
+// or the size of the HAL period for proportional / linear PCM tracks.
+static const int32_t kMaxTrackRetriesDirectMs = 200;
// don't warn about blocked writes or record buffer overflows more often than this
static const nsecs_t kWarningThrottleNs = seconds(5);
@@ -5825,8 +5839,15 @@
sp<Track> l = mActiveTracks.getLatest();
bool last = l.get() == track;
- if (track->isPausing()) {
- track->setPaused();
+ if (track->isPausePending()) {
+ track->pauseAck();
+ // It is possible a track might have been flushed or stopped.
+ // Other operations such as flush pending might occur on the next prepare.
+ if (track->isPausing()) {
+ track->setPaused();
+ }
+ // Always perform pause, as an immediate flush will change
+ // the pause state to be no longer isPausing().
if (mHwSupportsPause && last && !mHwPaused) {
doHwPause = true;
mHwPaused = true;
@@ -5852,11 +5873,19 @@
// Allow draining the buffer in case the client
// app does not call stop() and relies on underrun to stop:
// hence the test on (track->mRetryCount > 1).
- // If retryCount<=1 then track is about to underrun and be removed.
+ // If track->mRetryCount <= 1 then track is about to be disabled, paused, removed,
+ // so we accept any nonzero amount of data delivered by the AudioTrack (which will
+ // reset the retry counter).
// Do not use a high threshold for compressed audio.
+
+ // target retry count that we will use is based on the time we wait for retries.
+ const int32_t targetRetryCount = kMaxTrackRetriesDirectMs * 1000 / mActiveSleepTimeUs;
+ // the retry threshold is when we accept any size for PCM data. This is slightly
+ // smaller than the retry count so we can push small bits of data without a glitch.
+ const int32_t retryThreshold = targetRetryCount > 2 ? targetRetryCount - 1 : 1;
uint32_t minFrames;
if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()
- && (track->mRetryCount > 1) && audio_has_proportional_frames(mFormat)) {
+ && (track->mRetryCount > retryThreshold) && audio_has_proportional_frames(mFormat)) {
minFrames = mNormalFrameCount;
} else {
minFrames = 1;
@@ -5900,7 +5929,7 @@
mPreviousTrack = track;
// reset retry count
- track->mRetryCount = kMaxTrackRetriesDirect;
+ track->mRetryCount = targetRetryCount;
mActiveTrack = t;
mixerStatus = MIXER_TRACKS_READY;
if (mHwPaused) {
@@ -5954,15 +5983,17 @@
// indicate to client process that the track was disabled because of underrun;
// it will then automatically call start() when data is available
track->disable();
- } else if (last) {
+ // only do hw pause when track is going to be removed due to BUFFER TIMEOUT.
+ // unlike mixerthread, HAL can be paused for direct output
ALOGW("pause because of UNDERRUN, framesReady = %zu,"
"minFrames = %u, mFormat = %#x",
framesReady, minFrames, mFormat);
- mixerStatus = MIXER_TRACKS_ENABLED;
- if (mHwSupportsPause && !mHwPaused && !mStandby) {
+ if (last && mHwSupportsPause && !mHwPaused && !mStandby) {
doHwPause = true;
mHwPaused = true;
}
+ } else if (last) {
+ mixerStatus = MIXER_TRACKS_ENABLED;
}
}
}
@@ -6034,16 +6065,13 @@
mSleepTimeUs = mIdleSleepTimeUs;
return;
}
- if (mSleepTimeUs == 0) {
- if (mMixerStatus == MIXER_TRACKS_ENABLED) {
- mSleepTimeUs = mActiveSleepTimeUs;
- } else {
- mSleepTimeUs = mIdleSleepTimeUs;
- }
- } else if (mBytesWritten != 0 && audio_has_proportional_frames(mFormat)) {
- memset(mSinkBuffer, 0, mFrameCount * mFrameSize);
- mSleepTimeUs = 0;
+ if (mMixerStatus == MIXER_TRACKS_ENABLED) {
+ mSleepTimeUs = mActiveSleepTimeUs;
+ } else {
+ mSleepTimeUs = mIdleSleepTimeUs;
}
+ // Note: In S or later, we do not write zeroes for
+ // linear or proportional PCM direct tracks in underrun.
}
void AudioFlinger::DirectOutputThread::threadLoop_exit()
@@ -6368,8 +6396,15 @@
continue;
}
- if (track->isPausing()) {
- track->setPaused();
+ if (track->isPausePending()) {
+ track->pauseAck();
+ // It is possible a track might have been flushed or stopped.
+ // Other operations such as flush pending might occur on the next prepare.
+ if (track->isPausing()) {
+ track->setPaused();
+ }
+ // Always perform pause if last, as an immediate flush will change
+ // the pause state to be no longer isPausing().
if (last) {
if (mHwSupportsPause && !mHwPaused) {
doHwPause = true;
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index fb43a6e..4353b3d 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -1177,6 +1177,9 @@
mState = PAUSING;
ALOGV("%s(%d): ACTIVE/RESUMING => PAUSING on thread %d",
__func__, mId, (int)mThreadIoHandle);
+ if (isOffloadedOrDirect()) {
+ mPauseHwPending = true;
+ }
playbackThread->broadcast_l();
break;
@@ -1264,6 +1267,11 @@
mFlushHwPending = false;
}
+void AudioFlinger::PlaybackThread::Track::pauseAck()
+{
+ mPauseHwPending = false;
+}
+
void AudioFlinger::PlaybackThread::Track::reset()
{
// Do not reset twice to avoid discarding data written just after a flush and before
diff --git a/services/audiopolicy/engineconfigurable/tools/buildCommonTypesStructureFile.py b/services/audiopolicy/engineconfigurable/tools/buildCommonTypesStructureFile.py
index 5083b14..43b3dd2 100755
--- a/services/audiopolicy/engineconfigurable/tools/buildCommonTypesStructureFile.py
+++ b/services/audiopolicy/engineconfigurable/tools/buildCommonTypesStructureFile.py
@@ -172,12 +172,6 @@
logging.info("added stub input device mask")
# Transform input source in inclusive criterion
- shift = len(all_component_types['OutputDevicesMask'])
- if shift > 32:
- logging.critical("OutputDevicesMask incompatible with criterion representation on 32 bits")
- logging.info("EXIT ON FAILURE")
- exit(1)
-
for component_types in all_component_types:
values = ','.join('{}:{}'.format(value, key) for key, value in all_component_types[component_types].items())
logging.info("{}: <{}>".format(component_types, values))
diff --git a/services/camera/libcameraservice/Android.bp b/services/camera/libcameraservice/Android.bp
index 46698b3..d16ea1a 100644
--- a/services/camera/libcameraservice/Android.bp
+++ b/services/camera/libcameraservice/Android.bp
@@ -114,6 +114,7 @@
"libutils",
"libbinder",
"libactivitymanager_aidl",
+ "libpermission",
"libcutils",
"libmedia",
"libmediautils",
@@ -158,6 +159,7 @@
export_shared_lib_headers: [
"libbinder",
"libactivitymanager_aidl",
+ "libpermission",
"libcamera_client",
"libfmq",
"libsensorprivacy",