FFmpeg
extract_extradata_bsf.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <stdint.h>
20 
21 #include "libavutil/log.h"
22 #include "libavutil/opt.h"
23 
24 #include "av1.h"
25 #include "av1_parse.h"
26 #include "bsf.h"
27 #include "bsf_internal.h"
28 #include "bytestream.h"
29 #include "h2645_parse.h"
30 #include "h264.h"
31 #include "hevc.h"
32 #include "startcode.h"
33 #include "vc1_common.h"
34 #include "vvc.h"
35 
36 typedef struct ExtractExtradataContext {
37  const AVClass *class;
38 
40  uint8_t **data, int *size);
41 
42  /* AV1 specific fields */
44 
45  /* H264/HEVC specific fields */
47 
48  /* AVOptions */
49  int remove;
51 
52 static int val_in_array(const int *arr, size_t len, int val)
53 {
54  for (size_t i = 0; i < len; i++)
55  if (arr[i] == val)
56  return 1;
57  return 0;
58 }
59 
60 static int metadata_is_global(const AV1OBU *obu)
61 {
62  static const int metadata_obu_types[] = {
64  };
65  GetBitContext gb;
66  int metadata_type;
67 
68  if (init_get_bits(&gb, obu->data, obu->size_bits) < 0)
69  return 0;
70 
71  metadata_type = leb128(&gb);
72 
73  return val_in_array(metadata_obu_types, FF_ARRAY_ELEMS(metadata_obu_types),
74  metadata_type);
75 }
76 
77 static int obu_is_global(const AV1OBU *obu)
78 {
79  static const int extradata_obu_types[] = {
81  };
82 
83  if (!val_in_array(extradata_obu_types, FF_ARRAY_ELEMS(extradata_obu_types),
84  obu->type))
85  return 0;
86  if (obu->type != AV1_OBU_METADATA)
87  return 1;
88 
89  return metadata_is_global(obu);
90 }
91 
93  uint8_t **data, int *size)
94 {
95 
97 
98  int extradata_size = 0, filtered_size = 0;
99  int i, has_seq = 0, ret = 0;
100 
101  ret = ff_av1_packet_split(&s->av1_pkt, pkt->data, pkt->size, ctx);
102  if (ret < 0)
103  return ret;
104 
105  for (i = 0; i < s->av1_pkt.nb_obus; i++) {
106  AV1OBU *obu = &s->av1_pkt.obus[i];
107  if (obu_is_global(obu)) {
108  extradata_size += obu->raw_size;
109  if (obu->type == AV1_OBU_SEQUENCE_HEADER)
110  has_seq = 1;
111  } else if (s->remove) {
112  filtered_size += obu->raw_size;
113  }
114  }
115 
116  if (extradata_size && has_seq) {
117  AVBufferRef *filtered_buf = NULL;
118  PutByteContext pb_filtered_data, pb_extradata;
119  uint8_t *extradata;
120 
121  if (s->remove) {
122  filtered_buf = av_buffer_alloc(filtered_size + AV_INPUT_BUFFER_PADDING_SIZE);
123  if (!filtered_buf) {
124  return AVERROR(ENOMEM);
125  }
126  memset(filtered_buf->data + filtered_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
127  }
128 
129  extradata = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
130  if (!extradata) {
131  av_buffer_unref(&filtered_buf);
132  return AVERROR(ENOMEM);
133  }
134 
135  *data = extradata;
136  *size = extradata_size;
137 
138  bytestream2_init_writer(&pb_extradata, extradata, extradata_size);
139  if (s->remove)
140  bytestream2_init_writer(&pb_filtered_data, filtered_buf->data, filtered_size);
141 
142  for (i = 0; i < s->av1_pkt.nb_obus; i++) {
143  AV1OBU *obu = &s->av1_pkt.obus[i];
144  if (obu_is_global(obu)) {
145  bytestream2_put_bufferu(&pb_extradata, obu->raw_data, obu->raw_size);
146  } else if (s->remove) {
147  bytestream2_put_bufferu(&pb_filtered_data, obu->raw_data, obu->raw_size);
148  }
149  }
150 
151  if (s->remove) {
153  pkt->buf = filtered_buf;
154  pkt->data = filtered_buf->data;
155  pkt->size = filtered_size;
156  }
157  }
158 
159  return 0;
160 }
161 
163  uint8_t **data, int *size)
164 {
165  static const int extradata_nal_types_vvc[] = {
167  };
168  static const int extradata_nal_types_hevc[] = {
170  };
171  static const int extradata_nal_types_h264[] = {
173  };
174 
176 
177  int extradata_size = 0, filtered_size = 0;
178  const int *extradata_nal_types;
179  size_t nb_extradata_nal_types;
180  int i, has_sps = 0, has_vps = 0, ret = 0;
181 
182  if (ctx->par_in->codec_id == AV_CODEC_ID_VVC) {
183  extradata_nal_types = extradata_nal_types_vvc;
184  nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_vvc);
185  } else if (ctx->par_in->codec_id == AV_CODEC_ID_HEVC) {
186  extradata_nal_types = extradata_nal_types_hevc;
187  nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_hevc);
188  } else {
189  extradata_nal_types = extradata_nal_types_h264;
190  nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_h264);
191  }
192 
193  ret = ff_h2645_packet_split(&s->h2645_pkt, pkt->data, pkt->size,
194  ctx, 0, 0, ctx->par_in->codec_id, 1, 0);
195  if (ret < 0)
196  return ret;
197 
198  for (i = 0; i < s->h2645_pkt.nb_nals; i++) {
199  H2645NAL *nal = &s->h2645_pkt.nals[i];
200  if (val_in_array(extradata_nal_types, nb_extradata_nal_types, nal->type)) {
201  extradata_size += nal->raw_size + 3;
202  if (ctx->par_in->codec_id == AV_CODEC_ID_VVC) {
203  if (nal->type == VVC_SPS_NUT) has_sps = 1;
204  if (nal->type == VVC_VPS_NUT) has_vps = 1;
205  } else if (ctx->par_in->codec_id == AV_CODEC_ID_HEVC) {
206  if (nal->type == HEVC_NAL_SPS) has_sps = 1;
207  if (nal->type == HEVC_NAL_VPS) has_vps = 1;
208  } else {
209  if (nal->type == H264_NAL_SPS) has_sps = 1;
210  }
211  } else if (s->remove) {
212  filtered_size += nal->raw_size + 3;
213  }
214  }
215 
216  if (extradata_size &&
217  ((ctx->par_in->codec_id == AV_CODEC_ID_VVC && has_sps) ||
218  (ctx->par_in->codec_id == AV_CODEC_ID_HEVC && has_sps && has_vps) ||
219  (ctx->par_in->codec_id == AV_CODEC_ID_H264 && has_sps))) {
220  AVBufferRef *filtered_buf = NULL;
221  PutByteContext pb_filtered_data, pb_extradata;
222  uint8_t *extradata;
223 
224  if (s->remove) {
225  filtered_buf = av_buffer_alloc(filtered_size + AV_INPUT_BUFFER_PADDING_SIZE);
226  if (!filtered_buf) {
227  return AVERROR(ENOMEM);
228  }
229  memset(filtered_buf->data + filtered_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
230  }
231 
232  extradata = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
233  if (!extradata) {
234  av_buffer_unref(&filtered_buf);
235  return AVERROR(ENOMEM);
236  }
237 
238  *data = extradata;
239  *size = extradata_size;
240 
241  bytestream2_init_writer(&pb_extradata, extradata, extradata_size);
242  if (s->remove)
243  bytestream2_init_writer(&pb_filtered_data, filtered_buf->data, filtered_size);
244 
245  for (i = 0; i < s->h2645_pkt.nb_nals; i++) {
246  H2645NAL *nal = &s->h2645_pkt.nals[i];
247  if (val_in_array(extradata_nal_types, nb_extradata_nal_types,
248  nal->type)) {
249  bytestream2_put_be24u(&pb_extradata, 1); //startcode
250  bytestream2_put_bufferu(&pb_extradata, nal->raw_data, nal->raw_size);
251  } else if (s->remove) {
252  bytestream2_put_be24u(&pb_filtered_data, 1); // startcode
253  bytestream2_put_bufferu(&pb_filtered_data, nal->raw_data, nal->raw_size);
254  }
255  }
256 
257  if (s->remove) {
259  pkt->buf = filtered_buf;
260  pkt->data = filtered_buf->data;
261  pkt->size = filtered_size;
262  }
263  }
264 
265  return 0;
266 }
267 
269  uint8_t **data, int *size)
270 {
272  const uint8_t *ptr = pkt->data, *end = pkt->data + pkt->size;
273  uint32_t state = UINT32_MAX;
274  int has_extradata = 0, extradata_size = 0;
275 
276  while (ptr < end) {
277  ptr = avpriv_find_start_code(ptr, end, &state);
279  has_extradata = 1;
280  } else if (has_extradata && IS_MARKER(state)) {
281  extradata_size = ptr - 4 - pkt->data;
282  break;
283  }
284  }
285 
286  if (extradata_size) {
287  *data = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
288  if (!*data)
289  return AVERROR(ENOMEM);
290 
291  memcpy(*data, pkt->data, extradata_size);
292  *size = extradata_size;
293 
294  if (s->remove) {
295  pkt->data += extradata_size;
296  pkt->size -= extradata_size;
297  }
298  }
299 
300  return 0;
301 }
302 
304  uint8_t **data, int *size)
305 {
307  uint32_t state = UINT32_MAX;
308  int i, found = 0;
309 
310  for (i = 0; i < pkt->size; i++) {
311  state = (state << 8) | pkt->data[i];
312  if (state == 0x1B3)
313  found = 1;
314  else if (found && state != 0x1B5 && state < 0x200 && state >= 0x100) {
315  *size = i - 3;
317  if (!*data)
318  return AVERROR(ENOMEM);
319 
320  memcpy(*data, pkt->data, *size);
321 
322  if (s->remove) {
323  pkt->data += *size;
324  pkt->size -= *size;
325  }
326  break;
327  }
328  }
329  return 0;
330 }
331 
333  uint8_t **data, int *size)
334 {
336  const uint8_t *ptr = pkt->data, *end = pkt->data + pkt->size;
337  uint32_t state = UINT32_MAX;
338 
339  while (ptr < end) {
340  ptr = avpriv_find_start_code(ptr, end, &state);
341  if (state == 0x1B3 || state == 0x1B6) {
342  if (ptr - pkt->data > 4) {
343  *size = ptr - 4 - pkt->data;
345  if (!*data)
346  return AVERROR(ENOMEM);
347 
348  memcpy(*data, pkt->data, *size);
349 
350  if (s->remove) {
351  pkt->data += *size;
352  pkt->size -= *size;
353  }
354  }
355  break;
356  }
357  }
358  return 0;
359 }
360 
361 static const struct {
362  enum AVCodecID id;
364  uint8_t **data, int *size);
365 } extract_tab[] = {
377 };
378 
380 {
382  int i;
383 
384  for (i = 0; i < FF_ARRAY_ELEMS(extract_tab); i++) {
385  if (extract_tab[i].id == ctx->par_in->codec_id) {
386  s->extract = extract_tab[i].extract;
387  break;
388  }
389  }
390  if (!s->extract)
391  return AVERROR_BUG;
392 
393  return 0;
394 }
395 
397 {
399  uint8_t *extradata = NULL;
400  int extradata_size;
401  int ret = 0;
402 
404  if (ret < 0)
405  return ret;
406 
407  ret = s->extract(ctx, pkt, &extradata, &extradata_size);
408  if (ret < 0)
409  goto fail;
410 
411  if (extradata) {
412  memset(extradata + extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
414  extradata, extradata_size);
415  if (ret < 0) {
416  av_freep(&extradata);
417  goto fail;
418  }
419  }
420 
421  return 0;
422 
423 fail:
425  return ret;
426 }
427 
429 {
431  ff_av1_packet_uninit(&s->av1_pkt);
432  ff_h2645_packet_uninit(&s->h2645_pkt);
433 }
434 
435 static const enum AVCodecID codec_ids[] = {
448 };
449 
450 #define OFFSET(x) offsetof(ExtractExtradataContext, x)
451 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
452 static const AVOption options[] = {
453  { "remove", "remove the extradata from the bitstream", OFFSET(remove), AV_OPT_TYPE_INT,
454  { .i64 = 0 }, 0, 1, FLAGS },
455  { NULL },
456 };
457 
459  .class_name = "extract_extradata",
460  .item_name = av_default_item_name,
461  .option = options,
462  .version = LIBAVUTIL_VERSION_INT,
463 };
464 
466  .p.name = "extract_extradata",
467  .p.codec_ids = codec_ids,
468  .p.priv_class = &extract_extradata_class,
469  .priv_data_size = sizeof(ExtractExtradataContext),
472  .close = extract_extradata_close,
473 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:426
ExtractExtradataContext::h2645_pkt
H2645Packet h2645_pkt
Definition: extract_extradata_bsf.c:46
h2645_parse.h
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
bsf_internal.h
opt.h
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
VVC_PPS_NUT
@ VVC_PPS_NUT
Definition: vvc.h:45
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
extract_tab
static const struct @74 extract_tab[]
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
AV1_METADATA_TYPE_HDR_MDCV
@ AV1_METADATA_TYPE_HDR_MDCV
Definition: av1.h:45
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
extract_extradata_h2645
static int extract_extradata_h2645(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:162
extract_extradata_class
static const AVClass extract_extradata_class
Definition: extract_extradata_bsf.c:458
AVPacket::data
uint8_t * data
Definition: packet.h:515
AVOption
AVOption.
Definition: opt.h:251
ff_h2645_packet_uninit
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:597
AV_CODEC_ID_AVS2
@ AV_CODEC_ID_AVS2
Definition: codec_id.h:246
data
const char data[16]
Definition: mxf.c:148
AV1OBU
Definition: av1_parse.h:37
ExtractExtradataContext::av1_pkt
AV1Packet av1_pkt
Definition: extract_extradata_bsf.c:43
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
ExtractExtradataContext::remove
int remove
Definition: extract_extradata_bsf.c:49
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:515
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
AV1OBU::data
const uint8_t * data
Definition: av1_parse.h:40
ff_av1_packet_split
int ff_av1_packet_split(AV1Packet *pkt, const uint8_t *buf, int length, void *logctx)
Split an input packet into OBUs.
Definition: av1_parse.c:56
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
av1_parse.h
bsf.h
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:197
AV1Packet
An input packet split into OBUs.
Definition: av1_parse.h:59
fail
#define fail()
Definition: checkasm.h:177
ExtractExtradataContext::extract
int(* extract)(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:39
extract_extradata_filter
static int extract_extradata_filter(AVBSFContext *ctx, AVPacket *pkt)
Definition: extract_extradata_bsf.c:396
GetBitContext
Definition: get_bits.h:109
VVC_VPS_NUT
@ VVC_VPS_NUT
Definition: vvc.h:43
AV1_METADATA_TYPE_HDR_CLL
@ AV1_METADATA_TYPE_HDR_CLL
Definition: av1.h:44
val
static double val(void *priv, double ch)
Definition: aeval.c:78
extract_extradata_mpeg12
static int extract_extradata_mpeg12(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:303
pkt
AVPacket * pkt
Definition: movenc.c:59
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
s
#define s(width, name)
Definition: cbs_vp9.c:198
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
ctx
AVFormatContext * ctx
Definition: movenc.c:48
codec_ids
static enum AVCodecID codec_ids[]
Definition: extract_extradata_bsf.c:435
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
FLAGS
#define FLAGS
Definition: extract_extradata_bsf.c:451
if
if(ret)
Definition: filter_design.txt:179
metadata_is_global
static int metadata_is_global(const AV1OBU *obu)
Definition: extract_extradata_bsf.c:60
AV_CODEC_ID_AVS3
@ AV_CODEC_ID_AVS3
Definition: codec_id.h:248
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:498
H2645NAL::raw_size
int raw_size
Definition: h2645_parse.h:44
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
leb128
#define leb128(name)
Definition: cbs_av1.c:631
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
FFBitStreamFilter
Definition: bsf_internal.h:27
av_buffer_unref
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:139
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:283
HEVC_NAL_PPS
@ HEVC_NAL_PPS
Definition: hevc.h:63
VC1_CODE_SEQHDR
@ VC1_CODE_SEQHDR
Definition: vc1_common.h:40
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
IS_MARKER
#define IS_MARKER(state)
Definition: dca_parser.c:51
OFFSET
#define OFFSET(x)
Definition: extract_extradata_bsf.c:450
VC1_CODE_ENTRYPOINT
@ VC1_CODE_ENTRYPOINT
Definition: vc1_common.h:39
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:53
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
PutByteContext
Definition: bytestream.h:37
startcode.h
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
extract
int(* extract)(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:363
AVPacket::size
int size
Definition: packet.h:516
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:362
size
int size
Definition: twinvq_data.h:10344
H2645NAL
Definition: h2645_parse.h:34
obu_is_global
static int obu_is_global(const AV1OBU *obu)
Definition: extract_extradata_bsf.c:77
AV1_OBU_SEQUENCE_HEADER
@ AV1_OBU_SEQUENCE_HEADER
Definition: av1.h:30
extract_extradata_init
static int extract_extradata_init(AVBSFContext *ctx)
Definition: extract_extradata_bsf.c:379
options
static const AVOption options[]
Definition: extract_extradata_bsf.c:452
av1.h
val_in_array
static int val_in_array(const int *arr, size_t len, int val)
Definition: extract_extradata_bsf.c:52
ff_h2645_packet_split
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
Definition: h2645_parse.c:463
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:250
AV1OBU::raw_size
int raw_size
Size of entire OBU, including header.
Definition: av1_parse.h:49
extract_extradata_close
static void extract_extradata_close(AVBSFContext *ctx)
Definition: extract_extradata_bsf.c:428
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
vc1_common.h
AV1OBU::size_bits
int size_bits
Size, in bits, of just the data, excluding the trailing_one_bit and any trailing padding.
Definition: av1_parse.h:46
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:139
AV1OBU::raw_data
const uint8_t * raw_data
Definition: av1_parse.h:50
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
ff_av1_packet_uninit
void ff_av1_packet_uninit(AV1Packet *pkt)
Free all the allocated memory in the packet.
Definition: av1_parse.c:104
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
len
int len
Definition: vorbis_enc_data.h:426
hevc.h
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
ret
ret
Definition: filter_design.txt:187
H2645NAL::raw_data
const uint8_t * raw_data
Definition: h2645_parse.h:45
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
VVC_SPS_NUT
@ VVC_SPS_NUT
Definition: vvc.h:44
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
ExtractExtradataContext
Definition: extract_extradata_bsf.c:36
vvc.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
extract_extradata_mpeg4
static int extract_extradata_mpeg4(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:332
AV1OBU::type
int type
Definition: av1_parse.h:52
extract_extradata_vc1
static int extract_extradata_vc1(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:268
HEVC_NAL_SPS
@ HEVC_NAL_SPS
Definition: hevc.h:62
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
bytestream2_put_bufferu
static av_always_inline unsigned int bytestream2_put_bufferu(PutByteContext *p, const uint8_t *src, unsigned int size)
Definition: bytestream.h:301
AVPacket
This structure stores compressed data.
Definition: packet.h:492
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
state
static struct @374 state
bytestream.h
h264.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
ff_bsf_get_packet_ref
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:256
ff_extract_extradata_bsf
const FFBitStreamFilter ff_extract_extradata_bsf
Definition: extract_extradata_bsf.c:465
extract_extradata_av1
static int extract_extradata_av1(AVBSFContext *ctx, AVPacket *pkt, uint8_t **data, int *size)
Definition: extract_extradata_bsf.c:92
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
int
int
Definition: ffmpeg_filter.c:422
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
H2645Packet
Definition: h2645_parse.h:82
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1220
AV1_OBU_METADATA
@ AV1_OBU_METADATA
Definition: av1.h:34