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

Commit 40a312cd authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "CCodec: FrameReassembler to accept 0-size frames" am: c4764e0a 

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

Change-Id: I96e6b93fdf84cc6b4d72d3211ea0da5d3c3989d8
parents c3aa7691 c4764e0a

media/codec2/sfplugin/CCodecBufferChannel.cpp

+6 −0
Original line number Diff line number Diff line
@@ -276,6 +276,12 @@ status_t CCodecBufferChannel::queueInputBufferInternal( 
            }

        }

    } else if (eos) {

        Mutexed<Input>::Locked input(mInput);

        if (input->frameReassembler) {

            usesFrameReassembler = true;

            // drain any pending items with eos

            input->frameReassembler.process(buffer, &items);

        }

        flags |= C2FrameData::FLAG_END_OF_STREAM;

    }

    if (usesFrameReassembler) {

media/codec2/sfplugin/FrameReassembler.cpp

+1 −2
Original line number Diff line number Diff line
@@ -88,8 +88,7 @@ c2_status_t FrameReassembler::process( 
        const sp<MediaCodecBuffer> &buffer,

        std::list<std::unique_ptr<C2Work>> *items) {

    int64_t timeUs;

    if (buffer->size() == 0u

            || !buffer->meta()->findInt64("timeUs", &timeUs)) {

    if (!buffer->meta()->findInt64("timeUs", &timeUs)) {

        return C2_BAD_VALUE;

    }

media/codec2/sfplugin/tests/FrameReassembler_test.cpp

+214 −173
Original line number Diff line number Diff line
@@ -53,7 +53,8 @@ public: 
            C2Config::pcm_encoding_t encoding,

            size_t inputFrameSizeInBytes,

            size_t count,

            size_t expectedOutputSize) {

            size_t expectedOutputSize,

            bool separateEos) {

        FrameReassembler frameReassembler;

        frameReassembler.init(

                mPool,
@@ -67,7 +68,7 @@ public: 


        size_t inputIndex = 0, outputIndex = 0;

        size_t expectCount = 0;

        for (size_t i = 0; i < count; ++i) {

        for (size_t i = 0; i < count + (separateEos ? 1 : 0); ++i) {

            sp<MediaCodecBuffer> buffer = new MediaCodecBuffer(

                    new AMessage, new ABuffer(inputFrameSizeInBytes));

            buffer->setRange(0, inputFrameSizeInBytes);
@@ -77,9 +78,13 @@ public: 
            if (i == count - 1) {

                buffer->meta()->setInt32("eos", 1);

            }

            if (i == count && separateEos) {

                buffer->setRange(0, 0);

            } else {

                for (size_t j = 0; j < inputFrameSizeInBytes; ++j, ++inputIndex) {

                    buffer->base()[j] = (inputIndex & 0xFF);

                }

            }

            std::list<std::unique_ptr<C2Work>> items;

            ASSERT_EQ(C2_OK, frameReassembler.process(buffer, &items));

            while (!items.empty()) {
@@ -105,7 +110,8 @@ public: 
                ASSERT_EQ(encoderFrameSize * BytesPerSample(encoding), view.capacity());

                for (size_t j = 0; j < view.capacity(); ++j, ++outputIndex) {

                    ASSERT_TRUE(outputIndex < inputIndex

                             || inputIndex == inputFrameSizeInBytes * count);

                             || inputIndex == inputFrameSizeInBytes * count)

                        << "inputIndex = " << inputIndex << " outputIndex = " << outputIndex;

                    uint8_t expected = outputIndex < inputIndex ? (outputIndex & 0xFF) : 0;

                    if (expectCount < 10) {

                        ++expectCount;
@@ -137,6 +143,7 @@ const C2MemoryUsage FrameReassemblerTest::kUsage{C2MemoryUsage::CPU_READ, C2Memo 
// Push frames with exactly the same size as the encoder requested.

TEST_F(FrameReassemblerTest, PushExactFrameSize) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -144,7 +151,8 @@ TEST_F(FrameReassemblerTest, PushExactFrameSize) { 
                PCM_8,

                1024 /* input frame size in bytes = 1024 samples * 1 channel * 1 bytes/sample */,

                10 /* count */,

            10240 /* expected output size = 10 * 1024 bytes/frame */);

                10240 /* expected output size = 10 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -152,7 +160,8 @@ TEST_F(FrameReassemblerTest, PushExactFrameSize) { 
                PCM_16,

                2048 /* input frame size in bytes = 1024 samples * 1 channel * 2 bytes/sample */,

                10 /* count */,

            20480 /* expected output size = 10 * 2048 bytes/frame */);

                20480 /* expected output size = 10 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -160,128 +169,151 @@ TEST_F(FrameReassemblerTest, PushExactFrameSize) { 
                PCM_FLOAT,

                4096 /* input frame size in bytes = 1024 samples * 1 channel * 4 bytes/sample */,

                10 /* count */,

            40960 /* expected output size = 10 * 4096 bytes/frame */);

                40960 /* expected output size = 10 * 4096 bytes/frame */,

                separateEos);

    }

}



// Push frames with half the size that the encoder requested.

TEST_F(FrameReassemblerTest, PushHalfFrameSize) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_8,

            512 /* input frame size in bytes = 512 samples * 1 channel * 1 bytes per sample */,

                512 /* input frame size in bytes = 512 samples * 1 channel * 1 bytes/sample */,

                10 /* count */,

            5120 /* expected output size = 5 * 1024 bytes/frame */);

                5120 /* expected output size = 5 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_16,

            1024 /* input frame size in bytes = 512 samples * 1 channel * 2 bytes per sample */,

                1024 /* input frame size in bytes = 512 samples * 1 channel * 2 bytes/sample */,

                10 /* count */,

            10240 /* expected output size = 5 * 2048 bytes/frame */);

                10240 /* expected output size = 5 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_FLOAT,

            2048 /* input frame size in bytes = 512 samples * 1 channel * 4 bytes per sample */,

                2048 /* input frame size in bytes = 512 samples * 1 channel * 4 bytes/sample */,

                10 /* count */,

            20480 /* expected output size = 5 * 4096 bytes/frame */);

                20480 /* expected output size = 5 * 4096 bytes/frame */,

                separateEos);

    }

}



