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);
52  av_freep(&ctx->internal);
53  }
54  if (ctx->filter->priv_class && ctx->priv_data)
55  av_opt_free(ctx->priv_data);
56 
57  av_freep(&ctx->priv_data);
58 
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 #if FF_API_CHILD_CLASS_NEXT
84  .child_class_next = ff_bsf_child_class_next,
85 #endif
86  .child_class_iterate = ff_bsf_child_class_iterate,
88 };
89 
91 {
92  return &bsf_class;
93 }
94 
96 {
98  AVBSFInternal *bsfi;
99  int ret;
100 
101  ctx = av_mallocz(sizeof(*ctx));
102  if (!ctx)
103  return AVERROR(ENOMEM);
104 
105  ctx->av_class = &bsf_class;
106  ctx->filter = filter;
107 
110  if (!ctx->par_in || !ctx->par_out) {
111  ret = AVERROR(ENOMEM);
112  goto fail;
113  }
114  /* allocate priv data and init private options */
115  if (filter->priv_data_size) {
116  ctx->priv_data = av_mallocz(filter->priv_data_size);
117  if (!ctx->priv_data) {
118  ret = AVERROR(ENOMEM);
119  goto fail;
120  }
121  if (filter->priv_class) {
122  *(const AVClass **)ctx->priv_data = filter->priv_class;
124  }
125  }
126  /* Allocate AVBSFInternal; must happen after priv_data has been allocated
127  * so that a filter->close needing priv_data is never called without. */
128  bsfi = av_mallocz(sizeof(*bsfi));
129  if (!bsfi) {
130  ret = AVERROR(ENOMEM);
131  goto fail;
132  }
133  ctx->internal = bsfi;
134 
135  bsfi->buffer_pkt = av_packet_alloc();
136  if (!bsfi->buffer_pkt) {
137  ret = AVERROR(ENOMEM);
138  goto fail;
139  }
140 
141  *pctx = ctx;
142  return 0;
143 fail:
144  av_bsf_free(&ctx);
145  return ret;
146 }
147 
149 {
150  int ret, i;
151 
152  /* check that the codec is supported */
153  if (ctx->filter->codec_ids) {
154  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)
155  if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])
156  break;
157  if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {
159  av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "
160  "bitstream filter '%s'. Supported codecs are: ",
161  desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);
162  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {
163  enum AVCodecID codec_id = ctx->filter->codec_ids[i];
164  av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
165  avcodec_get_name(codec_id), codec_id);
166  }
167  av_log(ctx, AV_LOG_ERROR, "\n");
168  return AVERROR(EINVAL);
169  }
170  }
171 
172  /* initialize output parameters to be the same as input
173  * init below might overwrite that */
174  ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);
175  if (ret < 0)
176  return ret;
177 
178  ctx->time_base_out = ctx->time_base_in;
179 
180  if (ctx->filter->init) {
181  ret = ctx->filter->init(ctx);
182  if (ret < 0)
183  return ret;
184  }
185 
186  return 0;
187 }
188 
190 {
191  AVBSFInternal *bsfi = ctx->internal;
192 
193  bsfi->eof = 0;
194 
196 
197  if (ctx->filter->flush)
198  ctx->filter->flush(ctx);
199 }
200 
202 {
203  AVBSFInternal *bsfi = ctx->internal;
204  int ret;
205 
206  if (!pkt || IS_EMPTY(pkt)) {
207  bsfi->eof = 1;
208  return 0;
209  }
210 
211  if (bsfi->eof) {
212  av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
213  return AVERROR(EINVAL);
214  }
215 
216  if (!IS_EMPTY(bsfi->buffer_pkt))
217  return AVERROR(EAGAIN);
218 
219  ret = av_packet_make_refcounted(pkt);
220  if (ret < 0)
221  return ret;
222  av_packet_move_ref(bsfi->buffer_pkt, pkt);
223 
224  return 0;
225 }
226 
228 {
229  return ctx->filter->filter(ctx, pkt);
230 }
231 
233 {
234  AVBSFInternal *bsfi = ctx->internal;
235  AVPacket *tmp_pkt;
236 
237  if (bsfi->eof)
238  return AVERROR_EOF;
239 
240  if (IS_EMPTY(bsfi->buffer_pkt))
241  return AVERROR(EAGAIN);
242 
243  tmp_pkt = av_packet_alloc();
244  if (!tmp_pkt)
245  return AVERROR(ENOMEM);
246 
247  *pkt = bsfi->buffer_pkt;
248  bsfi->buffer_pkt = tmp_pkt;
249 
250  return 0;
251 }
252 
254 {
255  AVBSFInternal *bsfi = ctx->internal;
256 
257  if (bsfi->eof)
258  return AVERROR_EOF;
259 
260  if (IS_EMPTY(bsfi->buffer_pkt))
261  return AVERROR(EAGAIN);
262 
263  av_packet_move_ref(pkt, bsfi->buffer_pkt);
264 
265  return 0;
266 }
267 
268 typedef struct BSFListContext {
269  const AVClass *class;
270 
272  int nb_bsfs;
273 
274  unsigned idx; // index of currently processed BSF
275 
276  char * item_name;
278 
279 
280 static int bsf_list_init(AVBSFContext *bsf)
281 {
282  BSFListContext *lst = bsf->priv_data;
283  int ret, i;
284  const AVCodecParameters *cod_par = bsf->par_in;
285  AVRational tb = bsf->time_base_in;
286 
287  for (i = 0; i < lst->nb_bsfs; ++i) {
288  ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);
289  if (ret < 0)
290  goto fail;
291 
292  lst->bsfs[i]->time_base_in = tb;
293 
294  ret = av_bsf_init(lst->bsfs[i]);
295  if (ret < 0)
296  goto fail;
297 
298  cod_par = lst->bsfs[i]->par_out;
299  tb = lst->bsfs[i]->time_base_out;
300  }
301 
302  bsf->time_base_out = tb;
303  ret = avcodec_parameters_copy(bsf->par_out, cod_par);
304 
305 fail:
306  return ret;
307 }
308 
310 {
311  BSFListContext *lst = bsf->priv_data;
312  int ret, eof = 0;
313 
314  if (!lst->nb_bsfs)
315  return ff_bsf_get_packet_ref(bsf, out);
316 
317  while (1) {
318  /* get a packet from the previous filter up the chain */
319  if (lst->idx)
320  ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);
321  else
322  ret = ff_bsf_get_packet_ref(bsf, out);
323  if (ret == AVERROR(EAGAIN)) {
324  if (!lst->idx)
325  return ret;
326  lst->idx--;
327  continue;
328  } else if (ret == AVERROR_EOF) {
329  eof = 1;
330  } else if (ret < 0)
331  return ret;
332 
333  /* send it to the next filter down the chain */
334  if (lst->idx < lst->nb_bsfs) {
335  ret = av_bsf_send_packet(lst->bsfs[lst->idx], eof ? NULL : out);
336  av_assert1(ret != AVERROR(EAGAIN));
337  if (ret < 0) {
338  av_packet_unref(out);
339  return ret;
340  }
341  lst->idx++;
342  eof = 0;
343  } else if (eof) {
344  return ret;
345  } else {
346  return 0;
347  }
348  }
349 }
350 
351 static void bsf_list_flush(AVBSFContext *bsf)
352 {
353  BSFListContext *lst = bsf->priv_data;
354 
355  for (int i = 0; i < lst->nb_bsfs; i++)
356  av_bsf_flush(lst->bsfs[i]);
357  lst->idx = 0;
358 }
359 
360 static void bsf_list_close(AVBSFContext *bsf)
361 {
362  BSFListContext *lst = bsf->priv_data;
363  int i;
364 
365  for (i = 0; i < lst->nb_bsfs; ++i)
366  av_bsf_free(&lst->bsfs[i]);
367  av_freep(&lst->bsfs);
368  av_freep(&lst->item_name);
369 }
370 
371 static const char *bsf_list_item_name(void *ctx)
372 {
373  static const char *null_filter_name = "null";
374  AVBSFContext *bsf_ctx = ctx;
375  BSFListContext *lst = bsf_ctx->priv_data;
376 
377  if (!lst->nb_bsfs)
378  return null_filter_name;
379 
380  if (!lst->item_name) {
381  int i;
382  AVBPrint bp;
383  av_bprint_init(&bp, 16, 128);
384 
385  av_bprintf(&bp, "bsf_list(");
386  for (i = 0; i < lst->nb_bsfs; i++)
387  av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name);
388  av_bprintf(&bp, ")");
389 
390  av_bprint_finalize(&bp, &lst->item_name);
391  }
392 
393  return lst->item_name;
394 }
395 
396 static const AVClass bsf_list_class = {
397  .class_name = "bsf_list",
398  .item_name = bsf_list_item_name,
399  .version = LIBAVUTIL_VERSION_INT,
400 };
401 
403  .name = "bsf_list",
404  .priv_data_size = sizeof(BSFListContext),
405  .priv_class = &bsf_list_class,
406  .init = bsf_list_init,
409  .close = bsf_list_close,
410 };
411 
412 struct AVBSFList {
414  int nb_bsfs;
415 };
416 
418 {
419  return av_mallocz(sizeof(AVBSFList));
420 }
421 
423 {
424  int i;
425 
426  if (!*lst)
427  return;
428 
429  for (i = 0; i < (*lst)->nb_bsfs; ++i)
430  av_bsf_free(&(*lst)->bsfs[i]);
431  av_free((*lst)->bsfs);
432  av_freep(lst);
433 }
434 
436 {
437  return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf);
438 }
439 
440 static int bsf_list_append_internal(AVBSFList *lst, const char *bsf_name, const char *options, AVDictionary ** options_dict)
441 {
442  int ret;
443  const AVBitStreamFilter *filter;
444  AVBSFContext *bsf;
445 
446  filter = av_bsf_get_by_name(bsf_name);
447  if (!filter)
448  return AVERROR_BSF_NOT_FOUND;
449 
450  ret = av_bsf_alloc(filter, &bsf);
451  if (ret < 0)
452  return ret;
453 
454  if (options && filter->priv_class) {
455  const AVOption *opt = av_opt_next(bsf->priv_data, NULL);
456  const char * shorthand[2] = {NULL};
457 
458  if (opt)
459  shorthand[0] = opt->name;
460 
461  ret = av_opt_set_from_string(bsf->priv_data, options, shorthand, "=", ":");
462  if (ret < 0)
463  goto end;
464  }
465 
466  if (options_dict) {
467  ret = av_opt_set_dict2(bsf, options_dict, AV_OPT_SEARCH_CHILDREN);
468  if (ret < 0)
469  goto end;
470  }
471 
472  ret = av_bsf_list_append(lst, bsf);
473 
474 end:
475  if (ret < 0)
476  av_bsf_free(&bsf);
477 
478  return ret;
479 }
480 
481 int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)
482 {
483  return bsf_list_append_internal(lst, bsf_name, NULL, options);
484 }
485 
487 {
488  int ret = 0;
490 
491  if ((*lst)->nb_bsfs == 1) {
492  *bsf = (*lst)->bsfs[0];
493  av_freep(&(*lst)->bsfs);
494  (*lst)->nb_bsfs = 0;
495  goto end;
496  }
497 
498  ret = av_bsf_alloc(&ff_list_bsf, bsf);
499  if (ret < 0)
500  return ret;
501 
502  ctx = (*bsf)->priv_data;
503 
504  ctx->bsfs = (*lst)->bsfs;
505  ctx->nb_bsfs = (*lst)->nb_bsfs;
506 
507 end:
508  av_freep(lst);
509  return ret;
510 }
511 
512 static int bsf_parse_single(char *str, AVBSFList *bsf_lst)
513 {
514  char *bsf_name, *bsf_options_str;
515 
516  bsf_name = av_strtok(str, "=", &bsf_options_str);
517  if (!bsf_name)
518  return AVERROR(EINVAL);
519 
520  return bsf_list_append_internal(bsf_lst, bsf_name, bsf_options_str, NULL);
521 }
522 
523 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
524 {
525  AVBSFList *lst;
526  char *bsf_str, *buf, *dup, *saveptr;
527  int ret;
528 
529  if (!str)
530  return av_bsf_get_null_filter(bsf_lst);
531 
532  lst = av_bsf_list_alloc();
533  if (!lst)
534  return AVERROR(ENOMEM);
535 
536  if (!(dup = buf = av_strdup(str))) {
537  ret = AVERROR(ENOMEM);
538  goto end;
539  }
540 
541  while (bsf_str = av_strtok(buf, ",", &saveptr)) {
542  ret = bsf_parse_single(bsf_str, lst);
543  if (ret < 0)
544  goto end;
545 
546  buf = NULL;
547  }
548 
549  ret = av_bsf_list_finalize(&lst, bsf_lst);
550 end:
551  if (ret < 0)
552  av_bsf_list_free(&lst);
553  av_free(dup);
554  return ret;
555 }
556 
558 {
559  return av_bsf_alloc(&ff_list_bsf, bsf);
560 }
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)
Append bitstream filter to the list of bitstream filters.
Definition: bsf.c:435
#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:512
AVBSFContext ** bsfs
Definition: bsf.c:271
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:65
int av_bsf_get_null_filter(AVBSFContext **bsf)
Get null/pass-through bitstream filter.
Definition: bsf.c:557
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:274
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
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:412
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
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 const char * bsf_to_name(void *bsf)
Definition: bsf.c:73
AVPacket * pkt
Definition: movenc.c:59
static const AVClass bsf_class
Definition: bsf.c:78
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:189
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:1559
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:396
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
AVOptions.
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:690
#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:351
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:95
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#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:309
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:360
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:481
#define fail()
Definition: checkasm.h:133
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:148
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:523
#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:696
char * item_name
Definition: bsf.c:276
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:90
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
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
int nb_bsfs
Definition: bsf.c:272
int(* filter)(AVBSFContext *ctx, AVPacket *pkt)
Definition: bsf.h:129
AVBSFContext ** bsfs
Definition: bsf.c:413
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:201
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:634
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:227
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:417
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:414
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:51
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
const AVBitStreamFilter ff_list_bsf
Definition: bsf.c:402
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
Finalize list of bitstream filters.
Definition: bsf.c:486
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
const OptionDef options[]
Definition: ffmpeg_opt.c:3427
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:72
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:232
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:454
static const char * bsf_list_item_name(void *ctx)
Definition: bsf.c:371
#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:440
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
static int bsf_list_init(AVBSFContext *bsf)
Definition: bsf.c:280
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
This structure stores compressed data.
Definition: packet.h:346
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:253
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:422