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