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  if (ctx->internal)
50  av_freep(&ctx->internal);
51  av_freep(&ctx->priv_data);
52 
55 
56  av_freep(pctx);
57 }
58 
59 static void *bsf_child_next(void *obj, void *prev)
60 {
61  AVBSFContext *ctx = obj;
62  if (!prev && ctx->filter->priv_class)
63  return ctx->priv_data;
64  return NULL;
65 }
66 
67 static const char *bsf_to_name(void *bsf)
68 {
69  return ((AVBSFContext *)bsf)->filter->name;
70 }
71 
72 static const AVClass bsf_class = {
73  .class_name = "AVBSFContext",
74  .item_name = bsf_to_name,
75  .version = LIBAVUTIL_VERSION_INT,
76  .child_next = bsf_child_next,
77  .child_class_next = ff_bsf_child_class_next,
79 };
80 
82 {
83  return &bsf_class;
84 }
85 
87 {
89  AVBSFInternal *bsfi;
90  int ret;
91 
92  ctx = av_mallocz(sizeof(*ctx));
93  if (!ctx)
94  return AVERROR(ENOMEM);
95 
96  ctx->av_class = &bsf_class;
97  ctx->filter = filter;
98 
101  if (!ctx->par_in || !ctx->par_out) {
102  ret = AVERROR(ENOMEM);
103  goto fail;
104  }
105 
106  bsfi = av_mallocz(sizeof(*bsfi));
107  if (!bsfi) {
108  ret = AVERROR(ENOMEM);
109  goto fail;
110  }
111  ctx->internal = bsfi;
112 
113  bsfi->buffer_pkt = av_packet_alloc();
114  if (!bsfi->buffer_pkt) {
115  ret = AVERROR(ENOMEM);
116  goto fail;
117  }
118 
119  /* allocate priv data and init private options */
120  if (filter->priv_data_size) {
121  ctx->priv_data = av_mallocz(filter->priv_data_size);
122  if (!ctx->priv_data) {
123  ret = AVERROR(ENOMEM);
124  goto fail;
125  }
126  if (filter->priv_class) {
127  *(const AVClass **)ctx->priv_data = filter->priv_class;
129  }
130  }
131 
132  *pctx = ctx;
133  return 0;
134 fail:
135  av_bsf_free(&ctx);
136  return ret;
137 }
138 
140 {
141  int ret, i;
142 
143  /* check that the codec is supported */
144  if (ctx->filter->codec_ids) {
145  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)
146  if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])
147  break;
148  if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {
150  av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "
151  "bitstream filter '%s'. Supported codecs are: ",
152  desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);
153  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {
154  desc = avcodec_descriptor_get(ctx->filter->codec_ids[i]);
155  av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
156  desc ? desc->name : "unknown", ctx->filter->codec_ids[i]);
157  }
158  av_log(ctx, AV_LOG_ERROR, "\n");
159  return AVERROR(EINVAL);
160  }
161  }
162 
163  /* initialize output parameters to be the same as input
164  * init below might overwrite that */
165  ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);
166  if (ret < 0)
167  return ret;
168 
169  ctx->time_base_out = ctx->time_base_in;
170 
171  if (ctx->filter->init) {
172  ret = ctx->filter->init(ctx);
173  if (ret < 0)
174  return ret;
175  }
176 
177  return 0;
178 }
179 
181 {
182  AVBSFInternal *bsfi = ctx->internal;
183 
184  bsfi->eof = 0;
185 
187 
188  if (ctx->filter->flush)
189  ctx->filter->flush(ctx);
190 }
191 
193 {
194  AVBSFInternal *bsfi = ctx->internal;
195  int ret;
196 
197  if (!pkt || (!pkt->data && !pkt->side_data_elems)) {
198  bsfi->eof = 1;
199  return 0;
200  }
201 
202  if (bsfi->eof) {
203  av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
204  return AVERROR(EINVAL);
205  }
206 
207  if (bsfi->buffer_pkt->data ||
209  return AVERROR(EAGAIN);
210 
211  ret = av_packet_make_refcounted(pkt);
212  if (ret < 0)
213  return ret;
214  av_packet_move_ref(bsfi->buffer_pkt, pkt);
215 
216  return 0;
217 }
218 
220 {
221  return ctx->filter->filter(ctx, pkt);
222 }
223 
225 {
226  AVBSFInternal *bsfi = ctx->internal;
227  AVPacket *tmp_pkt;
228 
229  if (bsfi->eof)
230  return AVERROR_EOF;
231 
232  if (!bsfi->buffer_pkt->data &&
233  !bsfi->buffer_pkt->side_data_elems)
234  return AVERROR(EAGAIN);
235 
236  tmp_pkt = av_packet_alloc();
237  if (!tmp_pkt)
238  return AVERROR(ENOMEM);
239 
240  *pkt = bsfi->buffer_pkt;
241  bsfi->buffer_pkt = tmp_pkt;
242 
243  return 0;
244 }
245 
247 {
248  AVBSFInternal *bsfi = ctx->internal;
249 
250  if (bsfi->eof)
251  return AVERROR_EOF;
252 
253  if (!bsfi->buffer_pkt->data &&
254  !bsfi->buffer_pkt->side_data_elems)
255  return AVERROR(EAGAIN);
256 
257  av_packet_move_ref(pkt, bsfi->buffer_pkt);
258 
259  return 0;
260 }
261 
262 typedef struct BSFListContext {
263  const AVClass *class;
264 
266  int nb_bsfs;
267 
268  unsigned idx; // index of currently processed BSF
269  unsigned flushed_idx; // index of BSF being flushed
270 
271  char * item_name;
273 
274 
275 static int bsf_list_init(AVBSFContext *bsf)
276 {
277  BSFListContext *lst = bsf->priv_data;
278  int ret, i;
279  const AVCodecParameters *cod_par = bsf->par_in;
280  AVRational tb = bsf->time_base_in;
281 
282  for (i = 0; i < lst->nb_bsfs; ++i) {
283  ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);
284  if (ret < 0)
285  goto fail;
286 
287  lst->bsfs[i]->time_base_in = tb;
288 
289  ret = av_bsf_init(lst->bsfs[i]);
290  if (ret < 0)
291  goto fail;
292 
293  cod_par = lst->bsfs[i]->par_out;
294  tb = lst->bsfs[i]->time_base_out;
295  }
296 
297  bsf->time_base_out = tb;
298  ret = avcodec_parameters_copy(bsf->par_out, cod_par);
299 
300 fail:
301  return ret;
302 }
303 
305 {
306  BSFListContext *lst = bsf->priv_data;
307  int ret;
308 
309  if (!lst->nb_bsfs)
310  return ff_bsf_get_packet_ref(bsf, out);
311 
312  while (1) {
313  if (lst->idx > lst->flushed_idx) {
314  ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);
315  if (ret == AVERROR(EAGAIN)) {
316  /* no more packets from idx-1, try with previous */
317  lst->idx--;
318  continue;
319  } else if (ret == AVERROR_EOF) {
320  /* filter idx-1 is done, continue with idx...nb_bsfs */
321  lst->flushed_idx = lst->idx;
322  continue;
323  }else if (ret < 0) {
324  /* filtering error */
325  break;
326  }
327  } else {
328  ret = ff_bsf_get_packet_ref(bsf, out);
329  if (ret == AVERROR_EOF) {
330  lst->idx = lst->flushed_idx;
331  } else if (ret < 0)
332  break;
333  }
334 
335  if (lst->idx < lst->nb_bsfs) {
336  AVPacket *pkt;
337  if (ret == AVERROR_EOF && lst->idx == lst->flushed_idx) {
338  /* ff_bsf_get_packet_ref returned EOF and idx is first
339  * filter of yet not flushed filter chain */
340  pkt = NULL;
341  } else {
342  pkt = out;
343  }
344  ret = av_bsf_send_packet(lst->bsfs[lst->idx], pkt);
345  if (ret < 0)
346  break;
347  lst->idx++;
348  } else {
349  /* The end of filter chain, break to return result */
350  break;
351  }
352  }
353 
354  if (ret < 0)
355  av_packet_unref(out);
356 
357  return ret;
358 }
359 
360 static void bsf_list_flush(AVBSFContext *bsf)
361 {
362  BSFListContext *lst = bsf->priv_data;
363 
364  for (int i = 0; i < lst->nb_bsfs; i++)
365  av_bsf_flush(lst->bsfs[i]);
366  lst->idx = lst->flushed_idx = 0;
367 }
368 
369 static void bsf_list_close(AVBSFContext *bsf)
370 {
371  BSFListContext *lst = bsf->priv_data;
372  int i;
373 
374  for (i = 0; i < lst->nb_bsfs; ++i)
375  av_bsf_free(&lst->bsfs[i]);
376  av_freep(&lst->bsfs);
377  av_freep(&lst->item_name);
378 }
379 
380 static const char *bsf_list_item_name(void *ctx)
381 {
382  static const char *null_filter_name = "null";
383  AVBSFContext *bsf_ctx = ctx;
384  BSFListContext *lst = bsf_ctx->priv_data;
385 
386  if (!lst->nb_bsfs)
387  return null_filter_name;
388 
389  if (!lst->item_name) {
390  int i;
391  AVBPrint bp;
392  av_bprint_init(&bp, 16, 128);
393 
394  av_bprintf(&bp, "bsf_list(");
395  for (i = 0; i < lst->nb_bsfs; i++)
396  av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name);
397  av_bprintf(&bp, ")");
398 
399  av_bprint_finalize(&bp, &lst->item_name);
400  }
401 
402  return lst->item_name;
403 }
404 
405 static const AVClass bsf_list_class = {
406  .class_name = "bsf_list",
407  .item_name = bsf_list_item_name,
408  .version = LIBAVUTIL_VERSION_INT,
409 };
410 
412  .name = "bsf_list",
413  .priv_data_size = sizeof(BSFListContext),
414  .priv_class = &bsf_list_class,
415  .init = bsf_list_init,
418  .close = bsf_list_close,
419 };
420 
421 struct AVBSFList {
423  int nb_bsfs;
424 };
425 
427 {
428  return av_mallocz(sizeof(AVBSFList));
429 }
430 
432 {
433  int i;
434 
435  if (!*lst)
436  return;
437 
438  for (i = 0; i < (*lst)->nb_bsfs; ++i)
439  av_bsf_free(&(*lst)->bsfs[i]);
440  av_free((*lst)->bsfs);
441  av_freep(lst);
442 }
443 
445 {
446  return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf);
447 }
448 
449 int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)
450 {
451  int ret;
452  const AVBitStreamFilter *filter;
453  AVBSFContext *bsf;
454 
455  filter = av_bsf_get_by_name(bsf_name);
456  if (!filter)
457  return AVERROR_BSF_NOT_FOUND;
458 
459  ret = av_bsf_alloc(filter, &bsf);
460  if (ret < 0)
461  return ret;
462 
463  if (options) {
464  ret = av_opt_set_dict2(bsf, options, AV_OPT_SEARCH_CHILDREN);
465  if (ret < 0)
466  goto end;
467  }
468 
469  ret = av_bsf_list_append(lst, bsf);
470 
471 end:
472  if (ret < 0)
473  av_bsf_free(&bsf);
474 
475  return ret;
476 }
477 
479 {
480  int ret = 0;
482 
483  if ((*lst)->nb_bsfs == 1) {
484  *bsf = (*lst)->bsfs[0];
485  av_freep(&(*lst)->bsfs);
486  (*lst)->nb_bsfs = 0;
487  goto end;
488  }
489 
490  ret = av_bsf_alloc(&ff_list_bsf, bsf);
491  if (ret < 0)
492  return ret;
493 
494  ctx = (*bsf)->priv_data;
495 
496  ctx->bsfs = (*lst)->bsfs;
497  ctx->nb_bsfs = (*lst)->nb_bsfs;
498 
499 end:
500  av_freep(lst);
501  return ret;
502 }
503 
504 static int bsf_parse_single(const char *str, AVBSFList *bsf_lst)
505 {
506  char *bsf_name, *bsf_options_str, *buf;
507  AVDictionary *bsf_options = NULL;
508  int ret = 0;
509 
510  if (!(buf = av_strdup(str)))
511  return AVERROR(ENOMEM);
512 
513  bsf_name = av_strtok(buf, "=", &bsf_options_str);
514  if (!bsf_name) {
515  ret = AVERROR(EINVAL);
516  goto end;
517  }
518 
519  if (bsf_options_str) {
520  ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
521  if (ret < 0)
522  goto end;
523  }
524 
525  ret = av_bsf_list_append2(bsf_lst, bsf_name, &bsf_options);
526 
527 end:
528  av_dict_free(&bsf_options);
529  av_free(buf);
530  return ret;
531 }
532 
533 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
534 {
535  AVBSFList *lst;
536  char *bsf_str, *buf, *dup, *saveptr;
537  int ret;
538 
539  if (!str)
540  return av_bsf_get_null_filter(bsf_lst);
541 
542  lst = av_bsf_list_alloc();
543  if (!lst)
544  return AVERROR(ENOMEM);
545 
546  if (!(dup = buf = av_strdup(str))) {
547  ret = AVERROR(ENOMEM);
548  goto end;
549  }
550 
551  while (1) {
552  bsf_str = av_strtok(buf, ",", &saveptr);
553  if (!bsf_str)
554  break;
555 
556  ret = bsf_parse_single(bsf_str, lst);
557  if (ret < 0)
558  goto end;
559 
560  buf = NULL;
561  }
562 
563  ret = av_bsf_list_finalize(&lst, bsf_lst);
564 end:
565  if (ret < 0)
566  av_bsf_list_free(&lst);
567  av_free(dup);
568  return ret;
569 }
570 
572 {
573  return av_bsf_alloc(&ff_list_bsf, bsf);
574 }
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:265
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5911
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5877
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
static void * bsf_child_next(void *obj, void *prev)
Definition: bsf.c:59
static void flush(AVCodecContext *avctx)
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Memory handling functions.
unsigned idx
Definition: bsf.c:268
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:4036
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5852
The bitstream filter state.
Definition: avcodec.h:5843
int(* init)(AVBSFContext *ctx)
Definition: avcodec.h:5922
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Structure for chain/list of bitstream filters.
Definition: bsf.c:421
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 char * bsf_to_name(void *bsf)
Definition: bsf.c:67
static const AVClass bsf_class
Definition: bsf.c:72
int av_bsf_get_null_filter(AVBSFContext **bsf)
Get null/pass-through bitstream filter.
Definition: bsf.c:571
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5864
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4028
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:139
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:431
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:86
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:405
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:219
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:2030
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:504
const char * name
Definition: avcodec.h:5893
uint8_t * data
Definition: avcodec.h:1533
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:658
#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:360
#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:2051
#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:304
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:5900
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:5883
void(* close)(AVBSFContext *ctx)
Definition: avcodec.h:5924
unsigned flushed_idx
Definition: bsf.c:269
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:130
int side_data_elems
Definition: avcodec.h:1545
static void bsf_list_close(AVBSFContext *bsf)
Definition: bsf.c:369
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:2040
#define fail()
Definition: checkasm.h:122
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3364
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)
Append bitstream filter to the list of bitstream filters.
Definition: bsf.c:444
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:81
#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:449
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: avcodec.h:5889
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:666
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:192
char * item_name
Definition: bsf.c:271
AVFormatContext * ctx
Definition: movenc.c:48
const AVClass * av_class
A class for logging and AVOptions.
Definition: avcodec.h:5847
#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:266
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:5923
AVBSFList * av_bsf_list_alloc(void)
Allocate empty list of bitstream filters.
Definition: bsf.c:426
AVBSFContext ** bsfs
Definition: bsf.c:422
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:600
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:742
int nb_bsfs
Definition: bsf.c:423
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:734
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:5925
const AVBitStreamFilter ff_list_bsf
Definition: bsf.c:411
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:533
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1612
const OptionDef options[]
Definition: ffmpeg_opt.c:3439
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:224
static const char * bsf_list_item_name(void *ctx)
Definition: bsf.c:380
#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:275
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state / flush internal buffers.
Definition: bsf.c:180
FILE * out
Definition: movenc.c:54
#define av_freep(p)
AVBSFInternal * internal
Opaque libavcodec internal data.
Definition: avcodec.h:5858
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:1510
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5871
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:246
#define tb
Definition: regdef.h:68
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
Finalize list of bitstream filters.
Definition: bsf.c:478