FFmpeg
libxevd.c
Go to the documentation of this file.
1 /*
2  * libxevd decoder
3  * EVC (MPEG-5 Essential Video Coding) decoding using XEVD MPEG-5 EVC decoder library
4  *
5  * Copyright (C) 2021 Dawid Kozinski <d.kozinski@samsung.com>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include <float.h>
25 #include <stdlib.h>
26 
27 #include <xevd.h>
28 
29 #include "libavutil/internal.h"
30 #include "libavutil/common.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/cpu.h"
36 
37 #include "avcodec.h"
38 #include "internal.h"
39 #include "packet_internal.h"
40 #include "codec_internal.h"
41 #include "profiles.h"
42 #include "decode.h"
43 
44 #define XEVD_PARAM_BAD_NAME -1
45 #define XEVD_PARAM_BAD_VALUE -2
46 
47 #define EVC_NAL_HEADER_SIZE 2 /* byte */
48 
49 /**
50  * The structure stores all the states associated with the instance of Xeve MPEG-5 EVC decoder
51  */
52 typedef struct XevdContext {
53  const AVClass *class;
54 
55  XEVD id; // XEVD instance identifier @see xevd.h
56  XEVD_CDSC cdsc; // decoding parameters @see xevd.h
57 
58  // If end of stream occurs it is required "flushing" (aka draining) the codec,
59  // as the codec might buffer multiple frames or packets internally.
60  int draining_mode; // The flag is set if codec enters draining mode.
61 
62  AVPacket *pkt; // access unit (a set of NAL units that are consecutive in decoding order and containing exactly one encoded image)
63 } XevdContext;
64 
65 /**
66  * The function populates the XEVD_CDSC structure.
67  * XEVD_CDSC contains all decoder parameters that should be initialized before its use.
68  *
69  * @param[in] avctx codec context
70  * @param[out] cdsc contains all decoder parameters that should be initialized before its use
71  *
72  */
73 static void get_conf(AVCodecContext *avctx, XEVD_CDSC *cdsc)
74 {
75  int cpu_count = av_cpu_count();
76 
77  /* clear XEVS_CDSC structure */
78  memset(cdsc, 0, sizeof(XEVD_CDSC));
79 
80  /* init XEVD_CDSC */
81  if (avctx->thread_count <= 0)
82  cdsc->threads = (cpu_count < XEVD_MAX_TASK_CNT) ? cpu_count : XEVD_MAX_TASK_CNT;
83  else if (avctx->thread_count > XEVD_MAX_TASK_CNT)
84  cdsc->threads = XEVD_MAX_TASK_CNT;
85  else
86  cdsc->threads = avctx->thread_count;
87 }
88 
89 /**
90  * Read NAL unit length
91  * @param bs input data (bitstream)
92  * @return the length of NAL unit on success, 0 value on failure
93  */
94 static uint32_t read_nal_unit_length(const uint8_t *bs, int bs_size, AVCodecContext *avctx)
95 {
96  uint32_t len = 0;
97  XEVD_INFO info;
98  int ret;
99 
100  if (bs_size == XEVD_NAL_UNIT_LENGTH_BYTE) {
101  ret = xevd_info((void *)bs, XEVD_NAL_UNIT_LENGTH_BYTE, 1, &info);
102  if (XEVD_FAILED(ret)) {
103  av_log(avctx, AV_LOG_ERROR, "Cannot get bitstream information\n");
104  return 0;
105  }
106  len = info.nalu_len;
107  if (len == 0) {
108  av_log(avctx, AV_LOG_ERROR, "Invalid bitstream size! [%d]\n", bs_size);
109  return 0;
110  }
111  }
112 
113  return len;
114 }
115 
116 /**
117  * @param[in] xectx the structure that stores all the state associated with the instance of Xeve MPEG-5 EVC decoder
118  * @param[out] avctx codec context
119  * @return 0 on success, negative value on failure
120  */
121 static int export_stream_params(const XevdContext *xectx, AVCodecContext *avctx)
122 {
123  int ret;
124  int size;
125  int color_space;
126 
127  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
128 
129  size = 4;
130  ret = xevd_config(xectx->id, XEVD_CFG_GET_CODED_WIDTH, &avctx->coded_width, &size);
131  if (XEVD_FAILED(ret)) {
132  av_log(avctx, AV_LOG_ERROR, "Failed to get coded_width\n");
133  return AVERROR_EXTERNAL;
134  }
135 
136  ret = xevd_config(xectx->id, XEVD_CFG_GET_CODED_HEIGHT, &avctx->coded_height, &size);
137  if (XEVD_FAILED(ret)) {
138  av_log(avctx, AV_LOG_ERROR, "Failed to get coded_height\n");
139  return AVERROR_EXTERNAL;
140  }
141 
142  ret = xevd_config(xectx->id, XEVD_CFG_GET_WIDTH, &avctx->width, &size);
143  if (XEVD_FAILED(ret)) {
144  av_log(avctx, AV_LOG_ERROR, "Failed to get width\n");
145  return AVERROR_EXTERNAL;
146  }
147 
148  ret = xevd_config(xectx->id, XEVD_CFG_GET_HEIGHT, &avctx->height, &size);
149  if (XEVD_FAILED(ret)) {
150  av_log(avctx, AV_LOG_ERROR, "Failed to get height\n");
151  return AVERROR_EXTERNAL;
152  }
153 
154  ret = xevd_config(xectx->id, XEVD_CFG_GET_COLOR_SPACE, &color_space, &size);
155  if (XEVD_FAILED(ret)) {
156  av_log(avctx, AV_LOG_ERROR, "Failed to get color_space\n");
157  return AVERROR_EXTERNAL;
158  }
159  switch(color_space) {
160  case XEVD_CS_YCBCR400_10LE:
161  avctx->pix_fmt = AV_PIX_FMT_GRAY10LE;
162  break;
163  case XEVD_CS_YCBCR420_10LE:
165  break;
166  case XEVD_CS_YCBCR422_10LE:
168  break;
169  case XEVD_CS_YCBCR444_10LE:
171  break;
172  default:
173  av_log(avctx, AV_LOG_ERROR, "Unknown color space\n");
174  avctx->pix_fmt = AV_PIX_FMT_NONE;
175  return AVERROR_INVALIDDATA;
176  }
177 
178  // the function returns sps->num_reorder_pics
179  ret = xevd_config(xectx->id, XEVD_CFG_GET_MAX_CODING_DELAY, &avctx->max_b_frames, &size);
180  if (XEVD_FAILED(ret)) {
181  av_log(avctx, AV_LOG_ERROR, "Failed to get max_coding_delay\n");
182  return AVERROR_EXTERNAL;
183  }
184 
185  avctx->has_b_frames = (avctx->max_b_frames) ? 1 : 0;
186 
187  return 0;
188 }
189 
190 /**
191  * @brief Copy image in imgb to frame.
192  *
193  * @param avctx codec context
194  * @param[in] imgb
195  * @param[out] frame
196  * @return 0 on success, negative value on failure
197  */
198 static int libxevd_image_copy(struct AVCodecContext *avctx, XEVD_IMGB *imgb, struct AVFrame *frame)
199 {
200  int ret;
201  if (imgb->cs != XEVD_CS_YCBCR420_10LE) {
202  av_log(avctx, AV_LOG_ERROR, "Not supported pixel format: %s\n", av_get_pix_fmt_name(avctx->pix_fmt));
203  return AVERROR_INVALIDDATA;
204  }
205 
206  if (imgb->w[0] != avctx->width || imgb->h[0] != avctx->height) { // stream resolution changed
207  if (ff_set_dimensions(avctx, imgb->w[0], imgb->h[0]) < 0) {
208  av_log(avctx, AV_LOG_ERROR, "Cannot set new dimension\n");
209  return AVERROR_INVALIDDATA;
210  }
211  }
212 
213  if (ret = ff_get_buffer(avctx, frame, 0) < 0)
214  return ret;
215 
216  av_image_copy(frame->data, frame->linesize, (const uint8_t **)imgb->a,
217  imgb->s, avctx->pix_fmt,
218  imgb->w[0], imgb->h[0]);
219 
220  return 0;
221 }
222 
223 /**
224  * Initialize decoder
225  * Create a decoder instance and allocate all the needed resources
226  *
227  * @param avctx codec context
228  * @return 0 on success, negative error code on failure
229  */
231 {
232  XevdContext *xectx = avctx->priv_data;
233  XEVD_CDSC *cdsc = &(xectx->cdsc);
234 
235  /* read configurations and set values for created descriptor (XEVD_CDSC) */
236  get_conf(avctx, cdsc);
237 
238  /* create decoder */
239  xectx->id = xevd_create(&(xectx->cdsc), NULL);
240  if (xectx->id == NULL) {
241  av_log(avctx, AV_LOG_ERROR, "Cannot create XEVD encoder\n");
242  return AVERROR_EXTERNAL;
243  }
244 
245  xectx->draining_mode = 0;
246  xectx->pkt = av_packet_alloc();
247  if (!xectx->pkt) {
248  av_log(avctx, AV_LOG_ERROR, "Cannot allocate memory for AVPacket\n");
249  return AVERROR(ENOMEM);
250  }
251 
252  return 0;
253 }
254 
255 /**
256  * Decode frame with decoupled packet/frame dataflow
257  *
258  * @param avctx codec context
259  * @param[out] frame decoded frame
260  *
261  * @return 0 on success, negative error code on failure
262  */
264 {
265  XevdContext *xectx = avctx->priv_data;
266  AVPacket *pkt = xectx->pkt;
267  XEVD_IMGB *imgb = NULL;
268 
269  int xevd_ret = 0;
270  int ret = 0;
271 
272  // obtain access unit (input data) - a set of NAL units that are consecutive in decoding order and containing exactly one encoded image
273  ret = ff_decode_get_packet(avctx, pkt);
274  if (ret < 0 && ret != AVERROR_EOF) {
276 
277  return ret;
278  } else if(ret == AVERROR_EOF && xectx->draining_mode == 0) { // End of stream situations. Enter draining mode
279 
280  xectx->draining_mode = 1;
282  }
283 
284  if (pkt->size > 0) {
285  int bs_read_pos = 0;
286  XEVD_STAT stat;
287  XEVD_BITB bitb;
288  int nalu_size;
289  AVPacket* pkt_au;
290  imgb = NULL;
291 
292  pkt_au = av_packet_clone(pkt);
293  if (!pkt_au) {
294  av_log(avctx, AV_LOG_ERROR, "Cannot clone AVPacket\n");
296  return AVERROR(ENOMEM);
297  }
298 
300 
301  // get all nal units from AU
302  while(pkt_au->size > (bs_read_pos + XEVD_NAL_UNIT_LENGTH_BYTE)) {
303  memset(&stat, 0, sizeof(XEVD_STAT));
304 
305  nalu_size = read_nal_unit_length(pkt_au->data + bs_read_pos, XEVD_NAL_UNIT_LENGTH_BYTE, avctx);
306  if (nalu_size == 0) {
307  av_log(avctx, AV_LOG_ERROR, "Invalid bitstream\n");
308  av_packet_free(&pkt_au);
310 
311  return ret;
312  }
313  bs_read_pos += XEVD_NAL_UNIT_LENGTH_BYTE;
314 
315  bitb.addr = pkt_au->data + bs_read_pos;
316  bitb.ssize = nalu_size;
317  bitb.pdata[0] = pkt_au;
318  bitb.ts[XEVD_TS_DTS] = pkt_au->dts;
319 
320  /* main decoding block */
321  xevd_ret = xevd_decode(xectx->id, &bitb, &stat);
322  if (XEVD_FAILED(xevd_ret)) {
323  av_log(avctx, AV_LOG_ERROR, "Failed to decode bitstream\n");
324  av_packet_free(&pkt_au);
325 
326  return AVERROR_EXTERNAL;
327  }
328 
329  bs_read_pos += nalu_size;
330 
331  if (stat.nalu_type == XEVD_NUT_SPS) { // EVC stream parameters changed
332  if ((ret = export_stream_params(xectx, avctx)) != 0) {
333  av_log(avctx, AV_LOG_ERROR, "Failed to export stream params\n");
334  av_packet_free(&pkt_au);
335 
336  return ret;
337  }
338  }
339 
340  if (stat.read != nalu_size)
341  av_log(avctx, AV_LOG_INFO, "Different reading of bitstream (in:%d, read:%d)\n,", nalu_size, stat.read);
342 
343  // stat.fnum - has negative value if the decoded data is not frame
344  if (stat.fnum >= 0) {
345 
346  xevd_ret = xevd_pull(xectx->id, &imgb); // The function returns a valid image only if the return code is XEVD_OK
347 
348  if (XEVD_FAILED(xevd_ret)) {
349  av_log(avctx, AV_LOG_ERROR, "Failed to pull the decoded image (xevd error code: %d, frame#=%d)\n", xevd_ret, stat.fnum);
350 
351  av_packet_free(&pkt_au);
352 
353  return AVERROR_EXTERNAL;
354  } else if (xevd_ret == XEVD_OK_FRM_DELAYED) {
355  if(bs_read_pos == pkt_au->size) {
356  return AVERROR(EAGAIN);
357  }
358  } else { // XEVD_OK
359  if (!imgb) {
360  if(bs_read_pos == pkt_au->size) {
361  av_log(avctx, AV_LOG_ERROR, "Invalid decoded image data\n");
362 
363  av_packet_free(&pkt_au);
364  return AVERROR(EAGAIN);
365  }
366  } else {
367  // got frame
368  AVPacket* pkt_au_imgb = (AVPacket*)imgb->pdata[0];
369  if(!pkt_au_imgb) {
370  av_log(avctx, AV_LOG_ERROR, "Invalid data needed to fill frame properties\n");
371 
372  av_packet_free(&pkt_au);
374 
375  imgb->release(imgb);
376  imgb = NULL;
377 
378  return AVERROR_INVALIDDATA;
379  }
380 
381  ret = libxevd_image_copy(avctx, imgb, frame);
382  if(ret < 0) {
383  av_log(avctx, AV_LOG_ERROR, "Image copying error\n");
384 
385  av_packet_free(&pkt_au_imgb);
387 
388  imgb->release(imgb);
389  imgb = NULL;
390 
391  return ret;
392  }
393 
394  // use ff_decode_frame_props_from_pkt() to fill frame properties
395  ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt_au_imgb);
396  if (ret < 0) {
397  av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props_from_pkt error\n");
398 
399  av_packet_free(&pkt_au_imgb);
401 
402  imgb->release(imgb);
403  imgb = NULL;
404 
405  return ret;
406  }
407 
408  frame->pkt_dts = imgb->ts[XEVD_TS_DTS];
409  frame->pts = imgb->ts[XEVD_TS_PTS];
410 
411  av_packet_free(&pkt_au_imgb);
412 
413  // xevd_pull uses pool of objects of type XEVD_IMGB.
414  // The pool size is equal MAX_PB_SIZE (26), so release object when it is no more needed
415  imgb->release(imgb);
416  imgb = NULL;
417  }
418  }
419  }
420  }
421  } else { // decoder draining mode handling
422 
423  xevd_ret = xevd_pull(xectx->id, &imgb);
424 
425  if (xevd_ret == XEVD_ERR_UNEXPECTED) { // draining process completed
426  av_log(avctx, AV_LOG_DEBUG, "Draining process completed\n");
427 
428  return AVERROR_EOF;
429  } else if (XEVD_FAILED(xevd_ret)) { // handle all other errors
430  av_log(avctx, AV_LOG_ERROR, "Failed to pull the decoded image (xevd error code: %d)\n", xevd_ret);
431 
432  return AVERROR_EXTERNAL;
433  } else { // XEVD_OK
434  AVPacket* pkt_au_imgb;
435  if (!imgb) {
436  av_log(avctx, AV_LOG_ERROR, "Invalid decoded image data\n");
437 
438  return AVERROR_EXTERNAL;
439  }
440 
441  pkt_au_imgb = (AVPacket*)imgb->pdata[0];
442  if(!pkt_au_imgb) {
443  av_log(avctx, AV_LOG_ERROR, "Invalid data needed to fill frame properties\n");
444 
445  imgb->release(imgb);
446  imgb = NULL;
447 
449 
450  return AVERROR_INVALIDDATA;
451  }
452 
453  // got frame
454  ret = libxevd_image_copy(avctx, imgb, frame);
455  if(ret < 0) {
456  av_packet_free(&pkt_au_imgb);
458 
459  imgb->release(imgb);
460  imgb = NULL;
461 
462  return ret;
463  }
464  // use ff_decode_frame_props_from_pkt() to fill frame properties
465  ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt_au_imgb);
466  if (ret < 0) {
467  av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props_from_pkt error\n");
468 
469  av_packet_free(&pkt_au_imgb);
471 
472  imgb->release(imgb);
473  imgb = NULL;
474 
475  return ret;
476  }
477 
478  frame->pkt_dts = imgb->ts[XEVD_TS_DTS];
479  frame->pts = imgb->ts[XEVD_TS_PTS];
480 
481  av_packet_free(&pkt_au_imgb);
482 
483  // xevd_pull uses pool of objects of type XEVD_IMGB.
484  // The pool size is equal MAX_PB_SIZE (26), so release object when it is no more needed
485  imgb->release(imgb);
486  imgb = NULL;
487 
488  return 0;
489  }
490  }
491 
492  return ret;
493 }
494 
495 /**
496  * Destroy decoder
497  *
498  * @param avctx codec context
499  * @return 0 on success
500  */
502 {
503  XevdContext *xectx = avctx->priv_data;
504  if (xectx->id) {
505  xevd_delete(xectx->id);
506  xectx->id = NULL;
507  }
508 
509  xectx->draining_mode = 0;
510  av_packet_free(&xectx->pkt);
511 
512  return 0;
513 }
514 
515 #define OFFSET(x) offsetof(XevdContext, x)
516 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
517 
518 static const AVClass libxevd_class = {
519  .class_name = "libxevd",
520  .item_name = av_default_item_name,
521  .version = LIBAVUTIL_VERSION_INT,
522 };
523 
525  .p.name = "evc",
526  .p.long_name = NULL_IF_CONFIG_SMALL("EVC / MPEG-5 Essential Video Coding (EVC)"),
527  .p.type = AVMEDIA_TYPE_VIDEO,
528  .p.id = AV_CODEC_ID_EVC,
529  .init = libxevd_init,
531  .close = libxevd_close,
532  .priv_data_size = sizeof(XevdContext),
533  .p.priv_class = &libxevd_class,
535  .p.profiles = NULL_IF_CONFIG_SMALL(ff_evc_profiles),
536  .p.wrapper_name = "libxevd",
538 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:241
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
cpu_count
static atomic_int cpu_count
Definition: cpu.c:53
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
XevdContext
The structure stores all the states associated with the instance of Xeve MPEG-5 EVC decoder.
Definition: libxevd.c:52
ff_libxevd_decoder
const FFCodec ff_libxevd_decoder
Definition: libxevd.c:524
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:482
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:127
float.h
read_nal_unit_length
static uint32_t read_nal_unit_length(const uint8_t *bs, int bs_size, AVCodecContext *avctx)
Read NAL unit length.
Definition: libxevd.c:94
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:325
XevdContext::pkt
AVPacket * pkt
Definition: libxevd.c:62
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:74
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1536
ff_decode_frame_props_from_pkt
int ff_decode_frame_props_from_pkt(const AVCodecContext *avctx, AVFrame *frame, const AVPacket *pkt)
Set various frame properties from the provided packet.
Definition: decode.c:1440
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:640
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:156
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:748
libxevd_class
static const AVClass libxevd_class
Definition: libxevd.c:518
AV_CODEC_ID_EVC
@ AV_CODEC_ID_EVC
Definition: codec_id.h:324
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:124
info
MIPS optimizations info
Definition: mips.txt:2
ff_evc_profiles
const AVProfile ff_evc_profiles[]
Definition: profiles.c:197
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
decode.h
libxevd_close
static av_cold int libxevd_close(AVCodecContext *avctx)
Destroy decoder.
Definition: libxevd.c:501
frame
static AVFrame * frame
Definition: demux_decode.c:54
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:162
libxevd_init
static av_cold int libxevd_init(AVCodecContext *avctx)
Initialize decoder Create a decoder instance and allocate all the needed resources.
Definition: libxevd.c:230
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
export_stream_params
static int export_stream_params(const XevdContext *xectx, AVCodecContext *avctx)
Definition: libxevd.c:121
get_conf
static void get_conf(AVCodecContext *avctx, XEVD_CDSC *cdsc)
The function populates the XEVD_CDSC structure.
Definition: libxevd.c:73
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
profiles.h
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:459
libxevd_receive_frame
static int libxevd_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Decode frame with decoupled packet/frame dataflow.
Definition: libxevd.c:263
libxevd_image_copy
static int libxevd_image_copy(struct AVCodecContext *avctx, XEVD_IMGB *imgb, struct AVFrame *frame)
Copy image in imgb to frame.
Definition: libxevd.c:198
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:209
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
AVPacket::size
int size
Definition: packet.h:523
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
codec_internal.h
cpu.h
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:158
FF_CODEC_CAP_SETS_FRAME_PROPS
#define FF_CODEC_CAP_SETS_FRAME_PROPS
Codec handles output frame properties internally instead of letting the internal logic derive them fr...
Definition: codec_internal.h:78
size
int size
Definition: twinvq_data.h:10344
XevdContext::cdsc
XEVD_CDSC cdsc
Definition: libxevd.c:56
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:63
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
XevdContext::id
XEVD id
Definition: libxevd.c:55
internal.h
common.h
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
FF_CODEC_CAP_SETS_PKT_DTS
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
Definition: codec_internal.h:49
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
avcodec.h
ret
ret
Definition: filter_design.txt:187
pixfmt.h
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AVCodecContext
main external API structure.
Definition: avcodec.h:445
FF_CODEC_RECEIVE_FRAME_CB
#define FF_CODEC_RECEIVE_FRAME_CB(func)
Definition: codec_internal.h:312
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:640
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:724
packet_internal.h
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
XevdContext::draining_mode
int draining_mode
Definition: libxevd.c:60
AV_CODEC_CAP_AVOID_PROBING
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition: codec.h:138
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_image_copy
void av_image_copy(uint8_t *const dst_data[4], const int dst_linesizes[4], const uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:422
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2888
av_packet_clone
AVPacket * av_packet_clone(const AVPacket *src)
Create a new packet that references the same data as src.
Definition: avpacket.c:471