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