Merge changes I5a0827eb,Ibd0da668,I74c71975 am: 65f7dd435d (47bc0dd0) · Commits · e / os / android_frameworks_av

media/codec2/sfplugin/CCodec.cpp

+82 −13

Original line number	Diff line number	Diff line
		@@ -923,19 +923,84 @@ void CCodec::configure(const sp<AMessage> &msg) {
		/*
		* Handle desired color format.
		*/
		int32_t defaultColorFormat = COLOR_FormatYUV420Flexible;
		if ((config->mDomain & (Config::IS_VIDEO \| Config::IS_IMAGE))) {
		int32_t format = -1;
		int32_t format = 0;
		// Query vendor format for Flexible YUV
		std::vector<std::unique_ptr<C2Param>> heapParams;
		C2StoreFlexiblePixelFormatDescriptorsInfo *pixelFormatInfo = nullptr;
		if (mClient->query(
		{},
		{C2StoreFlexiblePixelFormatDescriptorsInfo::PARAM_TYPE},
		C2_MAY_BLOCK,
		&heapParams) == C2_OK
		&& heapParams.size() == 1u) {
		pixelFormatInfo = C2StoreFlexiblePixelFormatDescriptorsInfo::From(
		heapParams[0].get());
		} else {
		pixelFormatInfo = nullptr;
		}
		std::optional<uint32_t> flexPixelFormat{};
		std::optional<uint32_t> flexPlanarPixelFormat{};
		std::optional<uint32_t> flexSemiPlanarPixelFormat{};
		if (pixelFormatInfo && *pixelFormatInfo) {
		for (size_t i = 0; i < pixelFormatInfo->flexCount(); ++i) {
		const C2FlexiblePixelFormatDescriptorStruct &desc =
		pixelFormatInfo->m.values[i];
		if (desc.bitDepth != 8
		\|\| desc.subsampling != C2Color::YUV_420
		// TODO(b/180076105): some device report wrong layout
		// \|\| desc.layout == C2Color::INTERLEAVED_PACKED
		// \|\| desc.layout == C2Color::INTERLEAVED_ALIGNED
		\|\| desc.layout == C2Color::UNKNOWN_LAYOUT) {
		continue;
		}
		if (!flexPixelFormat) {
		flexPixelFormat = desc.pixelFormat;
		}
		if (desc.layout == C2Color::PLANAR_PACKED && !flexPlanarPixelFormat) {
		flexPlanarPixelFormat = desc.pixelFormat;
		}
		if (desc.layout == C2Color::SEMIPLANAR_PACKED && !flexSemiPlanarPixelFormat) {
		flexSemiPlanarPixelFormat = desc.pixelFormat;
		}
		}
		}
		if (!msg->findInt32(KEY_COLOR_FORMAT, &format)) {
		/*
		* Also handle default color format (encoders require color format, so this is only
		* needed for decoders.
		*/
		// Also handle default color format (encoders require color format, so this is only
		// needed for decoders.
		if (!(config->mDomain & Config::IS_ENCODER)) {
		format = (surface == nullptr) ? COLOR_FormatYUV420Planar : COLOR_FormatSurface;
		if (surface == nullptr) {
		format = flexPixelFormat.value_or(COLOR_FormatYUV420Flexible);
		} else {
		format = COLOR_FormatSurface;
		}
		defaultColorFormat = format;
		}
		} else {
		if ((config->mDomain & Config::IS_ENCODER) \|\| !surface) {
		switch (format) {
		case COLOR_FormatYUV420Flexible:
		format = flexPixelFormat.value_or(COLOR_FormatYUV420Planar);
		break;
		case COLOR_FormatYUV420Planar:
		case COLOR_FormatYUV420PackedPlanar:
		format = flexPlanarPixelFormat.value_or(
		flexPixelFormat.value_or(format));
		break;
		case COLOR_FormatYUV420SemiPlanar:
		case COLOR_FormatYUV420PackedSemiPlanar:
		format = flexSemiPlanarPixelFormat.value_or(
		flexPixelFormat.value_or(format));
		break;
		default:
		// No-op
		break;
		}
		}
		}

		if (format >= 0) {
		if (format != 0) {
		msg->setInt32("android._color-format", format);
		}
		}
		@@ -1087,14 +1152,18 @@ void CCodec::configure(const sp<AMessage> &msg) {

		// Set desired color format from configuration parameter
		int32_t format;
		if (msg->findInt32("android._color-format", &format)) {
		if (!msg->findInt32(KEY_COLOR_FORMAT, &format)) {
		format = defaultColorFormat;
		}
		if (config->mDomain & Config::IS_ENCODER) {
		config->mInputFormat->setInt32(KEY_COLOR_FORMAT, format);
		if (msg->findInt32("android._color-format", &format)) {
		config->mInputFormat->setInt32("android._color-format", format);
		}
		} else {
		config->mOutputFormat->setInt32(KEY_COLOR_FORMAT, format);
		}
		}
		}

		// propagate encoder delay and padding to output format
		if ((config->mDomain & Config::IS_DECODER) && (config->mDomain & Config::IS_AUDIO)) {
		@@ -2051,7 +2120,7 @@ public:
		}
		if (param->type() == C2PortAllocatorsTuning::input::PARAM_TYPE) {
		mInputAllocators.reset(
		C2PortAllocatorsTuning::input::From(params[0].get()));
		C2PortAllocatorsTuning::input::From(param));
		}
		}
		mInitStatus = OK;

