Merge "Modify hdr metrics" (3d5194f1) · Commits · e / os / android_frameworks_av

media/libstagefright/MediaCodec.cpp

+104 −59

Original line number	Diff line number	Diff line
		@@ -807,9 +807,7 @@ MediaCodec::MediaCodec(
		mWidth(0),
		mHeight(0),
		mRotationDegrees(0),
		mConfigColorTransfer(-1),
		mHDRStaticInfo(false),
		mHDR10PlusInfo(false),
		mHdrInfoFlags(0),
		mDequeueInputTimeoutGeneration(0),
		mDequeueInputReplyID(0),
		mDequeueOutputTimeoutGeneration(0),
		@@ -955,29 +953,73 @@ void MediaCodec::updateMediametrics() {
		mIndexOfFirstFrameWhenLowLatencyOn);
		}

		mediametrics_setInt32(mMetricsHandle, kCodecHDRStaticInfo, mHDRStaticInfo ? 1 : 0);
		mediametrics_setInt32(mMetricsHandle, kCodecHDR10PlusInfo, mHDR10PlusInfo ? 1 : 0);
		#if 0
		// enable for short term, only while debugging
		updateEphemeralMediametrics(mMetricsHandle);
		#endif
		}

		void MediaCodec::updateHDRFormatMetric() {
		void MediaCodec::updateHdrMetrics(bool isConfig) {
		if ((mDomain != DOMAIN_VIDEO && mDomain != DOMAIN_IMAGE) \|\| mMetricsHandle == 0) {
		return;
		}

		int32_t colorStandard = -1;
		if (mOutputFormat->findInt32(KEY_COLOR_STANDARD, &colorStandard)) {
		mediametrics_setInt32(mMetricsHandle,
		isConfig ? kCodecConfigColorStandard : kCodecParsedColorStandard, colorStandard);
		}
		int32_t colorRange = -1;
		if (mOutputFormat->findInt32(KEY_COLOR_RANGE, &colorRange)) {
		mediametrics_setInt32(mMetricsHandle,
		isConfig ? kCodecConfigColorRange : kCodecParsedColorRange, colorRange);
		}
		int32_t colorTransfer = -1;
		if (mOutputFormat->findInt32(KEY_COLOR_TRANSFER, &colorTransfer)) {
		mediametrics_setInt32(mMetricsHandle,
		isConfig ? kCodecConfigColorTransfer : kCodecParsedColorTransfer, colorTransfer);
		}
		HDRStaticInfo info;
		if (ColorUtils::getHDRStaticInfoFromFormat(mOutputFormat, &info)
		&& ColorUtils::isHDRStaticInfoValid(&info)) {
		mHdrInfoFlags \|= kFlagHasHdrStaticInfo;
		}
		mediametrics_setInt32(mMetricsHandle, kCodecHDRStaticInfo,
		(mHdrInfoFlags & kFlagHasHdrStaticInfo) ? 1 : 0);
		sp<ABuffer> hdr10PlusInfo;
		if (mOutputFormat->findBuffer("hdr10-plus-info", &hdr10PlusInfo)
		&& hdr10PlusInfo != nullptr && hdr10PlusInfo->size() > 0) {
		mHdrInfoFlags \|= kFlagHasHdr10PlusInfo;
		}
		mediametrics_setInt32(mMetricsHandle, kCodecHDR10PlusInfo,
		(mHdrInfoFlags & kFlagHasHdr10PlusInfo) ? 1 : 0);

		// hdr format
		sp<AMessage> codedFormat = (mFlags & kFlagIsEncoder) ? mOutputFormat : mInputFormat;

		AString mime;
		int32_t profile = -1;
		AString mediaType;
		if (mOutputFormat->findInt32(KEY_PROFILE, &profile)
		&& mOutputFormat->findString("mime", &mediaType)) {
		hdr_format hdrFormat = getHDRFormat(profile, mConfigColorTransfer, mediaType);

		if (codedFormat->findString("mime", &mime)
		&& codedFormat->findInt32(KEY_PROFILE, &profile)
		&& colorTransfer != -1) {
		hdr_format hdrFormat = getHdrFormat(mime, profile, colorTransfer);
		mediametrics_setInt32(mMetricsHandle, kCodecHDRFormat, static_cast<int>(hdrFormat));
		}
		}

		hdr_format MediaCodec::getHDRFormat(const int32_t profile, const int32_t transfer,
		const AString &mediaType) {
		switch (transfer) {
		hdr_format MediaCodec::getHdrFormat(const AString &mime, const int32_t profile,
		const int32_t colorTransfer) {
		return (mFlags & kFlagIsEncoder)
		? getHdrFormatForEncoder(mime, profile, colorTransfer)
		: getHdrFormatForDecoder(mime, profile, colorTransfer);
		}

		hdr_format MediaCodec::getHdrFormatForEncoder(const AString &mime, const int32_t profile,
		const int32_t colorTransfer) {
		switch (colorTransfer) {
		case COLOR_TRANSFER_ST2084:
		if (mediaType.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_VP9)) {
		if (mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_VP9)) {
		switch (profile) {
		case VP9Profile2HDR:
		return HDR_FORMAT_HDR10;
		@@ -986,7 +1028,7 @@ hdr_format MediaCodec::getHDRFormat(const int32_t profile, const int32_t transfe
		default:
		return HDR_FORMAT_NONE;
		}
		} else if (mediaType.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_AV1)) {
		} else if (mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_AV1)) {
		switch (profile) {
		case AV1ProfileMain10HDR10:
		return HDR_FORMAT_HDR10;
		@@ -995,7 +1037,7 @@ hdr_format MediaCodec::getHDRFormat(const int32_t profile, const int32_t transfe
		default:
		return HDR_FORMAT_NONE;
		}
		} else if (mediaType.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_HEVC)) {
		} else if (mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_HEVC)) {
		switch (profile) {
		case HEVCProfileMain10HDR10:
		return HDR_FORMAT_HDR10;
		@@ -1008,7 +1050,7 @@ hdr_format MediaCodec::getHDRFormat(const int32_t profile, const int32_t transfe
		return HDR_FORMAT_NONE;
		}
		case COLOR_TRANSFER_HLG:
		if (!mediaType.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_DOLBY_VISION)) {
		if (!mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_DOLBY_VISION)) {
		return HDR_FORMAT_HLG;
		} else {
		// TODO: DOLBY format
		@@ -1019,6 +1061,47 @@ hdr_format MediaCodec::getHDRFormat(const int32_t profile, const int32_t transfe
		}
		}

		hdr_format MediaCodec::getHdrFormatForDecoder(const AString &mime, const int32_t profile,
		const int32_t colorTransfer) {
		switch (colorTransfer) {
		case COLOR_TRANSFER_ST2084:
		if (!(mHdrInfoFlags & kFlagHasHdrStaticInfo) \|\| !profileSupport10Bits(mime, profile)) {
		return HDR_FORMAT_NONE;
		}
		return mHdrInfoFlags & kFlagHasHdr10PlusInfo ? HDR_FORMAT_HDR10PLUS : HDR_FORMAT_HDR10;
		case COLOR_TRANSFER_HLG:
		if (!mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_DOLBY_VISION)) {
		return HDR_FORMAT_HLG;
		}
		// TODO: DOLBY format
		}
		return HDR_FORMAT_NONE;
		}

		bool MediaCodec::profileSupport10Bits(const AString &mime, const int32_t profile) {
		if (mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_AV1)) {
		return true;
		} else if (mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_VP9)) {
		switch (profile) {
		case VP9Profile2:
		case VP9Profile3:
		case VP9Profile2HDR:
		case VP9Profile3HDR:
		case VP9Profile2HDR10Plus:
		case VP9Profile3HDR10Plus:
		return true;
		}
		} else if (mime.equalsIgnoreCase(MEDIA_MIMETYPE_VIDEO_HEVC)) {
		switch (profile) {
		case HEVCProfileMain10:
		case HEVCProfileMain10HDR10:
		case HEVCProfileMain10HDR10Plus:
		return true;
		}
		}
		return false;
		}


		void MediaCodec::updateEphemeralMediametrics(mediametrics_handle_t item) {
		ALOGD("MediaCodec::updateEphemeralMediametrics()");
		@@ -1060,6 +1143,7 @@ void MediaCodec::updateEphemeralMediametrics(mediametrics_handle_t item) {

		void MediaCodec::flushMediametrics() {
		updateMediametrics();
		mHdrInfoFlags = 0;
		if (mMetricsHandle != 0) {
		if (mediametrics_count(mMetricsHandle) > 0) {
		mediametrics_selfRecord(mMetricsHandle);
		@@ -1707,24 +1791,6 @@ status_t MediaCodec::configure(
		mediametrics_setInt32(mMetricsHandle, kCodecPriority, priority);
		}
		}
		int32_t colorStandard = -1;
		if (format->findInt32(KEY_COLOR_STANDARD, &colorStandard)) {
		mediametrics_setInt32(mMetricsHandle, kCodecConfigColorStandard, colorStandard);
		}
		int32_t colorRange = -1;
		if (format->findInt32(KEY_COLOR_RANGE, &colorRange)) {
		mediametrics_setInt32(mMetricsHandle, kCodecConfigColorRange, colorRange);
		}
		int32_t colorTransfer = -1;
		if (format->findInt32(KEY_COLOR_TRANSFER, &colorTransfer)) {
		mConfigColorTransfer = colorTransfer;
		mediametrics_setInt32(mMetricsHandle, kCodecConfigColorTransfer, colorTransfer);
		}
		HDRStaticInfo info;
		if (ColorUtils::getHDRStaticInfoFromFormat(format, &info)
		&& ColorUtils::isHDRStaticInfoValid(&info)) {
		mHDRStaticInfo = true;
		}
		}

		// Prevent possible integer overflow in downstream code.
		@@ -3382,8 +3448,6 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
		CHECK(msg->findMessage("input-format", &mInputFormat));
		CHECK(msg->findMessage("output-format", &mOutputFormat));

		updateHDRFormatMetric();

		// limit to confirming the opt-in behavior to minimize any behavioral change
		if (mSurface != nullptr && !mAllowFrameDroppingBySurface) {
		// signal frame dropping mode in the input format as this may also be
		@@ -3426,6 +3490,7 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
		if (interestingFormat->findInt32("level", &level)) {
		mediametrics_setInt32(mMetricsHandle, kCodecLevel, level);
		}
		updateHdrMetrics(true /* isConfig */);
		// bitrate and bitrate mode, encoder only
		if (mFlags & kFlagIsEncoder) {
		// encoder specific values
		@@ -3465,7 +3530,6 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
		mComponentName.c_str(),
		mInputFormat->debugString(4).c_str(),
		mOutputFormat->debugString(4).c_str());
		updateHDRFormatMetric();
		CHECK(obj != NULL);
		response->setObject("input-surface", obj);
		mHaveInputSurface = true;
		@@ -3490,7 +3554,6 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
		if (!msg->findInt32("err", &err)) {
		CHECK(msg->findMessage("input-format", &mInputFormat));
		CHECK(msg->findMessage("output-format", &mOutputFormat));
		updateHDRFormatMetric();
		mHaveInputSurface = true;
		} else {
		response->setInt32("err", err);
		@@ -4684,7 +4747,6 @@ void MediaCodec::handleOutputFormatChangeIfNeeded(const sp<MediaCodecBuffer> &bu
		buffer->meta()->setObject("changedKeys", changedKeys);
		}
		mOutputFormat = format;
		updateHDRFormatMetric();
		mapFormat(mComponentName, format, nullptr, true);
		ALOGV("[%s] output format changed to: %s",
		mComponentName.c_str(), mOutputFormat->debugString(4).c_str());
		@@ -4710,9 +4772,6 @@ void MediaCodec::handleOutputFormatChangeIfNeeded(const sp<MediaCodecBuffer> &bu
		HDRStaticInfo info;
		if (ColorUtils::getHDRStaticInfoFromFormat(mOutputFormat, &info)) {
		setNativeWindowHdrMetadata(mSurface.get(), &info);
		if (ColorUtils::isHDRStaticInfoValid(&info)) {
		mHDRStaticInfo = true;
		}
		}
		}

		@@ -4721,7 +4780,6 @@ void MediaCodec::handleOutputFormatChangeIfNeeded(const sp<MediaCodecBuffer> &bu
		&& hdr10PlusInfo != nullptr && hdr10PlusInfo->size() > 0) {
		native_window_set_buffers_hdr10_plus_metadata(mSurface.get(),
		hdr10PlusInfo->size(), hdr10PlusInfo->data());
		mHDR10PlusInfo = true;
		}

		if (mime.startsWithIgnoreCase("video/")) {
		@@ -4767,20 +4825,7 @@ void MediaCodec::handleOutputFormatChangeIfNeeded(const sp<MediaCodecBuffer> &bu
		}
		}

		if (mMetricsHandle != 0) {
		int32_t colorStandard = -1;
		if (format->findInt32(KEY_COLOR_STANDARD, &colorStandard)) {
		mediametrics_setInt32(mMetricsHandle, kCodecParsedColorStandard, colorStandard);
		}
		int32_t colorRange = -1;
		if (format->findInt32( KEY_COLOR_RANGE, &colorRange)) {
		mediametrics_setInt32(mMetricsHandle, kCodecParsedColorRange, colorRange);
		}
		int32_t colorTransfer = -1;
		if (format->findInt32(KEY_COLOR_TRANSFER, &colorTransfer)) {
		mediametrics_setInt32(mMetricsHandle, kCodecParsedColorTransfer, colorTransfer);
		}
		}
		updateHdrMetrics(false /* isConfig */);
		}

		void MediaCodec::extractCSD(const sp<AMessage> &format) {

media/libstagefright/include/media/stagefright/MediaCodec.h

+13 −6

Original line number	Diff line number	Diff line
		@@ -454,12 +454,19 @@ private:
		int32_t mRotationDegrees;
		int32_t mAllowFrameDroppingBySurface;

		int32_t mConfigColorTransfer;
		bool mHDRStaticInfo;
		bool mHDR10PlusInfo;
		void updateHDRFormatMetric();
		hdr_format getHDRFormat(const int32_t profile, const int32_t transfer,
		const AString &mediaType);
		enum {
		kFlagHasHdrStaticInfo = 1,
		kFlagHasHdr10PlusInfo = 2,
		};
		uint32_t mHdrInfoFlags;
		void updateHdrMetrics(bool isConfig);
		hdr_format getHdrFormat(const AString &mime, const int32_t profile,
		const int32_t colorTransfer);
		hdr_format getHdrFormatForEncoder(const AString &mime, const int32_t profile,
		const int32_t colorTransfer);
		hdr_format getHdrFormatForDecoder(const AString &mime, const int32_t profile,
		const int32_t colorTransfer);
		bool profileSupport10Bits(const AString &mime, const int32_t profile);

		// initial create parameters
		AString mInitName;