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

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