FFmpeg
Loading...
Searching...
No Matches
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 <stddef.h>
25
26#include <xevd.h>
27
28#include "libavutil/internal.h"
29#include "libavutil/common.h"
30#include "libavutil/mem.h"
31#include "libavutil/pixdesc.h"
32#include "libavutil/pixfmt.h"
33#include "libavutil/imgutils.h"
34#include "libavutil/cpu.h"
35
36#include "avcodec.h"
37#include "codec_internal.h"
38#include "profiles.h"
39#include "decode.h"
40
41#define XEVD_PARAM_BAD_NAME -1
42#define XEVD_PARAM_BAD_VALUE -2
43
44#define EVC_NAL_HEADER_SIZE 2 /* byte */
45
46/**
47 * The structure stores all the states associated with the instance of Xeve MPEG-5 EVC decoder
48 */
49typedef struct XevdContext {
50 XEVD id; // XEVD instance identifier @see xevd.h
51 XEVD_CDSC cdsc; // decoding parameters @see xevd.h
52
53 // If end of stream occurs it is required "flushing" (aka draining) the codec,
54 // as the codec might buffer multiple frames or packets internally.
55
56 AVPacket *pkt; // access unit (a set of NAL units that are consecutive in decoding order and containing exactly one encoded image)
58
59/**
60 * The function populates the XEVD_CDSC structure.
61 * XEVD_CDSC contains all decoder parameters that should be initialized before its use.
62 *
63 * @param[in] avctx codec context
64 * @param[out] cdsc contains all decoder parameters that should be initialized before its use
65 *
66 */
67static void get_conf(AVCodecContext *avctx, XEVD_CDSC *cdsc)
68{
69 int cpu_count = av_cpu_count();
70
71 /* clear XEVS_CDSC structure */
72 memset(cdsc, 0, sizeof(XEVD_CDSC));
73
74 /* init XEVD_CDSC */
75 if (avctx->thread_count <= 0)
76 cdsc->threads = (cpu_count < XEVD_MAX_TASK_CNT) ? cpu_count : XEVD_MAX_TASK_CNT;
77 else if (avctx->thread_count > XEVD_MAX_TASK_CNT)
78 cdsc->threads = XEVD_MAX_TASK_CNT;
79 else
80 cdsc->threads = avctx->thread_count;
81}
82
83/**
84 * Read NAL unit length
85 * @param bs input data (bitstream)
86 * @return the length of NAL unit on success, 0 value on failure
87 */
88static uint32_t read_nal_unit_length(const uint8_t *bs, int bs_size, AVCodecContext *avctx)
89{
90 uint32_t len = 0;
91 XEVD_INFO info;
92 int ret;
93
94 if (bs_size == XEVD_NAL_UNIT_LENGTH_BYTE) {
95 ret = xevd_info((void *)bs, XEVD_NAL_UNIT_LENGTH_BYTE, 1, &info);
96 if (XEVD_FAILED(ret)) {
97 av_log(avctx, AV_LOG_ERROR, "Cannot get bitstream information\n");
98 return 0;
99 }
100 len = info.nalu_len;
101 if (len == 0) {
102 av_log(avctx, AV_LOG_ERROR, "Invalid bitstream size! [%d]\n", bs_size);
103 return 0;
104 }
105 }
106
107 return len;
108}
109
110/**
111 * @param[in] xectx the structure that stores all the state associated with the instance of Xeve MPEG-5 EVC decoder
112 * @param[out] avctx codec context
113 * @return 0 on success, negative value on failure
114 */
115static int export_stream_params(const XevdContext *xectx, AVCodecContext *avctx)
116{
117 int ret;
118 int size;
119 int color_space;
120
122
123 size = 4;
124 ret = xevd_config(xectx->id, XEVD_CFG_GET_CODED_WIDTH, &avctx->coded_width, &size);
125 if (XEVD_FAILED(ret)) {
126 av_log(avctx, AV_LOG_ERROR, "Failed to get coded_width\n");
127 return AVERROR_EXTERNAL;
128 }
129
130 ret = xevd_config(xectx->id, XEVD_CFG_GET_CODED_HEIGHT, &avctx->coded_height, &size);
131 if (XEVD_FAILED(ret)) {
132 av_log(avctx, AV_LOG_ERROR, "Failed to get coded_height\n");
133 return AVERROR_EXTERNAL;
134 }
135
136 ret = xevd_config(xectx->id, XEVD_CFG_GET_WIDTH, &avctx->width, &size);
137 if (XEVD_FAILED(ret)) {
138 av_log(avctx, AV_LOG_ERROR, "Failed to get width\n");
139 return AVERROR_EXTERNAL;
140 }
141
142 ret = xevd_config(xectx->id, XEVD_CFG_GET_HEIGHT, &avctx->height, &size);
143 if (XEVD_FAILED(ret)) {
144 av_log(avctx, AV_LOG_ERROR, "Failed to get height\n");
145 return AVERROR_EXTERNAL;
146 }
147
148 ret = xevd_config(xectx->id, XEVD_CFG_GET_COLOR_SPACE, &color_space, &size);
149 if (XEVD_FAILED(ret)) {
150 av_log(avctx, AV_LOG_ERROR, "Failed to get color_space\n");
151 return AVERROR_EXTERNAL;
152 }
153 switch(color_space) {
154 case XEVD_CS_YCBCR400_10LE:
156 break;
157 case XEVD_CS_YCBCR420_10LE:
159 break;
160 case XEVD_CS_YCBCR422_10LE:
162 break;
163 case XEVD_CS_YCBCR444_10LE:
165 break;
166 default:
167 av_log(avctx, AV_LOG_ERROR, "Unknown color space\n");
168 avctx->pix_fmt = AV_PIX_FMT_NONE;
169 return AVERROR_INVALIDDATA;
170 }
171
172 // the function returns sps->num_reorder_pics
173 ret = xevd_config(xectx->id, XEVD_CFG_GET_MAX_CODING_DELAY, &avctx->has_b_frames, &size);
174 if (XEVD_FAILED(ret)) {
175 av_log(avctx, AV_LOG_ERROR, "Failed to get max_coding_delay\n");
176 return AVERROR_EXTERNAL;
177 }
178
179 return 0;
180}
181
182/**
183 * @brief Copy image in imgb to frame.
184 *
185 * @param avctx codec context
186 * @param[in] imgb
187 * @param[out] frame
188 * @return 0 on success, negative value on failure
189 */
190static int libxevd_image_copy(struct AVCodecContext *avctx, XEVD_IMGB *imgb, struct AVFrame *frame)
191{
192 int ret;
193 if (imgb->cs != XEVD_CS_YCBCR420_10LE) {
194 av_log(avctx, AV_LOG_ERROR, "Not supported pixel format: %s\n", av_get_pix_fmt_name(avctx->pix_fmt));
195 return AVERROR_INVALIDDATA;
196 }
197
198 if (imgb->w[0] != avctx->width || imgb->h[0] != avctx->height) { // stream resolution changed
199 if (ff_set_dimensions(avctx, imgb->w[0], imgb->h[0]) < 0) {
200 av_log(avctx, AV_LOG_ERROR, "Cannot set new dimension\n");
201 return AVERROR_INVALIDDATA;
202 }
203 }
204
205 ret = ff_get_buffer(avctx, frame, 0);
206 if (ret < 0)
207 return ret;
208
209 av_image_copy(frame->data, frame->linesize, (const uint8_t **)imgb->a,
210 imgb->s, avctx->pix_fmt,
211 imgb->w[0], imgb->h[0]);
212
213 return 0;
214}
215
216/**
217 * Initialize decoder
218 * Create a decoder instance and allocate all the needed resources
219 *
220 * @param avctx codec context
221 * @return 0 on success, negative error code on failure
222 */
224{
225 XevdContext *xectx = avctx->priv_data;
226 XEVD_CDSC *cdsc = &(xectx->cdsc);
227
228 /* read configurations and set values for created descriptor (XEVD_CDSC) */
229 get_conf(avctx, cdsc);
230
231 /* create decoder */
232 xectx->id = xevd_create(&(xectx->cdsc), NULL);
233 if (xectx->id == NULL) {
234 av_log(avctx, AV_LOG_ERROR, "Cannot create XEVD encoder\n");
235 return AVERROR_EXTERNAL;
236 }
237
238 xectx->pkt = av_packet_alloc();
239 if (!xectx->pkt) {
240 av_log(avctx, AV_LOG_ERROR, "Cannot allocate memory for AVPacket\n");
241 return AVERROR(ENOMEM);
242 }
243
244 return 0;
245}
246
248 XEVD_IMGB *imgb)
249{
250 AVPacket *pkt_au_imgb = (AVPacket*)imgb->pdata[0];
251 int ret;
252
253 if (!pkt_au_imgb) {
254 av_log(avctx, AV_LOG_ERROR, "Invalid data needed to fill frame properties\n");
255
257
258 imgb->release(imgb);
259 imgb = NULL;
260
261 return AVERROR_INVALIDDATA;
262 }
263
264 // got frame
265 ret = libxevd_image_copy(avctx, imgb, frame);
266 if (ret < 0) {
267 av_log(avctx, AV_LOG_ERROR, "Image copying error\n");
268
269 av_packet_free(&pkt_au_imgb);
271
272 imgb->release(imgb);
273 imgb = NULL;
274
275 return ret;
276 }
277
278 // use ff_decode_frame_props_from_pkt() to fill frame properties
279 ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt_au_imgb);
280 if (ret < 0) {
281 av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props_from_pkt error\n");
282
283 av_packet_free(&pkt_au_imgb);
285
286 imgb->release(imgb);
287 imgb = NULL;
288
289 return ret;
290 }
291
292 frame->pkt_dts = imgb->ts[XEVD_TS_DTS];
293 frame->pts = imgb->ts[XEVD_TS_PTS];
294
295 av_packet_free((AVPacket**)&imgb->pdata[0]);
296 av_freep(&imgb->pdata[1]);
297
298 // xevd_pull uses pool of objects of type XEVD_IMGB.
299 // The pool size is equal MAX_PB_SIZE (26), so release object when it is no more needed
300 imgb->release(imgb);
301 imgb = NULL;
302
303 return 0;
304}
305/**
306 * Decode frame with decoupled packet/frame dataflow
307 *
308 * @param avctx codec context
309 * @param[out] frame decoded frame
310 *
311 * @return 0 on success, negative error code on failure
312 */
314{
315 XevdContext *xectx = avctx->priv_data;
316 AVPacket *pkt = xectx->pkt;
317 XEVD_IMGB *imgb = NULL;
318
319 int xevd_ret = 0;
320 int ret = 0;
321
322 // obtain access unit (input data) - a set of NAL units that are consecutive in decoding order and containing exactly one encoded image
323 ret = ff_decode_get_packet(avctx, pkt);
324 if (ret < 0 && ret != AVERROR_EOF) {
326
327 return ret;
328 }
329
330 if (pkt->size > 0) {
331 int bs_read_pos = 0;
332 int pkt_au_retained = 0;
333 XEVD_STAT stat;
334 XEVD_BITB bitb;
335 int nalu_size;
336 AVPacket *pkt_au = av_packet_alloc();
337 imgb = NULL;
338
339 if (!pkt_au) {
341 return AVERROR(ENOMEM);
342 }
343 FFSWAP(AVPacket*, pkt_au, xectx->pkt);
344
345 // get all nal units from AU
346 while(pkt_au->size > (bs_read_pos + XEVD_NAL_UNIT_LENGTH_BYTE)) {
347 memset(&stat, 0, sizeof(XEVD_STAT));
348
349 nalu_size = read_nal_unit_length(pkt_au->data + bs_read_pos, XEVD_NAL_UNIT_LENGTH_BYTE, avctx);
350 if (nalu_size <= 0 || nalu_size > pkt_au->size - bs_read_pos - XEVD_NAL_UNIT_LENGTH_BYTE) {
351 av_log(avctx, AV_LOG_ERROR, "Invalid bitstream\n");
353 goto fail;
354 }
355 bs_read_pos += XEVD_NAL_UNIT_LENGTH_BYTE;
356
357 bitb.addr = pkt_au->data + bs_read_pos;
358 bitb.ssize = nalu_size;
359 bitb.pdata[0] = pkt_au;
360 bitb.pdata[1] = av_mallocz(sizeof(stat.stype));
361 bitb.ts[XEVD_TS_DTS] = pkt_au->dts;
362
363 if (!bitb.pdata[1]) {
364 ret = AVERROR(ENOMEM);
365 goto fail;
366 }
367
368 /* main decoding block */
369 xevd_ret = xevd_decode(xectx->id, &bitb, &stat);
370 if (XEVD_FAILED(xevd_ret)) {
371 av_log(avctx, AV_LOG_ERROR, "Failed to decode bitstream\n");
372 av_freep(&bitb.pdata[1]);
374 goto fail;
375 }
376
377 bs_read_pos += nalu_size;
378 if (stat.fnum < 0)
379 av_freep(&bitb.pdata[1]);
380
381 if (stat.nalu_type == XEVD_NUT_SPS) { // EVC stream parameters changed
382 if ((ret = export_stream_params(xectx, avctx)) != 0) {
383 av_log(avctx, AV_LOG_ERROR, "Failed to export stream params\n");
384 goto fail;
385 }
386 }
387
388 if (stat.read != nalu_size)
389 av_log(avctx, AV_LOG_INFO, "Different reading of bitstream (in:%d, read:%d)\n,", nalu_size, stat.read);
390
391 // stat.fnum - has negative value if the decoded data is not frame
392 if (stat.fnum >= 0) {
393 pkt_au_retained = 1;
394 // store stat.stype into the bitb.pdata[1] that will be retrieved in an image
395 *(int*)bitb.pdata[1] = stat.stype;
396
397 xevd_ret = xevd_pull(xectx->id, &imgb); // The function returns a valid image only if the return code is XEVD_OK
398
399 if (XEVD_FAILED(xevd_ret)) {
400 av_log(avctx, AV_LOG_ERROR, "Failed to pull the decoded image (xevd error code: %d, frame#=%d)\n", xevd_ret, stat.fnum);
402 goto fail;
403 } else if (xevd_ret == XEVD_OK_FRM_DELAYED) {
404 if(bs_read_pos == pkt_au->size) {
405 return AVERROR(EAGAIN);
406 }
407 } else { // XEVD_OK
408 if (!imgb) {
409 if(bs_read_pos == pkt_au->size) {
410 av_log(avctx, AV_LOG_ERROR, "Invalid decoded image data\n");
411 return AVERROR(EAGAIN);
412 }
413 } else {
414 if (*(int*)imgb->pdata[1] == XEVD_ST_I) {
415 frame->pict_type = AV_PICTURE_TYPE_I;
416 frame->flags |= AV_FRAME_FLAG_KEY;
417 }
418 return libxevd_return_frame(avctx, frame, imgb);
419 }
420 }
421 }
422 }
423 ret = AVERROR(EAGAIN);
424fail:
425 if (!pkt_au_retained)
426 av_packet_free(&pkt_au);
427 return ret;
428 } else { // decoder draining mode handling
429
430 while (1) {
431 xevd_ret = xevd_pull(xectx->id, &imgb);
432
433 if (xevd_ret == XEVD_ERR_UNEXPECTED) { // draining process completed
434 av_log(avctx, AV_LOG_DEBUG, "Draining process completed\n");
435
436 return AVERROR_EOF;
437 } else if (XEVD_FAILED(xevd_ret)) { // handle all other errors
438 av_log(avctx, AV_LOG_ERROR, "Failed to pull the decoded image (xevd error code: %d)\n", xevd_ret);
439
440 return AVERROR_EXTERNAL;
441 } else if (xevd_ret == XEVD_OK) {
442 if (!imgb) {
443 av_log(avctx, AV_LOG_ERROR, "Invalid decoded image data\n");
444
445 continue;
446 }
447
448 if (*(int*)imgb->pdata[1] == XEVD_ST_I) {
449 frame->pict_type = AV_PICTURE_TYPE_I;
450 frame->flags |= AV_FRAME_FLAG_KEY;
451 }
452 return libxevd_return_frame(avctx, frame, imgb);
453 }
454 av_log(avctx, AV_LOG_WARNING, "Unexpected return code while draining (xevd error code: %d)\n", xevd_ret);
455 return AVERROR_EOF;
456 }
457 }
458}
459
460/**
461 * Destroy decoder
462 *
463 * @param avctx codec context
464 * @return 0 on success
465 */
467{
468 XevdContext *xectx = avctx->priv_data;
469 if (xectx->id) {
470 xevd_delete(xectx->id);
471 xectx->id = NULL;
472 }
473
474 av_packet_free(&xectx->pkt);
475
476 return 0;
477}
478
480 .p.name = "libxevd",
481 CODEC_LONG_NAME("EVC / MPEG-5 Essential Video Coding (EVC)"),
482 .p.type = AVMEDIA_TYPE_VIDEO,
483 .p.id = AV_CODEC_ID_EVC,
484 .init = libxevd_init,
486 .close = libxevd_close,
487 .priv_data_size = sizeof(XevdContext),
488 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
491 .p.wrapper_name = "libxevd",
494};
const FFCodec ff_libxevd_decoder
Definition libxevd.c:479
Libavcodec external API header.
#define FF_CODEC_RECEIVE_FRAME_CB(func)
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
#define FF_CODEC_CAP_SETS_FRAME_PROPS
Codec handles output frame properties internally instead of letting the internal logic derive them fr...
#define CODEC_LONG_NAME(str)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal and external API header
#define NULL
Definition coverity.c:32
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition decode.c:1814
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition decode.c:255
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:1569
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition utils.c:91
static AVPacket * pkt
static AVFrame * frame
int ret
Definition ffplay.c:391
#define fail
Definition test.h:479
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition codec.h:112
#define AV_CODEC_CAP_AVOID_PROBING
Decoder is not a preferred choice for probing.
Definition codec.h:126
#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:79
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
@ AV_CODEC_ID_EVC
Definition codec_id.h:316
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition packet.c:74
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition packet.c:435
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition packet.c:63
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition error.h:59
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
#define AVERROR_EOF
End of file.
Definition error.h:57
#define AVERROR(e)
Definition error.h:45
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition frame.h:694
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition frame.c:499
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_INFO
Standard information.
Definition log.h:221
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
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_PICTURE_TYPE_I
Intra.
Definition avutil.h:278
misc image utilities
#define av_cold
Definition attributes.h:117
static atomic_int cpu_count
Definition cpu.c:57
int av_cpu_count(void)
Definition cpu.c:230
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:97
static void get_conf(AVCodecContext *avctx, XEVD_CDSC *cdsc)
The function populates the XEVD_CDSC structure.
Definition libxevd.c:67
static av_cold int libxevd_init(AVCodecContext *avctx)
Initialize decoder Create a decoder instance and allocate all the needed resources.
Definition libxevd.c:223
static int libxevd_image_copy(struct AVCodecContext *avctx, XEVD_IMGB *imgb, struct AVFrame *frame)
Copy image in imgb to frame.
Definition libxevd.c:190
static int libxevd_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Decode frame with decoupled packet/frame dataflow.
Definition libxevd.c:313
static int export_stream_params(const XevdContext *xectx, AVCodecContext *avctx)
Definition libxevd.c:115
static uint32_t read_nal_unit_length(const uint8_t *bs, int bs_size, AVCodecContext *avctx)
Read NAL unit length.
Definition libxevd.c:88
static av_cold int libxevd_close(AVCodecContext *avctx)
Destroy decoder.
Definition libxevd.c:466
static int libxevd_return_frame(AVCodecContext *avctx, AVFrame *frame, XEVD_IMGB *imgb)
Definition libxevd.c:247
#define FFSWAP(type, a, b)
Definition macros.h:52
Memory handling functions.
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:3404
pixel format definitions
#define AV_PIX_FMT_YUV420P10
Definition pixfmt.h:548
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition pixfmt.h:321
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition pixfmt.h:156
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition pixfmt.h:158
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition pixfmt.h:162
const AVProfile ff_evc_profiles[]
Definition profiles.c:220
main external API structure.
Definition avcodec.h:443
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:644
int width
picture width / height.
Definition avcodec.h:605
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition avcodec.h:713
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition avcodec.h:1589
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition avcodec.h:620
void * priv_data
Definition avcodec.h:470
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
This structure stores compressed data.
Definition packet.h:587
int size
Definition packet.h:611
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition packet.h:609
uint8_t * data
Definition packet.h:610
The structure stores all the states associated with the instance of Xeve MPEG-5 EVC decoder.
Definition libxevd.c:49
XEVD_CDSC cdsc
Definition libxevd.c:51
XEVD id
Definition libxevd.c:50
AVPacket * pkt
Definition libxevd.c:56
#define av_mallocz(s)
#define av_freep(p)
#define av_log(a,...)
int size
int len