FFmpeg: libswresample/swresample.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /