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/mem.h"
22 #include "libavutil/opt.h"
23 #include "swresample_internal.h"
24 #include "audioconvert.h"
25 #include "libavutil/avassert.h"
27 #include "libavutil/internal.h"
28 
29 #include <float.h>
30 
31 #define ALIGN 32
32 
34  if(!s || s->in_convert) // s needs to be allocated but not initialized
35  return AVERROR(EINVAL);
36  s->channel_map = channel_map;
37  return 0;
38 }
39 
41  const AVChannelLayout *out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
42  const AVChannelLayout *in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate,
43  int log_offset, void *log_ctx) {
44  struct SwrContext *s = *ps;
45  int ret;
46 
47  if (!s) s = swr_alloc();
48  if (!s) return AVERROR(ENOMEM);
49 
50  *ps = s;
51 
52  s->log_level_offset = log_offset;
53  s->log_ctx = log_ctx;
54 
55  if ((ret = av_opt_set_chlayout(s, "ochl", out_ch_layout, 0)) < 0)
56  goto fail;
57 
58  if ((ret = av_opt_set_int(s, "osf", out_sample_fmt, 0)) < 0)
59  goto fail;
60 
61  if ((ret = av_opt_set_int(s, "osr", out_sample_rate, 0)) < 0)
62  goto fail;
63 
64  if ((ret = av_opt_set_chlayout(s, "ichl", in_ch_layout, 0)) < 0)
65  goto fail;
66 
67  if ((ret = av_opt_set_int(s, "isf", in_sample_fmt, 0)) < 0)
68  goto fail;
69 
70  if ((ret = av_opt_set_int(s, "isr", in_sample_rate, 0)) < 0)
71  goto fail;
72 
73  av_opt_set_int(s, "uch", 0, 0);
74 
75  return 0;
76 fail:
77  av_log(s, AV_LOG_ERROR, "Failed to set option\n");
78  swr_free(ps);
79  return ret;
80 }
81 
82 static void set_audiodata_fmt(AudioData *a, enum AVSampleFormat fmt){
83  a->fmt = fmt;
84  a->bps = av_get_bytes_per_sample(fmt);
85  a->planar= av_sample_fmt_is_planar(fmt);
86  if (a->ch_count == 1)
87  a->planar = 1;
88 }
89 
90 static void free_temp(AudioData *a){
91  av_free(a->data);
92  memset(a, 0, sizeof(*a));
93 }
94 
95 static void clear_context(SwrContext *s){
96  s->in_buffer_index= 0;
97  s->in_buffer_count= 0;
98  s->resample_in_constraint= 0;
99  memset(s->in.ch, 0, sizeof(s->in.ch));
100  memset(s->out.ch, 0, sizeof(s->out.ch));
101  free_temp(&s->postin);
102  free_temp(&s->midbuf);
103  free_temp(&s->preout);
104  free_temp(&s->in_buffer);
105  free_temp(&s->silence);
106  free_temp(&s->drop_temp);
107  free_temp(&s->dither.noise);
108  free_temp(&s->dither.temp);
109  av_channel_layout_uninit(&s->in_ch_layout);
110  av_channel_layout_uninit(&s->out_ch_layout);
111  av_channel_layout_uninit(&s->used_ch_layout);
113  swri_audio_convert_free(&s->out_convert);
114  swri_audio_convert_free(&s->full_convert);
116 
117  s->delayed_samples_fixup = 0;
118  s->flushed = 0;
119 }
120 
122  SwrContext *s= *ss;
123  if(s){
124  clear_context(s);
125  av_channel_layout_uninit(&s->user_in_chlayout);
126  av_channel_layout_uninit(&s->user_out_chlayout);
127  av_channel_layout_uninit(&s->user_used_chlayout);
128 
129  if (s->resampler)
130  s->resampler->free(&s->resample);
131  }
132 
133  av_freep(ss);
134 }
135 
137  clear_context(s);
138 }
139 
141  int ret;
142  char l1[1024], l2[1024];
143 
144  clear_context(s);
145 
146  if((unsigned) s-> in_sample_fmt >= AV_SAMPLE_FMT_NB){
147  av_log(s, AV_LOG_ERROR, "Requested input sample format %d is invalid\n", s->in_sample_fmt);
148  return AVERROR(EINVAL);
149  }
150  if((unsigned) s->out_sample_fmt >= AV_SAMPLE_FMT_NB){
151  av_log(s, AV_LOG_ERROR, "Requested output sample format %d is invalid\n", s->out_sample_fmt);
152  return AVERROR(EINVAL);
153  }
154 
155  if(s-> in_sample_rate <= 0){
156  av_log(s, AV_LOG_ERROR, "Requested input sample rate %d is invalid\n", s->in_sample_rate);
157  return AVERROR(EINVAL);
158  }
159  if(s->out_sample_rate <= 0){
160  av_log(s, AV_LOG_ERROR, "Requested output sample rate %d is invalid\n", s->out_sample_rate);
161  return AVERROR(EINVAL);
162  }
163 
164  s->out.ch_count = s-> user_out_chlayout.nb_channels;
166 
167  if (!(ret = av_channel_layout_check(&s->user_in_chlayout)) || s->user_in_chlayout.nb_channels > SWR_CH_MAX) {
168  if (ret)
169  av_channel_layout_describe(&s->user_in_chlayout, l1, sizeof(l1));
170  av_log(s, AV_LOG_WARNING, "Input channel layout \"%s\" is invalid or unsupported.\n", ret ? l1 : "");
171  return AVERROR(EINVAL);
172  }
173 
174  if (!(ret = av_channel_layout_check(&s->user_out_chlayout)) || s->user_out_chlayout.nb_channels > SWR_CH_MAX) {
175  if (ret)
176  av_channel_layout_describe(&s->user_out_chlayout, l2, sizeof(l2));
177  av_log(s, AV_LOG_WARNING, "Output channel layout \"%s\" is invalid or unsupported.\n", ret ? l2 : "");
178  return AVERROR(EINVAL);
179  }
180 
181  ret = av_channel_layout_copy(&s->in_ch_layout, &s->user_in_chlayout);
182  ret |= av_channel_layout_copy(&s->out_ch_layout, &s->user_out_chlayout);
183  ret |= av_channel_layout_copy(&s->used_ch_layout, &s->user_used_chlayout);
184  if (ret < 0)
185  return ret;
186 
187  s->int_sample_fmt= s->user_int_sample_fmt;
188 
189  s->dither.method = s->user_dither_method;
190 
191  switch(s->engine){
192 #if CONFIG_LIBSOXR
193  case SWR_ENGINE_SOXR: s->resampler = &swri_soxr_resampler; break;
194 #endif
195  case SWR_ENGINE_SWR : s->resampler = &swri_resampler; break;
196  default:
197  av_log(s, AV_LOG_ERROR, "Requested resampling engine is unavailable\n");
198  return AVERROR(EINVAL);
199  }
200 
201  if (!av_channel_layout_check(&s->used_ch_layout))
202  av_channel_layout_default(&s->used_ch_layout, s->in.ch_count);
203 
204  if (s->used_ch_layout.nb_channels != s->in_ch_layout.nb_channels)
205  av_channel_layout_uninit(&s->in_ch_layout);
206 
207  if (s->used_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
208  av_channel_layout_default(&s->used_ch_layout, s->used_ch_layout.nb_channels);
209  if (s->in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC) {
210  ret = av_channel_layout_copy(&s->in_ch_layout, &s->used_ch_layout);
211  if (ret < 0)
212  return ret;
213  }
214  if (s->out_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC)
215  av_channel_layout_default(&s->out_ch_layout, s->out.ch_count);
216 
217  s->rematrix = av_channel_layout_compare(&s->out_ch_layout, &s->in_ch_layout) ||
218  s->rematrix_volume!=1.0 ||
219  s->rematrix_custom;
220 
221  if(s->int_sample_fmt == AV_SAMPLE_FMT_NONE){
222  // 16bit or less to 16bit or less with the same sample rate
224  && av_get_bytes_per_sample(s->out_sample_fmt) <= 2
225  && s->out_sample_rate==s->in_sample_rate) {
226  s->int_sample_fmt= AV_SAMPLE_FMT_S16P;
227  // 8 -> 8, 16->8, 8->16bit
229  +av_get_bytes_per_sample(s->out_sample_fmt) <= 3 ) {
230  s->int_sample_fmt= AV_SAMPLE_FMT_S16P;
231  }else if( av_get_bytes_per_sample(s-> in_sample_fmt) <= 2
232  && !s->rematrix
233  && s->out_sample_rate==s->in_sample_rate
234  && !(s->flags & SWR_FLAG_RESAMPLE)){
235  s->int_sample_fmt= AV_SAMPLE_FMT_S16P;
237  && av_get_planar_sample_fmt(s->out_sample_fmt) == AV_SAMPLE_FMT_S32P
238  && !s->rematrix
239  && s->out_sample_rate == s->in_sample_rate
240  && !(s->flags & SWR_FLAG_RESAMPLE)
241  && s->engine != SWR_ENGINE_SOXR){
242  s->int_sample_fmt= AV_SAMPLE_FMT_S32P;
243  }else if(av_get_bytes_per_sample(s->in_sample_fmt) <= 4){
244  s->int_sample_fmt= AV_SAMPLE_FMT_FLTP;
245  }else{
246  s->int_sample_fmt= AV_SAMPLE_FMT_DBLP;
247  }
248  }
249  av_log(s, AV_LOG_DEBUG, "Using %s internally between filters\n", av_get_sample_fmt_name(s->int_sample_fmt));
250 
251  if( s->int_sample_fmt != AV_SAMPLE_FMT_S16P
252  &&s->int_sample_fmt != AV_SAMPLE_FMT_S32P
253  &&s->int_sample_fmt != AV_SAMPLE_FMT_S64P
254  &&s->int_sample_fmt != AV_SAMPLE_FMT_FLTP
255  &&s->int_sample_fmt != AV_SAMPLE_FMT_DBLP){
256  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));
257  return AVERROR(EINVAL);
258  }
259 
261  set_audiodata_fmt(&s->out, s->out_sample_fmt);
262 
263  if (s->firstpts_in_samples != AV_NOPTS_VALUE) {
264  if (!s->async && s->min_compensation >= FLT_MAX/2)
265  s->async = 1;
266  if (s->firstpts == AV_NOPTS_VALUE)
267  s->firstpts =
268  s->outpts = s->firstpts_in_samples * s->out_sample_rate;
269  } else
270  s->firstpts = AV_NOPTS_VALUE;
271 
272  if (s->async) {
273  if (s->min_compensation >= FLT_MAX/2)
274  s->min_compensation = 0.001;
275  if (s->async > 1.0001) {
276  s->max_soft_compensation = s->async / (double) s->in_sample_rate;
277  }
278  }
279 
280  if (s->out_sample_rate!=s->in_sample_rate || (s->flags & SWR_FLAG_RESAMPLE)){
281  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);
282  if (!s->resample) {
283  av_log(s, AV_LOG_ERROR, "Failed to initialize resampler\n");
284  return AVERROR(ENOMEM);
285  }
286  }else
287  s->resampler->free(&s->resample);
288  if( s->int_sample_fmt != AV_SAMPLE_FMT_S16P
289  && s->int_sample_fmt != AV_SAMPLE_FMT_S32P
290  && s->int_sample_fmt != AV_SAMPLE_FMT_FLTP
291  && s->int_sample_fmt != AV_SAMPLE_FMT_DBLP
292  && s->resample){
293  av_log(s, AV_LOG_ERROR, "Resampling only supported with internal s16p/s32p/fltp/dblp\n");
294  ret = AVERROR(EINVAL);
295  goto fail;
296  }
297 
298 #define RSC 1 //FIXME finetune
299  if(!s-> in.ch_count)
300  s-> in.ch_count = s->in_ch_layout.nb_channels;
301  if (!av_channel_layout_check(&s->used_ch_layout))
302  av_channel_layout_default(&s->used_ch_layout, s->in.ch_count);
303  if(!s->out.ch_count)
304  s->out.ch_count = s->out_ch_layout.nb_channels;
305 
306  if(!s-> in.ch_count){
307  av_assert0(s->in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC);
308  av_log(s, AV_LOG_ERROR, "Input channel count and layout are unset\n");
309  ret = AVERROR(EINVAL);
310  goto fail;
311  }
312 
313  av_channel_layout_describe(&s->out_ch_layout, l2, sizeof(l2));
314  av_channel_layout_describe(&s->in_ch_layout, l1, sizeof(l1));
315  if (s->in_ch_layout.order != AV_CHANNEL_ORDER_UNSPEC && s->used_ch_layout.nb_channels != s->in_ch_layout.nb_channels) {
316  av_log(s, AV_LOG_ERROR, "Input channel layout %s mismatches specified channel count %d\n", l1, s->used_ch_layout.nb_channels);
317  ret = AVERROR(EINVAL);
318  goto fail;
319  }
320 
321  if (( s->out_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC
322  || s-> in_ch_layout.order == AV_CHANNEL_ORDER_UNSPEC) && s->used_ch_layout.nb_channels != s->out.ch_count && !s->rematrix_custom) {
323  av_log(s, AV_LOG_ERROR, "Rematrix is needed between %s and %s "
324  "but there is not enough information to do it\n", l1, l2);
325  ret = AVERROR(EINVAL);
326  goto fail;
327  }
328 
329 av_assert0(s->used_ch_layout.nb_channels);
330 av_assert0(s->out.ch_count);
331  s->resample_first= RSC*s->out.ch_count/s->used_ch_layout.nb_channels - RSC < s->out_sample_rate/(float)s-> in_sample_rate - 1.0;
332 
333  s->in_buffer= s->in;
334  s->silence = s->in;
335  s->drop_temp= s->out;
336 
337  if ((ret = swri_dither_init(s, s->out_sample_fmt, s->int_sample_fmt)) < 0)
338  goto fail;
339 
340  if(!s->resample && !s->rematrix && !s->channel_map && !s->dither.method){
341  s->full_convert = swri_audio_convert_alloc(s->out_sample_fmt,
342  s-> in_sample_fmt, s-> in.ch_count, NULL, 0);
343  return 0;
344  }
345 
346  s->in_convert = swri_audio_convert_alloc(s->int_sample_fmt,
347  s-> in_sample_fmt, s->used_ch_layout.nb_channels, s->channel_map, 0);
348  s->out_convert= swri_audio_convert_alloc(s->out_sample_fmt,
349  s->int_sample_fmt, s->out.ch_count, NULL, 0);
350 
351  if (!s->in_convert || !s->out_convert) {
352  ret = AVERROR(ENOMEM);
353  goto fail;
354  }
355 
356  s->postin= s->in;
357  s->preout= s->out;
358  s->midbuf= s->in;
359 
360  if(s->channel_map){
361  s->postin.ch_count=
362  s->midbuf.ch_count= s->used_ch_layout.nb_channels;
363  if(s->resample)
364  s->in_buffer.ch_count= s->used_ch_layout.nb_channels;
365  }
366  if(!s->resample_first){
367  s->midbuf.ch_count= s->out.ch_count;
368  if(s->resample)
369  s->in_buffer.ch_count = s->out.ch_count;
370  }
371 
372  set_audiodata_fmt(&s->postin, s->int_sample_fmt);
373  set_audiodata_fmt(&s->midbuf, s->int_sample_fmt);
374  set_audiodata_fmt(&s->preout, s->int_sample_fmt);
375 
376  if(s->resample){
377  set_audiodata_fmt(&s->in_buffer, s->int_sample_fmt);
378  }
379 
380  av_assert0(!s->preout.count);
381  s->dither.noise = s->preout;
382  s->dither.temp = s->preout;
383  if (s->dither.method > SWR_DITHER_NS) {
384  s->dither.noise.bps = 4;
385  s->dither.noise.fmt = AV_SAMPLE_FMT_FLTP;
386  s->dither.noise_scale = 1;
387  }
388 
389  if(s->rematrix || s->dither.method) {
391  if (ret < 0)
392  goto fail;
393  }
394 
395  return 0;
396 fail:
397  swr_close(s);
398  return ret;
399 
400 }
401 
402 int swri_realloc_audio(AudioData *a, int count){
403  int i, countb;
404  AudioData old;
405 
406  if(count < 0 || count > INT_MAX/2/a->bps/a->ch_count)
407  return AVERROR(EINVAL);
408 
409  if(a->count >= count)
410  return 0;
411 
412  count*=2;
413 
414  countb= FFALIGN(count*a->bps, ALIGN);
415  old= *a;
416 
417  av_assert0(a->bps);
418  av_assert0(a->ch_count);
419 
420  a->data = av_calloc(countb, a->ch_count);
421  if(!a->data)
422  return AVERROR(ENOMEM);
423  for(i=0; i<a->ch_count; i++){
424  a->ch[i]= a->data + i*(a->planar ? countb : a->bps);
425  if(a->count && a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);
426  }
427  if(a->count && !a->planar) memcpy(a->ch[0], old.ch[0], a->count*a->ch_count*a->bps);
428  av_freep(&old.data);
429  a->count= count;
430 
431  return 1;
432 }
433 
434 static void copy(AudioData *out, AudioData *in,
435  int count){
436  av_assert0(out->planar == in->planar);
437  av_assert0(out->bps == in->bps);
438  av_assert0(out->ch_count == in->ch_count);
439  if(out->planar){
440  int ch;
441  for(ch=0; ch<out->ch_count; ch++)
442  memcpy(out->ch[ch], in->ch[ch], count*out->bps);
443  }else
444  memcpy(out->ch[0], in->ch[0], count*out->ch_count*out->bps);
445 }
446 
447 static void fill_audiodata(AudioData *out, uint8_t *const in_arg [SWR_CH_MAX])
448 {
449  int i;
450  if(!in_arg){
451  memset(out->ch, 0, sizeof(out->ch));
452  }else if(out->planar){
453  for(i=0; i<out->ch_count; i++)
454  out->ch[i]= in_arg[i];
455  }else{
456  for(i=0; i<out->ch_count; i++)
457  out->ch[i]= in_arg[0] + i*out->bps;
458  }
459 }
460 
461 static void reversefill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){
462  int i;
463  if(out->planar){
464  for(i=0; i<out->ch_count; i++)
465  in_arg[i]= out->ch[i];
466  }else{
467  in_arg[0]= out->ch[0];
468  }
469 }
470 
471 /**
472  *
473  * out may be equal in.
474  */
475 static void buf_set(AudioData *out, AudioData *in, int count){
476  int ch;
477  if(in->planar){
478  for(ch=0; ch<out->ch_count; ch++)
479  out->ch[ch]= in->ch[ch] + count*out->bps;
480  }else{
481  for(ch=out->ch_count-1; ch>=0; ch--)
482  out->ch[ch]= in->ch[0] + (ch + count*out->ch_count) * out->bps;
483  }
484 }
485 
486 /**
487  *
488  * @return number of samples output per channel
489  */
490 static int resample(SwrContext *s, AudioData *out_param, int out_count,
491  const AudioData * in_param, int in_count){
492  AudioData in, out, tmp;
493  int ret_sum=0;
494  int border=0;
495  int padless = ARCH_X86 && s->engine == SWR_ENGINE_SWR ? 7 : 0;
496 
497  av_assert1(s->in_buffer.ch_count == in_param->ch_count);
498  av_assert1(s->in_buffer.planar == in_param->planar);
499  av_assert1(s->in_buffer.fmt == in_param->fmt);
500 
501  tmp=out=*out_param;
502  in = *in_param;
503 
504  border = s->resampler->invert_initial_buffer(s->resample, &s->in_buffer,
505  &in, in_count, &s->in_buffer_index, &s->in_buffer_count);
506  if (border == INT_MAX) {
507  return 0;
508  } else if (border < 0) {
509  return border;
510  } else if (border) {
511  buf_set(&in, &in, border);
512  in_count -= border;
513  s->resample_in_constraint = 0;
514  }
515 
516  do{
517  int ret, size, consumed;
518  if(!s->resample_in_constraint && s->in_buffer_count){
519  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
520  ret= s->resampler->multiple_resample(s->resample, &out, out_count, &tmp, s->in_buffer_count, &consumed);
521  out_count -= ret;
522  ret_sum += ret;
523  buf_set(&out, &out, ret);
524  s->in_buffer_count -= consumed;
525  s->in_buffer_index += consumed;
526 
527  if(!in_count)
528  break;
529  if(s->in_buffer_count <= border){
530  buf_set(&in, &in, -s->in_buffer_count);
531  in_count += s->in_buffer_count;
532  s->in_buffer_count=0;
533  s->in_buffer_index=0;
534  border = 0;
535  }
536  }
537 
538  if((s->flushed || in_count > padless) && !s->in_buffer_count){
539  s->in_buffer_index=0;
540  ret= s->resampler->multiple_resample(s->resample, &out, out_count, &in, FFMAX(in_count-padless, 0), &consumed);
541  out_count -= ret;
542  ret_sum += ret;
543  buf_set(&out, &out, ret);
544  in_count -= consumed;
545  buf_set(&in, &in, consumed);
546  }
547 
548  //TODO is this check sane considering the advanced copy avoidance below
549  size= s->in_buffer_index + s->in_buffer_count + in_count;
550  if( size > s->in_buffer.count
551  && s->in_buffer_count + in_count <= s->in_buffer_index){
552  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
553  copy(&s->in_buffer, &tmp, s->in_buffer_count);
554  s->in_buffer_index=0;
555  }else
556  if((ret=swri_realloc_audio(&s->in_buffer, size)) < 0)
557  return ret;
558 
559  if(in_count){
560  int count= in_count;
561  if(s->in_buffer_count && s->in_buffer_count+2 < count && out_count) count= s->in_buffer_count+2;
562 
563  buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
564  copy(&tmp, &in, /*in_*/count);
565  s->in_buffer_count += count;
566  in_count -= count;
567  border += count;
568  buf_set(&in, &in, count);
569  s->resample_in_constraint= 0;
570  if(s->in_buffer_count != count || in_count)
571  continue;
572  if (padless) {
573  padless = 0;
574  continue;
575  }
576  }
577  break;
578  }while(1);
579 
580  s->resample_in_constraint= !!out_count;
581 
582  return ret_sum;
583 }
584 
585 static int swr_convert_internal(struct SwrContext *s, AudioData *out, int out_count,
586  AudioData *in , int in_count){
588  int ret/*, in_max*/;
589  AudioData preout_tmp, midbuf_tmp;
590 
591  if(s->full_convert){
592  av_assert0(!s->resample);
593  swri_audio_convert(s->full_convert, out, in, in_count);
594  return out_count;
595  }
596 
597 // in_max= out_count*(int64_t)s->in_sample_rate / s->out_sample_rate + resample_filter_taps;
598 // in_count= FFMIN(in_count, in_in + 2 - s->hist_buffer_count);
599 
600  if((ret=swri_realloc_audio(&s->postin, in_count))<0)
601  return ret;
602  if(s->resample_first){
603  av_assert0(s->midbuf.ch_count == s->used_ch_layout.nb_channels);
604  if((ret=swri_realloc_audio(&s->midbuf, out_count))<0)
605  return ret;
606  }else{
607  av_assert0(s->midbuf.ch_count == s->out.ch_count);
608  if((ret=swri_realloc_audio(&s->midbuf, in_count))<0)
609  return ret;
610  }
611  if((ret=swri_realloc_audio(&s->preout, out_count))<0)
612  return ret;
613 
614  postin= &s->postin;
615 
616  midbuf_tmp= s->midbuf;
617  midbuf= &midbuf_tmp;
618  preout_tmp= s->preout;
619  preout= &preout_tmp;
620 
621  if(s->int_sample_fmt == s-> in_sample_fmt && s->in.planar && !s->channel_map)
622  postin= in;
623 
624  if(s->resample_first ? !s->resample : !s->rematrix)
625  midbuf= postin;
626 
627  if(s->resample_first ? !s->rematrix : !s->resample)
628  preout= midbuf;
629 
630  if(s->int_sample_fmt == s->out_sample_fmt && s->out.planar
631  && !(s->out_sample_fmt==AV_SAMPLE_FMT_S32P && (s->dither.output_sample_bits&31))){
632  if(preout==in){
633  out_count= FFMIN(out_count, in_count); //TODO check at the end if this is needed or redundant
634  av_assert0(s->in.planar); //we only support planar internally so it has to be, we support copying non planar though
635  copy(out, in, out_count);
636  return out_count;
637  }
638  else if(preout==postin) preout= midbuf= postin= out;
639  else if(preout==midbuf) preout= midbuf= out;
640  else preout= out;
641  }
642 
643  if(in != postin){
644  swri_audio_convert(s->in_convert, postin, in, in_count);
645  }
646 
647  if(s->resample_first){
648  if(postin != midbuf)
649  if ((out_count = resample(s, midbuf, out_count, postin, in_count)) < 0)
650  return out_count;
651  if(midbuf != preout)
652  swri_rematrix(s, preout, midbuf, out_count, preout==out);
653  }else{
654  if(postin != midbuf)
655  swri_rematrix(s, midbuf, postin, in_count, midbuf==out);
656  if(midbuf != preout)
657  if ((out_count = resample(s, preout, out_count, midbuf, in_count)) < 0)
658  return out_count;
659  }
660 
661  if(preout != out && out_count){
662  AudioData *conv_src = preout;
663  if(s->dither.method){
664  int ch;
665  int dither_count= FFMAX(out_count, 1<<16);
666 
667  if (preout == in) {
668  conv_src = &s->dither.temp;
669  if((ret=swri_realloc_audio(&s->dither.temp, dither_count))<0)
670  return ret;
671  }
672 
673  if((ret=swri_realloc_audio(&s->dither.noise, dither_count))<0)
674  return ret;
675  if(ret)
676  for(ch=0; ch<s->dither.noise.ch_count; ch++)
677  if((ret=swri_get_dither(s, s->dither.noise.ch[ch], s->dither.noise.count, (12345678913579ULL*ch + 3141592) % 2718281828U, s->dither.noise.fmt))<0)
678  return ret;
679  av_assert0(s->dither.noise.ch_count == preout->ch_count);
680 
681  if(s->dither.noise_pos + out_count > s->dither.noise.count)
682  s->dither.noise_pos = 0;
683 
684  if (s->dither.method < SWR_DITHER_NS){
685  if (s->mix_2_1_simd) {
686  int len1= out_count&~15;
687  int off = len1 * preout->bps;
688 
689  if(len1)
690  for(ch=0; ch<preout->ch_count; ch++)
691  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);
692  if(out_count != len1)
693  for(ch=0; ch<preout->ch_count; ch++)
694  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);
695  } else {
696  for(ch=0; ch<preout->ch_count; ch++)
697  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);
698  }
699  } else {
700  switch(s->int_sample_fmt) {
701  case AV_SAMPLE_FMT_S16P :swri_noise_shaping_int16(s, conv_src, preout, &s->dither.noise, out_count); break;
702  case AV_SAMPLE_FMT_S32P :swri_noise_shaping_int32(s, conv_src, preout, &s->dither.noise, out_count); break;
703  case AV_SAMPLE_FMT_FLTP :swri_noise_shaping_float(s, conv_src, preout, &s->dither.noise, out_count); break;
704  case AV_SAMPLE_FMT_DBLP :swri_noise_shaping_double(s,conv_src, preout, &s->dither.noise, out_count); break;
705  }
706  }
707  s->dither.noise_pos += out_count;
708  }
709 //FIXME packed doesn't need more than 1 chan here!
710  swri_audio_convert(s->out_convert, out, conv_src, out_count);
711  }
712  return out_count;
713 }
714 
716  return !!s->in_buffer.ch_count;
717 }
718 
720  uint8_t * const *out_arg, int out_count,
721  const uint8_t * const *in_arg, int in_count)
722 {
723  AudioData * in= &s->in;
724  AudioData *out= &s->out;
725  int av_unused max_output;
726 
727  if (!swr_is_initialized(s)) {
728  av_log(s, AV_LOG_ERROR, "Context has not been initialized\n");
729  return AVERROR(EINVAL);
730  }
731 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL >1
732  max_output = swr_get_out_samples(s, in_count);
733 #endif
734 
735  while(s->drop_output > 0){
736  int ret;
737  uint8_t *tmp_arg[SWR_CH_MAX];
738 #define MAX_DROP_STEP 16384
739  if((ret=swri_realloc_audio(&s->drop_temp, FFMIN(s->drop_output, MAX_DROP_STEP)))<0)
740  return ret;
741 
742  reversefill_audiodata(&s->drop_temp, tmp_arg);
743  s->drop_output *= -1; //FIXME find a less hackish solution
744  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
745  s->drop_output *= -1;
746  in_count = 0;
747  if(ret>0) {
748  s->drop_output -= ret;
749  if (!s->drop_output && !out_arg)
750  return 0;
751  continue;
752  }
753 
754  av_assert0(s->drop_output);
755  return 0;
756  }
757 
758  if(!in_arg){
759  if(s->resample){
760  if (!s->flushed)
761  s->resampler->flush(s);
762  s->resample_in_constraint = 0;
763  s->flushed = 1;
764  }else if(!s->in_buffer_count){
765  return 0;
766  }
767  }else
768  fill_audiodata(in , (void*)in_arg);
769 
770  fill_audiodata(out, out_arg);
771 
772  if(s->resample){
773  int ret = swr_convert_internal(s, out, out_count, in, in_count);
774  if(ret>0 && !s->drop_output)
775  s->outpts += ret * (int64_t)s->in_sample_rate;
776 
777  av_assert2(max_output < 0 || ret <= max_output);
778 
779  return ret;
780  }else{
781  AudioData tmp= *in;
782  int ret2=0;
783  int ret, size;
784  size = FFMIN(out_count, s->in_buffer_count);
785  if(size){
786  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
788  if(ret<0)
789  return ret;
790  ret2= ret;
791  s->in_buffer_count -= ret;
792  s->in_buffer_index += ret;
793  buf_set(out, out, ret);
794  out_count -= ret;
795  if(!s->in_buffer_count)
796  s->in_buffer_index = 0;
797  }
798 
799  if(in_count){
800  size= s->in_buffer_index + s->in_buffer_count + in_count - out_count;
801 
802  if(in_count > out_count) { //FIXME move after swr_convert_internal
803  if( size > s->in_buffer.count
804  && s->in_buffer_count + in_count - out_count <= s->in_buffer_index){
805  buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
806  copy(&s->in_buffer, &tmp, s->in_buffer_count);
807  s->in_buffer_index=0;
808  }else
809  if((ret=swri_realloc_audio(&s->in_buffer, size)) < 0)
810  return ret;
811  }
812 
813  if(out_count){
814  size = FFMIN(in_count, out_count);
816  if(ret<0)
817  return ret;
818  buf_set(in, in, ret);
819  in_count -= ret;
820  ret2 += ret;
821  }
822  if(in_count){
823  buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
824  copy(&tmp, in, in_count);
825  s->in_buffer_count += in_count;
826  }
827  }
828  if(ret2>0 && !s->drop_output)
829  s->outpts += ret2 * (int64_t)s->in_sample_rate;
830  av_assert2(max_output < 0 || ret2 < 0 || ret2 <= max_output);
831  return ret2;
832  }
833 }
834 
835 int swr_drop_output(struct SwrContext *s, int count){
836  const uint8_t *tmp_arg[SWR_CH_MAX];
837  s->drop_output += count;
838 
839  if(s->drop_output <= 0)
840  return 0;
841 
842  av_log(s, AV_LOG_VERBOSE, "discarding %d audio samples\n", count);
843  return swr_convert(s, NULL, s->drop_output, tmp_arg, 0);
844 }
845 
846 int swr_inject_silence(struct SwrContext *s, int count){
847  int ret, i;
848  uint8_t *tmp_arg[SWR_CH_MAX];
849 
850  if(count <= 0)
851  return 0;
852 
853 #define MAX_SILENCE_STEP 16384
854  while (count > MAX_SILENCE_STEP) {
856  return ret;
857  count -= MAX_SILENCE_STEP;
858  }
859 
860  if((ret=swri_realloc_audio(&s->silence, count))<0)
861  return ret;
862 
863  if(s->silence.planar) for(i=0; i<s->silence.ch_count; i++) {
864  memset(s->silence.ch[i], s->silence.bps==1 ? 0x80 : 0, count*s->silence.bps);
865  } else
866  memset(s->silence.ch[0], s->silence.bps==1 ? 0x80 : 0, count*s->silence.bps*s->silence.ch_count);
867 
868  reversefill_audiodata(&s->silence, tmp_arg);
869  av_log(s, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", count);
870  ret = swr_convert(s, NULL, 0, (const uint8_t**)tmp_arg, count);
871  return ret;
872 }
873 
874 int64_t swr_get_delay(struct SwrContext *s, int64_t base){
875  if (s->resampler && s->resample){
876  return s->resampler->get_delay(s, base);
877  }else{
878  return (s->in_buffer_count*base + (s->in_sample_rate>>1))/ s->in_sample_rate;
879  }
880 }
881 
882 int swr_get_out_samples(struct SwrContext *s, int in_samples)
883 {
884  int64_t out_samples;
885 
886  if (in_samples < 0)
887  return AVERROR(EINVAL);
888 
889  if (s->resampler && s->resample) {
890  if (!s->resampler->get_out_samples)
891  return AVERROR(ENOSYS);
892  out_samples = s->resampler->get_out_samples(s, in_samples);
893  } else {
894  out_samples = s->in_buffer_count + in_samples;
895  av_assert0(s->out_sample_rate == s->in_sample_rate);
896  }
897 
898  if (out_samples > INT_MAX)
899  return AVERROR(EINVAL);
900 
901  return out_samples;
902 }
903 
904 int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance){
905  int ret;
906 
907  if (!s || compensation_distance < 0)
908  return AVERROR(EINVAL);
909  if (!compensation_distance && sample_delta)
910  return AVERROR(EINVAL);
911  if (!s->resample) {
912  s->flags |= SWR_FLAG_RESAMPLE;
913  ret = swr_init(s);
914  if (ret < 0)
915  return ret;
916  }
917  if (!s->resampler->set_compensation){
918  return AVERROR(EINVAL);
919  }else{
920  return s->resampler->set_compensation(s->resample, sample_delta, compensation_distance);
921  }
922 }
923 
924 int64_t swr_next_pts(struct SwrContext *s, int64_t pts){
925  if(pts == INT64_MIN)
926  return s->outpts;
927 
928  if (s->firstpts == AV_NOPTS_VALUE)
929  s->outpts = s->firstpts = pts;
930 
931  if(s->min_compensation >= FLT_MAX) {
932  return (s->outpts = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate));
933  } else {
934  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;
935  double fdelta = delta /(double)(s->in_sample_rate * (int64_t)s->out_sample_rate);
936 
937  if(fabs(fdelta) > s->min_compensation) {
938  if(s->outpts == s->firstpts || fabs(fdelta) > s->min_hard_compensation){
939  int ret;
940  if(delta > 0) ret = swr_inject_silence(s, delta / s->out_sample_rate);
941  else ret = swr_drop_output (s, -delta / s-> in_sample_rate);
942  if(ret<0){
943  av_log(s, AV_LOG_ERROR, "Failed to compensate for timestamp delta of %f\n", fdelta);
944  }
945  } else if(s->soft_compensation_duration && s->max_soft_compensation) {
946  int duration = s->out_sample_rate * s->soft_compensation_duration;
947  double max_soft_compensation = s->max_soft_compensation / (s->max_soft_compensation < 0 ? -s->in_sample_rate : 1);
949  av_log(s, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n", fdelta, comp, duration);
951  }
952  }
953 
954  return s->outpts;
955  }
956 }
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:585
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
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:55
SwrContext::in_sample_rate
int in_sample_rate
input sample rate
Definition: swresample_internal.h:105
free_temp
static void free_temp(AudioData *a)
Definition: swresample.c:90
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
swr_set_compensation
int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance)
Activate resampling compensation ("soft" compensation).
Definition: swresample.c:904
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:106
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:104
SwrContext::user_in_chlayout
AVChannelLayout user_in_chlayout
User set input channel layout.
Definition: swresample_internal.h:118
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:128
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:33
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:316
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
copy
static void copy(AudioData *out, AudioData *in, int count)
Definition: swresample.c:434
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
SwrContext::in_buffer_index
int in_buffer_index
cached buffer position
Definition: swresample_internal.h:154
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
buf_set
static void buf_set(AudioData *out, AudioData *in, int count)
out may be equal in.
Definition: swresample.c:475
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:184
swri_realloc_audio
int swri_realloc_audio(AudioData *a, int count)
Definition: swresample.c:402
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:715
fill_audiodata
static void fill_audiodata(AudioData *out, uint8_t *const in_arg[SWR_CH_MAX])
Definition: swresample.c:447
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:644
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
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:924
swr_convert
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t *const *out_arg, int out_count, const uint8_t *const *in_arg, int in_count)
Convert audio.
Definition: swresample.c:719
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:874
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:147
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:846
swr_init
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:140
duration
int64_t duration
Definition: movenc.c:65
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:648
float
float
Definition: af_crystalizer.c:121
s
#define s(width, name)
Definition: cbs_vp9.c:198
SwrContext::user_out_chlayout
AVChannelLayout user_out_chlayout
User set output channel layout.
Definition: swresample_internal.h:119
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:116
swr_alloc
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:148
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:563
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:163
channel_map
static const uint8_t channel_map[8][8]
Definition: atrac3plusdec.c:52
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:103
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:148
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:461
SwrContext::log_ctx
void * log_ctx
parent logging context
Definition: swresample_internal.h:98
double
double
Definition: af_crystalizer.c:131
av_clipf
av_clipf
Definition: af_crystalizer.c:121
resample
static int resample(SwrContext *s, AudioData *out_param, int out_count, const AudioData *in_param, int in_count)
Definition: swresample.c:490
swri_soxr_resampler
struct Resampler const swri_soxr_resampler
Definition: soxr_resample.c:126
ALIGN
#define ALIGN
Definition: swresample.c:31
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:799
AudioData::ch_count
int ch_count
number of channels
Definition: swresample_internal.h:48
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
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:40
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:311
SwrContext::preout
AudioData preout
pre-output audio data: used for rematrix/resample
Definition: swresample_internal.h:149
av_opt_set_chlayout
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)
Definition: opt.c:941
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:835
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:121
swri_rematrix_free
av_cold void swri_rematrix_free(SwrContext *s)
Definition: rematrix.c:556
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_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:804
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:834
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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
swri_get_dither
int swri_get_dither(SwrContext *s, void *dst, int len, unsigned seed, enum AVSampleFormat noise_fmt)
Definition: dither.c:27
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
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:138
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:80
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:95
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
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:82
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:778
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
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:437
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
swri_rematrix_init
av_cold int swri_rematrix_init(SwrContext *s)
Definition: rematrix.c:450
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:444
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:882
mem.h
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:146
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:136
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:504
audioconvert.h