FFmpeg: libavcodec/bsf.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /