FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rkmppdec.c
Go to the documentation of this file.
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"
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 
52 
55 } RKMPPDecoder;
56 
57 typedef struct {
61 
62 typedef struct {
63  MppFrame frame;
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;
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 
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 
153 {
154  RKMPPDecodeContext *rk_context = avctx->priv_data;
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,
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 
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 {
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 
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;
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) {
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 
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);
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 
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, \
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  };
598 
599 RKMPP_DEC(h264, AV_CODEC_ID_H264, "h264_mp4toannexb")
600 RKMPP_DEC(hevc, AV_CODEC_ID_HEVC, "hevc_mp4toannexb")
static int rkmpp_write_data(AVCodecContext *avctx, uint8_t *buffer, int size, int64_t pts)
Definition: rkmppdec.c:89
char eos_reached
Definition: rkmppdec.c:51
#define NULL
Definition: coverity.c:32
static void rkmpp_flush(AVCodecContext *avctx)
Definition: rkmppdec.c:551
#define RECEIVE_FRAME_TIMEOUT
Definition: rkmppdec.c:41
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
#define FRAMEGROUP_MAX_FRAMES
Definition: rkmppdec.c:42
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:393
const char * desc
Definition: nvenc.c:63
int size
Definition: avcodec.h:1401
static MppCodingType rkmpp_get_codingtype(AVCodecContext *avctx)
Definition: rkmppdec.c:67
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:227
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1697
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:207
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static AVPacket pkt
static int rkmpp_close_decoder(AVCodecContext *avctx)
Definition: rkmppdec.c:124
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
Definition: frame.h:538
static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: rkmppdec.c:320
DRM frame descriptor.
AVClass * av_class
Definition: rkmppdec.c:58
AVBufferRef * decoder_ref
Definition: rkmppdec.c:59
uint8_t
MppApi * mpi
Definition: rkmppdec.c:46
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:294
static uint32_t rkmpp_get_frameformat(MppFrameFormat mppformat)
Definition: rkmppdec.c:78
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:294
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1588
static AVFrame * frame
uint8_t * data
Definition: avcodec.h:1400
#define AVERROR_EOF
End of file.
Definition: error.h:55
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:348
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:113
ptrdiff_t size
Definition: opengl_enc.c:101
#define av_log(a,...)
static int rkmpp_init_decoder(AVCodecContext *avctx)
Definition: rkmppdec.c:152
DRM layer descriptor.
Definition: hwcontext_drm.h:93
static void rkmpp_release_decoder(void *opaque, uint8_t *data)
Definition: rkmppdec.c:131
char first_packet
Definition: rkmppdec.c:50
int width
Definition: frame.h:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
char first_frame
Definition: rkmppdec.c:49
#define AVERROR(e)
Definition: error.h:43
#define HW_CONFIG_INTERNAL(format)
Definition: hwaccel.h:57
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:446
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:457
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:85
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:28
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:325
#define fail()
Definition: checkasm.h:113
reference-counted frame API
MppBufferGroup frame_group
Definition: rkmppdec.c:47
static const chunk_decoder decoder[8]
Definition: dfa.c:330
int width
picture width / height.
Definition: avcodec.h:1660
AVBufferRef * device_ref
Definition: rkmppdec.c:54
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
MppFrame frame
Definition: rkmppdec.c:63
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVBufferRef * av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
Allocate an AVHWDeviceContext for a given hardware type.
Definition: hwcontext.c:134
Libavcodec external API header.
static int rkmpp_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: rkmppdec.c:512
enum AVCodecID codec_id
Definition: avcodec.h:1498
main external API structure.
Definition: avcodec.h:1488
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:590
uint8_t * data
The data buffer.
Definition: buffer.h:89
#define RKMPP_DEC(NAME, ID, BSFS)
Definition: rkmppdec.c:578
int extradata_size
Definition: avcodec.h:1589
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
int av_hwdevice_ctx_init(AVBufferRef *ref)
Finalize the device context before use.
Definition: hwcontext.c:192
Describe the class of an AVClass context structure.
Definition: log.h:67
DRM-managed buffers exposed through PRIME buffer sharing.
Definition: pixfmt.h:324
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:122
refcounted data buffer API
static const AVCodecHWConfigInternal * rkmpp_hw_configs[]
Definition: rkmppdec.c:567
API-specific header for AV_HWDEVICE_TYPE_DRM.
static int64_t pts
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
A reference to a data buffer.
Definition: buffer.h:81
static int rkmpp_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Definition: rkmppdec.c:269
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:279
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:239
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:1515
#define av_free(p)
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:353
MppCtx ctx
Definition: rkmppdec.c:45
enum AVColorPrimaries color_primaries
Definition: frame.h:448
int height
Definition: frame.h:259
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:450
AVBufferRef * frames_ref
Definition: rkmppdec.c:53
AVBufferRef * decoder_ref
Definition: rkmppdec.c:64
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:220
This structure stores compressed data.
Definition: avcodec.h:1377
static void rkmpp_release_frame(void *opaque, uint8_t *data)
Definition: rkmppdec.c:307
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1393
GLuint buffer
Definition: opengl_enc.c:102