使用h264_rkmpp作为解码器时候，从avcodec_receive_frame返回的frme->pkt_size一直为-1

[MUCHWAY]

1. 我正确安装了ffmpeg和rkmpp，并且使用wiki中的测试指令，可以正常找到h264_rkmpp解码器和编码器。
2. 使用命令行进行测试：

   
   ./ffmpeg -stream_loop -1 -hwaccel rkmpp -hwaccel_output_format drm_prime -i ./h264-video.mp4 -an -sn -vframes 5000 -f null -
   ./ffmpeg -stream_loop -1 -hwaccel rkmpp -i ./h264-video.mp4 -an -sn -vframes 5000 -f null -
   ./ffmpeg -stream_loop -1 -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc 1 -i ./h264-video.mp4 -an -sn -vframes 5000 -f null -

./ffmpeg -i rtsp://192.168.101.37:554/live -c:v h264_rkmpp -c:a copy rtsp_output.h264

上面几个测试，h264_rkmpp工作都是正常的。

3. 我在程序中像下面这样调用h264_rkmpp作为解码器：
```c
    AVCodec *codec_ = avcodec_find_decoder_by_name("h264_rkmpp"); //只要我把h264_rkmpp换成h264，我的代码就是工作正常的。
    if (codec_ == NULL) {
        printf("Could not find video decoder!\n");
        return -1;
    }

    g_iDecCtx = avcodec_alloc_context3(codec_);
    if (g_iDecCtx == NULL) {
        printf("Could not allocate video codec context!\n");
        return -1;
    }

    avcodec_parameters_to_context(g_iDecCtx, g_iStream->codecpar);

    int ret = avcodec_open2(g_iDecCtx, codec_, NULL);
    if (ret < 0) {
        printf("Could not open codec: %s!\n", av_err2str(ret));
        return -1;
    }

我从解码器接收解码完成的frame：

ret = avcodec_receive_frame(g_iDecCtx, g_Frame); //这里的ret返回值一直是0的
printf(" Packet Size: %d\n", g_Frame->pkt_size); //这里打印的g_Frame->pkt_size 一直是-1

4. 我将h264_rkmpp作为编码器：

   AVCodec *codec = avcodec_find_encoder_by_name("h264_rkmpp");
   if (!codec) {
       printf("Codec libx264 not found\n");
       return -1;
   }

   它作为编码器就是工作正常的。

我现在很疑惑，经过上面的验证，在命令行中使用h264_rkmpp作为编码器和解码器是ok的，在程序中作为编码器也是ok的，就是作为解码器时候就不行。

[nyanmisaka]

According to the FFmpeg documentation, the AVFrame->pkt_size is set to a negative value if unknown.

Hardware decoders are different from software decoders. You cannot trace packets based on decoded frames. This feature is not available here.

[MUCHWAY]

Thank you very much for your answer, can you share the usage when using h264_rkmpp as the decoder.

[nyanmisaka]

Thank you very much for your answer, can you share the usage when using h264_rkmpp as the decoder.

You can refer to the example qsv_decode.c. The usage of rkmpp and qsv decoders is very similar.

[MUCHWAY]

hello，I refer to the example qsv_decode.c , but the size of frame returned by avcodec_receive_frame is still -1.

/*
 * Copyright (c) 2015 Anton Khirnov
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/**
 * @file Intel QSV-accelerated H.264 decoding API usage example
 * @example qsv_decode.c
 *
 * Perform QSV-accelerated H.264 decoding with output frames in the
 * GPU video surfaces, write the decoded frames to an output file.
 */

#include <stdio.h>

#include "libavformat/avformat.h"
#include "libavformat/avio.h"

#include "libavcodec/avcodec.h"

#include "libavutil/buffer.h"
#include "libavutil/error.h"
#include "libavutil/hwcontext.h"
// #include "libavutil/hwcontext_qsv.h"
#include "libavutil/mem.h"

static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
{
    while (*pix_fmts != AV_PIX_FMT_NONE) {
        if (*pix_fmts == AV_PIX_FMT_DRM_PRIME) {
            return AV_PIX_FMT_DRM_PRIME;
        }

        pix_fmts++;
    }

    fprintf(stderr, "The QSV pixel format not offered in get_format()\n");

    return AV_PIX_FMT_NONE;
}

static int decode_packet(AVCodecContext *decoder_ctx,
                         AVFrame *frame, AVFrame *sw_frame,
                         AVPacket *pkt, AVIOContext *output_ctx)
{
    int ret = 0;

    ret = avcodec_send_packet(decoder_ctx, pkt);
    if (ret < 0) {
        fprintf(stderr, "Error during decoding\n");
        return ret;
    }

    while (ret >= 0) {
        int i, j;

        ret = avcodec_receive_frame(decoder_ctx, frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            fprintf(stderr, "Error during decoding\n");
            return ret;
        }

        printf("size %d\n", frame->pkt_size);

        /* A real program would do something useful with the decoded frame here.
         * We just retrieve the raw data and write it to a file, which is rather
         * useless but pedagogic. */
        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
        if (ret < 0) {
            fprintf(stderr, "Error transferring the data to system memory\n");
            goto fail;
        }

        for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
            for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
                avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);

fail:
        av_frame_unref(sw_frame);
        av_frame_unref(frame);

        if (ret < 0)
            return ret;
    }

    return 0;
}

int main(int argc, char **argv)
{
    AVFormatContext *input_ctx = NULL;
    AVStream *video_st = NULL;
    AVCodecContext *decoder_ctx = NULL;
    const AVCodec *decoder;

    AVPacket *pkt = NULL;
    AVFrame *frame = NULL, *sw_frame = NULL;

    AVIOContext *output_ctx = NULL;

    int ret, i;

    AVBufferRef *device_ref = NULL;

    if (argc < 3) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        return 1;
    }

    /* open the input file */
    ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
        goto finish;
    }

    /* find the first H.264 video stream */
    for (i = 0; i < input_ctx->nb_streams; i++) {
        AVStream *st = input_ctx->streams[i];

        if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
            video_st = st;
        else
            st->discard = AVDISCARD_ALL;
    }
    if (!video_st) {
        fprintf(stderr, "No H.264 video stream in the input file\n");
        goto finish;
    }

    /* open the hardware device */
    ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_RKMPP,
                                 "auto", NULL, 0);
    if (ret < 0) {
        fprintf(stderr, "Cannot open the hardware device\n");
        goto finish;
    }

    /* initialize the decoder */
    decoder = avcodec_find_decoder_by_name("h264_rkmpp");
    if (!decoder) {
        fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
        goto finish;
    }

    decoder_ctx = avcodec_alloc_context3(decoder);
    if (!decoder_ctx) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }
    decoder_ctx->codec_id = AV_CODEC_ID_H264;
    if (video_st->codecpar->extradata_size) {
        decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
                                            AV_INPUT_BUFFER_PADDING_SIZE);
        if (!decoder_ctx->extradata) {
            ret = AVERROR(ENOMEM);
            goto finish;
        }
        memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
               video_st->codecpar->extradata_size);
        decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
    }

    decoder_ctx->hw_device_ctx = av_buffer_ref(device_ref);
    decoder_ctx->get_format  = get_format;

    ret = avcodec_open2(decoder_ctx, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Error opening the decoder: ");
        goto finish;
    }

    /* open the output stream */
    ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Error opening the output context: ");
        goto finish;
    }

    frame    = av_frame_alloc();
    sw_frame = av_frame_alloc();
    pkt      = av_packet_alloc();
    if (!frame || !sw_frame || !pkt) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }

    /* actual decoding */
    while (ret >= 0) {
        ret = av_read_frame(input_ctx, pkt);
        if (ret < 0)
            break;

        if (pkt->stream_index == video_st->index)
            ret = decode_packet(decoder_ctx, frame, sw_frame, pkt, output_ctx);

        av_packet_unref(pkt);
    }

    /* flush the decoder */
    ret = decode_packet(decoder_ctx, frame, sw_frame, NULL, output_ctx);

finish:
    if (ret < 0) {
        char buf[1024];
        av_strerror(ret, buf, sizeof(buf));
        fprintf(stderr, "%s\n", buf);
    }

    avformat_close_input(&input_ctx);

    av_frame_free(&frame);
    av_frame_free(&sw_frame);
    av_packet_free(&pkt);

    avcodec_free_context(&decoder_ctx);

    av_buffer_unref(&device_ref);

    avio_close(output_ctx);

    return ret;
}

[nyanmisaka]

What do you mean size of frame?

The objects produced by the decoder is frame, not packet (pkt). So pkt_size is always the default value -1.

What you are looking for should be buffer size. (AVFrame->buf)