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  int ret;
86 
87  ctx = av_mallocz(sizeof(*ctx));
88  if (!ctx)
89  return AVERROR(ENOMEM);
90 
91  ctx->av_class = &bsf_class;
92  ctx->filter = filter;
93 
96  if (!ctx->par_in || !ctx->par_out) {
97  ret = AVERROR(ENOMEM);
98  goto fail;
99  }
100 
101  ctx->internal = av_mallocz(sizeof(*ctx->internal));
102  if (!ctx->internal) {
103  ret = AVERROR(ENOMEM);
104  goto fail;
105  }
106 
108  if (!ctx->internal->buffer_pkt) {
109  ret = AVERROR(ENOMEM);
110  goto fail;
111  }
112 
113  av_opt_set_defaults(ctx);
114 
115  /* allocate priv data and init private options */
116  if (filter->priv_data_size) {
117  ctx->priv_data = av_mallocz(filter->priv_data_size);
118  if (!ctx->priv_data) {
119  ret = AVERROR(ENOMEM);
120  goto fail;
121  }
122  if (filter->priv_class) {
123  *(const AVClass **)ctx->priv_data = filter->priv_class;
125  }
126  }
127 
128  *pctx = ctx;
129  return 0;
130 fail:
131  av_bsf_free(&ctx);
132  return ret;
133 }
134 
136 {
137  int ret, i;
138 
139  /* check that the codec is supported */
140  if (ctx->filter->codec_ids) {
141  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++)
142  if (ctx->par_in->codec_id == ctx->filter->codec_ids[i])
143  break;
144  if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) {
146  av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the "
147  "bitstream filter '%s'. Supported codecs are: ",
148  desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name);
149  for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) {
150  desc = avcodec_descriptor_get(ctx->filter->codec_ids[i]);
151  av_log(ctx, AV_LOG_ERROR, "%s (%d) ",
152  desc ? desc->name : "unknown", ctx->filter->codec_ids[i]);
153  }
154  av_log(ctx, AV_LOG_ERROR, "\n");
155  return AVERROR(EINVAL);
156  }
157  }
158 
159  /* initialize output parameters to be the same as input
160  * init below might overwrite that */
161  ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in);
162  if (ret < 0)
163  return ret;
164 
165  ctx->time_base_out = ctx->time_base_in;
166 
167  if (ctx->filter->init) {
168  ret = ctx->filter->init(ctx);
169  if (ret < 0)
170  return ret;
171  }
172 
173  return 0;
174 }
175 
177 {
178  ctx->internal->eof = 0;
179 
181 
182  if (ctx->filter->flush)
183  ctx->filter->flush(ctx);
184 }
185 
187 {
188  int ret;
189 
190  if (!pkt || (!pkt->data && !pkt->side_data_elems)) {
191  ctx->internal->eof = 1;
192  return 0;
193  }
194 
195  if (ctx->internal->eof) {
196  av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
197  return AVERROR(EINVAL);
198  }
199 
200  if (ctx->internal->buffer_pkt->data ||
202  return AVERROR(EAGAIN);
203 
204  ret = av_packet_make_refcounted(pkt);
205  if (ret < 0)
206  return ret;
208 
209  return 0;
210 }
211 
213 {
214  return ctx->filter->filter(ctx, pkt);
215 }
216 
218 {
219  AVBSFInternal *in = ctx->internal;
220  AVPacket *tmp_pkt;
221 
222  if (in->eof)
223  return AVERROR_EOF;
224 
225  if (!ctx->internal->buffer_pkt->data &&
227  return AVERROR(EAGAIN);
228 
229  tmp_pkt = av_packet_alloc();
230  if (!tmp_pkt)
231  return AVERROR(ENOMEM);
232 
233  *pkt = ctx->internal->buffer_pkt;
234  ctx->internal->buffer_pkt = tmp_pkt;
235 
236  return 0;
237 }
238 
240 {
241  AVBSFInternal *in = ctx->internal;
242 
243  if (in->eof)
244  return AVERROR_EOF;
245 
246  if (!ctx->internal->buffer_pkt->data &&
248  return AVERROR(EAGAIN);
249 
251 
252  return 0;
253 }
254 
255 typedef struct BSFListContext {
256  const AVClass *class;
257 
259  int nb_bsfs;
260 
261  unsigned idx; // index of currently processed BSF
262  unsigned flushed_idx; // index of BSF being flushed
263 
264  char * item_name;
266 
267 
268 static int bsf_list_init(AVBSFContext *bsf)
269 {
270  BSFListContext *lst = bsf->priv_data;
271  int ret, i;
272  const AVCodecParameters *cod_par = bsf->par_in;
273  AVRational tb = bsf->time_base_in;
274 
275  for (i = 0; i < lst->nb_bsfs; ++i) {
276  ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par);
277  if (ret < 0)
278  goto fail;
279 
280  lst->bsfs[i]->time_base_in = tb;
281 
282  ret = av_bsf_init(lst->bsfs[i]);
283  if (ret < 0)
284  goto fail;
285 
286  cod_par = lst->bsfs[i]->par_out;
287  tb = lst->bsfs[i]->time_base_out;
288  }
289 
290  bsf->time_base_out = tb;
291  ret = avcodec_parameters_copy(bsf->par_out, cod_par);
292 
293 fail:
294  return ret;
295 }
296 
298 {
299  BSFListContext *lst = bsf->priv_data;
300  int ret;
301 
302  if (!lst->nb_bsfs)
303  return ff_bsf_get_packet_ref(bsf, out);
304 
305  while (1) {
306  if (lst->idx > lst->flushed_idx) {
307  ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out);
308  if (ret == AVERROR(EAGAIN)) {
309  /* no more packets from idx-1, try with previous */
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:258
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
Definition: avcodec.h:5842
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5808
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:261
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:1328
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5783
The bitstream filter state.
Definition: avcodec.h:5774
int(* init)(AVBSFContext *ctx)
Definition: avcodec.h:5853
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:69
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:5795
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3960
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:135
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: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:398
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:212
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:2019
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:5824
uint8_t * data
Definition: avcodec.h:1480
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:2040
#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:297
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:5831
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:5814
void(* close)(AVBSFContext *ctx)
Definition: avcodec.h:5855
unsigned flushed_idx
Definition: bsf.c:262
int side_data_elems
Definition: avcodec.h:1492
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:2029
#define fail()
Definition: checkasm.h:122
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3277
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: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:442
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: avcodec.h:5820
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:186
char * item_name
Definition: bsf.c:264
AVFormatContext * ctx
Definition: movenc.c:48
const AVClass * av_class
A class for logging and AVOptions.
Definition: avcodec.h:5778
#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:1601
int nb_bsfs
Definition: bsf.c:259
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:5854
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:727
int nb_bsfs
Definition: bsf.c:416
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:719
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:5856
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:1581
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:217
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:268
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state / flush internal buffers.
Definition: bsf.c:176
FILE * out
Definition: movenc.c:54
#define av_freep(p)
AVBSFInternal * internal
Opaque libavcodec internal data.
Definition: avcodec.h:5789
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:1457
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5802
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:239
#define tb
Definition: regdef.h:68
int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
Finalize list of bitstream filters.
Definition: bsf.c:471