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 
51  av_freep(&ctx->internal);
52  av_freep(&ctx->priv_data);
53 
56 
57  av_freep(pctx);
58 }
59 
60 static void *bsf_child_next(void *obj, void *prev)
61 {
62  AVBSFContext *ctx = obj;
63  if (!prev && ctx->filter->priv_class)
64  return ctx->priv_data;
65  return NULL;
66 }
67 
68 static const AVClass bsf_class = {
69  .class_name = "AVBSFContext",
70  .item_name = av_default_item_name,
71  .version = LIBAVUTIL_VERSION_INT,
72  .child_next = bsf_child_next,
73  .child_class_next = ff_bsf_child_class_next,
74 };
75 
77 {
78  return &bsf_class;
79 }
80 
82 {
84  int ret;
85 
86  ctx = av_mallocz(sizeof(*ctx));
87  if (!ctx)
88  return AVERROR(ENOMEM);
89 
90  ctx->av_class = &bsf_class;
91  ctx->filter = filter;
92 
95  if (!ctx->par_in || !ctx->par_out) {
96  ret = AVERROR(ENOMEM);
97  goto fail;
98  }
99 
100  ctx->internal = av_mallocz(sizeof(*ctx->internal));
101  if (!ctx->internal) {
102  ret = AVERROR(ENOMEM);
103  goto fail;
104  }
105 
107  if (!ctx->internal->buffer_pkt) {
108  ret = AVERROR(ENOMEM);
109  goto fail;
110  }
111 
112  av_opt_set_defaults(ctx);
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 
127  *pctx = ctx;
128  return 0;
129 fail:
130  av_bsf_free(&ctx);
131  return ret;
132 }
133 
135 {
136  int ret, i;
137 
138  /* check that the codec is supported */
139  if (ctx->filter->codec_ids) {
140  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)
141  if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])
142  break;
143  if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {
145  av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "
146  "bitstream filter '%s'. Supported codecs are: ",
147  desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);
148  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {
149  desc = avcodec_descriptor_get(ctx->filter->codec_ids[i]);
150  av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
151  desc ? desc->name : "unknown", ctx->filter->codec_ids[i]);
152  }
153  av_log(ctx, AV_LOG_ERROR, "\n");
154  return AVERROR(EINVAL);
155  }
156  }
157 
158  /* initialize output parameters to be the same as input
159  * init below might overwrite that */
160  ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);
161  if (ret < 0)
162  return ret;
163 
164  ctx->time_base_out = ctx->time_base_in;
165 
166  if (ctx->filter->init) {
167  ret = ctx->filter->init(ctx);
168  if (ret < 0)
169  return ret;
170  }
171 
172  return 0;
173 }
174 
176 {
177  ctx->internal->eof = 0;
178 
180 
181  if (ctx->filter->flush)
182  ctx->filter->flush(ctx);
183 }
184 
186 {
187  int ret;
188 
189  if (!pkt || (!pkt->data && !pkt->side_data_elems)) {
190  ctx->internal->eof = 1;
191  return 0;
192  }
193 
194  if (ctx->internal->eof) {
195  av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
196  return AVERROR(EINVAL);
197  }
198 
199  if (ctx->internal->buffer_pkt->data ||
201  return AVERROR(EAGAIN);
202 
203  ret = av_packet_make_refcounted(pkt);
204  if (ret < 0)
205  return ret;
207 
208  return 0;
209 }
210 
212 {
213  return ctx->filter->filter(ctx, pkt);
214 }
215 
217 {
218  AVBSFInternal *in = ctx->internal;
219  AVPacket *tmp_pkt;
220 
221  if (in->eof)
222  return AVERROR_EOF;
223 
224  if (!ctx->internal->buffer_pkt->data &&
226  return AVERROR(EAGAIN);
227 
228  tmp_pkt = av_packet_alloc();
229  if (!tmp_pkt)
230  return AVERROR(ENOMEM);
231 
232  *pkt = ctx->internal->buffer_pkt;
233  ctx->internal->buffer_pkt = tmp_pkt;
234 
235  return 0;
236 }
237 
239 {
240  AVBSFInternal *in = ctx->internal;
241 
242  if (in->eof)
243  return AVERROR_EOF;
244 
245  if (!ctx->internal->buffer_pkt->data &&
247  return AVERROR(EAGAIN);
248 
250 
251  return 0;
252 }
253 
254 typedef struct BSFListContext {
255  const AVClass *class;
256 
258  int nb_bsfs;
259 
260  unsigned idx; // index of currently processed BSF
261  unsigned flushed_idx; // index of BSF being flushed
262 
263  char * item_name;
265 
266 
267 static int bsf_list_init(AVBSFContext *bsf)
268 {
269  BSFListContext *lst = bsf->priv_data;
270  int ret, i;
271  const AVCodecParameters *cod_par = bsf->par_in;
272  AVRational tb = bsf->time_base_in;
273 
274  for (i = 0; i < lst->nb_bsfs; ++i) {
275  ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);
276  if (ret < 0)
277  goto fail;
278 
279  lst->bsfs[i]->time_base_in = tb;
280 
281  ret = av_bsf_init(lst->bsfs[i]);
282  if (ret < 0)
283  goto fail;
284 
285  cod_par = lst->bsfs[i]->par_out;
286  tb = lst->bsfs[i]->time_base_out;
287  }
288 
289  bsf->time_base_out = tb;
290  ret = avcodec_parameters_copy(bsf->par_out, cod_par);
291 
292 fail:
293  return ret;
294 }
295 
297 {
298  BSFListContext *lst = bsf->priv_data;
299  int ret;
300 
301  if (!lst->nb_bsfs)
302  return ff_bsf_get_packet_ref(bsf, out);
303 
304  while (1) {
305  if (lst->idx > lst->flushed_idx) {
306  ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);
307  if (ret == AVERROR(EAGAIN)) {
308  /* no more packets from idx-1, try with previous */
309  ret = 0;
310  lst->idx--;
311  continue;
312  } else if (ret == AVERROR_EOF) {
313  /* filter idx-1 is done, continue with idx...nb_bsfs */
314  lst->flushed_idx = lst->idx;
315  continue;
316  }else if (ret < 0) {
317  /* filtering error */
318  break;
319  }
320  } else {
321  ret = ff_bsf_get_packet_ref(bsf, out);
322  if (ret == AVERROR_EOF) {
323  lst->idx = lst->flushed_idx;
324  } else if (ret < 0)
325  break;
326  }
327 
328  if (lst->idx < lst->nb_bsfs) {
329  AVPacket *pkt;
330  if (ret == AVERROR_EOF && lst->idx == lst->flushed_idx) {
331  /* ff_bsf_get_packet_ref returned EOF and idx is first
332  * filter of yet not flushed filter chain */
333  pkt = NULL;
334  } else {
335  pkt = out;
336  }
337  ret = av_bsf_send_packet(lst->bsfs[lst->idx], pkt);
338  if (ret < 0)
339  break;
340  lst->idx++;
341  } else {
342  /* The end of filter chain, break to return result */
343  break;
344  }
345  }
346 
347  if (ret < 0)
348  av_packet_unref(out);
349 
350  return ret;
351 }
352 
353 static void bsf_list_flush(AVBSFContext *bsf)
354 {
355  BSFListContext *lst = bsf->priv_data;
356 
357  for (int i = 0; i < lst->nb_bsfs; i++)
358  av_bsf_flush(lst->bsfs[i]);
359  lst->idx = lst->flushed_idx = 0;
360 }
361 
362 static void bsf_list_close(AVBSFContext *bsf)
363 {
364  BSFListContext *lst = bsf->priv_data;
365  int i;
366 
367  for (i = 0; i < lst->nb_bsfs; ++i)
368  av_bsf_free(&lst->bsfs[i]);
369  av_freep(&lst->bsfs);
370  av_freep(&lst->item_name);
371 }
372 
373 static const char *bsf_list_item_name(void *ctx)
374 {
375  static const char *null_filter_name = "null";
376  AVBSFContext *bsf_ctx = ctx;
377  BSFListContext *lst = bsf_ctx->priv_data;
378 
379  if (!lst->nb_bsfs)
380  return null_filter_name;
381 
382  if (!lst->item_name) {
383  int i;
384  AVBPrint bp;
385  av_bprint_init(&bp, 16, 128);
386 
387  av_bprintf(&bp, "bsf_list(");
388  for (i = 0; i < lst->nb_bsfs; i++)
389  av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name);
390  av_bprintf(&bp, ")");
391 
392  av_bprint_finalize(&bp, &lst->item_name);
393  }
394 
395  return lst->item_name;
396 }
397 
398 static const AVClass bsf_list_class = {
399  .class_name = "bsf_list",
400  .item_name = bsf_list_item_name,
401  .version = LIBAVUTIL_VERSION_INT,
402 };
403 
405  .name = "bsf_list",
406  .priv_data_size = sizeof(BSFListContext),
407  .priv_class = &bsf_list_class,
408  .init = bsf_list_init,
411  .close = bsf_list_close,
412 };
413 
414 struct AVBSFList {
416  int nb_bsfs;
417 };
418 
420 {
421  return av_mallocz(sizeof(AVBSFList));
422 }
423 
425 {
426  int i;
427 
428  if (!*lst)
429  return;
430 
431  for (i = 0; i < (*lst)->nb_bsfs; ++i)
432  av_bsf_free(&(*lst)->bsfs[i]);
433  av_free((*lst)->bsfs);
434  av_freep(lst);
435 }
436 
438 {
439  return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf);
440 }
441 
442 int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options)
443 {
444  int ret;
445  const AVBitStreamFilter *filter;
446  AVBSFContext *bsf;
447 
448  filter = av_bsf_get_by_name(bsf_name);
449  if (!filter)
450  return AVERROR_BSF_NOT_FOUND;
451 
452  ret = av_bsf_alloc(filter, &bsf);
453  if (ret < 0)
454  return ret;
455 
456  if (options) {
457  ret = av_opt_set_dict2(bsf, options, AV_OPT_SEARCH_CHILDREN);
458  if (ret < 0)
459  goto end;
460  }
461 
462  ret = av_bsf_list_append(lst, bsf);
463 
464 end:
465  if (ret < 0)
466  av_bsf_free(&bsf);
467 
468  return ret;
469 }
470 
472 {
473  int ret = 0;
475 
476  if ((*lst)->nb_bsfs == 1) {
477  *bsf = (*lst)->bsfs[0];
478  av_freep(&(*lst)->bsfs);
479  (*lst)->nb_bsfs = 0;
480  goto end;
481  }
482 
483  ret = av_bsf_alloc(&ff_list_bsf, bsf);
484  if (ret < 0)
485  return ret;
486 
487  ctx = (*bsf)->priv_data;
488 
489  ctx->bsfs = (*lst)->bsfs;
490  ctx->nb_bsfs = (*lst)->nb_bsfs;
491 
492 end:
493  av_freep(lst);
494  return ret;
495 }
496 
497 static int bsf_parse_single(const char *str, AVBSFList *bsf_lst)
498 {
499  char *bsf_name, *bsf_options_str, *buf;
500  AVDictionary *bsf_options = NULL;
501  int ret = 0;
502 
503  if (!(buf = av_strdup(str)))
504  return AVERROR(ENOMEM);
505 
506  bsf_name = av_strtok(buf, "=", &bsf_options_str);
507  if (!bsf_name) {
508  ret = AVERROR(EINVAL);
509  goto end;
510  }
511 
512  if (bsf_options_str) {
513  ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
514  if (ret < 0)
515  goto end;
516  }
517 
518  ret = av_bsf_list_append2(bsf_lst, bsf_name, &bsf_options);
519 
520  av_dict_free(&bsf_options);
521 end:
522  av_free(buf);
523  return ret;
524 }
525 
526 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
527 {
528  AVBSFList *lst;
529  char *bsf_str, *buf, *dup, *saveptr;
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  if (!(dup = buf = av_strdup(str))) {
540  ret = AVERROR(ENOMEM);
541  goto end;
542  }
543 
544  while (1) {
545  bsf_str = av_strtok(buf, ",", &saveptr);
546  if (!bsf_str)
547  break;
548 
549  ret = bsf_parse_single(bsf_str, lst);
550  if (ret < 0)
551  goto end;
552 
553  buf = NULL;
554  }
555 
556  ret = av_bsf_list_finalize(&lst, bsf_lst);
557 end:
558  if (ret < 0)
559  av_bsf_list_free(&lst);
560  av_free(dup);
561  return ret;
562 }
563 
565 {
566  return av_bsf_alloc(&ff_list_bsf, bsf);
567 }
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:257
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5831
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5797
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
static void * bsf_child_next(void *obj, void *prev)
Definition: bsf.c:60
static void flush(AVCodecContext *avctx)
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Memory handling functions.
unsigned idx
Definition: bsf.c:260
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:1305
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5772
The bitstream filter state.
Definition: avcodec.h:5763
int(* init)(AVBSFContext *ctx)
Definition: avcodec.h:5842
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:414
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:68
int av_bsf_get_null_filter(AVBSFContext **bsf)
Get null/pass-through bitstream filter.
Definition: bsf.c:564
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5784
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:134
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:424
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:81
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:398
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:211
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:2000
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:497
const char * name
Definition: avcodec.h:5813
uint8_t * data
Definition: avcodec.h:1477
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:353
#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:2021
#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:296
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:5820
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:5803
void(* close)(AVBSFContext *ctx)
Definition: avcodec.h:5844
unsigned flushed_idx
Definition: bsf.c:261
int side_data_elems
Definition: avcodec.h:1489
static void bsf_list_close(AVBSFContext *bsf)
Definition: bsf.c:362
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:2010
#define fail()
Definition: checkasm.h:120
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf)
Append bitstream filter to the list of bitstream filters.
Definition: bsf.c:437
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:76
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:556
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:442
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: avcodec.h:5809
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:185
char * item_name
Definition: bsf.c:263
AVFormatContext * ctx
Definition: movenc.c:48
const AVClass * av_class
A class for logging and AVOptions.
Definition: avcodec.h:5767
#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:1578
int nb_bsfs
Definition: bsf.c:258
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:5843
AVBSFList * av_bsf_list_alloc(void)
Allocate empty list of bitstream filters.
Definition: bsf.c:419
AVBSFContext ** bsfs
Definition: bsf.c:415
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
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
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:724
int nb_bsfs
Definition: bsf.c:416
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:716
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:5845
const AVBitStreamFilter ff_list_bsf
Definition: bsf.c:404
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:526
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1558
const OptionDef options[]
Definition: ffmpeg_opt.c:3364
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:216
static const char * bsf_list_item_name(void *ctx)
Definition: bsf.c:373
#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:267
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state / flush internal buffers.
Definition: bsf.c:175
FILE * out
Definition: movenc.c:54
#define av_freep(p)
AVBSFInternal * internal
Opaque libavcodec internal data.
Definition: avcodec.h:5778
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:1454
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5791
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:238
#define tb
Definition: regdef.h:68
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
Finalize list of bitstream filters.
Definition: bsf.c:471