avcodec/rkmpp : Fix broken build due to missing control operation
[ffmpeg.git] / libavcodec / rkmppdec.c
1 /*
2  * RockChip MPP Video Decoder
3  * Copyright (c) 2017 Lionel CHAZALLON
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <drm_fourcc.h>
23 #include <pthread.h>
24 #include <rockchip/mpp_buffer.h>
25 #include <rockchip/rk_mpi.h>
26 #include <time.h>
27 #include <unistd.h>
28
29 #include "avcodec.h"
30 #include "decode.h"
31 #include "hwaccel.h"
32 #include "internal.h"
33 #include "libavutil/buffer.h"
34 #include "libavutil/common.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/hwcontext.h"
37 #include "libavutil/hwcontext_drm.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/log.h"
40
41 #define RECEIVE_FRAME_TIMEOUT   100
42 #define FRAMEGROUP_MAX_FRAMES   16
43 #define INPUT_MAX_PACKETS       4
44
45 typedef struct {
46     MppCtx ctx;
47     MppApi *mpi;
48     MppBufferGroup frame_group;
49
50     char first_frame;
51     char first_packet;
52     char eos_reached;
53
54     AVBufferRef *frames_ref;
55     AVBufferRef *device_ref;
56 } RKMPPDecoder;
57
58 typedef struct {
59     AVClass *av_class;
60     AVBufferRef *decoder_ref;
61 } RKMPPDecodeContext;
62
63 typedef struct {
64     MppFrame frame;
65     AVBufferRef *decoder_ref;
66 } RKMPPFrameContext;
67
68 static MppCodingType rkmpp_get_codingtype(AVCodecContext *avctx)
69 {
70     switch (avctx->codec_id) {
71     case AV_CODEC_ID_H264:          return MPP_VIDEO_CodingAVC;
72     case AV_CODEC_ID_HEVC:          return MPP_VIDEO_CodingHEVC;
73     case AV_CODEC_ID_VP8:           return MPP_VIDEO_CodingVP8;
74     case AV_CODEC_ID_VP9:           return MPP_VIDEO_CodingVP9;
75     default:                        return MPP_VIDEO_CodingUnused;
76     }
77 }
78
79 static uint32_t rkmpp_get_frameformat(MppFrameFormat mppformat)
80 {
81     switch (mppformat) {
82     case MPP_FMT_YUV420SP:          return DRM_FORMAT_NV12;
83 #ifdef DRM_FORMAT_NV12_10
84     case MPP_FMT_YUV420SP_10BIT:    return DRM_FORMAT_NV12_10;
85 #endif
86     default:                        return 0;
87     }
88 }
89
90 static int rkmpp_write_data(AVCodecContext *avctx, uint8_t *buffer, int size, int64_t pts)
91 {
92     RKMPPDecodeContext *rk_context = avctx->priv_data;
93     RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
94     int ret;
95     MppPacket packet;
96
97     // create the MPP packet
98     ret = mpp_packet_init(&packet, buffer, size);
99     if (ret != MPP_OK) {
100         av_log(avctx, AV_LOG_ERROR, "Failed to init MPP packet (code = %d)\n", ret);
101         return AVERROR_UNKNOWN;
102     }
103
104     mpp_packet_set_pts(packet, pts);
105
106     if (!buffer)
107         mpp_packet_set_eos(packet);
108
109     ret = decoder->mpi->decode_put_packet(decoder->ctx, packet);
110     if (ret != MPP_OK) {
111         if (ret == MPP_ERR_BUFFER_FULL) {
112             av_log(avctx, AV_LOG_DEBUG, "Buffer full writing %d bytes to decoder\n", size);
113             ret = AVERROR(EAGAIN);
114         } else
115             ret = AVERROR_UNKNOWN;
116     }
117     else
118         av_log(avctx, AV_LOG_DEBUG, "Wrote %d bytes to decoder\n", size);
119
120     mpp_packet_deinit(&packet);
121
122     return ret;
123 }
124
125 static int rkmpp_close_decoder(AVCodecContext *avctx)
126 {
127     RKMPPDecodeContext *rk_context = avctx->priv_data;
128     av_buffer_unref(&rk_context->decoder_ref);
129     return 0;
130 }
131
132 static void rkmpp_release_decoder(void *opaque, uint8_t *data)
133 {
134     RKMPPDecoder *decoder = (RKMPPDecoder *)data;
135
136     if (decoder->mpi) {
137         decoder->mpi->reset(decoder->ctx);
138         mpp_destroy(decoder->ctx);
139         decoder->ctx = NULL;
140     }
141
142     if (decoder->frame_group) {
143         mpp_buffer_group_put(decoder->frame_group);
144         decoder->frame_group = NULL;
145     }
146
147     av_buffer_unref(&decoder->frames_ref);
148     av_buffer_unref(&decoder->device_ref);
149
150     av_free(decoder);
151 }
152
153 static int rkmpp_init_decoder(AVCodecContext *avctx)
154 {
155     RKMPPDecodeContext *rk_context = avctx->priv_data;
156     RKMPPDecoder *decoder = NULL;
157     MppCodingType codectype = MPP_VIDEO_CodingUnused;
158     int ret;
159     RK_S64 paramS64;
160     RK_S32 paramS32;
161
162     avctx->pix_fmt = AV_PIX_FMT_DRM_PRIME;
163
164     // create a decoder and a ref to it
165     decoder = av_mallocz(sizeof(RKMPPDecoder));
166     if (!decoder) {
167         ret = AVERROR(ENOMEM);
168         goto fail;
169     }
170
171     rk_context->decoder_ref = av_buffer_create((uint8_t *)decoder, sizeof(*decoder), rkmpp_release_decoder,
172                                                NULL, AV_BUFFER_FLAG_READONLY);
173     if (!rk_context->decoder_ref) {
174         av_free(decoder);
175         ret = AVERROR(ENOMEM);
176         goto fail;
177     }
178
179     av_log(avctx, AV_LOG_DEBUG, "Initializing RKMPP decoder.\n");
180
181     codectype = rkmpp_get_codingtype(avctx);
182     if (codectype == MPP_VIDEO_CodingUnused) {
183         av_log(avctx, AV_LOG_ERROR, "Unknown codec type (%d).\n", avctx->codec_id);
184         ret = AVERROR_UNKNOWN;
185         goto fail;
186     }
187
188     ret = mpp_check_support_format(MPP_CTX_DEC, codectype);
189     if (ret != MPP_OK) {
190         av_log(avctx, AV_LOG_ERROR, "Codec type (%d) unsupported by MPP\n", avctx->codec_id);
191         ret = AVERROR_UNKNOWN;
192         goto fail;
193     }
194
195     // Create the MPP context
196     ret = mpp_create(&decoder->ctx, &decoder->mpi);
197     if (ret != MPP_OK) {
198         av_log(avctx, AV_LOG_ERROR, "Failed to create MPP context (code = %d).\n", ret);
199         ret = AVERROR_UNKNOWN;
200         goto fail;
201     }
202
203     // initialize mpp
204     ret = mpp_init(decoder->ctx, MPP_CTX_DEC, codectype);
205     if (ret != MPP_OK) {
206         av_log(avctx, AV_LOG_ERROR, "Failed to initialize MPP context (code = %d).\n", ret);
207         ret = AVERROR_UNKNOWN;
208         goto fail;
209     }
210
211     // make decode calls blocking with a timeout
212     paramS32 = MPP_POLL_BLOCK;
213     ret = decoder->mpi->control(decoder->ctx, MPP_SET_OUTPUT_BLOCK, &paramS32);
214     if (ret != MPP_OK) {
215         av_log(avctx, AV_LOG_ERROR, "Failed to set blocking mode on MPI (code = %d).\n", ret);
216         ret = AVERROR_UNKNOWN;
217         goto fail;
218     }
219
220     paramS64 = RECEIVE_FRAME_TIMEOUT;
221     ret = decoder->mpi->control(decoder->ctx, MPP_SET_OUTPUT_BLOCK_TIMEOUT, &paramS64);
222     if (ret != MPP_OK) {
223         av_log(avctx, AV_LOG_ERROR, "Failed to set block timeout on MPI (code = %d).\n", ret);
224         ret = AVERROR_UNKNOWN;
225         goto fail;
226     }
227
228     ret = mpp_buffer_group_get_internal(&decoder->frame_group, MPP_BUFFER_TYPE_ION);
229     if (ret) {
230        av_log(avctx, AV_LOG_ERROR, "Failed to retrieve buffer group (code = %d)\n", ret);
231        ret = AVERROR_UNKNOWN;
232        goto fail;
233     }
234
235     ret = decoder->mpi->control(decoder->ctx, MPP_DEC_SET_EXT_BUF_GROUP, decoder->frame_group);
236     if (ret) {
237         av_log(avctx, AV_LOG_ERROR, "Failed to assign buffer group (code = %d)\n", ret);
238         ret = AVERROR_UNKNOWN;
239         goto fail;
240     }
241
242     ret = mpp_buffer_group_limit_config(decoder->frame_group, 0, FRAMEGROUP_MAX_FRAMES);
243     if (ret) {
244         av_log(avctx, AV_LOG_ERROR, "Failed to set buffer group limit (code = %d)\n", ret);
245         ret = AVERROR_UNKNOWN;
246         goto fail;
247     }
248
249     decoder->first_packet = 1;
250
251     av_log(avctx, AV_LOG_DEBUG, "RKMPP decoder initialized successfully.\n");
252
253     decoder->device_ref = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_DRM);
254     if (!decoder->device_ref) {
255         ret = AVERROR(ENOMEM);
256         goto fail;
257     }
258     ret = av_hwdevice_ctx_init(decoder->device_ref);
259     if (ret < 0)
260         goto fail;
261
262     return 0;
263
264 fail:
265     av_log(avctx, AV_LOG_ERROR, "Failed to initialize RKMPP decoder.\n");
266     rkmpp_close_decoder(avctx);
267     return ret;
268 }
269
270 static int rkmpp_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
271 {
272     RKMPPDecodeContext *rk_context = avctx->priv_data;
273     RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
274     int ret;
275
276     // handle EOF
277     if (!avpkt->size) {
278         av_log(avctx, AV_LOG_DEBUG, "End of stream.\n");
279         decoder->eos_reached = 1;
280         ret = rkmpp_write_data(avctx, NULL, 0, 0);
281         if (ret)
282             av_log(avctx, AV_LOG_ERROR, "Failed to send EOS to decoder (code = %d)\n", ret);
283         return ret;
284     }
285
286     // on first packet, send extradata
287     if (decoder->first_packet) {
288         if (avctx->extradata_size) {
289             ret = rkmpp_write_data(avctx, avctx->extradata,
290                                             avctx->extradata_size,
291                                             avpkt->pts);
292             if (ret) {
293                 av_log(avctx, AV_LOG_ERROR, "Failed to write extradata to decoder (code = %d)\n", ret);
294                 return ret;
295             }
296         }
297         decoder->first_packet = 0;
298     }
299
300     // now send packet
301     ret = rkmpp_write_data(avctx, avpkt->data, avpkt->size, avpkt->pts);
302     if (ret && ret!=AVERROR(EAGAIN))
303         av_log(avctx, AV_LOG_ERROR, "Failed to write data to decoder (code = %d)\n", ret);
304
305     return ret;
306 }
307
308 static void rkmpp_release_frame(void *opaque, uint8_t *data)
309 {
310     AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor *)data;
311     AVBufferRef *framecontextref = (AVBufferRef *)opaque;
312     RKMPPFrameContext *framecontext = (RKMPPFrameContext *)framecontextref->data;
313
314     mpp_frame_deinit(&framecontext->frame);
315     av_buffer_unref(&framecontext->decoder_ref);
316     av_buffer_unref(&framecontextref);
317
318     av_free(desc);
319 }
320
321 static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame)
322 {
323     RKMPPDecodeContext *rk_context = avctx->priv_data;
324     RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
325     RKMPPFrameContext *framecontext = NULL;
326     AVBufferRef *framecontextref = NULL;
327     int ret;
328     MppFrame mppframe = NULL;
329     MppBuffer buffer = NULL;
330     AVDRMFrameDescriptor *desc = NULL;
331     AVDRMLayerDescriptor *layer = NULL;
332     int retrycount = 0;
333     int mode;
334     MppFrameFormat mppformat;
335     uint32_t drmformat;
336
337     // on start of decoding, MPP can return -1, which is supposed to be expected
338     // this is due to some internal MPP init which is not completed, that will
339     // only happen in the first few frames queries, but should not be interpreted
340     // as an error, Therefore we need to retry a couple times when we get -1
341     // in order to let it time to complete it's init, then we sleep a bit between retries.
342 retry_get_frame:
343     ret = decoder->mpi->decode_get_frame(decoder->ctx, &mppframe);
344     if (ret != MPP_OK && ret != MPP_ERR_TIMEOUT && !decoder->first_frame) {
345         if (retrycount < 5) {
346             av_log(avctx, AV_LOG_DEBUG, "Failed to get a frame, retrying (code = %d, retrycount = %d)\n", ret, retrycount);
347             usleep(10000);
348             retrycount++;
349             goto retry_get_frame;
350         } else {
351             av_log(avctx, AV_LOG_ERROR, "Failed to get a frame from MPP (code = %d)\n", ret);
352             goto fail;
353         }
354     }
355
356     if (mppframe) {
357         // Check whether we have a special frame or not
358         if (mpp_frame_get_info_change(mppframe)) {
359             AVHWFramesContext *hwframes;
360
361             av_log(avctx, AV_LOG_INFO, "Decoder noticed an info change (%dx%d), format=%d\n",
362                                         (int)mpp_frame_get_width(mppframe), (int)mpp_frame_get_height(mppframe),
363                                         (int)mpp_frame_get_fmt(mppframe));
364
365             avctx->width = mpp_frame_get_width(mppframe);
366             avctx->height = mpp_frame_get_height(mppframe);
367
368             decoder->mpi->control(decoder->ctx, MPP_DEC_SET_INFO_CHANGE_READY, NULL);
369             decoder->first_frame = 1;
370
371             av_buffer_unref(&decoder->frames_ref);
372
373             decoder->frames_ref = av_hwframe_ctx_alloc(decoder->device_ref);
374             if (!decoder->frames_ref) {
375                 ret = AVERROR(ENOMEM);
376                 goto fail;
377             }
378
379             mppformat = mpp_frame_get_fmt(mppframe);
380             drmformat = rkmpp_get_frameformat(mppformat);
381
382             hwframes = (AVHWFramesContext*)decoder->frames_ref->data;
383             hwframes->format    = AV_PIX_FMT_DRM_PRIME;
384             hwframes->sw_format = drmformat == DRM_FORMAT_NV12 ? AV_PIX_FMT_NV12 : AV_PIX_FMT_NONE;
385             hwframes->width     = avctx->width;
386             hwframes->height    = avctx->height;
387             ret = av_hwframe_ctx_init(decoder->frames_ref);
388             if (ret < 0)
389                 goto fail;
390
391             // here decoder is fully initialized, we need to feed it again with data
392             ret = AVERROR(EAGAIN);
393             goto fail;
394         } else if (mpp_frame_get_eos(mppframe)) {
395             av_log(avctx, AV_LOG_DEBUG, "Received a EOS frame.\n");
396             decoder->eos_reached = 1;
397             ret = AVERROR_EOF;
398             goto fail;
399         } else if (mpp_frame_get_discard(mppframe)) {
400             av_log(avctx, AV_LOG_DEBUG, "Received a discard frame.\n");
401             ret = AVERROR(EAGAIN);
402             goto fail;
403         } else if (mpp_frame_get_errinfo(mppframe)) {
404             av_log(avctx, AV_LOG_ERROR, "Received a errinfo frame.\n");
405             ret = AVERROR_UNKNOWN;
406             goto fail;
407         }
408
409         // here we should have a valid frame
410         av_log(avctx, AV_LOG_DEBUG, "Received a frame.\n");
411
412         // setup general frame fields
413         frame->format           = AV_PIX_FMT_DRM_PRIME;
414         frame->width            = mpp_frame_get_width(mppframe);
415         frame->height           = mpp_frame_get_height(mppframe);
416         frame->pts              = mpp_frame_get_pts(mppframe);
417         frame->color_range      = mpp_frame_get_color_range(mppframe);
418         frame->color_primaries  = mpp_frame_get_color_primaries(mppframe);
419         frame->color_trc        = mpp_frame_get_color_trc(mppframe);
420         frame->colorspace       = mpp_frame_get_colorspace(mppframe);
421
422         mode = mpp_frame_get_mode(mppframe);
423         frame->interlaced_frame = ((mode & MPP_FRAME_FLAG_FIELD_ORDER_MASK) == MPP_FRAME_FLAG_DEINTERLACED);
424         frame->top_field_first  = ((mode & MPP_FRAME_FLAG_FIELD_ORDER_MASK) == MPP_FRAME_FLAG_TOP_FIRST);
425
426         mppformat = mpp_frame_get_fmt(mppframe);
427         drmformat = rkmpp_get_frameformat(mppformat);
428
429         // now setup the frame buffer info
430         buffer = mpp_frame_get_buffer(mppframe);
431         if (buffer) {
432             desc = av_mallocz(sizeof(AVDRMFrameDescriptor));
433             if (!desc) {
434                 ret = AVERROR(ENOMEM);
435                 goto fail;
436             }
437
438             desc->nb_objects = 1;
439             desc->objects[0].fd = mpp_buffer_get_fd(buffer);
440             desc->objects[0].size = mpp_buffer_get_size(buffer);
441
442             desc->nb_layers = 1;
443             layer = &desc->layers[0];
444             layer->format = drmformat;
445             layer->nb_planes = 2;
446
447             layer->planes[0].object_index = 0;
448             layer->planes[0].offset = 0;
449             layer->planes[0].pitch = mpp_frame_get_hor_stride(mppframe);
450
451             layer->planes[1].object_index = 0;
452             layer->planes[1].offset = layer->planes[0].pitch * mpp_frame_get_ver_stride(mppframe);
453             layer->planes[1].pitch = layer->planes[0].pitch;
454
455             // we also allocate a struct in buf[0] that will allow to hold additionnal information
456             // for releasing properly MPP frames and decoder
457             framecontextref = av_buffer_allocz(sizeof(*framecontext));
458             if (!framecontextref) {
459                 ret = AVERROR(ENOMEM);
460                 goto fail;
461             }
462
463             // MPP decoder needs to be closed only when all frames have been released.
464             framecontext = (RKMPPFrameContext *)framecontextref->data;
465             framecontext->decoder_ref = av_buffer_ref(rk_context->decoder_ref);
466             framecontext->frame = mppframe;
467
468             frame->data[0]  = (uint8_t *)desc;
469             frame->buf[0]   = av_buffer_create((uint8_t *)desc, sizeof(*desc), rkmpp_release_frame,
470                                                framecontextref, AV_BUFFER_FLAG_READONLY);
471
472             if (!frame->buf[0]) {
473                 ret = AVERROR(ENOMEM);
474                 goto fail;
475             }
476
477             frame->hw_frames_ctx = av_buffer_ref(decoder->frames_ref);
478             if (!frame->hw_frames_ctx) {
479                 ret = AVERROR(ENOMEM);
480                 goto fail;
481             }
482
483             decoder->first_frame = 0;
484             return 0;
485         } else {
486             av_log(avctx, AV_LOG_ERROR, "Failed to retrieve the frame buffer, frame is dropped (code = %d)\n", ret);
487             mpp_frame_deinit(&mppframe);
488         }
489     } else if (decoder->eos_reached) {
490         return AVERROR_EOF;
491     } else if (ret == MPP_ERR_TIMEOUT) {
492         av_log(avctx, AV_LOG_DEBUG, "Timeout when trying to get a frame from MPP\n");
493     }
494
495     return AVERROR(EAGAIN);
496
497 fail:
498     if (mppframe)
499         mpp_frame_deinit(&mppframe);
500
501     if (framecontext)
502         av_buffer_unref(&framecontext->decoder_ref);
503
504     if (framecontextref)
505         av_buffer_unref(&framecontextref);
506
507     if (desc)
508         av_free(desc);
509
510     return ret;
511 }
512
513 static int rkmpp_receive_frame(AVCodecContext *avctx, AVFrame *frame)
514 {
515     RKMPPDecodeContext *rk_context = avctx->priv_data;
516     RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
517     int ret = MPP_NOK;
518     AVPacket pkt = {0};
519     RK_S32 usedslots, freeslots;
520
521     if (!decoder->eos_reached) {
522         // we get the available slots in decoder
523         ret = decoder->mpi->control(decoder->ctx, MPP_DEC_GET_STREAM_COUNT, &usedslots);
524         if (ret != MPP_OK) {
525             av_log(avctx, AV_LOG_ERROR, "Failed to get decoder used slots (code = %d).\n", ret);
526             return ret;
527         }
528
529         freeslots = INPUT_MAX_PACKETS - usedslots;
530         if (freeslots > 0) {
531             ret = ff_decode_get_packet(avctx, &pkt);
532             if (ret < 0 && ret != AVERROR_EOF) {
533                 return ret;
534             }
535
536             ret = rkmpp_send_packet(avctx, &pkt);
537             av_packet_unref(&pkt);
538
539             if (ret < 0) {
540                 av_log(avctx, AV_LOG_ERROR, "Failed to send packet to decoder (code = %d)\n", ret);
541                 return ret;
542             }
543         }
544
545         // make sure we keep decoder full
546         if (freeslots > 1)
547             return AVERROR(EAGAIN);
548     }
549
550     return rkmpp_retrieve_frame(avctx, frame);
551 }
552
553 static void rkmpp_flush(AVCodecContext *avctx)
554 {
555     RKMPPDecodeContext *rk_context = avctx->priv_data;
556     RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
557     int ret = MPP_NOK;
558
559     av_log(avctx, AV_LOG_DEBUG, "Flush.\n");
560
561     ret = decoder->mpi->reset(decoder->ctx);
562     if (ret == MPP_OK) {
563         decoder->first_frame = 1;
564         decoder->first_packet = 1;
565     } else
566         av_log(avctx, AV_LOG_ERROR, "Failed to reset MPI (code = %d)\n", ret);
567 }
568
569 static const AVCodecHWConfigInternal *rkmpp_hw_configs[] = {
570     HW_CONFIG_INTERNAL(DRM_PRIME),
571     NULL
572 };
573
574 #define RKMPP_DEC_CLASS(NAME) \
575     static const AVClass rkmpp_##NAME##_dec_class = { \
576         .class_name = "rkmpp_" #NAME "_dec", \
577         .version    = LIBAVUTIL_VERSION_INT, \
578     };
579
580 #define RKMPP_DEC(NAME, ID, BSFS) \
581     RKMPP_DEC_CLASS(NAME) \
582     AVCodec ff_##NAME##_rkmpp_decoder = { \
583         .name           = #NAME "_rkmpp", \
584         .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (rkmpp)"), \
585         .type           = AVMEDIA_TYPE_VIDEO, \
586         .id             = ID, \
587         .priv_data_size = sizeof(RKMPPDecodeContext), \
588         .init           = rkmpp_init_decoder, \
589         .close          = rkmpp_close_decoder, \
590         .receive_frame  = rkmpp_receive_frame, \
591         .flush          = rkmpp_flush, \
592         .priv_class     = &rkmpp_##NAME##_dec_class, \
593         .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \
594         .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_DRM_PRIME, \
595                                                          AV_PIX_FMT_NONE}, \
596         .hw_configs     = rkmpp_hw_configs, \
597         .bsfs           = BSFS, \
598         .wrapper_name   = "rkmpp", \
599     };
600
601 RKMPP_DEC(h264,  AV_CODEC_ID_H264,          "h264_mp4toannexb")
602 RKMPP_DEC(hevc,  AV_CODEC_ID_HEVC,          "hevc_mp4toannexb")
603 RKMPP_DEC(vp8,   AV_CODEC_ID_VP8,           NULL)
604 RKMPP_DEC(vp9,   AV_CODEC_ID_VP9,           NULL)