FFmpeg  4.4.5
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 #if FF_API_CHILD_CLASS_NEXT
84  .child_class_next = ff_bsf_child_class_next,
85 #endif
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 
108  ctx->par_in = avcodec_parameters_alloc();
109  ctx->par_out = avcodec_parameters_alloc();
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) {
158  const AVCodecDescriptor *desc = avcodec_descriptor_get(ctx->par_in->codec_id);
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  desc = avcodec_descriptor_get(ctx->filter->codec_ids[i]);
164  av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
165  desc ? desc->name : "unknown", ctx->filter->codec_ids[i]);
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 
220  if (ret < 0)
221  return ret;
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 
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) {
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 }
static void flush(AVCodecContext *avctx)
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
const AVClass * ff_bsf_child_class_iterate(void **opaque)
const AVClass * ff_bsf_child_class_next(const AVClass *prev)
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
static const AVClass bsf_class
Definition: bsf.c:78
static void bsf_list_close(AVBSFContext *bsf)
Definition: bsf.c:360
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
static int bsf_list_init(AVBSFContext *bsf)
Definition: bsf.c:280
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:253
static const char * bsf_to_name(void *bsf)
Definition: bsf.c:73
static int bsf_list_append_internal(AVBSFList *lst, const char *bsf_name, const char *options, AVDictionary **options_dict)
Definition: bsf.c:440
const AVBitStreamFilter ff_list_bsf
Definition: bsf.c:402
static void * bsf_child_next(void *obj, void *prev)
Definition: bsf.c:65
static const AVClass bsf_list_class
Definition: bsf.c:396
static void bsf_list_flush(AVBSFContext *bsf)
Definition: bsf.c:351
#define IS_EMPTY(pkt)
Definition: bsf.c:33
static int bsf_parse_single(char *str, AVBSFList *bsf_lst)
Definition: bsf.c:512
static int bsf_list_filter(AVBSFContext *bsf, AVPacket *out)
Definition: bsf.c:309
static const char * bsf_list_item_name(void *ctx)
Definition: bsf.c:371
static av_always_inline void filter(int16_t *output, ptrdiff_t out_stride, const int16_t *low, ptrdiff_t low_stride, const int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhddsp.c:27
#define fail()
Definition: checkasm.h:133
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:51
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:72
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
#define NULL
Definition: coverity.c:32
const OptionDef options[]
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
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
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 AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
AVBSFList * av_bsf_list_alloc(void)
Allocate empty list of bitstream filters.
Definition: bsf.c:417
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
void av_bsf_list_free(AVBSFList **lst)
Free list of bitstream filters.
Definition: bsf.c:422
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_append(AVBSFList *lst, AVBSFContext *bsf)
Append bitstream filter to the list of bitstream filters.
Definition: bsf.c:435
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:189
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:95
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:227
const AVClass * av_bsf_get_class(void)
Get the AVClass for AVBSFContext.
Definition: bsf.c:90
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
Finalize list of bitstream filters.
Definition: bsf.c:486
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:201
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
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
int av_bsf_get_null_filter(AVBSFContext **bsf)
Get null/pass-through bitstream filter.
Definition: bsf.c:557
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
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:481
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:696
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:690
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:49
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:296
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
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
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
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int i
Definition: input.c:407
const char * desc
Definition: libsvtav1.c:79
@ AV_CLASS_CATEGORY_BITSTREAM_FILTER
Definition: log.h:38
Memory handling functions.
AVOptions.
#define tb
Definition: regdef.h:68
The bitstream filter state.
Definition: bsf.h:49
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:95
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:70
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:83
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:89
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: bsf.h:58
AVPacket * buffer_pkt
Definition: bsf.c:36
int eof
Definition: bsf.c:37
Structure for chain/list of bitstream filters.
Definition: bsf.c:412
int nb_bsfs
Definition: bsf.c:414
AVBSFContext ** bsfs
Definition: bsf.c:413
const char * name
Definition: bsf.h:99
Describe the class of an AVClass context structure.
Definition: log.h:67
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:133
const struct AVClass *(* child_class_iterate)(void **iter)
Iterate over the AVClasses corresponding to potential AVOptions-enabled children.
Definition: log.h:160
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
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1237
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1699
void * priv_data
Format private data.
Definition: avformat.h:1260
AVOption.
Definition: opt.h:248
const char * name
Definition: opt.h:249
This structure stores compressed data.
Definition: packet.h:346
Rational number (pair of numerator and denominator).
Definition: rational.h:58
char * item_name
Definition: bsf.c:276
int nb_bsfs
Definition: bsf.c:272
AVBSFContext ** bsfs
Definition: bsf.c:271
unsigned idx
Definition: bsf.c:274
#define av_free(p)
#define av_freep(p)
#define av_log(a,...)
FILE * out
Definition: movenc.c:54
AVPacket * pkt
Definition: movenc.c:59
AVFormatContext * ctx
Definition: movenc.c:48