Snap for 6333744 from 322300408f13880ff9f1d758a645869e7d19b60e to rvc-release (f4377ba8) · Commits · e / os / android_frameworks_av

media/codec2/components/hevc/C2SoftHevcEnc.cpp

+22 −1

Original line number	Original line	Diff line number	Diff line
	@@ -628,6 +628,7 @@ c2_status_t C2SoftHevcEnc::initEncoder() {
	mComplexity = mIntf->getComplexity_l();		mComplexity = mIntf->getComplexity_l();
	mQuality = mIntf->getQuality_l();		mQuality = mIntf->getQuality_l();
	mGop = mIntf->getGop_l();		mGop = mIntf->getGop_l();
			mRequestSync = mIntf->getRequestSync_l();
	}		}

	c2_status_t status = initEncParams();		c2_status_t status = initEncParams();
	@@ -956,7 +957,7 @@ void C2SoftHevcEnc::process(const std::unique_ptr<C2Work>& work,
	}		}
	}		}

	// handle dynamic config parameters		// handle dynamic bitrate change
	{		{
	IntfImpl::Lock lock = mIntf->lock();		IntfImpl::Lock lock = mIntf->lock();
	std::shared_ptr<C2StreamBitrateInfo::output> bitrate = mIntf->getBitrate_l();		std::shared_ptr<C2StreamBitrateInfo::output> bitrate = mIntf->getBitrate_l();
	@@ -983,6 +984,26 @@ void C2SoftHevcEnc::process(const std::unique_ptr<C2Work>& work,
	work->workletsProcessed = 1u;		work->workletsProcessed = 1u;
	return;		return;
	}		}
			// handle request key frame
			{
			IntfImpl::Lock lock = mIntf->lock();
			std::shared_ptr<C2StreamRequestSyncFrameTuning::output> requestSync;
			requestSync = mIntf->getRequestSync_l();
			lock.unlock();
			if (requestSync != mRequestSync) {
			// we can handle IDR immediately
			if (requestSync->value) {
			// unset request
			C2StreamRequestSyncFrameTuning::output clearSync(0u, C2_FALSE);
			std::vector<std::unique_ptr<C2SettingResult>> failures;
			mIntf->config({ &clearSync }, C2_MAY_BLOCK, &failures);
			ALOGV("Got sync request");
			//Force this as an IDR frame
			s_encode_ip.i4_force_idr_flag = 1;
			}
			mRequestSync = requestSync;
			}
			}

	uint64_t timeDelay = 0;		uint64_t timeDelay = 0;
	uint64_t timeTaken = 0;		uint64_t timeTaken = 0;

media/codec2/components/hevc/C2SoftHevcEnc.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -88,6 +88,7 @@ struct C2SoftHevcEnc : public SimpleC2Component {
	std::shared_ptr<C2StreamComplexityTuning::output> mComplexity;		std::shared_ptr<C2StreamComplexityTuning::output> mComplexity;
	std::shared_ptr<C2StreamQualityTuning::output> mQuality;		std::shared_ptr<C2StreamQualityTuning::output> mQuality;
	std::shared_ptr<C2StreamGopTuning::output> mGop;		std::shared_ptr<C2StreamGopTuning::output> mGop;
			std::shared_ptr<C2StreamRequestSyncFrameTuning::output> mRequestSync;
	#ifdef FILE_DUMP_ENABLE		#ifdef FILE_DUMP_ENABLE
	char mInFile[200];		char mInFile[200];
	char mOutFile[200];		char mOutFile[200];

media/codec2/components/vpx/C2SoftVpxDec.cpp

+7 −1

Original line number	Original line	Diff line number	Diff line
	@@ -784,7 +784,13 @@ status_t C2SoftVpxDec::outputBuffer(
	}		}

	}		}
	CHECK(img->fmt == VPX_IMG_FMT_I420 \|\| img->fmt == VPX_IMG_FMT_I42016);		if(img->fmt != VPX_IMG_FMT_I420 && img->fmt != VPX_IMG_FMT_I42016) {
			ALOGE("img->fmt %d not supported", img->fmt);
			mSignalledError = true;
			work->workletsProcessed = 1u;
			work->result = C2_CORRUPTED;
			return false;
			}

	std::shared_ptr<C2GraphicBlock> block;		std::shared_ptr<C2GraphicBlock> block;
	uint32_t format = HAL_PIXEL_FORMAT_YV12;		uint32_t format = HAL_PIXEL_FORMAT_YV12;

media/extractors/mp4/MPEG4Extractor.cpp

+28 −7

Original line number	Original line	Diff line number	Diff line
	@@ -165,8 +165,9 @@ private:
	status_t parseTrackFragmentRun(off64_t offset, off64_t size);		status_t parseTrackFragmentRun(off64_t offset, off64_t size);
	status_t parseSampleAuxiliaryInformationSizes(off64_t offset, off64_t size);		status_t parseSampleAuxiliaryInformationSizes(off64_t offset, off64_t size);
	status_t parseSampleAuxiliaryInformationOffsets(off64_t offset, off64_t size);		status_t parseSampleAuxiliaryInformationOffsets(off64_t offset, off64_t size);
	status_t parseClearEncryptedSizes(off64_t offset, bool isSubsampleEncryption, uint32_t flags);		status_t parseClearEncryptedSizes(
	status_t parseSampleEncryption(off64_t offset);		off64_t offset, bool isSubsampleEncryption, uint32_t flags, off64_t size);
			status_t parseSampleEncryption(off64_t offset, off64_t size);
	// returns -1 for invalid layer ID		// returns -1 for invalid layer ID
	int32_t parseHEVCLayerId(const uint8_t *data, size_t size);		int32_t parseHEVCLayerId(const uint8_t *data, size_t size);

	@@ -5184,7 +5185,7 @@ status_t MPEG4Source::parseChunk(off64_t *offset) {

	case FOURCC("senc"): {		case FOURCC("senc"): {
	status_t err;		status_t err;
	if ((err = parseSampleEncryption(data_offset)) != OK) {		if ((err = parseSampleEncryption(data_offset, chunk_data_size)) != OK) {
	return err;		return err;
	}		}
	*offset += chunk_size;		*offset += chunk_size;
	@@ -5376,12 +5377,13 @@ status_t MPEG4Source::parseSampleAuxiliaryInformationOffsets(
	off64_t drmoffset = mCurrentSampleInfoOffsets[0]; // from moof		off64_t drmoffset = mCurrentSampleInfoOffsets[0]; // from moof

	drmoffset += mCurrentMoofOffset;		drmoffset += mCurrentMoofOffset;
			size -= mCurrentMoofOffset;

	return parseClearEncryptedSizes(drmoffset, false, 0);		return parseClearEncryptedSizes(drmoffset, false, 0, size);
	}		}

	status_t MPEG4Source::parseClearEncryptedSizes(		status_t MPEG4Source::parseClearEncryptedSizes(
	off64_t offset, bool isSubsampleEncryption, uint32_t flags) {		off64_t offset, bool isSubsampleEncryption, uint32_t flags, off64_t size) {

	int32_t ivlength;		int32_t ivlength;
	if (!AMediaFormat_getInt32(mFormat, AMEDIAFORMAT_KEY_CRYPTO_DEFAULT_IV_SIZE, &ivlength)) {		if (!AMediaFormat_getInt32(mFormat, AMEDIAFORMAT_KEY_CRYPTO_DEFAULT_IV_SIZE, &ivlength)) {
	@@ -5396,10 +5398,14 @@ status_t MPEG4Source::parseClearEncryptedSizes(

	uint32_t sampleCount = mCurrentSampleInfoCount;		uint32_t sampleCount = mCurrentSampleInfoCount;
	if (isSubsampleEncryption) {		if (isSubsampleEncryption) {
			if(size < 4){
			return ERROR_MALFORMED;
			}
	if (!mDataSource->getUInt32(offset, &sampleCount)) {		if (!mDataSource->getUInt32(offset, &sampleCount)) {
	return ERROR_IO;		return ERROR_IO;
	}		}
	offset += 4;		offset += 4;
			size -= 4;
	}		}

	// read CencSampleAuxiliaryDataFormats		// read CencSampleAuxiliaryDataFormats
	@@ -5414,11 +5420,15 @@ status_t MPEG4Source::parseClearEncryptedSizes(
	}		}

	memset(smpl->iv, 0, 16);		memset(smpl->iv, 0, 16);
			if(size < ivlength){
			return ERROR_MALFORMED;
			}
	if (mDataSource->readAt(offset, smpl->iv, ivlength) != ivlength) {		if (mDataSource->readAt(offset, smpl->iv, ivlength) != ivlength) {
	return ERROR_IO;		return ERROR_IO;
	}		}

	offset += ivlength;		offset += ivlength;
			size -= ivlength;

	bool readSubsamples;		bool readSubsamples;
	if (isSubsampleEncryption) {		if (isSubsampleEncryption) {
	@@ -5433,13 +5443,20 @@ status_t MPEG4Source::parseClearEncryptedSizes(

	if (readSubsamples) {		if (readSubsamples) {
	uint16_t numsubsamples;		uint16_t numsubsamples;
			if(size < 2){
			return ERROR_MALFORMED;
			}
	if (!mDataSource->getUInt16(offset, &numsubsamples)) {		if (!mDataSource->getUInt16(offset, &numsubsamples)) {
	return ERROR_IO;		return ERROR_IO;
	}		}
	offset += 2;		offset += 2;
			size -= 2;
	for (size_t j = 0; j < numsubsamples; j++) {		for (size_t j = 0; j < numsubsamples; j++) {
	uint16_t numclear;		uint16_t numclear;
	uint32_t numencrypted;		uint32_t numencrypted;
			if(size < 6){
			return ERROR_MALFORMED;
			}
	if (!mDataSource->getUInt16(offset, &numclear)) {		if (!mDataSource->getUInt16(offset, &numclear)) {
	return ERROR_IO;		return ERROR_IO;
	}		}
	@@ -5448,6 +5465,7 @@ status_t MPEG4Source::parseClearEncryptedSizes(
	return ERROR_IO;		return ERROR_IO;
	}		}
	offset += 4;		offset += 4;
			size -= 6;
	smpl->clearsizes.add(numclear);		smpl->clearsizes.add(numclear);
	smpl->encryptedsizes.add(numencrypted);		smpl->encryptedsizes.add(numencrypted);
	}		}
	@@ -5460,12 +5478,15 @@ status_t MPEG4Source::parseClearEncryptedSizes(
	return OK;		return OK;
	}		}

	status_t MPEG4Source::parseSampleEncryption(off64_t offset) {		status_t MPEG4Source::parseSampleEncryption(off64_t offset, off64_t chunk_data_size) {
	uint32_t flags;		uint32_t flags;
			if(chunk_data_size < 4) {
			return ERROR_MALFORMED;
			}
	if (!mDataSource->getUInt32(offset, &flags)) { // actually version + flags		if (!mDataSource->getUInt32(offset, &flags)) { // actually version + flags
	return ERROR_MALFORMED;		return ERROR_MALFORMED;
	}		}
	return parseClearEncryptedSizes(offset + 4, true, flags);		return parseClearEncryptedSizes(offset + 4, true, flags, chunk_data_size - 4);
	}		}

	status_t MPEG4Source::parseTrackFragmentHeader(off64_t offset, off64_t size) {		status_t MPEG4Source::parseTrackFragmentHeader(off64_t offset, off64_t size) {

media/libstagefright/ACodecBufferChannel.cpp

+6 −1

Original line number	Original line	Diff line number	Diff line
	@@ -134,7 +134,12 @@ status_t ACodecBufferChannel::queueSecureInputBuffer(
	}		}
	ssize_t result = -1;		ssize_t result = -1;
	ssize_t codecDataOffset = 0;		ssize_t codecDataOffset = 0;
	if (mCrypto != NULL) {		if (numSubSamples == 1
			&& subSamples[0].mNumBytesOfClearData == 0
			&& subSamples[0].mNumBytesOfEncryptedData == 0) {
			// We don't need to go through crypto or descrambler if the input is empty.
			result = 0;
			} else if (mCrypto != NULL) {
	hardware::drm::V1_0::DestinationBuffer destination;		hardware::drm::V1_0::DestinationBuffer destination;
	if (secure) {		if (secure) {
	destination.type = DrmBufferType::NATIVE_HANDLE;		destination.type = DrmBufferType::NATIVE_HANDLE;