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