FFmpeg
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 <string.h>
20 
21 #include "libavutil/avassert.h"
22 #include "libavutil/log.h"
23 #include "libavutil/mem.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/bprint.h"
27 
28 #include "bsf.h"
29 #include "bsf_internal.h"
30 #include "codec_desc.h"
31 #include "codec_par.h"
32 
33 #define IS_EMPTY(pkt) (!(pkt)->data && !(pkt)->side_data_elems)
34 
35 struct AVBSFInternal {
37  int eof;
38 };
39 
41 {
43 
44  if (!pctx || !*pctx)
45  return;
46  ctx = *pctx;
47 
48  if (ctx->internal) {
49  if (ctx->filter->close)
50  ctx->filter->close(ctx);
51  av_packet_free(&ctx->internal->buffer_pkt);
53  }
54  if (ctx->filter->priv_class && ctx->priv_data)
56 
58 
59  avcodec_parameters_free(&ctx->par_in);
60  avcodec_parameters_free(&ctx->par_out);
61 
62  av_freep(pctx);
63 }
64 
65 static void *bsf_child_next(void *obj, void *prev)
66 {
67  AVBSFContext *ctx = obj;
68  if (!prev && ctx->filter->priv_class)
69  return ctx->priv_data;
70  return NULL;
71 }
72 
73 static const char *bsf_to_name(void *bsf)
74 {
75  return ((AVBSFContext *)bsf)->filter->name;
76 }
77 
78 static const AVClass bsf_class = {
79  .class_name = "AVBSFContext",
80  .item_name = bsf_to_name,
81  .version = LIBAVUTIL_VERSION_INT,
82  .child_next = bsf_child_next,
83  .child_class_iterate = ff_bsf_child_class_iterate,
85 };
86 
88 {
89  return &bsf_class;
90 }
91 
93 {
95  AVBSFInternal *bsfi;
96  int ret;
97 
98  ctx = av_mallocz(sizeof(*ctx));
99  if (!ctx)
100  return AVERROR(ENOMEM);
101 
102  ctx->av_class = &bsf_class;
103  ctx->filter = filter;
104 
105  ctx->par_in = avcodec_parameters_alloc();
106  ctx->par_out = avcodec_parameters_alloc();
107  if (!ctx->par_in || !ctx->par_out) {
108  ret = AVERROR(ENOMEM);
109  goto fail;
110  }
111  /* allocate priv data and init private options */
112  if (filter->priv_data_size) {
113  ctx->priv_data = av_mallocz(filter->priv_data_size);
114  if (!ctx->priv_data) {
115  ret = AVERROR(ENOMEM);
116  goto fail;
117  }
118  if (filter->priv_class) {
119  *(const AVClass **)ctx->priv_data = filter->priv_class;
121  }
122  }
123  /* Allocate AVBSFInternal; must happen after priv_data has been allocated
124  * so that a filter->close needing priv_data is never called without. */
125  bsfi = av_mallocz(sizeof(*bsfi));
126  if (!bsfi) {
127  ret = AVERROR(ENOMEM);
128  goto fail;
129  }
130  ctx->internal = bsfi;
131 
132  bsfi->buffer_pkt = av_packet_alloc();
133  if (!bsfi->buffer_pkt) {
134  ret = AVERROR(ENOMEM);
135  goto fail;
136  }
137 
138  *pctx = ctx;
139  return 0;
140 fail:
141  av_bsf_free(&ctx);
142  return ret;
143 }
144 
146 {
147  int ret, i;
148 
149  /* check that the codec is supported */
150  if (ctx->filter->codec_ids) {
151  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)
152  if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])
153  break;
154  if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {
155  const AVCodecDescriptor *desc = avcodec_descriptor_get(ctx->par_in->codec_id);
156  av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "
157  "bitstream filter '%s'. Supported codecs are: ",
158  desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);
159  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {
160  enum AVCodecID codec_id = ctx->filter->codec_ids[i];
161  av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
163  }
164  av_log(ctx, AV_LOG_ERROR, "\n");
165  return AVERROR(EINVAL);
166  }
167  }
168 
169  /* initialize output parameters to be the same as input
170  * init below might overwrite that */
171  ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);
172  if (ret < 0)
173  return ret;
174 
175  ctx->time_base_out = ctx->time_base_in;
176 
177  if (ctx->filter->init) {
178  ret = ctx->filter->init(ctx);
179  if (ret < 0)
180  return ret;
181  }
182 
183  return 0;
184 }
185 
187 {
188  AVBSFInternal *bsfi = ctx->internal;
189 
190  bsfi->eof = 0;
191 
193 
194  if (ctx->filter->flush)
195  ctx->filter->flush(ctx);
196 }
197 
199 {
200  AVBSFInternal *bsfi = ctx->internal;
201  int ret;
202 
203  if (!pkt || IS_EMPTY(pkt)) {
204  bsfi->eof = 1;
205  return 0;
206  }
207 
208  if (bsfi->eof) {
209  av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
210  return AVERROR(EINVAL);
211  }
212 
213  if (!IS_EMPTY(bsfi->buffer_pkt))
214  return AVERROR(EAGAIN);
215 
217  if (ret < 0)
218  return ret;
220 
221  return 0;
222 }
223 
225 {
226  return ctx->filter->filter(ctx, pkt);
227 }
228 
230 {
231  AVBSFInternal *bsfi = ctx->internal;
232  AVPacket *tmp_pkt;
233 
234  if (bsfi->eof)
235  return AVERROR_EOF;
236 
237  if (IS_EMPTY(bsfi->buffer_pkt))
238  return AVERROR(EAGAIN);
239 
240  tmp_pkt = av_packet_alloc();
241  if (!tmp_pkt)
242  return AVERROR(ENOMEM);
243 
244  *pkt = bsfi->buffer_pkt;
245  bsfi->buffer_pkt = tmp_pkt;
246 
247  return 0;
248 }
249 
251 {
252  AVBSFInternal *bsfi = ctx->internal;
253 
254  if (bsfi->eof)
255  return AVERROR_EOF;
256 
257  if (IS_EMPTY(bsfi->buffer_pkt))
258  return AVERROR(EAGAIN);
259 
261 
262  return 0;
263 }
264 
265 typedef struct BSFListContext {
266  const AVClass *class;
267 
269  int nb_bsfs;
270 
271  unsigned idx; // index of currently processed BSF
272 
273  char * item_name;
275 
276 
277 static int bsf_list_init(AVBSFContext *bsf)
278 {
279  BSFListContext *lst = bsf->priv_data;
280  int ret, i;
281  const AVCodecParameters *cod_par = bsf->par_in;
282  AVRational tb = bsf->time_base_in;
283 
284  for (i = 0; i < lst->nb_bsfs; ++i) {
285  ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);
286  if (ret < 0)
287  goto fail;
288 
289  lst->bsfs[i]->time_base_in = tb;
290 
291  ret = av_bsf_init(lst->bsfs[i]);
292  if (ret < 0)
293  goto fail;
294 
295  cod_par = lst->bsfs[i]->par_out;
296  tb = lst->bsfs[i]->time_base_out;
297  }
298 
299  bsf->time_base_out = tb;
300  ret = avcodec_parameters_copy(bsf->par_out, cod_par);
301 
302 fail:
303  return ret;
304 }
305 
307 {
308  BSFListContext *lst = bsf->priv_data;
309  int ret, eof = 0;
310 
311  if (!lst->nb_bsfs)
312  return ff_bsf_get_packet_ref(bsf, out);
313 
314  while (1) {
315  /* get a packet from the previous filter up the chain */
316  if (lst->idx)
317  ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);
318  else
319  ret = ff_bsf_get_packet_ref(bsf, out);
320  if (ret == AVERROR(EAGAIN)) {
321  if (!lst->idx)
322  return ret;
323  lst->idx--;
324  continue;
325  } else if (ret == AVERROR_EOF) {
326  eof = 1;
327  } else if (ret < 0)
328  return ret;
329 
330  /* send it to the next filter down the chain */
331  if (lst->idx < lst->nb_bsfs) {
332  ret = av_bsf_send_packet(lst->bsfs[lst->idx], eof ? NULL : out);
333  av_assert1(ret != AVERROR(EAGAIN));
334  if (ret < 0) {
336  return ret;
337  }
338  lst->idx++;
339  eof = 0;
340  } else if (eof) {
341  return ret;
342  } else {
343  return 0;
344  }
345  }
346 }
347 
348 static void bsf_list_flush(AVBSFContext *bsf)
349 {
350  BSFListContext *lst = bsf->priv_data;
351 
352  for (int i = 0; i < lst->nb_bsfs; i++)
353  av_bsf_flush(lst->bsfs[i]);
354  lst->idx = 0;
355 }
356 
357 static void bsf_list_close(AVBSFContext *bsf)
358 {
359  BSFListContext *lst = bsf->priv_data;
360  int i;
361 
362  for (i = 0; i < lst->nb_bsfs; ++i)
363  av_bsf_free(&lst->bsfs[i]);
364  av_freep(&lst->bsfs);
365  av_freep(&lst->item_name);
366 }
367 
368 static const char *bsf_list_item_name(void *ctx)
369 {
370  static const char *null_filter_name = "null";
371  AVBSFContext *bsf_ctx = ctx;
372  BSFListContext *lst = bsf_ctx->priv_data;
373 
374  if (!lst->nb_bsfs)
375  return null_filter_name;
376 
377  if (!lst->item_name) {
378  int i;
379  AVBPrint bp;
380  av_bprint_init(&bp, 16, 128);
381 
382  av_bprintf(&bp, "bsf_list(");
383  for (i = 0; i < lst->nb_bsfs; i++)
384  av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name);
385  av_bprintf(&bp, ")");
386 
387  av_bprint_finalize(&bp, &lst->item_name);
388  }
389 
390  return lst->item_name;
391 }
392 
393 static const AVClass bsf_list_class = {
394  .class_name = "bsf_list",
395  .item_name = bsf_list_item_name,
396  .version = LIBAVUTIL_VERSION_INT,
397 };
398 
400  .name = "bsf_list",
401  .priv_data_size = sizeof(BSFListContext),
402  .priv_class = &bsf_list_class,
403  .init = bsf_list_init,
406  .close = bsf_list_close,
407 };
408 
409 struct AVBSFList {
411  int nb_bsfs;
412 };
413 
415 {
416  return av_mallocz(sizeof(AVBSFList));
417 }
418 
420 {
421  int i;
422 
423  if (!*lst)
424  return;
425 
426  for (i = 0; i < (*lst)->nb_bsfs; ++i)
427  av_bsf_free(&(*lst)->bsfs[i]);
428  av_free((*lst)->bsfs);
429  av_freep(lst);
430 }
431 
433 {
434  return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf);
435 }
436 
437 static int bsf_list_append_internal(AVBSFList *lst, const char *bsf_name, const char *options, AVDictionary ** options_dict)
438 {
439  int ret;
440  const AVBitStreamFilter *filter;
441  AVBSFContext *bsf;
442 
443  filter = av_bsf_get_by_name(bsf_name);
444  if (!filter)
445  return AVERROR_BSF_NOT_FOUND;
446 
447  ret = av_bsf_alloc(filter, &bsf);
448  if (ret < 0)
449  return ret;
450 
451  if (options && filter->priv_class) {
452  const AVOption *opt = av_opt_next(bsf->priv_data, NULL);
453  const char * shorthand[2] = {NULL};
454 
455  if (opt)
456  shorthand[0] = opt->name;
457 
458  ret = av_opt_set_from_string(bsf->priv_data, options, shorthand, "=", ":");
459  if (ret < 0)
460  goto end;
461  }
462 
463  if (options_dict) {
464  ret = av_opt_set_dict2(bsf, options_dict, AV_OPT_SEARCH_CHILDREN);
465  if (ret < 0)
466  goto end;
467  }
468 
469  ret = av_bsf_list_append(lst, bsf);
470 
471 end:
472  if (ret < 0)
473  av_bsf_free(&bsf);
474 
475  return ret;
476 }
477 
478 int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)
479 {
480  return bsf_list_append_internal(lst, bsf_name, NULL, options);
481 }
482 
484 {
485  int ret = 0;
487 
488  if ((*lst)->nb_bsfs == 1) {
489  *bsf = (*lst)->bsfs[0];
490  av_freep(&(*lst)->bsfs);
491  (*lst)->nb_bsfs = 0;
492  goto end;
493  }
494 
495  ret = av_bsf_alloc(&ff_list_bsf, bsf);
496  if (ret < 0)
497  return ret;
498 
499  ctx = (*bsf)->priv_data;
500 
501  ctx->bsfs = (*lst)->bsfs;
502  ctx->nb_bsfs = (*lst)->nb_bsfs;
503 
504 end:
505  av_freep(lst);
506  return ret;
507 }
508 
509 static int bsf_parse_single(char *str, AVBSFList *bsf_lst)
510 {
511  char *bsf_name, *bsf_options_str;
512 
513  bsf_name = av_strtok(str, "=", &bsf_options_str);
514  if (!bsf_name)
515  return AVERROR(EINVAL);
516 
517  return bsf_list_append_internal(bsf_lst, bsf_name, bsf_options_str, NULL);
518 }
519 
520 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
521 {
522  AVBSFList *lst;
523  char *bsf_str, *buf, *dup, *saveptr;
524  int ret;
525 
526  if (!str)
527  return av_bsf_get_null_filter(bsf_lst);
528 
529  lst = av_bsf_list_alloc();
530  if (!lst)
531  return AVERROR(ENOMEM);
532 
533  if (!(dup = buf = av_strdup(str))) {
534  ret = AVERROR(ENOMEM);
535  goto end;
536  }
537 
538  while (bsf_str = av_strtok(buf, ",", &saveptr)) {
539  ret = bsf_parse_single(bsf_str, lst);
540  if (ret < 0)
541  goto end;
542 
543  buf = NULL;
544  }
545 
546  ret = av_bsf_list_finalize(&lst, bsf_lst);
547 end:
548  if (ret < 0)
549  av_bsf_list_free(&lst);
550  av_free(dup);
551  return ret;
552 }
553 
555 {
556  return av_bsf_alloc(&ff_list_bsf, bsf);
557 }
AVBSFList::nb_bsfs
int nb_bsfs
Definition: bsf.c:411
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:403
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
AVBSFInternal::buffer_pkt
AVPacket * buffer_pkt
Definition: bsf.c:36
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
out
FILE * out
Definition: movenc.c:54
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVBitStreamFilter::name
const char * name
Definition: bsf.h:99
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:145
BSFListContext::bsfs
AVBSFContext ** bsfs
Definition: bsf.c:268
av_bsf_list_alloc
AVBSFList * av_bsf_list_alloc(void)
Allocate empty list of bitstream filters.
Definition: bsf.c:414
bsf_list_append_internal
static int bsf_list_append_internal(AVBSFList *lst, const char *bsf_name, const char *options, AVDictionary **options_dict)
Definition: bsf.c:437
AVOption
AVOption.
Definition: opt.h:248
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:61
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
AVDictionary
Definition: dict.c:30
ff_bsf_get_packet
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:229
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1555
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:70
AVBSFContext
The bitstream filter state.
Definition: bsf.h:49
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:78
BSFListContext
Definition: bsf.c:265
bsf.h
fail
#define fail()
Definition: checkasm.h:134
bsf_child_next
static void * bsf_child_next(void *obj, void *prev)
Definition: bsf.c:65
av_bsf_get_null_filter
int av_bsf_get_null_filter(AVBSFContext **bsf)
Get null/pass-through bitstream filter.
Definition: bsf.c:554
AVBSFContext::par_out
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:83
BSFListContext::nb_bsfs
int nb_bsfs
Definition: bsf.c:269
BSFListContext::idx
unsigned idx
Definition: bsf.c:271
bsf_list_filter
static int bsf_list_filter(AVBSFContext *bsf, AVPacket *out)
Definition: bsf.c:306
bsf_list_flush
static void bsf_list_flush(AVBSFContext *bsf)
Definition: bsf.c:348
avassert.h
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:181
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
av_bsf_list_free
void av_bsf_list_free(AVBSFList **lst)
Free list of bitstream filters.
Definition: bsf.c:419
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:186
av_bsf_get_class
const AVClass * av_bsf_get_class(void)
Get the AVClass for AVBSFContext.
Definition: bsf.c:87
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:89
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
av_bsf_list_finalize
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
Finalize list of bitstream filters.
Definition: bsf.c:483
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
NULL
#define NULL
Definition: coverity.c:32
av_bsf_list_parse_str
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
Parse string describing list of bitstream filters and create single AVBSFContext describing the whole...
Definition: bsf.c:520
AVBSFInternal::eof
int eof
Definition: bsf.c:37
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_opt_set_from_string
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1559
AVERROR_BSF_NOT_FOUND
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:49
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:459
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
ff_bsf_child_class_iterate
const AVClass * ff_bsf_child_class_iterate(void **opaque)
Definition: bitstream_filters.c:94
options
const OptionDef options[]
bsf_class
static const AVClass bsf_class
Definition: bsf.c:78
IS_EMPTY
#define IS_EMPTY(pkt)
Definition: bsf.c:33
AVClass::category
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:120
bsf_list_item_name
static const char * bsf_list_item_name(void *ctx)
Definition: bsf.c:368
AVOption::name
const char * name
Definition: opt.h:249
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1631
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:465
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:59
bsf_list_class
static const AVClass bsf_list_class
Definition: bsf.c:393
bsf_parse_single
static int bsf_parse_single(char *str, AVBSFList *bsf_lst)
Definition: bsf.c:509
av_bsf_list_append2
int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary **options)
Construct new bitstream filter context given it's name and options and append it to the list of bitst...
Definition: bsf.c:478
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:72
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:448
bsf_list_init
static int bsf_list_init(AVBSFContext *bsf)
Definition: bsf.c:277
bprint.h
i
int i
Definition: input.c:407
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:224
ff_list_bsf
const AVBitStreamFilter ff_list_bsf
Definition: bsf.c:399
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
BSFListContext::item_name
char * item_name
Definition: bsf.c:273
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:244
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:51
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:95
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:70
ret
ret
Definition: filter_design.txt:187
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:72
AVFormatContext::av_class
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1102
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:198
av_bsf_list_append
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)
Append bitstream filter to the list of bitstream filters.
Definition: bsf.c:432
av_bsf_flush
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:186
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:303
AVBSFList
Structure for chain/list of bitstream filters.
Definition: bsf.c:409
AVBitStreamFilter
Definition: bsf.h:98
bsf_list_close
static void bsf_list_close(AVBSFContext *bsf)
Definition: bsf.c:357
AVBSFInternal
Definition: bsf.c:35
AVBSFContext::filter
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:260
desc
const char * desc
Definition: libsvtav1.c:79
mem.h
AV_CLASS_CATEGORY_BITSTREAM_FILTER
@ AV_CLASS_CATEGORY_BITSTREAM_FILTER
Definition: log.h:38
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
codec_par.h
AVPacket
This structure stores compressed data.
Definition: packet.h:342
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:40
convert_header.str
string str
Definition: convert_header.py:20
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:250
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3508
bsf_to_name
static const char * bsf_to_name(void *bsf)
Definition: bsf.c:73
avstring.h
codec_desc.h
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1125
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:92
AVBSFList::bsfs
AVBSFContext ** bsfs
Definition: bsf.c:410