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