Merge changes I1b44cd58,Ic9a9baa3 into main (42d3cb49) · Commits · e / os / android_frameworks_av

media/codec2/components/apv/C2SoftApvEnc.cpp

+8 −89

Original line number	Diff line number	Diff line
		@@ -85,17 +85,6 @@ class C2SoftApvEnc::IntfImpl : public SimpleInterface<void>::BaseParams {
		.withSetter(SizeSetter)
		.build());

		// matches limits in codec library
		addParameter(DefineParam(mBitrateMode, C2_PARAMKEY_BITRATE_MODE)
		.withDefault(new C2StreamBitrateModeTuning::output(
		0u, C2Config::BITRATE_VARIABLE))
		.withFields({C2F(mBitrateMode, value)
		.oneOf({C2Config::BITRATE_CONST,
		C2Config::BITRATE_VARIABLE,
		C2Config::BITRATE_IGNORE})})
		.withSetter(Setter<decltype(*mBitrateMode)>::StrictValueWithNoDeps)
		.build());

		addParameter(DefineParam(mBitrate, C2_PARAMKEY_BITRATE)
		.withDefault(new C2StreamBitrateInfo::output(0u, 512000))
		.withFields({C2F(mBitrate, value).inRange(512000, 240000000)})
		@@ -718,25 +707,6 @@ class C2SoftApvEnc::IntfImpl : public SimpleInterface<void>::BaseParams {
		return bandIdc;
		}

		int32_t getBitrateMode_l() const {
		int32_t bitrateMode = C2Config::BITRATE_CONST;

		switch (mBitrateMode->value) {
		case C2Config::BITRATE_CONST:
		bitrateMode = OAPV_RC_CQP;
		break;
		case C2Config::BITRATE_VARIABLE:
		bitrateMode = OAPV_RC_ABR;
		break;
		case C2Config::BITRATE_IGNORE:
		bitrateMode = 0;
		break;
		default:
		ALOGE("Unrecognized bitrate mode: %x", mBitrateMode->value);
		}
		return bitrateMode;
		}

		std::shared_ptr<C2StreamPictureSizeInfo::input> getSize_l() const { return mSize; }
		std::shared_ptr<C2StreamFrameRateInfo::output> getFrameRate_l() const { return mFrameRate; }
		std::shared_ptr<C2StreamBitrateInfo::output> getBitrate_l() const { return mBitrate; }
		@@ -763,7 +733,6 @@ class C2SoftApvEnc::IntfImpl : public SimpleInterface<void>::BaseParams {
		std::shared_ptr<C2StreamPictureSizeInfo::input> mSize;
		std::shared_ptr<C2StreamFrameRateInfo::output> mFrameRate;
		std::shared_ptr<C2StreamBitrateInfo::output> mBitrate;
		std::shared_ptr<C2StreamBitrateModeTuning::output> mBitrateMode;
		std::shared_ptr<C2StreamQualityTuning::output> mQuality;
		std::shared_ptr<C2StreamColorAspectsInfo::input> mColorAspects;
		std::shared_ptr<C2StreamColorAspectsInfo::output> mCodedColorAspects;
		@@ -968,15 +937,9 @@ void C2SoftApvEnc::setParams(oapve_param_t& param) {
		param.fps_num = (int)(mFrameRate->value * 100);
		param.fps_den = 100;
		param.bitrate = (int)(mBitrate->value / 1000);
		param.rc_type = mIntf->getBitrateMode_l();
		param.rc_type = OAPV_RC_ABR;

		int ApvQP = kApvDefaultQP;
		if (param.rc_type == OAPV_RC_CQP) {
		ApvQP = getQpFromQuality(mQuality->value);
		ALOGI("Bitrate mode is CQ, so QP value is derived from Quality. Quality is %d, QP is %d",
		mQuality->value, ApvQP);
		}
		param.qp = ApvQP;
		param.qp = kApvDefaultQP;
		param.band_idc = mIntf->getBandIdc_l();
		param.profile_idc = mIntf->getProfile_l();
		param.level_idc = mIntf->getLevel_l();
		@@ -1031,9 +994,7 @@ c2_status_t C2SoftApvEnc::setEncodeArgs(oapv_frms_t* inputFrames, const C2Graphi
		case C2PlanarLayout::TYPE_YUV: {
		if (IsP010(*input)) {
		ALOGV("Convert from P010 to P210");
		if (mColorFormat == OAPV_CF_YCBCR422) {
		ColorConvertP010ToYUV422P10le(input, inputFrames->frm[0].imgb);
		} else if (mColorFormat == OAPV_CF_PLANAR2) {
		if (mColorFormat == OAPV_CF_PLANAR2) {
		uint16_t srcY = (uint16_t)(input->data()[0]);
		uint16_t srcUV = (uint16_t)(input->data()[1]);
		uint16_t dstY = (uint16_t)inputFrames->frm[0].imgb->a[0];
		@@ -1043,7 +1004,7 @@ c2_status_t C2SoftApvEnc::setEncodeArgs(oapv_frms_t* inputFrames, const C2Graphi
		convertP010ToP210(dstY, dstUV, srcY, srcUV,
		layout.planes[layout.PLANE_Y].rowInc / 2,
		layout.planes[layout.PLANE_U].rowInc / 2,
		dstYStride, dstUVStride, input->width(), input->height());
		dstYStride, dstUVStride, width, height);
		} else {
		ALOGE("Not supported color format. %d", mColorFormat);
		return C2_BAD_VALUE;
		@@ -1060,7 +1021,7 @@ c2_status_t C2SoftApvEnc::setEncodeArgs(oapv_frms_t* inputFrames, const C2Graphi
		layout.planes[layout.PLANE_Y].rowInc,
		layout.planes[layout.PLANE_U].rowInc,
		dstYStride, dstUVStride,
		input->width(), input->height(), CONV_FORMAT_I420);
		width, height, CONV_FORMAT_I420);
		} else if (IsI420(*input)) {
		ALOGV("Convert from I420 to P210");
		uint8_t srcY = (uint8_t)input->data()[0];
		@@ -1075,7 +1036,7 @@ c2_status_t C2SoftApvEnc::setEncodeArgs(oapv_frms_t* inputFrames, const C2Graphi
		layout.planes[C2PlanarLayout::PLANE_U].rowInc,
		layout.planes[C2PlanarLayout::PLANE_V].rowInc,
		dstYStride, dstUVStride,
		input->width(), input->height(),
		width, height,
		CONV_FORMAT_I420);

		} else {
		@@ -1093,50 +1054,6 @@ c2_status_t C2SoftApvEnc::setEncodeArgs(oapv_frms_t* inputFrames, const C2Graphi
		return C2_OK;
		}

		void C2SoftApvEnc::ColorConvertP010ToYUV422P10le(const C2GraphicView* const input,
		oapv_imgb_t* imgb) {
		uint32_t width = input->width();
		uint32_t height = input->height();

		uint8_t* yPlane = (uint8_t*)input->data()[0];
		auto* uvPlane = (uint8_t*)input->data()[1];
		uint32_t stride[3];
		stride[0] = width * 2;
		stride[1] = stride[2] = width;

		uint8_t dst, src;
		uint16_t tmp;
		for (int32_t y = 0; y < height; ++y) {
		src = yPlane + y * stride[0];
		dst = (uint8_t)imgb->a[0] + y stride[0];
		for (int32_t x = 0; x < stride[0]; x += 2) {
		tmp = (src[x + 1] << 2) \| (src[x] >> 6);
		dst[x] = tmp & 0xFF;
		dst[x + 1] = tmp >> 8;
		}
		}

		uint8_t dst_u, dst_v;
		for (int32_t y = 0; y < height / 2; ++y) {
		src = uvPlane + y * stride[1] * 2;
		dst_u = (uint8_t)imgb->a[1] + (y 2) * stride[1];
		dst_v = (uint8_t)imgb->a[2] + (y 2) * stride[2];
		for (int32_t x = 0; x < stride[1] * 2; x += 4) {
		tmp = (src[x + 1] << 2) \| (src[x] >> 6); // cb
		dst_u[x / 2] = tmp & 0xFF;
		dst_u[x / 2 + 1] = tmp >> 8;
		dst_u[x / 2 + stride[1]] = dst_u[x / 2];
		dst_u[x / 2 + stride[1] + 1] = dst_u[x / 2 + 1];

		tmp = (src[x + 3] << 2) \| (src[x + 2] >> 6); // cr
		dst_v[x / 2] = tmp & 0xFF;
		dst_v[x / 2 + 1] = tmp >> 8;
		dst_v[x / 2 + stride[2]] = dst_v[x / 2];
		dst_v[x / 2 + stride[2] + 1] = dst_v[x / 2 + 1];
		}
		}
		}

		void C2SoftApvEnc::finishWork(uint64_t workIndex, const std::unique_ptr<C2Work>& work,
		const std::shared_ptr<C2BlockPool>& pool, oapv_bitb_t* bitb,
		oapve_stat_t* stat) {
		@@ -1385,6 +1302,8 @@ void C2SoftApvEnc::process(const std::unique_ptr<C2Work>& work,
		return;
		}

		view->setCrop_be(C2Rect(mSize->width, mSize->height));

		error = setEncodeArgs(&mInputFrames, view.get(), workIndex);
		if (error != C2_OK) {
		ALOGE("setEncodeArgs has failed. err = %d", error);

media/codec2/components/apv/C2SoftApvEnc.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -84,7 +84,6 @@ struct C2SoftApvEnc final : public SimpleC2Component {
		std::shared_ptr<C2StreamColorAspectsInfo::output> mCodedColorAspects;
		std::shared_ptr<C2StreamPictureQuantizationTuning::output> mPictureQuantization;
		std::shared_ptr<C2StreamQualityTuning::output> mQuality;
		std::shared_ptr<C2StreamBitrateModeTuning::output> mBitrateMode;
		std::shared_ptr<C2LinearBlock> mOutBlock;
		std::shared_ptr<C2StreamComplexityTuning::output> mComplexity;
		std::shared_ptr<C2StreamPixelFormatInfo::input> mPixelFormat;

media/libstagefright/data/media_codecs_sw.xml

+1 −1

Original line number	Diff line number	Diff line
		@@ -425,7 +425,7 @@
		<Limit name="block-size" value="16x16" />
		<Limit name="block-count" range="1-32768" /> <!-- max 4096x2048 equivalent -->
		<Limit name="bitrate" range="1-240000000" />
		<Feature name="bitrate-modes" value="VBR,CBR" />
		<Feature name="bitrate-modes" value="VBR" />
		<Attribute name="software-codec" />
		</MediaCodec>
		</Encoders>