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