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