// Push frames with twice the size that the encoder requested.

TEST_F(FrameReassemblerTest, PushDoubleFrameSize) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_8,

            2048 /* input frame size in bytes = 2048 samples * 1 channel * 1 bytes per sample */,

                2048 /* input frame size in bytes = 2048 samples * 1 channel * 1 bytes/sample */,

                10 /* count */,

            20480 /* expected output size = 20 * 1024 bytes/frame */);

                20480 /* expected output size = 20 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_16,

            4096 /* input frame size in bytes = 2048 samples * 1 channel * 2 bytes per sample */,

                4096 /* input frame size in bytes = 2048 samples * 1 channel * 2 bytes/sample */,

                10 /* count */,

            40960 /* expected output size = 20 * 2048 bytes/frame */);

                40960 /* expected output size = 20 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_FLOAT,

            8192 /* input frame size in bytes = 2048 samples * 1 channel * 4 bytes per sample */,

                8192 /* input frame size in bytes = 2048 samples * 1 channel * 4 bytes/sample */,

                10 /* count */,

            81920 /* expected output size = 20 * 4096 bytes/frame */);

                81920 /* expected output size = 20 * 4096 bytes/frame */,

                separateEos);

    }

}



// Push frames with a little bit larger (+5 samples) than the requested size.

TEST_F(FrameReassemblerTest, PushLittleLargerFrameSize) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_8,

            1029 /* input frame size in bytes = 1029 samples * 1 channel * 1 bytes per sample */,

                1029 /* input frame size in bytes = 1029 samples * 1 channel * 1 bytes/sample */,

                10 /* count */,

            11264 /* expected output size = 11 * 1024 bytes/frame */);

                11264 /* expected output size = 11 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_16,

            2058 /* input frame size in bytes = 1029 samples * 1 channel * 2 bytes per sample */,

                2058 /* input frame size in bytes = 1029 samples * 1 channel * 2 bytes/sample */,

                10 /* count */,

            22528 /* expected output size = 11 * 2048 bytes/frame */);

                22528 /* expected output size = 11 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_FLOAT,

            4116 /* input frame size in bytes = 1029 samples * 1 channel * 4 bytes per sample */,

                4116 /* input frame size in bytes = 1029 samples * 1 channel * 4 bytes/sample */,

                10 /* count */,

            45056 /* expected output size = 11 * 4096 bytes/frame */);

                45056 /* expected output size = 11 * 4096 bytes/frame */,

                separateEos);

    }

}