media/codec2/sfplugin/CCodecBuffers.cpp

+18 −3

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@
		#include <mediadrm/ICrypto.h>

		#include "CCodecBuffers.h"
		#include "Codec2Mapper.h"

		namespace android {

		@@ -1006,18 +1007,32 @@ void GraphicInputBuffers::flush() {
		// track of the flushed work.
		}

		static uint32_t extractPixelFormat(const sp<AMessage> &format) {
		int32_t frameworkColorFormat = 0;
		if (!format->findInt32("android._color-format", &frameworkColorFormat)) {
		return PIXEL_FORMAT_UNKNOWN;
		}
		uint32_t pixelFormat = PIXEL_FORMAT_UNKNOWN;
		if (C2Mapper::mapPixelFormatFrameworkToCodec(frameworkColorFormat, &pixelFormat)) {
		return pixelFormat;
		}
		return PIXEL_FORMAT_UNKNOWN;
		}

		std::unique_ptr<InputBuffers> GraphicInputBuffers::toArrayMode(size_t size) {
		std::unique_ptr<InputBuffersArray> array(
		new InputBuffersArray(mComponentName.c_str(), "2D-BB-Input[N]"));
		array->setPool(mPool);
		array->setFormat(mFormat);
		uint32_t pixelFormat = extractPixelFormat(mFormat);
		array->initialize(
		mImpl,
		size,
		[pool = mPool, format = mFormat, lbp = mLocalBufferPool]() -> sp<Codec2Buffer> {
		[pool = mPool, format = mFormat, lbp = mLocalBufferPool, pixelFormat]()
		-> sp<Codec2Buffer> {
		C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
		return AllocateGraphicBuffer(
		pool, format, HAL_PIXEL_FORMAT_YV12, usage, lbp);
		pool, format, pixelFormat, usage, lbp);
		});
		return std::move(array);
		}
		@@ -1030,7 +1045,7 @@ sp<Codec2Buffer> GraphicInputBuffers::createNewBuffer() {
		// TODO: read usage from intf
		C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
		return AllocateGraphicBuffer(
		mPool, mFormat, HAL_PIXEL_FORMAT_YV12, usage, mLocalBufferPool);
		mPool, mFormat, extractPixelFormat(mFormat), usage, mLocalBufferPool);
		}

		// OutputBuffersArray

