FFmpeg
swresample.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2011-2013 Michael Niedermayer (michaelni@gmx.at)
3  *
4  * This file is part of libswresample
5  *
6  * libswresample 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  * libswresample 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 libswresample; 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/opt.h"
22 #include "swresample_internal.h"
23 #include "audioconvert.h"
24 #include "libavutil/avassert.h"
26 #include "libavutil/internal.h"
27 
28 #include <float.h>
29 
30 #define ALIGN 32
31 
32 int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map){
33  if(!s || s->in_convert) // s needs to be allocated but not initialized
34  return AVERROR(EINVAL);
35  s->channel_map = channel_map;
36  return 0;
37 }
38 
39 #if FF_API_OLD_CHANNEL_LAYOUT
41 struct SwrContext *swr_alloc_set_opts(struct SwrContext *s,
44  int log_offset, void *log_ctx){
45  if(!s) s= swr_alloc();
46  if(!s) return NULL;
47 
48  s->log_level_offset= log_offset;
49  s->log_ctx= log_ctx;
50 
51  if (av_opt_set_int(s, "ocl", out_ch_layout, 0) < 0)
52  goto fail;
53 
54  if (av_opt_set_int(s, "osf", out_sample_fmt, 0) < 0)
55  goto fail;
56 
57  if (av_opt_set_int(s, "osr", out_sample_rate, 0) < 0)
58  goto fail;
59 
60  if (av_opt_set_int(s, "icl", in_ch_layout, 0) < 0)
61  goto fail;
62 
63  if (av_opt_set_int(s, "isf", in_sample_fmt, 0) < 0)
64  goto fail;
65 
66  if (av_opt_set_int(s, "isr", in_sample_rate, 0) < 0)
67  goto fail;
68 
69  if (av_opt_set_int(s, "ich", av_get_channel_layout_nb_channels(s-> user_in_ch_layout), 0) < 0)
70  goto fail;
71 
72  if (av_opt_set_int(s, "och", av_get_channel_layout_nb_channels(s->user_out_ch_layout), 0) < 0)
73  goto fail;
74 
75  av_opt_set_int(s, "uch", 0, 0);
76  return s;
77 fail:
78  av_log(s, AV_LOG_ERROR, "Failed to set option\n");
79  swr_free(&s);
80  return NULL;
81 }
83 #endif
84 
88  int log_offset, void *log_ctx) {
89  struct SwrContext *s = *ps;
90  int ret;
91 
92  if (!s) s = swr_alloc();
93  if (!s) return AVERROR(ENOMEM);
94 
95  *ps = s;
96 
97  s->log_level_offset = log_offset;
98  s->log_ctx = log_ctx;
99 
100  if ((ret = av_opt_set_chlayout(s, "ochl", out_ch_layout, 0)) < 0)
101  goto fail;
102 
103  if ((ret = av_opt_set_int(s, "osf", out_sample_fmt, 0)) < 0)
104  goto fail;
105 
106  if ((ret = av_opt_set_int(s, "osr", out_sample_rate, 0)) < 0)
107  goto fail;
108 
109  if ((ret = av_opt_set_chlayout(s, "ichl", in_ch_layout, 0)) < 0)
110  goto fail;
111 
112  if ((ret = av_opt_set_int(s, "isf", in_sample_fmt, 0)) < 0)
113  goto fail;
114 
115  if ((ret = av_opt_set_int(s, "isr", in_sample_rate, 0)) < 0)
116  goto fail;
117 
118  av_opt_set_int(s, "uch", 0, 0);
119 
120 #if FF_API_OLD_CHANNEL_LAYOUT
121  // Clear old API values so they don't take precedence in swr_init()
122  av_opt_set_int(s, "icl", 0, 0);
123  av_opt_set_int(s, "ocl", 0, 0);
124  av_opt_set_int(s, "ich", 0, 0);
125  av_opt_set_int(s, "och", 0, 0);
126 #endif
127 
128  return 0;
129 fail:
130  av_log(s, AV_LOG_ERROR, "Failed to set option\n");
131  swr_free(ps);
132  return ret;
133 }
134 
135 static void set_audiodata_fmt(AudioData *a, enum AVSampleFormat fmt){
136  a->fmt = fmt;
137  a->bps = av_get_bytes_per_sample(fmt);
138  a->planar= av_sample_fmt_is_planar(fmt);
139  if (a->ch_count == 1)
140  a->planar = 1;
141 }
142 
143 static void free_temp(AudioData *a){
144  av_free(a->data);
145  memset(a, 0, sizeof(*a));
146 }
147 
148 static void clear_context(SwrContext *s){
149  s->in_buffer_index= 0;
150  s->in_buffer_count= 0;
151  s->resample_in_constraint= 0;
152  memset(s->in.ch, 0, sizeof(s->in.ch));
153  memset(s->out.ch, 0, sizeof(s->out.ch));
154  free_temp(&s->postin);
155  free_temp(&s->midbuf);
156  free_temp(&s->preout);
157  free_temp(&s->in_buffer);
158  free_temp(&s->silence);
159  free_temp(&s->drop_temp);
160  free_temp(&s->dither.noise);
161  free_temp(&s->dither.temp);
162  av_channel_layout_uninit(&s->in_ch_layout);
163  av_channel_layout_uninit(&s->out_ch_layout);
165  swri_audio_convert_free(&s->out_convert);
166  swri_audio_convert_free(&s->full_convert);
168 
169  s->delayed_samples_fixup = 0;
170  s->flushed = 0;
171 }
172 
174  SwrContext *s= *ss;
175  if(s){
176  clear_context(s);
177  av_channel_layout_uninit(&s->user_in_chlayout);
178  av_channel_layout_uninit(&s->user_out_chlayout);
179 
180  if (s->resampler)
181  s->resampler->free(&s->resample);
182  }
183 
184  av_freep(ss);
185 }
186 
188  clear_context(s);
189 }
190 
192  int ret;
193  char l1[1024], l2[1024];
194 
195  clear_context(s);
196 
198  av_log(s, AV_LOG_ERROR, "Requested input sample format %d is invalid\n", s->in_sample_fmt);
199  return AVERROR(EINVAL);
200  }
201  if(s->out_sample_fmt >= AV_SAMPLE_FMT_NB){
202  av_log(s, AV_LOG_ERROR, "Requested output sample format %d is invalid\n", s->out_sample_fmt);
203  return AVERROR(EINVAL);
204  }
205 
206  if(s-> in_sample_rate <= 0){
207  av_log(s, AV_LOG_ERROR, "Requested input sample rate %d is invalid\n", s->in_sample_rate);
208  return AVERROR(EINVAL);
209  }
210  if(s->out_sample_rate <= 0){
211  av_log(s, AV_LOG_ERROR, "Requested output sample rate %d is invalid\n", s->out_sample_rate);
212  return AVERROR(EINVAL);
213  }
214  s->used_ch_count = s->user_used_ch_count;
215 #if FF_API_OLD_CHANNEL_LAYOUT
216  s->out.ch_count = s-> user_out_ch_count;
217  s-> in.ch_count = s-> user_in_ch_count;
218 
219  // if the old/new fields are set inconsistently, prefer the old ones
220  if ((s->user_in_ch_count && s->user_in_ch_count != s->user_in_chlayout.nb_channels) ||
221  (s->user_in_ch_layout && (s->user_in_chlayout.order != AV_CHANNEL_ORDER_NATIVE ||
222  s->user_in_chlayout.u.mask != s->user_in_ch_layout))) {
223  av_channel_layout_uninit(&s->in_ch_layout);
224  if (s->user_in_ch_layout)
225  av_channel_layout_from_mask(&s->in_ch_layout, s->user_in_ch_layout);
226  else {
227  s->in_ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
228  s->in_ch_layout.nb_channels = s->user_in_ch_count;
229  }
230  } else if (av_channel_layout_check(&s->user_in_chlayout))
231  av_channel_layout_copy(&s->in_ch_layout, &s->user_in_chlayout);
232 
233  if ((s->user_out_ch_count && s->user_out_ch_count != s->user_out_chlayout.nb_channels) ||
234  (s->user_out_ch_layout && (s->user_out_chlayout.order != AV_CHANNEL_ORDER_NATIVE ||
235  s->user_out_chlayout.u.mask != s->user_out_ch_layout))) {
236  av_channel_layout_uninit(&s->out_ch_layout);
237  if (s->user_out_ch_layout)
238  av_channel_layout_from_mask(&s->out_ch_layout, s->user_out_ch_layout);
239  else {
240  s->out_ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
241  s->out_ch_layout.nb_channels = s->user_out_ch_count;
242  }
243  } else if (av_channel_layout_check(&s->user_out_chlayout))
244  av_channel_layout_copy(&s->out_ch_layout, &s->user_out_chlayout);
245 
246  if (!s->out.ch_count && !s->user_out_ch_layout)
247  s->out.ch_count = s->out_ch_layout.nb_channels;
248  if (!s-> in.ch_count && !s-> user_in_ch_layout)
249  s-> in.ch_count = s->in_ch_layout.nb_channels;
250 
251  if (!(ret = av_channel_layout_check(&s->in_ch_layout)) || s->in_ch_layout.nb_channels > SWR_CH_MAX) {
252  if (ret)
253  av_channel_layout_describe(&s->in_ch_layout, l1, sizeof(l1));
254  av_log(s, AV_LOG_WARNING, "Input channel layout \"%s\" is invalid or unsupported.\n", ret ? l1 : "");
255  return AVERROR(EINVAL);
256  }
257 
258  if (!(ret = av_channel_layout_check(&s->out_ch_layout)) || s->out_ch_layout.nb_channels > SWR_CH_MAX) {
259  if (ret)
260  av_channel_layout_describe(&s->out_ch_layout, l2, sizeof(l2));
261  av_log(s, AV_LOG_WARNING, "Output channel layout \"%s\" is invalid or unsupported.\n", ret ? l2 : "");
262  return AVERROR(EINVAL);
263  }
264 #else
265  s->out.ch_count = s-> user_out_chlayout.nb_channels;
267 
268  if (!(ret = av_channel_layout_check(&s->user_in_chlayout)) || s->user_in_chlayout.nb_channels > SWR_CH_MAX) {
269  if (ret)
270  av_channel_layout_describe(&s->user_in_chlayout, l1, sizeof(l1));
271  av_log(s, AV_LOG_WARNING, "Input channel layout \"%s\" is invalid or unsupported.\n", ret ? l1 : "");
272  return AVERROR(EINVAL);
273  }
274 
275  if (!(ret = av_channel_layout_check(&s->user_out_chlayout)) || s->user_out_chlayout.nb_channels > SWR_CH_MAX) {
276  if (ret)
277  av_channel_layout_describe(&s->user_out_chlayout, l2, sizeof(l2));
278  av_log(s, AV_LOG_WARNING, "Output channel layout \"%s\" is invalid or unsupported.\n", ret ? l2 : "");
279  return AVERROR(EINVAL);
280  }
281 
282  ret = av_channel_layout_copy(&s->in_ch_layout, &s->user_in_chlayout);
283  ret |= av_channel_layout_copy(&s->out_ch_layout, &s->user_out_chlayout);
284  if (ret < 0)
285  return ret;
286 #endif
287 
288  s->int_sample_fmt= s->user_int_sample_fmt;
289 
290  s->dither.method = s->user_dither_method;
291 
292  switch(s->engine){
293 #if CONFIG_LIBSOXR
294  case SWR_ENGINE_SOXR: s->resampler = &swri_soxr_resampler; break;
295 #endif
296  case SWR_ENGINE_SWR : s->resampler = &swri_resampler; break;
297  default:
298  av_log(s, AV_LOG_ERROR, "Requested resampling engine is unavailable\n");
299  return AVERROR(EINVAL);
300  }
301 
302  if(!s->used_ch_count)
303  s->used_ch_count= s->in.ch_count;
304 
305  if (s->used_ch_count && s->in_ch_layout.order != AV_CHANNEL_ORDER_UNSPEC && s->used_ch_count != s->in_ch_layout.nb_channels) {
306  av_log(s, AV_LOG_WARNING, "Input channel layout has a different number of channels than the number of used channels, ignoring layout\n");
307  av_channel_layout_uninit(&s->in_ch_layout);
308  }
309 
310  if (s->in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
311  av_channel_layout_default(&s->in_ch_layout, s->used_ch_count);
312  if (s->out_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
313  av_channel_layout_default(&s->out_ch_layout, s->out.ch_count);
314 
315  s->rematrix = av_channel_layout_compare(&s->out_ch_layout, &s->in_ch_layout) ||
316  s->rematrix_volume!=1.0 ||
317  s->rematrix_custom;
318 
319  if(s->int_sample_fmt == AV_SAMPLE_FMT_NONE){
321  && av_get_bytes_per_sample(s->out_sample_fmt) <= 2){
322  s->int_sample_fmt= AV_SAMPLE_FMT_S16P;
323  }else if( av_get_bytes_per_sample(s-> in_sample_fmt) <= 2
324  && !s->rematrix
325  && s->out_sample_rate==s->in_sample_rate
326  && !(s->flags & SWR_FLAG_RESAMPLE)){
327  s->int_sample_fmt= AV_SAMPLE_FMT_S16P;
329  && av_get_planar_sample_fmt(s->out_sample_fmt) == AV_SAMPLE_FMT_S32P
330  && !s->rematrix
331  && s->out_sample_rate == s->in_sample_rate
332  && !(s->flags & SWR_FLAG_RESAMPLE)
333  && s->engine != SWR_ENGINE_SOXR){
334  s->int_sample_fmt= AV_SAMPLE_FMT_S32P;
335  }else if(av_get_bytes_per_sample(s->in_sample_fmt) <= 4){
336  s->int_sample_fmt= AV_SAMPLE_FMT_FLTP;
337  }else{
338  s->int_sample_fmt= AV_SAMPLE_FMT_DBLP;
339  }
340  }
341  av_log(s, AV_LOG_DEBUG, "Using %s internally between filters\n", av_get_sample_fmt_name(s->int_sample_fmt));
342 
343  if( s->int_sample_fmt != AV_SAMPLE_FMT_S16P
344  &&s->int_sample_fmt != AV_SAMPLE_FMT_S32P
345  &&s->int_sample_fmt != AV_SAMPLE_FMT_S64P
346  &&s->int_sample_fmt != AV_SAMPLE_FMT_FLTP
347  &&s->int_sample_fmt != AV_SAMPLE_FMT_DBLP){
348  av_log(s, AV_LOG_ERROR, "Requested sample format %s is not supported internally, s16p/s32p/s64p/fltp/dblp are supported\n", av_get_sample_fmt_name(s->int_sample_fmt));
349  return AVERROR(EINVAL);
350  }
351 
353  set_audiodata_fmt(&s->out, s->out_sample_fmt);
354 
355  if (s->firstpts_in_samples != AV_NOPTS_VALUE) {
356  if (!s->async && s->min_compensation >= FLT_MAX/2)
357  s->async = 1;
358  s->firstpts =
359  s->outpts = s->firstpts_in_samples * s->out_sample_rate;
360  } else
361  s->firstpts = AV_NOPTS_VALUE;
362 
363  if (s->async) {
364  if (s->min_compensation >= FLT_MAX/2)
365  s->min_compensation = 0.001;
366  if (s->async > 1.0001) {
367  s->max_soft_compensation = s->async / (double) s->in_sample_rate;
368  }
369  }
370 
371  if (s->out_sample_rate!=s->in_sample_rate || (s->flags & SWR_FLAG_RESAMPLE)){
372  s->resample = s->resampler->init(s->resample, s->out_sample_rate, s->in_sample_rate, s->filter_size, s->phase_shift, s->linear_interp, s->cutoff, s->int_sample_fmt, s->filter_type, s->kaiser_beta, s->precision, s->cheby, s->exact_rational);
373  if (!s->resample) {
374  av_log(s, AV_LOG_ERROR, "Failed to initialize resampler\n");
375  return AVERROR(ENOMEM);
376  }
377  }else
378  s->resampler->free(&s->resample);
379  if( s->int_sample_fmt != AV_SAMPLE_FMT_S16P
380  && s->int_sample_fmt != AV_SAMPLE_FMT_S32P
381  && s->int_sample_fmt != AV_SAMPLE_FMT_FLTP
382  && s->int_sample_fmt != AV_SAMPLE_FMT_DBLP
383  && s->resample){
384  av_log(s, AV_LOG_ERROR, "Resampling only supported with internal s16p/s32p/fltp/dblp\n");
385  ret = AVERROR(EINVAL);
386  goto fail;
387  }
388 
389 #define RSC 1 //FIXME finetune
390  if(!s-> in.ch_count)
391  s-> in.ch_count = s->in_ch_layout.nb_channels;
392  if(!s->used_ch_count)
393  s->used_ch_count= s->in.ch_count;
394  if(!s->out.ch_count)
395  s->out.ch_count = s->out_ch_layout.nb_channels;
396 
397  if(!s-> in.ch_count){
398  av_assert0(s->in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC);
399  av_log(s, AV_LOG_ERROR, "Input channel count and layout are unset\n");
400  ret = AVERROR(EINVAL);
401  goto fail;
402  }
403 
404  av_channel_layout_describe(&s->out_ch_layout, l2, sizeof(l2));
405 #if FF_API_OLD_CHANNEL_LAYOUT
406  if (s->out_ch_layout.order != AV_CHANNEL_ORDER_UNSPEC && s->out.ch_count != s->out_ch_layout.nb_channels) {
407  av_log(s, AV_LOG_ERROR, "Output channel layout %s mismatches specified channel count %d\n", l2, s->out.ch_count);
408  ret = AVERROR(EINVAL);
409  goto fail;
410  }
411 #endif
412  av_channel_layout_describe(&s->in_ch_layout, l1, sizeof(l1));
413  if (s->in_ch_layout.order != AV_CHANNEL_ORDER_UNSPEC && s->used_ch_count != s->in_ch_layout.nb_channels) {
414  av_log(s, AV_LOG_ERROR, "Input channel layout %s mismatches specified channel count %d\n", l1, s->used_ch_count);
415  ret = AVERROR(EINVAL);
416  goto fail;
417  }
418 
419  if (( s->out_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC
420  || s-> in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC) && s->used_ch_count != s->out.ch_count && !s->rematrix_custom) {
421  av_log(s, AV_LOG_ERROR, "Rematrix is needed between %s and %s "
422  "but there is not enough information to do it\n", l1, l2);
423  ret = AVERROR(EINVAL);
424  goto fail;
425  }
426 
427 av_assert0(s->used_ch_count);
428 av_assert0(s->out.ch_count);
429  s->resample_first= RSC*s->out.ch_count/s->used_ch_count - RSC < s->out_sample_rate/(float)s-> in_sample_rate - 1.0;
430 
431  s->in_buffer= s->in;
432  s->silence = s->in;
433  s->drop_temp= s->out;
434 
435  if ((ret = swri_dither_init(s, s->out_sample_fmt, s->int_sample_fmt)) < 0)
436  goto fail;
437 
438  if(!s->resample && !s->rematrix && !s->channel_map && !s->dither.method){
439  s->full_convert = swri_audio_convert_alloc(s->out_sample_fmt,
440  s-> in_sample_fmt, s-> in.ch_count, NULL, 0);
441  return 0;
442  }
443 
444  s->in_convert = swri_audio_convert_alloc(s->int_sample_fmt,
445  s-> in_sample_fmt, s->used_ch_count, s->channel_map, 0);
446  s->out_convert= swri_audio_convert_alloc(s->out_sample_fmt,
447  s->int_sample_fmt, s->out.ch_count, NULL, 0);
448 
449  if (!s->in_convert || !s->out_convert) {
450  ret = AVERROR(ENOMEM);
451  goto fail;
452  }
453 
454  s->postin= s->in;
455  s->preout= s->out;
456  s->midbuf= s->in;
457 
458  if(s->channel_map){
459  s->postin.ch_count=
460  s->midbuf.ch_count= s->used_ch_count;
461  if(s->resample)
462  s->in_buffer.ch_count= s->used_ch_count;
463  }
464  if(!s->resample_first){
465  s->midbuf.ch_count= s->out.ch_count;
466  if(s->resample)
467  s->in_buffer.ch_count = s->out.ch_count;
468  }
469 
470  set_audiodata_fmt(&s->postin, s->int_sample_fmt);
471  set_audiodata_fmt(&s->midbuf, s->int_sample_fmt);
472  set_audiodata_fmt(&s->preout, s->int_sample_fmt);
473 
474  if(s->resample){
475  set_audiodata_fmt(&s->in_buffer, s->int_sample_fmt);
476  }
477 
478  av_assert0(!s->preout.count);
479  s->dither.noise = s->preout;
480  s->dither.temp = s->preout;
481  if (s->dither.method > SWR_DITHER_NS) {
482  s->dither.noise.bps = 4;
483  s->dither.noise.fmt = AV_SAMPLE_FMT_FLTP;
484  s->dither.noise_scale = 1;
485  }
486 
487  if(s->rematrix || s->dither.method) {
489  if (ret < 0)
490  goto fail;
491  }
492 
493  return 0;
494 fail:
495  swr_close(s);
496  return ret;
497 
498 }
499 
500 int swri_realloc_audio(AudioData *a, int count){
501  int i, countb;
502  AudioData old;
503 
504  if(count < 0 || count > INT_MAX/2/a->bps/a->ch_count)
505  return AVERROR(EINVAL);
506 
507  if(a->count >= count)
508  return 0;
509 
510  count*=2;
511 
512  countb= FFALIGN(count*a->bps, ALIGN);
513  old= *a;
514 
515  av_assert0(a->bps);
516  av_assert0(a->ch_count);
517 
518  a->data = av_calloc(countb, a->ch_count);
519  if(!a->data)
520  return AVERROR(ENOMEM);
521  for(i=0; i<a->ch_count; i++){
522  a->ch[i]= a->data + i*(a->planar ? countb : a->bps);
523  if(a->count && a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);
524  }
525  if(a->count && !a->planar) memcpy(a->ch[0], old.ch[0], a->count*a->ch_count*a->bps);
526  av_freep(&old.data);
527  a->count= count;
528 
529  return 1;
530 }
531 
532 static void copy(AudioData *out, AudioData *in,
533  int count){
534  av_assert0(out->planar == in->planar);
535  av_assert0(out->bps == in->bps);
536  av_assert0(out->ch_count == in->ch_count);
537  if(out->planar){
538  int ch;
539  for(ch=0; ch<out->ch_count; ch++)
540  memcpy(out->ch[ch], in->ch[ch], count*out->bps);
541  }else
542  memcpy(out->ch[0], in->ch[0], count*out->ch_count*out->bps);
543 }
544 
545 static void fill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){
546  int i;
547  if(!in_arg){
548  memset(out->ch, 0, sizeof(out->ch));
549  }else if(out->planar){
550  for(i=0; i<out->ch_count; i++)
551  out->ch[i]= in_arg[i];
552  }else{
553  for(i=0; i<out->ch_count; i++)
554  out->ch[i]= in_arg[0] + i*out->bps;
555  }
556 }
557 
558 static void reversefill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){
559  int i;
560  if(out->planar){
561  for(i=0; i<out->ch_count; i++)
562  in_arg[i]= out->ch[i];
563  }else{
564  in_arg[0]= out->ch[0];
565  }
566 }
567 
568 /**
569  *
570  * out may be equal in.
571  */
572 static void buf_set(AudioData *out, AudioData *in, int count){
573  int ch;
574  if(in->planar){
575  for(ch=0; ch<out->ch_count; ch++)
576  out->ch[ch]= in->ch[ch] + count*out->bps;
577  }else{
578  for(ch=out->ch_count-1; ch>=0; ch--)
579  out->ch[ch]= in->ch[0] + (ch + count*out->ch_count) * out->bps;
580  }
581 }
582 
583 /**
584  *
585  * @return number of samples output per channel
586  */
587 static int resample(SwrContext *s, AudioData *out_param, int out_count,
588  const AudioData * in_param, int in_count){
589  AudioData in, out, tmp;
590  int ret_sum=0;
591  int border=0;
592  int padless = ARCH_X86 && s->engine == SWR_ENGINE_SWR ? 7 : 0;
593 
594  av_assert1(s->in_buffer.ch_count == in_param->ch_count);
595  av_assert1(s->in_buffer.planar == in_param->planar);
596  av_assert1(s->in_buffer.fmt == in_param->fmt);
597 
598  tmp=out=*out_param;
599  in = *in_param;
600 
601  border = s->resampler->invert_initial_buffer(s->resample, &s->in_buffer,
602  &in, in_count, &s->in_buffer_index, &s->in_buffer_count);
603  if (border == INT_MAX) {
604  return 0;
605  } else if (border < 0) {
606  return border;
607  } else if (border) {
608  buf_set(&in, &in, border);
609  in_count -= border;
610  s->resample_in_constraint = 0;
611  }
612 
613  do{
614  int ret, size, consumed;
615  if(!s->resample_in_constraint && s->in_buffer_count){
616  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
617  ret= s->resampler->multiple_resample(s->resample, &out, out_count, &tmp, s->in_buffer_count, &consumed);
618  out_count -= ret;
619  ret_sum += ret;
620  buf_set(&out, &out, ret);
621  s->in_buffer_count -= consumed;
622  s->in_buffer_index += consumed;
623 
624  if(!in_count)
625  break;
626  if(s->in_buffer_count <= border){
627  buf_set(&in, &in, -s->in_buffer_count);
628  in_count += s->in_buffer_count;
629  s->in_buffer_count=0;
630  s->in_buffer_index=0;
631  border = 0;
632  }
633  }
634 
635  if((s->flushed || in_count > padless) && !s->in_buffer_count){
636  s->in_buffer_index=0;
637  ret= s->resampler->multiple_resample(s->resample, &out, out_count, &in, FFMAX(in_count-padless, 0), &consumed);
638  out_count -= ret;
639  ret_sum += ret;
640  buf_set(&out, &out, ret);
641  in_count -= consumed;
642  buf_set(&in, &in, consumed);
643  }
644 
645  //TODO is this check sane considering the advanced copy avoidance below
646  size= s->in_buffer_index + s->in_buffer_count + in_count;
647  if( size > s->in_buffer.count
648  && s->in_buffer_count + in_count <= s->in_buffer_index){
649  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
650  copy(&s->in_buffer, &tmp, s->in_buffer_count);
651  s->in_buffer_index=0;
652  }else
653  if((ret=swri_realloc_audio(&s->in_buffer, size)) < 0)
654  return ret;
655 
656  if(in_count){
657  int count= in_count;
658  if(s->in_buffer_count && s->in_buffer_count+2 < count && out_count) count= s->in_buffer_count+2;
659 
660  buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
661  copy(&tmp, &in, /*in_*/count);
662  s->in_buffer_count += count;
663  in_count -= count;
664  border += count;
665  buf_set(&in, &in, count);
666  s->resample_in_constraint= 0;
667  if(s->in_buffer_count != count || in_count)
668  continue;
669  if (padless) {
670  padless = 0;
671  continue;
672  }
673  }
674  break;
675  }while(1);
676 
677  s->resample_in_constraint= !!out_count;
678 
679  return ret_sum;
680 }
681 
682 static int swr_convert_internal(struct SwrContext *s, AudioData *out, int out_count,
683  AudioData *in , int in_count){
685  int ret/*, in_max*/;
686  AudioData preout_tmp, midbuf_tmp;
687 
688  if(s->full_convert){
689  av_assert0(!s->resample);
690  swri_audio_convert(s->full_convert, out, in, in_count);
691  return out_count;
692  }
693 
694 // in_max= out_count*(int64_t)s->in_sample_rate / s->out_sample_rate + resample_filter_taps;
695 // in_count= FFMIN(in_count, in_in + 2 - s->hist_buffer_count);
696 
697  if((ret=swri_realloc_audio(&s->postin, in_count))<0)
698  return ret;
699  if(s->resample_first){
700  av_assert0(s->midbuf.ch_count == s->used_ch_count);
701  if((ret=swri_realloc_audio(&s->midbuf, out_count))<0)
702  return ret;
703  }else{
704  av_assert0(s->midbuf.ch_count == s->out.ch_count);
705  if((ret=swri_realloc_audio(&s->midbuf, in_count))<0)
706  return ret;
707  }
708  if((ret=swri_realloc_audio(&s->preout, out_count))<0)
709  return ret;
710 
711  postin= &s->postin;
712 
713  midbuf_tmp= s->midbuf;
714  midbuf= &midbuf_tmp;
715  preout_tmp= s->preout;
716  preout= &preout_tmp;
717 
718  if(s->int_sample_fmt == s-> in_sample_fmt && s->in.planar && !s->channel_map)
719  postin= in;
720 
721  if(s->resample_first ? !s->resample : !s->rematrix)
722  midbuf= postin;
723 
724  if(s->resample_first ? !s->rematrix : !s->resample)
725  preout= midbuf;
726 
727  if(s->int_sample_fmt == s->out_sample_fmt && s->out.planar
728  && !(s->out_sample_fmt==AV_SAMPLE_FMT_S32P && (s->dither.output_sample_bits&31))){
729  if(preout==in){
730  out_count= FFMIN(out_count, in_count); //TODO check at the end if this is needed or redundant
731  av_assert0(s->in.planar); //we only support planar internally so it has to be, we support copying non planar though
732  copy(out, in, out_count);
733  return out_count;
734  }
735  else if(preout==postin) preout= midbuf= postin= out;
736  else if(preout==midbuf) preout= midbuf= out;
737  else preout= out;
738  }
739 
740  if(in != postin){
741  swri_audio_convert(s->in_convert, postin, in, in_count);
742  }
743 
744  if(s->resample_first){
745  if(postin != midbuf)
746  if ((out_count = resample(s, midbuf, out_count, postin, in_count)) < 0)
747  return out_count;
748  if(midbuf != preout)
749  swri_rematrix(s, preout, midbuf, out_count, preout==out);
750  }else{
751  if(postin != midbuf)
752  swri_rematrix(s, midbuf, postin, in_count, midbuf==out);
753  if(midbuf != preout)
754  if ((out_count = resample(s, preout, out_count, midbuf, in_count)) < 0)
755  return out_count;
756  }
757 
758  if(preout != out && out_count){
759  AudioData *conv_src = preout;
760  if(s->dither.method){
761  int ch;
762  int dither_count= FFMAX(out_count, 1<<16);
763 
764  if (preout == in) {
765  conv_src = &s->dither.temp;
766  if((ret=swri_realloc_audio(&s->dither.temp, dither_count))<0)
767  return ret;
768  }
769 
770  if((ret=swri_realloc_audio(&s->dither.noise, dither_count))<0)
771  return ret;
772  if(ret)
773  for(ch=0; ch<s->dither.noise.ch_count; ch++)
774  if((ret=swri_get_dither(s, s->dither.noise.ch[ch], s->dither.noise.count, (12345678913579ULL*ch + 3141592) % 2718281828U, s->dither.noise.fmt))<0)
775  return ret;
776  av_assert0(s->dither.noise.ch_count == preout->ch_count);
777 
778  if(s->dither.noise_pos + out_count > s->dither.noise.count)
779  s->dither.noise_pos = 0;
780 
781  if (s->dither.method < SWR_DITHER_NS){
782  if (s->mix_2_1_simd) {
783  int len1= out_count&~15;
784  int off = len1 * preout->bps;
785 
786  if(len1)
787  for(ch=0; ch<preout->ch_count; ch++)
788  s->mix_2_1_simd(conv_src->ch[ch], preout->ch[ch], s->dither.noise.ch[ch] + s->dither.noise.bps * s->dither.noise_pos, s->native_simd_one, 0, 0, len1);
789  if(out_count != len1)
790  for(ch=0; ch<preout->ch_count; ch++)
791  s->mix_2_1_f(conv_src->ch[ch] + off, preout->ch[ch] + off, s->dither.noise.ch[ch] + s->dither.noise.bps * s->dither.noise_pos + off, s->native_one, 0, 0, out_count - len1);
792  } else {
793  for(ch=0; ch<preout->ch_count; ch++)
794  s->mix_2_1_f(conv_src->ch[ch], preout->ch[ch], s->dither.noise.ch[ch] + s->dither.noise.bps * s->dither.noise_pos, s->native_one, 0, 0, out_count);
795  }
796  } else {
797  switch(s->int_sample_fmt) {
798  case AV_SAMPLE_FMT_S16P :swri_noise_shaping_int16(s, conv_src, preout, &s->dither.noise, out_count); break;
799  case AV_SAMPLE_FMT_S32P :swri_noise_shaping_int32(s, conv_src, preout, &s->dither.noise, out_count); break;
800  case AV_SAMPLE_FMT_FLTP :swri_noise_shaping_float(s, conv_src, preout, &s->dither.noise, out_count); break;
801  case AV_SAMPLE_FMT_DBLP :swri_noise_shaping_double(s,conv_src, preout, &s->dither.noise, out_count); break;
802  }
803  }
804  s->dither.noise_pos += out_count;
805  }
806 //FIXME packed doesn't need more than 1 chan here!
807  swri_audio_convert(s->out_convert, out, conv_src, out_count);
808  }
809  return out_count;
810 }
811 
813  return !!s->in_buffer.ch_count;
814 }
815 
816 int attribute_align_arg swr_convert(struct SwrContext *s,
817  uint8_t **out_arg, int out_count,
818  const uint8_t **in_arg, int in_count)
819 {
820  AudioData * in= &s->in;
821  AudioData *out= &s->out;
822  int av_unused max_output;
823 
824  if (!swr_is_initialized(s)) {
825  av_log(s, AV_LOG_ERROR, "Context has not been initialized\n");
826  return AVERROR(EINVAL);
827  }
828 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL >1
829  max_output = swr_get_out_samples(s, in_count);
830 #endif
831 
832  while(s->drop_output > 0){
833  int ret;
834  uint8_t *tmp_arg[SWR_CH_MAX];
835 #define MAX_DROP_STEP 16384
836  if((ret=swri_realloc_audio(&s->drop_temp, FFMIN(s->drop_output, MAX_DROP_STEP)))<0)
837  return ret;
838 
839  reversefill_audiodata(&s->drop_temp, tmp_arg);
840  s->drop_output *= -1; //FIXME find a less hackish solution
841  ret = swr_convert(s, tmp_arg, FFMIN(-s->drop_output, MAX_DROP_STEP), in_arg, in_count); //FIXME optimize but this is as good as never called so maybe it doesn't matter
842  s->drop_output *= -1;
843  in_count = 0;
844  if(ret>0) {
845  s->drop_output -= ret;
846  if (!s->drop_output && !out_arg)
847  return 0;
848  continue;
849  }
850 
851  av_assert0(s->drop_output);
852  return 0;
853  }
854 
855  if(!in_arg){
856  if(s->resample){
857  if (!s->flushed)
858  s->resampler->flush(s);
859  s->resample_in_constraint = 0;
860  s->flushed = 1;
861  }else if(!s->in_buffer_count){
862  return 0;
863  }
864  }else
865  fill_audiodata(in , (void*)in_arg);
866 
867  fill_audiodata(out, out_arg);
868 
869  if(s->resample){
870  int ret = swr_convert_internal(s, out, out_count, in, in_count);
871  if(ret>0 && !s->drop_output)
872  s->outpts += ret * (int64_t)s->in_sample_rate;
873 
874  av_assert2(max_output < 0 || ret <= max_output);
875 
876  return ret;
877  }else{
878  AudioData tmp= *in;
879  int ret2=0;
880  int ret, size;
881  size = FFMIN(out_count, s->in_buffer_count);
882  if(size){
883  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
885  if(ret<0)
886  return ret;
887  ret2= ret;
888  s->in_buffer_count -= ret;
889  s->in_buffer_index += ret;
890  buf_set(out, out, ret);
891  out_count -= ret;
892  if(!s->in_buffer_count)
893  s->in_buffer_index = 0;
894  }
895 
896  if(in_count){
897  size= s->in_buffer_index + s->in_buffer_count + in_count - out_count;
898 
899  if(in_count > out_count) { //FIXME move after swr_convert_internal
900  if( size > s->in_buffer.count
901  && s->in_buffer_count + in_count - out_count <= s->in_buffer_index){
902  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
903  copy(&s->in_buffer, &tmp, s->in_buffer_count);
904  s->in_buffer_index=0;
905  }else
906  if((ret=swri_realloc_audio(&s->in_buffer, size)) < 0)
907  return ret;
908  }
909 
910  if(out_count){
911  size = FFMIN(in_count, out_count);
913  if(ret<0)
914  return ret;
915  buf_set(in, in, ret);
916  in_count -= ret;
917  ret2 += ret;
918  }
919  if(in_count){
920  buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
921  copy(&tmp, in, in_count);
922  s->in_buffer_count += in_count;
923  }
924  }
925  if(ret2>0 && !s->drop_output)
926  s->outpts += ret2 * (int64_t)s->in_sample_rate;
927  av_assert2(max_output < 0 || ret2 < 0 || ret2 <= max_output);
928  return ret2;
929  }
930 }
931 
932 int swr_drop_output(struct SwrContext *s, int count){
933  const uint8_t *tmp_arg[SWR_CH_MAX];
934  s->drop_output += count;
935 
936  if(s->drop_output <= 0)
937  return 0;
938 
939  av_log(s, AV_LOG_VERBOSE, "discarding %d audio samples\n", count);
940  return swr_convert(s, NULL, s->drop_output, tmp_arg, 0);
941 }
942 
943 int swr_inject_silence(struct SwrContext *s, int count){
944  int ret, i;
945  uint8_t *tmp_arg[SWR_CH_MAX];
946 
947  if(count <= 0)
948  return 0;
949 
950 #define MAX_SILENCE_STEP 16384
951  while (count > MAX_SILENCE_STEP) {
953  return ret;
954  count -= MAX_SILENCE_STEP;
955  }
956 
957  if((ret=swri_realloc_audio(&s->silence, count))<0)
958  return ret;
959 
960  if(s->silence.planar) for(i=0; i<s->silence.ch_count; i++) {
961  memset(s->silence.ch[i], s->silence.bps==1 ? 0x80 : 0, count*s->silence.bps);
962  } else
963  memset(s->silence.ch[0], s->silence.bps==1 ? 0x80 : 0, count*s->silence.bps*s->silence.ch_count);
964 
965  reversefill_audiodata(&s->silence, tmp_arg);
966  av_log(s, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", count);
967  ret = swr_convert(s, NULL, 0, (const uint8_t**)tmp_arg, count);
968  return ret;
969 }
970 
971 int64_t swr_get_delay(struct SwrContext *s, int64_t base){
972  if (s->resampler && s->resample){
973  return s->resampler->get_delay(s, base);
974  }else{
975  return (s->in_buffer_count*base + (s->in_sample_rate>>1))/ s->in_sample_rate;
976  }
977 }
978 
979 int swr_get_out_samples(struct SwrContext *s, int in_samples)
980 {
981  int64_t out_samples;
982 
983  if (in_samples < 0)
984  return AVERROR(EINVAL);
985 
986  if (s->resampler && s->resample) {
987  if (!s->resampler->get_out_samples)
988  return AVERROR(ENOSYS);
989  out_samples = s->resampler->get_out_samples(s, in_samples);
990  } else {
991  out_samples = s->in_buffer_count + in_samples;
992  av_assert0(s->out_sample_rate == s->in_sample_rate);
993  }
994 
995  if (out_samples > INT_MAX)
996  return AVERROR(EINVAL);
997 
998  return out_samples;
999 }
1000 
1001 int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance){
1002  int ret;
1003 
1004  if (!s || compensation_distance < 0)
1005  return AVERROR(EINVAL);
1006  if (!compensation_distance && sample_delta)
1007  return AVERROR(EINVAL);
1008  if (!s->resample) {
1009  s->flags |= SWR_FLAG_RESAMPLE;
1010  ret = swr_init(s);
1011  if (ret < 0)
1012  return ret;
1013  }
1014  if (!s->resampler->set_compensation){
1015  return AVERROR(EINVAL);
1016  }else{
1017  return s->resampler->set_compensation(s->resample, sample_delta, compensation_distance);
1018  }
1019 }
1020 
1021 int64_t swr_next_pts(struct SwrContext *s, int64_t pts){
1022  if(pts == INT64_MIN)
1023  return s->outpts;
1024 
1025  if (s->firstpts == AV_NOPTS_VALUE)
1026  s->outpts = s->firstpts = pts;
1027 
1028  if(s->min_compensation >= FLT_MAX) {
1029  return (s->outpts = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate));
1030  } else {
1031  int64_t delta = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate) - s->outpts + s->drop_output*(int64_t)s->in_sample_rate;
1032  double fdelta = delta /(double)(s->in_sample_rate * (int64_t)s->out_sample_rate);
1033 
1034  if(fabs(fdelta) > s->min_compensation) {
1035  if(s->outpts == s->firstpts || fabs(fdelta) > s->min_hard_compensation){
1036  int ret;
1037  if(delta > 0) ret = swr_inject_silence(s, delta / s->out_sample_rate);
1038  else ret = swr_drop_output (s, -delta / s-> in_sample_rate);
1039  if(ret<0){
1040  av_log(s, AV_LOG_ERROR, "Failed to compensate for timestamp delta of %f\n", fdelta);
1041  }
1042  } else if(s->soft_compensation_duration && s->max_soft_compensation) {
1043  int duration = s->out_sample_rate * s->soft_compensation_duration;
1044  double max_soft_compensation = s->max_soft_compensation / (s->max_soft_compensation < 0 ? -s->in_sample_rate : 1);
1046  av_log(s, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n", fdelta, comp, duration);
1048  }
1049  }
1050 
1051  return s->outpts;
1052  }
1053 }
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
swr_convert_internal
static int swr_convert_internal(struct SwrContext *s, AudioData *out, int out_count, AudioData *in, int in_count)
Definition: swresample.c:682
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
opt.h
fill_audiodata
static void fill_audiodata(AudioData *out, uint8_t *in_arg[SWR_CH_MAX])
Definition: swresample.c:545
swri_noise_shaping_int16
void swri_noise_shaping_int16(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
out
FILE * out
Definition: movenc.c:54
SwrContext::in_sample_rate
int in_sample_rate
input sample rate
Definition: swresample_internal.h:104
free_temp
static void free_temp(AudioData *a)
Definition: swresample.c:143
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:86
swr_set_compensation
int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance)
Activate resampling compensation ("soft" compensation).
Definition: swresample.c:1001
AudioData::bps
int bps
bytes per sample
Definition: swresample_internal.h:49
av_unused
#define av_unused
Definition: attributes.h:131
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
SwrContext::out_sample_rate
int out_sample_rate
output sample rate
Definition: swresample_internal.h:105
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
SwrContext::out_ch_layout
AVChannelLayout out_ch_layout
output channel layout
Definition: swresample_internal.h:103
SwrContext::user_in_chlayout
AVChannelLayout user_in_chlayout
User set input channel layout.
Definition: swresample_internal.h:124
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:141
float.h
swr_set_channel_mapping
int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map)
Set a customized input channel mapping.
Definition: swresample.c:32
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:298
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
copy
static void copy(AudioData *out, AudioData *in, int count)
Definition: swresample.c:532
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:303
SwrContext::in_buffer_index
int in_buffer_index
cached buffer position
Definition: swresample_internal.h:160
swri_noise_shaping_float
void swri_noise_shaping_float(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
SWR_ENGINE_SOXR
@ SWR_ENGINE_SOXR
SoX Resampler.
Definition: swresample.h:168
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:637
buf_set
static void buf_set(AudioData *out, AudioData *in, int count)
out may be equal in.
Definition: swresample.c:572
AudioData
Definition: swresample_internal.h:45
SwrContext::out_sample_fmt
enum AVSampleFormat out_sample_fmt
output sample format
Definition: swresample_internal.h:101
fail
#define fail()
Definition: checkasm.h:133
swri_realloc_audio
int swri_realloc_audio(AudioData *a, int count)
Definition: swresample.c:500
MAX_SILENCE_STEP
#define MAX_SILENCE_STEP
swr_is_initialized
int swr_is_initialized(struct SwrContext *s)
Check whether an swr context has been initialized or not.
Definition: swresample.c:812
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:69
pts
static int64_t pts
Definition: transcode_aac.c:654
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:260
swr_next_pts
int64_t swr_next_pts(struct SwrContext *s, int64_t pts)
Convert the next timestamp from input to output timestamps are in 1/(in_sample_rate * out_sample_rate...
Definition: swresample.c:1021
swr_get_delay
int64_t swr_get_delay(struct SwrContext *s, int64_t base)
Gets the delay the next input sample will experience relative to the next output sample.
Definition: swresample.c:971
av_get_planar_sample_fmt
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
Definition: samplefmt.c:86
SwrContext::postin
AudioData postin
post-input audio data: used for rematrix/resample
Definition: swresample_internal.h:153
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
swr_inject_silence
int swr_inject_silence(struct SwrContext *s, int count)
Injects the specified number of silence samples.
Definition: swresample.c:943
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:112
swr_init
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:191
duration
int64_t duration
Definition: movenc.c:64
float
float
Definition: af_crystalizer.c:122
s
#define s(width, name)
Definition: cbs_vp9.c:256
SwrContext::user_out_chlayout
AVChannelLayout user_out_chlayout
User set output channel layout.
Definition: swresample_internal.h:125
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:106
swr_alloc
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:167
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
swri_rematrix
int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy)
Definition: rematrix.c:582
SWR_DITHER_NS
@ SWR_DITHER_NS
not part of API/ABI
Definition: swresample.h:154
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AudioData::planar
int planar
1 if planar audio, 0 otherwise
Definition: swresample_internal.h:51
SwrContext::in_convert
struct AudioConvert * in_convert
input conversion context
Definition: swresample_internal.h:169
swri_audio_convert
int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len)
Convert between audio sample formats.
av_get_sample_fmt_name
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:51
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
AudioData::data
uint8_t * data
samples buffer
Definition: swresample_internal.h:47
AudioData::ch
uint8_t * ch[SWR_CH_MAX]
samples buffer per channel
Definition: swresample_internal.h:46
if
if(ret)
Definition: filter_design.txt:179
SwrContext::in_ch_layout
AVChannelLayout in_ch_layout
input channel layout
Definition: swresample_internal.h:102
swri_noise_shaping_int32
void swri_noise_shaping_int32(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
SwrContext::midbuf
AudioData midbuf
intermediate audio data (postin/preout)
Definition: swresample_internal.h:154
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
reversefill_audiodata
static void reversefill_audiodata(AudioData *out, uint8_t *in_arg[SWR_CH_MAX])
Definition: swresample.c:558
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:930
SwrContext::log_ctx
void * log_ctx
parent logging context
Definition: swresample_internal.h:98
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:960
double
double
Definition: af_crystalizer.c:132
av_clipf
av_clipf
Definition: af_crystalizer.c:122
resample
static int resample(SwrContext *s, AudioData *out_param, int out_count, const AudioData *in_param, int in_count)
Definition: swresample.c:587
swri_soxr_resampler
struct Resampler const swri_soxr_resampler
Definition: soxr_resample.c:126
ALIGN
#define ALIGN
Definition: swresample.c:30
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:624
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
AudioData::ch_count
int ch_count
number of channels
Definition: swresample_internal.h:48
swr_alloc_set_opts2
int swr_alloc_set_opts2(struct SwrContext **ps, const AVChannelLayout *out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, const AVChannelLayout *in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
Definition: swresample.c:85
AV_SAMPLE_FMT_NB
@ AV_SAMPLE_FMT_NB
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:71
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:293
SwrContext::preout
AudioData preout
pre-output audio data: used for rematrix/resample
Definition: swresample_internal.h:155
av_opt_set_chlayout
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)
Definition: opt.c:786
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:318
SWR_FLAG_RESAMPLE
#define SWR_FLAG_RESAMPLE
Force resampling even if equal sample rate.
Definition: swresample.h:143
swr_drop_output
int swr_drop_output(struct SwrContext *s, int count)
Drops the specified number of output samples.
Definition: swresample.c:932
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:173
swr_convert
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t **out_arg, int out_count, const uint8_t **in_arg, int in_count)
Convert audio.
Definition: swresample.c:816
swri_rematrix_free
av_cold void swri_rematrix_free(SwrContext *s)
Definition: rematrix.c:575
SWR_ENGINE_SWR
@ SWR_ENGINE_SWR
SW Resampler.
Definition: swresample.h:167
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
swresample_internal.h
swri_audio_convert_alloc
AudioConvert * swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags)
Create an audio sample format converter context.
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
internal.h
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:904
swri_get_dither
int swri_get_dither(SwrContext *s, void *dst, int len, unsigned seed, enum AVSampleFormat noise_fmt)
Definition: dither.c:26
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
SwrContext::max_soft_compensation
float max_soft_compensation
swr maximum soft compensation in seconds over soft_compensation_duration
Definition: swresample_internal.h:144
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
swri_dither_init
av_cold int swri_dither_init(SwrContext *s, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt)
Definition: dither.c:79
swri_noise_shaping_double
void swri_noise_shaping_double(SwrContext *s, AudioData *dsts, const AudioData *srcs, const AudioData *noises, int count)
clear_context
static void clear_context(SwrContext *s)
Definition: swresample.c:148
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:389
ret
ret
Definition: filter_design.txt:187
RSC
#define RSC
SwrContext::in_sample_fmt
enum AVSampleFormat in_sample_fmt
input sample format
Definition: swresample_internal.h:99
set_audiodata_fmt
static void set_audiodata_fmt(AudioData *a, enum AVSampleFormat fmt)
Definition: swresample.c:135
U
#define U(x)
Definition: vpx_arith.h:37
AudioData::fmt
enum AVSampleFormat fmt
sample format
Definition: swresample_internal.h:52
channel_layout.h
MAX_DROP_STEP
#define MAX_DROP_STEP
swri_audio_convert_free
void swri_audio_convert_free(AudioConvert **ctx)
Free audio sample format converter context.
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:776
swri_rematrix_init
av_cold int swri_rematrix_init(SwrContext *s)
Definition: rematrix.c:469
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
swr_get_out_samples
int swr_get_out_samples(struct SwrContext *s, int in_samples)
Find an upper bound on the number of samples that the next swr_convert call will output,...
Definition: swresample.c:979
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
SwrContext::in
AudioData in
input audio data
Definition: swresample_internal.h:152
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
swr_close
av_cold void swr_close(SwrContext *s)
Closes the context so that swr_is_initialized() returns 0.
Definition: swresample.c:187
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SWR_CH_MAX
#define SWR_CH_MAX
Definition: swresample.c:35
swri_resampler
struct Resampler const swri_resampler
Definition: resample.c:608
audioconvert.h