USB_UVC_DETECT/MppDecoder/MppDecoder.cpp

#include "MppDecoder.h"
#include <string.h>
#include <iostream>
#include <stdexcept>

bool MppDecoder::init()
{
    MppDecCfg cfg = NULL;
    RK_U32 need_split = 1;

    if (m_rgbData == nullptr)
    {
        m_rgbData = new unsigned char[m_width * m_height * 3];
    }

    MPP_RET ret = mpp_create(&m_ctx, &m_mpi);
    if (ret)
    {
        std::cerr << "mpp_create failed\n";
        return false;
    }

    MpiCmd cmd = MPP_CMD_BASE;
    MppParam param = NULL;

    cmd = MPP_DEC_SET_PARSER_SPLIT_MODE;
    param = &need_split;
    ret = m_mpi->control(m_ctx, cmd, param);
    if (ret)
    {
        std::cerr << "set parser split mode failed\n";
        return false;
    }

    ret = mpp_init(m_ctx, MPP_CTX_DEC, MPP_VIDEO_CodingMJPEG);
    if (ret)
    {
        std::cerr << "mpp_init failed\n";
        return false;
    }

    MppFrameFormat fmt = MPP_FMT_YUV420SP;
    param = &fmt;
    ret = m_mpi->control(m_ctx, MPP_DEC_SET_OUTPUT_FORMAT, param);
    if (ret)
    {
        std::cerr << "set format failed\n";
        return false;
    }

    ret = mpp_frame_init(&m_frame);
    if (ret)
    {
        std::cerr << "mpp_frame_init failed\n";
        return false;
    }

    ret = mpp_buffer_group_get_internal(&m_frameGroup, MPP_BUFFER_TYPE_ION);
    if (ret)
    {
        std::cerr << "mpp_buffer_group_get_internal failed\n";
        return false;
    }

    ret = mpp_buffer_group_get_internal(&m_PacketGroup, MPP_BUFFER_TYPE_ION);
    if (ret)
    {
        std::cerr << "mpp_buffer_group_get_internal failed\n";
        return false;
    }

    RK_U32 hor_stride = MPP_ALIGN(m_width, 16);
    RK_U32 ver_stride = MPP_ALIGN(m_height, 16);
    ret = mpp_buffer_get(m_frameGroup, &m_frameBuffer, hor_stride * ver_stride * 4);
    if (ret)
    {
        std::cerr << "mpp_buffer_get failed\n";
        return false;
    }
    mpp_frame_set_buffer(m_frame, m_frameBuffer);

    ret = mpp_buffer_get(m_PacketGroup, &m_packetBuffer, m_width * m_height * 3);
    if (ret)
    {
        std::cerr << "mpp_buffer_get failed\n";
        return false;
    }
    ret = mpp_packet_init_with_buffer(&m_packet, m_packetBuffer);
    if (ret)
    {
        std::cerr << "mpp_packet_init_with_buffer failed\n";
        return false;
    }
    m_inputBufferPtr = (unsigned char *)mpp_buffer_get_ptr(m_packetBuffer);
    return true;
}

bool MppDecoder::decodeJpegToRgb(const char *jpegData, size_t jpegSize, unsigned char **rgbData, int *width, int *height)
{
    
    memset(m_inputBufferPtr, 0, m_width * m_height * 3);
    memcpy(m_inputBufferPtr, jpegData, jpegSize);
    mpp_packet_set_pos(m_packet, m_inputBufferPtr);
    mpp_packet_set_length(m_packet, jpegSize);
    mpp_packet_set_eos(m_packet);

    MPP_RET ret;

    ret = m_mpi->poll(m_ctx, MPP_PORT_INPUT, MPP_POLL_BLOCK);
    if (ret)
    {
        std::cerr << "m_mpi->poll failed\n";
        return false;
    }

    ret = m_mpi->dequeue(m_ctx, MPP_PORT_INPUT, &m_task);
    if (ret)
    {
        std::cerr << "m_mpi->dequeue failed\n";
        return false;
    }

    mpp_task_meta_set_packet(m_task, KEY_INPUT_PACKET, m_packet);
    mpp_task_meta_set_frame(m_task, KEY_OUTPUT_FRAME, m_frame);
    ret = m_mpi->enqueue(m_ctx, MPP_PORT_INPUT, m_task);
    if (ret)
    {
        std::cerr << "m_mpi->enqueue failed\n";
        return false;
    }

    ret = m_mpi->poll(m_ctx, MPP_PORT_OUTPUT, MPP_POLL_BLOCK);
    if (ret)
    {
        std::cerr << "m_mpi->poll failed\n";
        return false;
    }

    ret = m_mpi->dequeue(m_ctx, MPP_PORT_OUTPUT, &m_task);
    if (ret)
    {
        std::cerr << "m_mpi->dequeue failed\n";
        return false;
    }

    if (m_task)
    {
        MppFrame Output = nullptr;
        mpp_task_meta_get_frame(m_task, KEY_OUTPUT_FRAME, &Output);
        if (Output)
        {
            int width = mpp_frame_get_width(Output);
            int height = mpp_frame_get_height(Output);
            std::cout << "Output Frame Width: " << width << ", Height: " << height << std::endl;
        }
    }
}

bool MppDecoder::readMemToBuffer(const char *data, size_t size, MppBuffer &buffer)
{
    // mpp_buffer_get(m_inputBufferGroup, &buffer, size);

    // if (!buffer)
    // {
    //     std::cout << "mpp_buffer_get failed\n";
    //     return false;
    // }
    // m_inputBufferPtr = mpp_buffer_get_ptr(buffer);
    // if (!m_inputBufferPtr)
    // {
    //     std::cout << "mpp_buffer_get_ptr failed\n";
    //     return false;
    // }

    // return true;
}