media/codec2/sfplugin/Codec2Buffer.cpp

+213 −123

File changed.

Preview size limit exceeded, changes collapsed.

media/codec2/sfplugin/tests/CCodecBuffers_test.cpp

+314 −2

Original line number	Diff line number	Diff line
		@@ -18,11 +18,12 @@

		#include <gtest/gtest.h>

		#include <media/stagefright/foundation/AString.h>
		#include <codec2/hidl/client.h>
		#include <media/stagefright/MediaCodecConstants.h>

		#include <C2BlockInternal.h>
		#include <C2PlatformSupport.h>
		#include <Codec2Mapper.h>

		namespace android {

		@@ -105,6 +106,318 @@ TEST(RawGraphicOutputBuffersTest, ChangeNumSlots) {
		}
		}

		TEST(RawGraphicOutputBuffersTest, FlexYuvColorFormat) {
		constexpr int32_t kWidth = 320;
		constexpr int32_t kHeight = 240;

		std::vector<uint32_t> flexPixelFormats({HAL_PIXEL_FORMAT_YCbCr_420_888});
		std::shared_ptr<Codec2Client> client = Codec2Client::CreateFromService("default");
		if (client) {
		// Query vendor format for Flexible YUV
		std::vector<std::unique_ptr<C2Param>> heapParams;
		C2StoreFlexiblePixelFormatDescriptorsInfo *pixelFormatInfo = nullptr;
		if (client->query(
		{},
		{C2StoreFlexiblePixelFormatDescriptorsInfo::PARAM_TYPE},
		C2_MAY_BLOCK,
		&heapParams) == C2_OK
		&& heapParams.size() == 1u) {
		pixelFormatInfo = C2StoreFlexiblePixelFormatDescriptorsInfo::From(
		heapParams[0].get());
		} else {
		pixelFormatInfo = nullptr;
		}
		if (pixelFormatInfo && *pixelFormatInfo) {
		for (size_t i = 0; i < pixelFormatInfo->flexCount(); ++i) {
		const C2FlexiblePixelFormatDescriptorStruct &desc =
		pixelFormatInfo->m.values[i];
		if (desc.bitDepth != 8
		\|\| desc.subsampling != C2Color::YUV_420
		// TODO(b/180076105): some devices report wrong layouts
		// \|\| desc.layout == C2Color::INTERLEAVED_PACKED
		// \|\| desc.layout == C2Color::INTERLEAVED_ALIGNED
		\|\| desc.layout == C2Color::UNKNOWN_LAYOUT) {
		continue;
		}
		flexPixelFormats.push_back(desc.pixelFormat);
		}
		}
		}

		for (uint32_t pixelFormat : flexPixelFormats) {
		std::shared_ptr<RawGraphicOutputBuffers> buffers =
		std::make_shared<RawGraphicOutputBuffers>(
		AStringPrintf("test pixel format 0x%x", pixelFormat).c_str());

		sp<AMessage> format{new AMessage};
		format->setInt32(KEY_WIDTH, kWidth);
		format->setInt32(KEY_HEIGHT, kHeight);
		format->setInt32(KEY_COLOR_FORMAT, COLOR_FormatYUV420Flexible);
		int32_t fwkPixelFormat = 0;
		if (C2Mapper::mapPixelFormatCodecToFramework(pixelFormat, &fwkPixelFormat)) {
		format->setInt32("android._color-format", fwkPixelFormat);
		}
		buffers->setFormat(format);

		std::shared_ptr<C2BlockPool> pool;
		ASSERT_EQ(OK, GetCodec2BlockPool(C2BlockPool::BASIC_GRAPHIC, nullptr, &pool));

		std::shared_ptr<C2GraphicBlock> block;
		ASSERT_EQ(OK, pool->fetchGraphicBlock(
		kWidth, kHeight, pixelFormat,
		C2MemoryUsage{C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}, &block));

		{
		C2GraphicView view = block->map().get();
		C2PlanarLayout layout = view.layout();

		// Verify the block is in YUV420 format
		ASSERT_EQ(C2PlanarLayout::TYPE_YUV, layout.type);
		ASSERT_EQ(3u, layout.numPlanes);
		const C2PlaneInfo& yPlane = layout.planes[C2PlanarLayout::PLANE_Y];
		const C2PlaneInfo& uPlane = layout.planes[C2PlanarLayout::PLANE_U];
		const C2PlaneInfo& vPlane = layout.planes[C2PlanarLayout::PLANE_V];

		// Y plane
		ASSERT_EQ(1u, yPlane.colSampling);
		ASSERT_EQ(1u, yPlane.rowSampling);
		ASSERT_EQ(8u, yPlane.allocatedDepth);
		ASSERT_EQ(8u, yPlane.bitDepth);
		ASSERT_EQ(0u, yPlane.rightShift);

		// U plane
		ASSERT_EQ(2u, uPlane.colSampling);
		ASSERT_EQ(2u, uPlane.rowSampling);
		ASSERT_EQ(8u, uPlane.allocatedDepth);
		ASSERT_EQ(8u, uPlane.bitDepth);
		ASSERT_EQ(0u, uPlane.rightShift);

		// V plane
		ASSERT_EQ(2u, vPlane.colSampling);
		ASSERT_EQ(2u, vPlane.rowSampling);
		ASSERT_EQ(8u, vPlane.allocatedDepth);
		ASSERT_EQ(8u, vPlane.bitDepth);
		ASSERT_EQ(0u, vPlane.rightShift);

		uint8_t *yRowPtr = view.data()[C2PlanarLayout::PLANE_Y];
		uint8_t *uRowPtr = view.data()[C2PlanarLayout::PLANE_U];
		uint8_t *vRowPtr = view.data()[C2PlanarLayout::PLANE_V];
		for (int32_t row = 0; row < kHeight; ++row) {
		uint8_t *yPtr = yRowPtr;
		uint8_t *uPtr = uRowPtr;
		uint8_t *vPtr = vRowPtr;
		for (int32_t col = 0; col < kWidth; ++col) {
		*yPtr = ((row + col) & 0xFF);
		yPtr += yPlane.colInc;

		if (row < kHeight / 2 && col < kWidth / 2) {
		*uPtr = ((row + col + 1) & 0xFF);
		*vPtr = ((row + col + 2) & 0xFF);
		uPtr += uPlane.colInc;
		vPtr += vPlane.colInc;
		}
		}
		yRowPtr += yPlane.rowInc;
		if (row < kHeight / 2) {
		uRowPtr += uPlane.rowInc;
		vRowPtr += vPlane.rowInc;
		}
		}
		}

		std::shared_ptr<C2Buffer> c2Buffer = C2Buffer::CreateGraphicBuffer(block->share(
		block->crop(), C2Fence{}));
		size_t index;
		sp<MediaCodecBuffer> clientBuffer;
		ASSERT_EQ(OK, buffers->registerBuffer(c2Buffer, &index, &clientBuffer));
		ASSERT_NE(nullptr, clientBuffer);
		sp<ABuffer> imageData;
		ASSERT_TRUE(clientBuffer->format()->findBuffer("image-data", &imageData));
		MediaImage2 img = (MediaImage2 )imageData->data();
		ASSERT_EQ(MediaImage2::MEDIA_IMAGE_TYPE_YUV, img->mType);
		ASSERT_EQ(3u, img->mNumPlanes);
		ASSERT_EQ(kWidth, img->mWidth);
		ASSERT_EQ(kHeight, img->mHeight);
		ASSERT_EQ(8u, img->mBitDepth);
		ASSERT_EQ(8u, img->mBitDepthAllocated);
		const MediaImage2::PlaneInfo &yPlane = img->mPlane[MediaImage2::Y];
		const MediaImage2::PlaneInfo &uPlane = img->mPlane[MediaImage2::U];
		const MediaImage2::PlaneInfo &vPlane = img->mPlane[MediaImage2::V];
		ASSERT_EQ(1u, yPlane.mHorizSubsampling);
		ASSERT_EQ(1u, yPlane.mVertSubsampling);
		ASSERT_EQ(2u, uPlane.mHorizSubsampling);
		ASSERT_EQ(2u, uPlane.mVertSubsampling);
		ASSERT_EQ(2u, vPlane.mHorizSubsampling);
		ASSERT_EQ(2u, vPlane.mVertSubsampling);

		uint8_t *yRowPtr = clientBuffer->data() + yPlane.mOffset;
		uint8_t *uRowPtr = clientBuffer->data() + uPlane.mOffset;
		uint8_t *vRowPtr = clientBuffer->data() + vPlane.mOffset;
		for (int32_t row = 0; row < kHeight; ++row) {
		uint8_t *yPtr = yRowPtr;
		uint8_t *uPtr = uRowPtr;
		uint8_t *vPtr = vRowPtr;
		for (int32_t col = 0; col < kWidth; ++col) {
		ASSERT_EQ((row + col) & 0xFF, *yPtr);
		yPtr += yPlane.mColInc;
		if (row < kHeight / 2 && col < kWidth / 2) {
		ASSERT_EQ((row + col + 1) & 0xFF, *uPtr);
		ASSERT_EQ((row + col + 2) & 0xFF, *vPtr);
		uPtr += uPlane.mColInc;
		vPtr += vPlane.mColInc;
		}
		}
		yRowPtr += yPlane.mRowInc;
		if (row < kHeight / 2) {
		uRowPtr += uPlane.mRowInc;
		vRowPtr += vPlane.mRowInc;
		}
		}
		}
		}

		TEST(RawGraphicOutputBuffersTest, P010ColorFormat) {
		constexpr int32_t kWidth = 320;
		constexpr int32_t kHeight = 240;

		std::shared_ptr<RawGraphicOutputBuffers> buffers =
		std::make_shared<RawGraphicOutputBuffers>("test P010");

		sp<AMessage> format{new AMessage};
		format->setInt32(KEY_WIDTH, kWidth);
		format->setInt32(KEY_HEIGHT, kHeight);
		format->setInt32(KEY_COLOR_FORMAT, COLOR_FormatYUVP010);
		int32_t fwkPixelFormat = 0;
		if (C2Mapper::mapPixelFormatCodecToFramework(HAL_PIXEL_FORMAT_YCBCR_P010, &fwkPixelFormat)) {
		format->setInt32("android._color-format", fwkPixelFormat);
		}
		buffers->setFormat(format);

		std::shared_ptr<C2BlockPool> pool;
		ASSERT_EQ(OK, GetCodec2BlockPool(C2BlockPool::BASIC_GRAPHIC, nullptr, &pool));

		std::shared_ptr<C2GraphicBlock> block;
		c2_status_t err = pool->fetchGraphicBlock(
		kWidth, kHeight, HAL_PIXEL_FORMAT_YCBCR_P010,
		C2MemoryUsage{C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}, &block);
		if (err != C2_OK) {
		GTEST_SKIP();
		}

		{
		C2GraphicView view = block->map().get();
		C2PlanarLayout layout = view.layout();

		// Verify the block is in YUV420 format
		ASSERT_EQ(C2PlanarLayout::TYPE_YUV, layout.type);
		ASSERT_EQ(3u, layout.numPlanes);
		const C2PlaneInfo& yPlane = layout.planes[C2PlanarLayout::PLANE_Y];
		const C2PlaneInfo& uPlane = layout.planes[C2PlanarLayout::PLANE_U];
		const C2PlaneInfo& vPlane = layout.planes[C2PlanarLayout::PLANE_V];

		// Y plane
		ASSERT_EQ(1u, yPlane.colSampling);
		ASSERT_EQ(1u, yPlane.rowSampling);
		ASSERT_EQ(16u, yPlane.allocatedDepth);
		ASSERT_EQ(10u, yPlane.bitDepth);
		ASSERT_EQ(6u, yPlane.rightShift);

		// U plane
		ASSERT_EQ(2u, uPlane.colSampling);
		ASSERT_EQ(2u, uPlane.rowSampling);
		ASSERT_EQ(16u, uPlane.allocatedDepth);
		ASSERT_EQ(10u, uPlane.bitDepth);
		ASSERT_EQ(6u, uPlane.rightShift);

		// V plane
		ASSERT_EQ(2u, vPlane.colSampling);
		ASSERT_EQ(2u, vPlane.rowSampling);
		ASSERT_EQ(16u, vPlane.allocatedDepth);
		ASSERT_EQ(10u, vPlane.bitDepth);
		ASSERT_EQ(6u, vPlane.rightShift);

		uint8_t *yRowPtr = view.data()[C2PlanarLayout::PLANE_Y];
		uint8_t *uRowPtr = view.data()[C2PlanarLayout::PLANE_U];
		uint8_t *vRowPtr = view.data()[C2PlanarLayout::PLANE_V];
		for (int32_t row = 0; row < kHeight; ++row) {
		uint8_t *yPtr = yRowPtr;
		uint8_t *uPtr = uRowPtr;
		uint8_t *vPtr = vRowPtr;
		for (int32_t col = 0; col < kWidth; ++col) {
		yPtr[0] = ((row + col) & 0x3) << 6;
		yPtr[1] = ((row + col) & 0x3FC) >> 2;
		yPtr += yPlane.colInc;

		if (row < kHeight / 2 && col < kWidth / 2) {
		uPtr[0] = ((row + col + 1) & 0x3) << 6;
		uPtr[1] = ((row + col + 1) & 0x3FC) >> 2;
		vPtr[0] = ((row + col + 2) & 0x3) << 6;
		vPtr[1] = ((row + col + 2) & 0x3FC) >> 2;
		uPtr += uPlane.colInc;
		vPtr += vPlane.colInc;
		}
		}
		yRowPtr += yPlane.rowInc;
		if (row < kHeight / 2) {
		uRowPtr += uPlane.rowInc;
		vRowPtr += vPlane.rowInc;
		}
		}
		}

		std::shared_ptr<C2Buffer> c2Buffer = C2Buffer::CreateGraphicBuffer(block->share(
		block->crop(), C2Fence{}));
		size_t index;
		sp<MediaCodecBuffer> clientBuffer;
		ASSERT_EQ(OK, buffers->registerBuffer(c2Buffer, &index, &clientBuffer));
		ASSERT_NE(nullptr, clientBuffer);
		sp<ABuffer> imageData;
		ASSERT_TRUE(clientBuffer->format()->findBuffer("image-data", &imageData));
		MediaImage2 img = (MediaImage2 )imageData->data();
		ASSERT_EQ(MediaImage2::MEDIA_IMAGE_TYPE_YUV, img->mType);
		ASSERT_EQ(3u, img->mNumPlanes);
		ASSERT_EQ(kWidth, img->mWidth);
		ASSERT_EQ(kHeight, img->mHeight);
		ASSERT_EQ(10u, img->mBitDepth);
		ASSERT_EQ(16u, img->mBitDepthAllocated);
		const MediaImage2::PlaneInfo &yPlane = img->mPlane[MediaImage2::Y];
		const MediaImage2::PlaneInfo &uPlane = img->mPlane[MediaImage2::U];
		const MediaImage2::PlaneInfo &vPlane = img->mPlane[MediaImage2::V];
		ASSERT_EQ(1u, yPlane.mHorizSubsampling);
		ASSERT_EQ(1u, yPlane.mVertSubsampling);
		ASSERT_EQ(2u, uPlane.mHorizSubsampling);
		ASSERT_EQ(2u, uPlane.mVertSubsampling);
		ASSERT_EQ(2u, vPlane.mHorizSubsampling);
		ASSERT_EQ(2u, vPlane.mVertSubsampling);

		uint8_t *yRowPtr = clientBuffer->data() + yPlane.mOffset;
		uint8_t *uRowPtr = clientBuffer->data() + uPlane.mOffset;
		uint8_t *vRowPtr = clientBuffer->data() + vPlane.mOffset;
		for (int32_t row = 0; row < kHeight; ++row) {
		uint8_t *yPtr = yRowPtr;
		uint8_t *uPtr = uRowPtr;
		uint8_t *vPtr = vRowPtr;
		for (int32_t col = 0; col < kWidth; ++col) {
		ASSERT_EQ(((row + col) & 0x3) << 6, yPtr[0]);
		ASSERT_EQ(((row + col) & 0x3FC) >> 2, yPtr[1]);
		yPtr += yPlane.mColInc;
		if (row < kHeight / 2 && col < kWidth / 2) {
		ASSERT_EQ(((row + col + 1) & 0x3) << 6, uPtr[0]);
		ASSERT_EQ(((row + col + 1) & 0x3FC) >> 2, uPtr[1]);
		ASSERT_EQ(((row + col + 2) & 0x3) << 6, vPtr[0]);
		ASSERT_EQ(((row + col + 2) & 0x3FC) >> 2, vPtr[1]);
		uPtr += uPlane.mColInc;
		vPtr += vPlane.mColInc;
		}
		}
		yRowPtr += yPlane.mRowInc;
		if (row < kHeight / 2) {
		uRowPtr += uPlane.mRowInc;
		vRowPtr += vPlane.mRowInc;
		}
		}
		}

		class TestGraphicAllocation : public C2GraphicAllocation {
		public:
		TestGraphicAllocation(
		@@ -407,7 +720,6 @@ public:
		}
		}
		}

		size_t yPlaneSize = stride * kHeight;
		size_t uvPlaneSize = stride * kHeight / 4;
		size_t capacity = yPlaneSize + uvPlaneSize * 2;