// Push frames with a little bit smaller (-5 samples) than the requested size.

TEST_F(FrameReassemblerTest, PushLittleSmallerFrameSize) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_8,

            1019 /* input frame size in bytes = 1019 samples * 1 channel * 1 bytes per sample */,

                1019 /* input frame size in bytes = 1019 samples * 1 channel * 1 bytes/sample */,

                10 /* count */,

            10240 /* expected output size = 10 * 1024 bytes/frame */);

                10240 /* expected output size = 10 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_16,

            2038 /* input frame size in bytes = 1019 samples * 1 channel * 2 bytes per sample */,

                2038 /* input frame size in bytes = 1019 samples * 1 channel * 2 bytes/sample */,

                10 /* count */,

            20480 /* expected output size = 10 * 2048 bytes/frame */);

                20480 /* expected output size = 10 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,

                1 /* channel count */,

                PCM_FLOAT,

            4076 /* input frame size in bytes = 1019 samples * 1 channel * 4 bytes per sample */,

                4076 /* input frame size in bytes = 1019 samples * 1 channel * 4 bytes/sample */,

                10 /* count */,

            40960 /* expected output size = 10 * 4096 bytes/frame */);

                40960 /* expected output size = 10 * 4096 bytes/frame */,

                separateEos);

    }

}



// Push single-byte frames

TEST_F(FrameReassemblerTest, PushSingleByte) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -289,7 +321,8 @@ TEST_F(FrameReassemblerTest, PushSingleByte) { 
                PCM_8,

                1 /* input frame size in bytes */,

                100000 /* count */,

            100352 /* expected output size = 98 * 1024 bytes/frame */);

                100352 /* expected output size = 98 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -297,7 +330,8 @@ TEST_F(FrameReassemblerTest, PushSingleByte) { 
                PCM_16,

                1 /* input frame size in bytes */,

                100000 /* count */,

            100352 /* expected output size = 49 * 2048 bytes/frame */);

                100352 /* expected output size = 49 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -305,12 +339,15 @@ TEST_F(FrameReassemblerTest, PushSingleByte) { 
                PCM_FLOAT,

                1 /* input frame size in bytes */,

                100000 /* count */,

            102400 /* expected output size = 25 * 4096 bytes/frame */);

                102400 /* expected output size = 25 * 4096 bytes/frame */,

                separateEos);

    }

}



// Push one big chunk.

TEST_F(FrameReassemblerTest, PushBigChunk) {

    ASSERT_EQ(OK, initStatus());

    for (bool separateEos : {false, true}) {

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -318,7 +355,8 @@ TEST_F(FrameReassemblerTest, PushBigChunk) { 
                PCM_8,

                100000 /* input frame size in bytes */,

                1 /* count */,

            100352 /* expected output size = 98 * 1024 bytes/frame */);

                100352 /* expected output size = 98 * 1024 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -326,7 +364,8 @@ TEST_F(FrameReassemblerTest, PushBigChunk) { 
                PCM_16,

                100000 /* input frame size in bytes */,

                1 /* count */,

            100352 /* expected output size = 49 * 2048 bytes/frame */);

                100352 /* expected output size = 49 * 2048 bytes/frame */,

                separateEos);

        testPushSameSize(

                1024 /* frame size in samples */,

                48000 /* sample rate */,
@@ -334,7 +373,9 @@ TEST_F(FrameReassemblerTest, PushBigChunk) { 
                PCM_FLOAT,

                100000 /* input frame size in bytes */,

                1 /* count */,

            102400 /* expected output size = 25 * 4096 bytes/frame */);

                102400 /* expected output size = 25 * 4096 bytes/frame */,

                separateEos);

    }

}



} // namespace android