Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 586c7414 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge changes I5a0827eb,Ibd0da668,I74c71975 am: 65f7dd43 am: 47bc0dd0 am:... 

Merge changes I5a0827eb,Ibd0da668,I74c71975 am: 65f7dd43 am: 47bc0dd0 am: 42813e62 am: 95c92a2c

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/1585096

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: Iff6f1d94eb87115da1361b04670bf3f9de9ede2a
parents eb603457 95c92a2c

media/codec2/sfplugin/CCodec.cpp

+82 −13
Original line number Diff line number Diff line
@@ -924,19 +924,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);

            }

        }
@@ -1089,14 +1154,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)) {
@@ -2053,7 +2122,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 {
@@ -1008,18 +1009,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);

}
@@ -1033,7 +1048,7 @@ sp<Codec2Buffer> GraphicInputBuffers::createNewBuffer() { 
    (void)mFormat->findInt64("android._C2MemoryUsage", &usageValue);

    C2MemoryUsage usage{usageValue | 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;

    }

}