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