media/codec2/sfplugin/utils/Codec2Mapper.cpp

+11 −7

Original line number	Diff line number	Diff line
		@@ -958,17 +958,16 @@ bool C2Mapper::mapPixelFormatFrameworkToCodec(
		*c2Value = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
		return true;
		case COLOR_FormatYUV420Flexible:
		*c2Value = HAL_PIXEL_FORMAT_YCBCR_420_888;
		return true;
		case COLOR_FormatYUV420Planar:
		case COLOR_FormatYUV420SemiPlanar:
		case COLOR_FormatYUV420PackedPlanar:
		case COLOR_FormatYUV420PackedSemiPlanar:
		*c2Value = HAL_PIXEL_FORMAT_YV12;
		*c2Value = HAL_PIXEL_FORMAT_YCBCR_420_888;
		return true;
		default:
		// TODO: support some sort of passthrough
		return false;
		// Passthrough
		*c2Value = uint32_t(frameworkValue);
		return true;
		}
		}

		@@ -979,11 +978,16 @@ bool C2Mapper::mapPixelFormatCodecToFramework(
		case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
		*frameworkValue = COLOR_FormatSurface;
		return true;
		case HAL_PIXEL_FORMAT_YV12:
		case HAL_PIXEL_FORMAT_YCBCR_422_SP:
		case HAL_PIXEL_FORMAT_YCRCB_420_SP:
		case HAL_PIXEL_FORMAT_YCBCR_422_I:
		case HAL_PIXEL_FORMAT_YCBCR_420_888:
		case HAL_PIXEL_FORMAT_YV12:
		*frameworkValue = COLOR_FormatYUV420Flexible;
		return true;
		default:
		return false;
		// Passthrough
		*frameworkValue = int32_t(c2Value);
		return true;
		}
		}