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 32int 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 40FF_DISABLE_DEPRECATION_WARNINGS 41struct 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; 77fail: 78 av_log(s, AV_LOG_ERROR, "Failed to set option\n"); 79 swr_free(&s); 80 return NULL; 81} 82FF_ENABLE_DEPRECATION_WARNINGS 83#endif 84 85int 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; 129fail: 130 av_log(s, AV_LOG_ERROR, "Failed to set option\n"); 131 swr_free(ps); 132 return ret; 133} 134 135static 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 143static void free_temp(AudioData *a){ 144 av_free(a->data); 145 memset(a, 0, sizeof(*a)); 146} 147 148static 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 173av_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 187av_cold void swr_close(SwrContext *s){ 188 clear_context(s); 189} 190 191av_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 427av_assert0(s->used_ch_count); 428av_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; 494fail: 495 swr_close(s); 496 return ret; 497 498} 499 500int 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 532static 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 545static 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 558static 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 */ 572static 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 */ 587static 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 682static 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 812int swr_is_initialized(struct SwrContext *s) { 813 return !!s->in_buffer.ch_count; 814} 815 816int 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 932int 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 943int 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 971int64_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 979int 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 1001int 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 1021int64_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