Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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