Libav
utils.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/common.h"
22 #include "libavutil/dict.h"
23 #include "libavutil/error.h"
24 #include "libavutil/log.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/opt.h"
27 
28 #include "avresample.h"
29 #include "internal.h"
30 #include "audio_data.h"
31 #include "audio_convert.h"
32 #include "audio_mix.h"
33 #include "resample.h"
34 
36 {
37  int ret;
38 
39  /* set channel mixing parameters */
41  if (avr->in_channels <= 0 || avr->in_channels > AVRESAMPLE_MAX_CHANNELS) {
42  av_log(avr, AV_LOG_ERROR, "Invalid input channel layout: %"PRIu64"\n",
43  avr->in_channel_layout);
44  return AVERROR(EINVAL);
45  }
47  if (avr->out_channels <= 0 || avr->out_channels > AVRESAMPLE_MAX_CHANNELS) {
48  av_log(avr, AV_LOG_ERROR, "Invalid output channel layout: %"PRIu64"\n",
49  avr->out_channel_layout);
50  return AVERROR(EINVAL);
51  }
53  avr->downmix_needed = avr->in_channels > avr->out_channels;
54  avr->upmix_needed = avr->out_channels > avr->in_channels ||
55  (!avr->downmix_needed && (avr->mix_matrix ||
57  avr->mixing_needed = avr->downmix_needed || avr->upmix_needed;
58 
59  /* set resampling parameters */
60  avr->resample_needed = avr->in_sample_rate != avr->out_sample_rate ||
61  avr->force_resampling;
62 
63  /* select internal sample format if not specified by the user */
65  (avr->mixing_needed || avr->resample_needed)) {
68  int max_bps = FFMAX(av_get_bytes_per_sample(in_fmt),
69  av_get_bytes_per_sample(out_fmt));
70  if (max_bps <= 2) {
72  } else if (avr->mixing_needed) {
74  } else {
75  if (max_bps <= 4) {
76  if (in_fmt == AV_SAMPLE_FMT_S32P ||
77  out_fmt == AV_SAMPLE_FMT_S32P) {
78  if (in_fmt == AV_SAMPLE_FMT_FLTP ||
79  out_fmt == AV_SAMPLE_FMT_FLTP) {
80  /* if one is s32 and the other is flt, use dbl */
82  } else {
83  /* if one is s32 and the other is s32, s16, or u8, use s32 */
85  }
86  } else {
87  /* if one is flt and the other is flt, s16 or u8, use flt */
89  }
90  } else {
91  /* if either is dbl, use dbl */
93  }
94  }
95  av_log(avr, AV_LOG_DEBUG, "Using %s as internal sample format\n",
97  }
98 
99  /* treat all mono as planar for easier comparison */
100  if (avr->in_channels == 1)
102  if (avr->out_channels == 1)
104 
105  /* we may need to add an extra conversion in order to remap channels if
106  the output format is not planar */
107  if (avr->use_channel_map && !avr->mixing_needed && !avr->resample_needed &&
110  }
111 
112  /* set sample format conversion parameters */
113  if (avr->resample_needed || avr->mixing_needed)
115  else
116  avr->in_convert_needed = avr->use_channel_map &&
118 
119  if (avr->resample_needed || avr->mixing_needed || avr->in_convert_needed)
121  else
122  avr->out_convert_needed = avr->in_sample_fmt != avr->out_sample_fmt;
123 
124  avr->in_copy_needed = !avr->in_convert_needed && (avr->mixing_needed ||
125  (avr->use_channel_map && avr->resample_needed));
126 
127  if (avr->use_channel_map) {
128  if (avr->in_copy_needed) {
129  avr->remap_point = REMAP_IN_COPY;
130  av_dlog(avr, "remap channels during in_copy\n");
131  } else if (avr->in_convert_needed) {
133  av_dlog(avr, "remap channels during in_convert\n");
134  } else if (avr->out_convert_needed) {
136  av_dlog(avr, "remap channels during out_convert\n");
137  } else {
139  av_dlog(avr, "remap channels during out_copy\n");
140  }
141 
142 #ifdef DEBUG
143  {
144  int ch;
145  av_dlog(avr, "output map: ");
146  if (avr->ch_map_info.do_remap)
147  for (ch = 0; ch < avr->in_channels; ch++)
148  av_dlog(avr, " % 2d", avr->ch_map_info.channel_map[ch]);
149  else
150  av_dlog(avr, "n/a");
151  av_dlog(avr, "\n");
152  av_dlog(avr, "copy map: ");
153  if (avr->ch_map_info.do_copy)
154  for (ch = 0; ch < avr->in_channels; ch++)
155  av_dlog(avr, " % 2d", avr->ch_map_info.channel_copy[ch]);
156  else
157  av_dlog(avr, "n/a");
158  av_dlog(avr, "\n");
159  av_dlog(avr, "zero map: ");
160  if (avr->ch_map_info.do_zero)
161  for (ch = 0; ch < avr->in_channels; ch++)
162  av_dlog(avr, " % 2d", avr->ch_map_info.channel_zero[ch]);
163  else
164  av_dlog(avr, "n/a");
165  av_dlog(avr, "\n");
166  av_dlog(avr, "input map: ");
167  for (ch = 0; ch < avr->in_channels; ch++)
168  av_dlog(avr, " % 2d", avr->ch_map_info.input_map[ch]);
169  av_dlog(avr, "\n");
170  }
171 #endif
172  } else
173  avr->remap_point = REMAP_NONE;
174 
175  /* allocate buffers */
176  if (avr->in_copy_needed || avr->in_convert_needed) {
178  0, avr->internal_sample_fmt,
179  "in_buffer");
180  if (!avr->in_buffer) {
181  ret = AVERROR(EINVAL);
182  goto error;
183  }
184  }
185  if (avr->resample_needed) {
187  1024, avr->internal_sample_fmt,
188  "resample_out_buffer");
189  if (!avr->resample_out_buffer) {
190  ret = AVERROR(EINVAL);
191  goto error;
192  }
193  }
194  if (avr->out_convert_needed) {
196  avr->out_sample_fmt, "out_buffer");
197  if (!avr->out_buffer) {
198  ret = AVERROR(EINVAL);
199  goto error;
200  }
201  }
203  1024);
204  if (!avr->out_fifo) {
205  ret = AVERROR(ENOMEM);
206  goto error;
207  }
208 
209  /* setup contexts */
210  if (avr->in_convert_needed) {
212  avr->in_sample_fmt, avr->in_channels,
213  avr->in_sample_rate,
214  avr->remap_point == REMAP_IN_CONVERT);
215  if (!avr->ac_in) {
216  ret = AVERROR(ENOMEM);
217  goto error;
218  }
219  }
220  if (avr->out_convert_needed) {
221  enum AVSampleFormat src_fmt;
222  if (avr->in_convert_needed)
223  src_fmt = avr->internal_sample_fmt;
224  else
225  src_fmt = avr->in_sample_fmt;
226  avr->ac_out = ff_audio_convert_alloc(avr, avr->out_sample_fmt, src_fmt,
227  avr->out_channels,
228  avr->out_sample_rate,
230  if (!avr->ac_out) {
231  ret = AVERROR(ENOMEM);
232  goto error;
233  }
234  }
235  if (avr->resample_needed) {
236  avr->resample = ff_audio_resample_init(avr);
237  if (!avr->resample) {
238  ret = AVERROR(ENOMEM);
239  goto error;
240  }
241  }
242  if (avr->mixing_needed) {
243  avr->am = ff_audio_mix_alloc(avr);
244  if (!avr->am) {
245  ret = AVERROR(ENOMEM);
246  goto error;
247  }
248  }
249 
250  return 0;
251 
252 error:
253  avresample_close(avr);
254  return ret;
255 }
256 
258 {
263  avr->out_fifo = NULL;
267  ff_audio_mix_free(&avr->am);
268  av_freep(&avr->mix_matrix);
269 
270  avr->use_channel_map = 0;
271 }
272 
274 {
275  if (!*avr)
276  return;
277  avresample_close(*avr);
278  av_opt_free(*avr);
279  av_freep(avr);
280 }
281 
283  AudioData *output, AudioData *converted)
284 {
285  int ret;
286 
287  if (!output || av_audio_fifo_size(avr->out_fifo) > 0 ||
288  (converted && output->allocated_samples < converted->nb_samples)) {
289  if (converted) {
290  /* if there are any samples in the output FIFO or if the
291  user-supplied output buffer is not large enough for all samples,
292  we add to the output FIFO */
293  av_dlog(avr, "[FIFO] add %s to out_fifo\n", converted->name);
294  ret = ff_audio_data_add_to_fifo(avr->out_fifo, converted, 0,
295  converted->nb_samples);
296  if (ret < 0)
297  return ret;
298  }
299 
300  /* if the user specified an output buffer, read samples from the output
301  FIFO to the user output */
302  if (output && output->allocated_samples > 0) {
303  av_dlog(avr, "[FIFO] read from out_fifo to output\n");
304  av_dlog(avr, "[end conversion]\n");
305  return ff_audio_data_read_from_fifo(avr->out_fifo, output,
306  output->allocated_samples);
307  }
308  } else if (converted) {
309  /* copy directly to output if it is large enough or there is not any
310  data in the output FIFO */
311  av_dlog(avr, "[copy] %s to output\n", converted->name);
312  output->nb_samples = 0;
313  ret = ff_audio_data_copy(output, converted,
314  avr->remap_point == REMAP_OUT_COPY ?
315  &avr->ch_map_info : NULL);
316  if (ret < 0)
317  return ret;
318  av_dlog(avr, "[end conversion]\n");
319  return output->nb_samples;
320  }
321  av_dlog(avr, "[end conversion]\n");
322  return 0;
323 }
324 
326  uint8_t **output, int out_plane_size,
327  int out_samples, uint8_t **input,
328  int in_plane_size, int in_samples)
329 {
330  AudioData input_buffer;
332  AudioData *current_buffer;
333  int ret, direct_output;
334 
335  /* reset internal buffers */
336  if (avr->in_buffer) {
337  avr->in_buffer->nb_samples = 0;
340  }
341  if (avr->resample_out_buffer) {
345  }
346  if (avr->out_buffer) {
347  avr->out_buffer->nb_samples = 0;
350  }
351 
352  av_dlog(avr, "[start conversion]\n");
353 
354  /* initialize output_buffer with output data */
355  direct_output = output && av_audio_fifo_size(avr->out_fifo) == 0;
356  if (output) {
357  ret = ff_audio_data_init(&output_buffer, output, out_plane_size,
358  avr->out_channels, out_samples,
359  avr->out_sample_fmt, 0, "output");
360  if (ret < 0)
361  return ret;
362  output_buffer.nb_samples = 0;
363  }
364 
365  if (input) {
366  /* initialize input_buffer with input data */
367  ret = ff_audio_data_init(&input_buffer, input, in_plane_size,
368  avr->in_channels, in_samples,
369  avr->in_sample_fmt, 1, "input");
370  if (ret < 0)
371  return ret;
372  current_buffer = &input_buffer;
373 
374  if (avr->upmix_needed && !avr->in_convert_needed && !avr->resample_needed &&
375  !avr->out_convert_needed && direct_output && out_samples >= in_samples) {
376  /* in some rare cases we can copy input to output and upmix
377  directly in the output buffer */
378  av_dlog(avr, "[copy] %s to output\n", current_buffer->name);
379  ret = ff_audio_data_copy(&output_buffer, current_buffer,
380  avr->remap_point == REMAP_OUT_COPY ?
381  &avr->ch_map_info : NULL);
382  if (ret < 0)
383  return ret;
384  current_buffer = &output_buffer;
385  } else if (avr->remap_point == REMAP_OUT_COPY &&
386  (!direct_output || out_samples < in_samples)) {
387  /* if remapping channels during output copy, we may need to
388  * use an intermediate buffer in order to remap before adding
389  * samples to the output fifo */
390  av_dlog(avr, "[copy] %s to out_buffer\n", current_buffer->name);
391  ret = ff_audio_data_copy(avr->out_buffer, current_buffer,
392  &avr->ch_map_info);
393  if (ret < 0)
394  return ret;
395  current_buffer = avr->out_buffer;
396  } else if (avr->in_copy_needed || avr->in_convert_needed) {
397  /* if needed, copy or convert input to in_buffer, and downmix if
398  applicable */
399  if (avr->in_convert_needed) {
400  ret = ff_audio_data_realloc(avr->in_buffer,
401  current_buffer->nb_samples);
402  if (ret < 0)
403  return ret;
404  av_dlog(avr, "[convert] %s to in_buffer\n", current_buffer->name);
405  ret = ff_audio_convert(avr->ac_in, avr->in_buffer,
406  current_buffer);
407  if (ret < 0)
408  return ret;
409  } else {
410  av_dlog(avr, "[copy] %s to in_buffer\n", current_buffer->name);
411  ret = ff_audio_data_copy(avr->in_buffer, current_buffer,
412  avr->remap_point == REMAP_IN_COPY ?
413  &avr->ch_map_info : NULL);
414  if (ret < 0)
415  return ret;
416  }
418  if (avr->downmix_needed) {
419  av_dlog(avr, "[downmix] in_buffer\n");
420  ret = ff_audio_mix(avr->am, avr->in_buffer);
421  if (ret < 0)
422  return ret;
423  }
424  current_buffer = avr->in_buffer;
425  }
426  } else {
427  /* flush resampling buffer and/or output FIFO if input is NULL */
428  if (!avr->resample_needed)
429  return handle_buffered_output(avr, output ? &output_buffer : NULL,
430  NULL);
431  current_buffer = NULL;
432  }
433 
434  if (avr->resample_needed) {
435  AudioData *resample_out;
436 
437  if (!avr->out_convert_needed && direct_output && out_samples > 0)
438  resample_out = &output_buffer;
439  else
440  resample_out = avr->resample_out_buffer;
441  av_dlog(avr, "[resample] %s to %s\n",
442  current_buffer ? current_buffer->name : "null",
443  resample_out->name);
444  ret = ff_audio_resample(avr->resample, resample_out,
445  current_buffer);
446  if (ret < 0)
447  return ret;
448 
449  /* if resampling did not produce any samples, just return 0 */
450  if (resample_out->nb_samples == 0) {
451  av_dlog(avr, "[end conversion]\n");
452  return 0;
453  }
454 
455  current_buffer = resample_out;
456  }
457 
458  if (avr->upmix_needed) {
459  av_dlog(avr, "[upmix] %s\n", current_buffer->name);
460  ret = ff_audio_mix(avr->am, current_buffer);
461  if (ret < 0)
462  return ret;
463  }
464 
465  /* if we resampled or upmixed directly to output, return here */
466  if (current_buffer == &output_buffer) {
467  av_dlog(avr, "[end conversion]\n");
468  return current_buffer->nb_samples;
469  }
470 
471  if (avr->out_convert_needed) {
472  if (direct_output && out_samples >= current_buffer->nb_samples) {
473  /* convert directly to output */
474  av_dlog(avr, "[convert] %s to output\n", current_buffer->name);
475  ret = ff_audio_convert(avr->ac_out, &output_buffer, current_buffer);
476  if (ret < 0)
477  return ret;
478 
479  av_dlog(avr, "[end conversion]\n");
480  return output_buffer.nb_samples;
481  } else {
483  current_buffer->nb_samples);
484  if (ret < 0)
485  return ret;
486  av_dlog(avr, "[convert] %s to out_buffer\n", current_buffer->name);
487  ret = ff_audio_convert(avr->ac_out, avr->out_buffer,
488  current_buffer);
489  if (ret < 0)
490  return ret;
491  current_buffer = avr->out_buffer;
492  }
493  }
494 
495  return handle_buffered_output(avr, output ? &output_buffer : NULL,
496  current_buffer);
497 }
498 
500  int stride)
501 {
502  int in_channels, out_channels, i, o;
503 
504  if (avr->am)
505  return ff_audio_mix_get_matrix(avr->am, matrix, stride);
506 
509 
510  if ( in_channels <= 0 || in_channels > AVRESAMPLE_MAX_CHANNELS ||
511  out_channels <= 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
512  av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
513  return AVERROR(EINVAL);
514  }
515 
516  if (!avr->mix_matrix) {
517  av_log(avr, AV_LOG_ERROR, "matrix is not set\n");
518  return AVERROR(EINVAL);
519  }
520 
521  for (o = 0; o < out_channels; o++)
522  for (i = 0; i < in_channels; i++)
523  matrix[o * stride + i] = avr->mix_matrix[o * in_channels + i];
524 
525  return 0;
526 }
527 
528 int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix,
529  int stride)
530 {
531  int in_channels, out_channels, i, o;
532 
533  if (avr->am)
534  return ff_audio_mix_set_matrix(avr->am, matrix, stride);
535 
538 
539  if ( in_channels <= 0 || in_channels > AVRESAMPLE_MAX_CHANNELS ||
540  out_channels <= 0 || out_channels > AVRESAMPLE_MAX_CHANNELS) {
541  av_log(avr, AV_LOG_ERROR, "Invalid channel layouts\n");
542  return AVERROR(EINVAL);
543  }
544 
545  if (avr->mix_matrix)
546  av_freep(&avr->mix_matrix);
547  avr->mix_matrix = av_malloc(in_channels * out_channels *
548  sizeof(*avr->mix_matrix));
549  if (!avr->mix_matrix)
550  return AVERROR(ENOMEM);
551 
552  for (o = 0; o < out_channels; o++)
553  for (i = 0; i < in_channels; i++)
554  avr->mix_matrix[o * in_channels + i] = matrix[o * stride + i];
555 
556  return 0;
557 }
558 
560  const int *channel_map)
561 {
562  ChannelMapInfo *info = &avr->ch_map_info;
563  int in_channels, ch, i;
564 
566  if (in_channels <= 0 || in_channels > AVRESAMPLE_MAX_CHANNELS) {
567  av_log(avr, AV_LOG_ERROR, "Invalid input channel layout\n");
568  return AVERROR(EINVAL);
569  }
570 
571  memset(info, 0, sizeof(*info));
572  memset(info->input_map, -1, sizeof(info->input_map));
573 
574  for (ch = 0; ch < in_channels; ch++) {
575  if (channel_map[ch] >= in_channels) {
576  av_log(avr, AV_LOG_ERROR, "Invalid channel map\n");
577  return AVERROR(EINVAL);
578  }
579  if (channel_map[ch] < 0) {
580  info->channel_zero[ch] = 1;
581  info->channel_map[ch] = -1;
582  info->do_zero = 1;
583  } else if (info->input_map[channel_map[ch]] >= 0) {
584  info->channel_copy[ch] = info->input_map[channel_map[ch]];
585  info->channel_map[ch] = -1;
586  info->do_copy = 1;
587  } else {
588  info->channel_map[ch] = channel_map[ch];
589  info->input_map[channel_map[ch]] = ch;
590  info->do_remap = 1;
591  }
592  }
593  /* Fill-in unmapped input channels with unmapped output channels.
594  This is used when remapping during conversion from interleaved to
595  planar format. */
596  for (ch = 0, i = 0; ch < in_channels && i < in_channels; ch++, i++) {
597  while (ch < in_channels && info->input_map[ch] >= 0)
598  ch++;
599  while (i < in_channels && info->channel_map[i] >= 0)
600  i++;
601  if (ch >= in_channels || i >= in_channels)
602  break;
603  info->input_map[ch] = i;
604  }
605 
606  avr->use_channel_map = 1;
607  return 0;
608 }
609 
611 {
612  return av_audio_fifo_size(avr->out_fifo);
613 }
614 
615 int avresample_read(AVAudioResampleContext *avr, uint8_t **output, int nb_samples)
616 {
617  if (!output)
618  return av_audio_fifo_drain(avr->out_fifo, nb_samples);
619  return av_audio_fifo_read(avr->out_fifo, (void**)output, nb_samples);
620 }
621 
622 unsigned avresample_version(void)
623 {
625 }
626 
627 const char *avresample_license(void)
628 {
629 #define LICENSE_PREFIX "libavresample license: "
630  return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
631 }
632 
633 const char *avresample_configuration(void)
634 {
635  return LIBAV_CONFIGURATION;
636 }
int in_channels
number of input channels
Definition: internal.h:77
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
AudioConvert * ac_in
input sample format conversion context
Definition: internal.h:93
const char * name
name for debug logging
Definition: audio_data.h:53
int ff_audio_data_realloc(AudioData *a, int nb_samples)
Reallocate AudioData.
Definition: audio_data.c:153
#define LIBAVRESAMPLE_VERSION_INT
Definition: version.h:34
int input_map[AVRESAMPLE_MAX_CHANNELS]
dest index of each input channel
Definition: internal.h:50
AudioData * out_buffer
buffer for converted output
Definition: internal.h:90
Audio buffer used for intermediate storage between conversion phases.
Definition: oss_audio.c:47
memory handling functions
int ff_audio_data_add_to_fifo(AVAudioFifo *af, AudioData *a, int offset, int nb_samples)
Add samples in AudioData to an AVAudioFifo.
Definition: audio_data.c:342
int do_zero
zeroing needed
Definition: internal.h:49
AudioData * ff_audio_data_alloc(int channels, int nb_samples, enum AVSampleFormat sample_fmt, const char *name)
Allocate AudioData.
Definition: audio_data.c:110
int avresample_read(AVAudioResampleContext *avr, uint8_t **output, int nb_samples)
Read samples from the output FIFO.
Definition: utils.c:615
double * mix_matrix
mix matrix only used if avresample_set_matrix() is called before avresample_open() ...
Definition: internal.h:103
uint64_t out_channel_layout
output channel layout
Definition: internal.h:59
int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in)
Convert audio data from one sample format to another.
#define LIBAV_CONFIGURATION
Definition: config.h:4
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:45
int avresample_set_channel_mapping(AVAudioResampleContext *avr, const int *channel_map)
Set a customized input channel mapping.
Definition: utils.c:559
int stride
Definition: mace.c:144
int ff_audio_mix(AudioMix *am, AudioData *src)
Apply channel mixing to audio data using the current mixing matrix.
Definition: audio_mix.c:428
int channel_zero[AVRESAMPLE_MAX_CHANNELS]
dest index to zero
Definition: internal.h:48
void avresample_free(AVAudioResampleContext **avr)
Free AVAudioResampleContext and associated AVOption values.
Definition: utils.c:273
int nb_samples
current number of samples
Definition: audio_data.h:41
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
AudioData * in_buffer
buffer for converted input
Definition: internal.h:88
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
Definition: audio_fifo.c:139
Public dictionary API.
int allocated_channels
allocated channel count
Definition: audio_data.h:44
uint8_t
AVOptions.
int out_channels
number of output channels
Definition: internal.h:78
static int handle_buffered_output(AVAudioResampleContext *avr, AudioData *output, AudioData *converted)
Definition: utils.c:282
#define LICENSE_PREFIX
int ff_audio_mix_set_matrix(AudioMix *am, const double *matrix, int stride)
Set the current mixing matrix.
Definition: audio_mix.c:653
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
Definition: samplefmt.c:73
const char * avresample_license(void)
Return the libavresample license.
Definition: utils.c:627
signed 32 bits, planar
Definition: samplefmt.h:59
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:186
AudioConvert * ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map)
Allocate and initialize AudioConvert context for sample format conversion.
void avresample_close(AVAudioResampleContext *avr)
Close AVAudioResampleContext.
Definition: utils.c:257
float, planar
Definition: samplefmt.h:60
AudioMix * am
channel mixing context
Definition: internal.h:96
int ff_audio_data_set_channels(AudioData *a, int channels)
Definition: audio_data.c:51
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
error code definitions
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:60
int out_convert_needed
output sample format conversion is needed
Definition: internal.h:85
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
void ff_audio_convert_free(AudioConvert **ac)
Free AudioConvert.
AudioConvert * ac_out
output sample format conversion context
Definition: internal.h:94
#define LIBAV_LICENSE
Definition: config.h:5
#define FFMAX(a, b)
Definition: common.h:55
int ff_audio_data_read_from_fifo(AVAudioFifo *af, AudioData *a, int nb_samples)
Read samples from an AVAudioFifo to AudioData.
Definition: audio_data.c:357
int channel_copy[AVRESAMPLE_MAX_CHANNELS]
dest index to copy from
Definition: internal.h:46
int upmix_needed
upmixing is needed
Definition: internal.h:81
static void output_buffer(int16_t **samples, int nchan, int blocksize, int32_t **buffer)
Definition: shorten.c:257
ResampleContext * resample
resampling context
Definition: internal.h:95
enum RemapPoint remap_point
Definition: internal.h:106
external API header
#define FFMIN(a, b)
Definition: common.h:57
int do_remap
remap needed
Definition: internal.h:45
int ff_audio_data_init(AudioData *a, uint8_t **src, int plane_size, int channels, int nb_samples, enum AVSampleFormat sample_fmt, int read_only, const char *name)
Initialize AudioData using a given source.
Definition: audio_data.c:65
ChannelMapInfo ch_map_info
Definition: internal.h:107
uint64_t in_channel_layout
input channel layout
Definition: internal.h:56
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:47
int avresample_set_matrix(AVAudioResampleContext *avr, const double *matrix, int stride)
Set channel mixing matrix.
Definition: utils.c:528
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:95
int in_sample_rate
input sample rate
Definition: internal.h:58
#define attribute_align_arg
Definition: internal.h:53
int avresample_get_matrix(AVAudioResampleContext *avr, double *matrix, int stride)
Get the current channel mixing matrix.
Definition: utils.c:499
NULL
Definition: eval.c:55
int avresample_available(AVAudioResampleContext *avr)
Return the number of available samples in the output FIFO.
Definition: utils.c:610
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:68
AVAudioFifo * out_fifo
FIFO for output samples.
Definition: internal.h:91
ResampleContext * ff_audio_resample_init(AVAudioResampleContext *avr)
Allocate and initialize a ResampleContext.
Definition: resample.c:146
#define AVRESAMPLE_MAX_CHANNELS
Definition: avresample.h:103
enum AVSampleFormat internal_sample_fmt
internal sample format
Definition: internal.h:62
int force_resampling
force resampling
Definition: internal.h:68
void ff_audio_mix_free(AudioMix **am_p)
Free an AudioMix context.
Definition: audio_mix.c:409
int in_copy_needed
input data copy is needed
Definition: internal.h:86
const char * avresample_configuration(void)
Return the libavresample build-time configuration.
Definition: utils.c:633
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:101
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
Definition: audio_fifo.c:159
int ff_audio_resample(ResampleContext *c, AudioData *dst, AudioData *src)
Resample audio data.
Definition: resample.c:409
enum AVSampleFormat in_sample_fmt
input sample format
Definition: internal.h:57
int attribute_align_arg avresample_convert(AVAudioResampleContext *avr, uint8_t **output, int out_plane_size, int out_samples, uint8_t **input, int in_plane_size, int in_samples)
Convert input samples and write them to the output FIFO.
Definition: utils.c:325
int in_convert_needed
input sample format conversion is needed
Definition: internal.h:84
int channel_map[AVRESAMPLE_MAX_CHANNELS]
source index of each output channel, -1 if not remapped
Definition: internal.h:44
enum AVSampleFormat out_sample_fmt
output sample format
Definition: internal.h:60
int ff_audio_data_copy(AudioData *dst, AudioData *src, ChannelMapInfo *map)
Copy data from one AudioData to another.
Definition: audio_data.c:216
void av_opt_free(void *obj)
Free all string and binary options in obj.
Definition: opt.c:613
common internal and external API header
int resample_channels
number of channels used for resampling
Definition: internal.h:79
AudioData * resample_out_buffer
buffer for output from resampler
Definition: internal.h:89
int resample_needed
resampling is needed
Definition: internal.h:83
int do_copy
copy needed
Definition: internal.h:47
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
AudioMix * ff_audio_mix_alloc(AVAudioResampleContext *avr)
Allocate and initialize an AudioMix context.
Definition: audio_mix.c:341
unsigned avresample_version(void)
Return the LIBAVRESAMPLE_VERSION_INT constant.
Definition: utils.c:622
int allocated_samples
number of samples the buffer can hold
Definition: audio_data.h:40
signed 16 bits, planar
Definition: samplefmt.h:58
int out_sample_rate
output sample rate
Definition: internal.h:61
void ff_audio_data_free(AudioData **a)
Free AudioData.
Definition: audio_data.c:208
int downmix_needed
downmixing is needed
Definition: internal.h:80
int avresample_open(AVAudioResampleContext *avr)
Initialize AVAudioResampleContext.
Definition: utils.c:35
void ff_audio_resample_free(ResampleContext **c)
Free a ResampleContext.
Definition: resample.c:238
double, planar
Definition: samplefmt.h:61
int mixing_needed
either upmixing or downmixing is needed
Definition: internal.h:82
int ff_audio_mix_get_matrix(AudioMix *am, double *matrix, int stride)
Get the current mixing matrix.
Definition: audio_mix.c:483