//TODO split options array out?
#define OFFSET(x) offsetof(SwrContext,x)
static const AVOption options[]={
-{"ich", "input channel count", OFFSET( in.ch_count ), FF_OPT_TYPE_INT, {.dbl=2}, 1, SWR_CH_MAX, 0},
-{"och", "output channel count", OFFSET(out.ch_count ), FF_OPT_TYPE_INT, {.dbl=2}, 1, SWR_CH_MAX, 0},
-{"isr", "input sample rate" , OFFSET( in_sample_rate), FF_OPT_TYPE_INT, {.dbl=48000}, 1, INT_MAX, 0},
-{"osr", "output sample rate" , OFFSET(out_sample_rate), FF_OPT_TYPE_INT, {.dbl=48000}, 1, INT_MAX, 0},
-//{"ip" , "input planar" , OFFSET( in.planar ), FF_OPT_TYPE_INT, {.dbl=0}, 0, 1, 0},
-//{"op" , "output planar" , OFFSET(out.planar ), FF_OPT_TYPE_INT, {.dbl=0}, 0, 1, 0},
-{"isf", "input sample format", OFFSET( in_sample_fmt ), FF_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_S16}, 0, AV_SAMPLE_FMT_NB-1+256, 0},
-{"osf", "output sample format", OFFSET(out_sample_fmt ), FF_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_S16}, 0, AV_SAMPLE_FMT_NB-1+256, 0},
-{"tsf", "internal sample format", OFFSET(int_sample_fmt ), FF_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_NONE}, -1, AV_SAMPLE_FMT_FLT, 0},
-{"icl", "input channel layout" , OFFSET( in_ch_layout), FF_OPT_TYPE_INT64, {.dbl=0}, 0, INT64_MAX, 0, "channel_layout"},
-{"ocl", "output channel layout", OFFSET(out_ch_layout), FF_OPT_TYPE_INT64, {.dbl=0}, 0, INT64_MAX, 0, "channel_layout"},
-{"clev", "center mix level" , OFFSET(clev) , FF_OPT_TYPE_FLOAT, {.dbl=C_30DB}, 0, 4, 0},
-{"slev", "sourround mix level" , OFFSET(slev) , FF_OPT_TYPE_FLOAT, {.dbl=C_30DB}, 0, 4, 0},
-{"flags", NULL , OFFSET(flags) , FF_OPT_TYPE_FLAGS, {.dbl=0}, 0, UINT_MAX, 0, "flags"},
-{"res", "force resampling", 0, FF_OPT_TYPE_CONST, {.dbl=SWR_FLAG_RESAMPLE}, INT_MIN, INT_MAX, 0, "flags"},
+{"ich", "input channel count", OFFSET( in.ch_count ), AV_OPT_TYPE_INT, {.dbl=2}, 1, SWR_CH_MAX, 0},
+{"och", "output channel count", OFFSET(out.ch_count ), AV_OPT_TYPE_INT, {.dbl=2}, 1, SWR_CH_MAX, 0},
+{"uch", "used channel count", OFFSET(used_ch_count ), AV_OPT_TYPE_INT, {.dbl=0}, 0, SWR_CH_MAX, 0},
+{"isr", "input sample rate" , OFFSET( in_sample_rate), AV_OPT_TYPE_INT, {.dbl=48000}, 1, INT_MAX, 0},
+{"osr", "output sample rate" , OFFSET(out_sample_rate), AV_OPT_TYPE_INT, {.dbl=48000}, 1, INT_MAX, 0},
+//{"ip" , "input planar" , OFFSET( in.planar ), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, 0},
+//{"op" , "output planar" , OFFSET(out.planar ), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, 0},
+{"isf", "input sample format", OFFSET( in_sample_fmt ), AV_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_S16}, 0, AV_SAMPLE_FMT_NB-1+256, 0},
+{"osf", "output sample format", OFFSET(out_sample_fmt ), AV_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_S16}, 0, AV_SAMPLE_FMT_NB-1+256, 0},
+{"tsf", "internal sample format", OFFSET(int_sample_fmt ), AV_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_NONE}, -1, AV_SAMPLE_FMT_FLT, 0},
+{"icl", "input channel layout" , OFFSET( in_ch_layout), AV_OPT_TYPE_INT64, {.dbl=0}, 0, INT64_MAX, 0, "channel_layout"},
+{"ocl", "output channel layout", OFFSET(out_ch_layout), AV_OPT_TYPE_INT64, {.dbl=0}, 0, INT64_MAX, 0, "channel_layout"},
+{"clev", "center mix level" , OFFSET(clev) , AV_OPT_TYPE_FLOAT, {.dbl=C_30DB}, 0, 4, 0},
+{"slev", "sourround mix level" , OFFSET(slev) , AV_OPT_TYPE_FLOAT, {.dbl=C_30DB}, 0, 4, 0},
+{"rmvol", "rematrix volume" , OFFSET(rematrix_volume), AV_OPT_TYPE_FLOAT, {.dbl=1.0}, -1000, 1000, 0},
+{"flags", NULL , OFFSET(flags) , AV_OPT_TYPE_FLAGS, {.dbl=0}, 0, UINT_MAX, 0, "flags"},
+{"res", "force resampling", 0, AV_OPT_TYPE_CONST, {.dbl=SWR_FLAG_RESAMPLE}, INT_MIN, INT_MAX, 0, "flags"},
{0}
};
return "SWR";
}
-static const AVClass av_class = { "SwrContext", context_to_name, options, LIBAVUTIL_VERSION_INT, OFFSET(log_level_offset), OFFSET(log_ctx) };
+static const AVClass av_class = {
+ .class_name = "SwrContext",
+ .item_name = context_to_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+ .log_level_offset_offset = OFFSET(log_level_offset),
+ .parent_log_context_offset = OFFSET(log_ctx),
+};
static int resample(SwrContext *s, AudioData *out_param, int out_count,
const AudioData * in_param, int in_count);
SwrContext *s= av_mallocz(sizeof(SwrContext));
if(s){
s->av_class= &av_class;
- av_opt_set_defaults2(s, 0, 0);
+ av_opt_set_defaults(s);
}
return s;
}
SwrContext *swr_alloc2(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){
+ const int *channel_map, int log_offset, void *log_ctx){
if(!s) s= swr_alloc();
if(!s) return NULL;
s->log_level_offset= log_offset;
s->log_ctx= log_ctx;
- av_set_int(s, "ocl", out_ch_layout);
- av_set_int(s, "osf", out_sample_fmt);
- av_set_int(s, "osr", out_sample_rate);
- av_set_int(s, "icl", in_ch_layout);
- av_set_int(s, "isf", in_sample_fmt);
- av_set_int(s, "isr", in_sample_rate);
+ av_opt_set_int(s, "ocl", out_ch_layout, 0);
+ av_opt_set_int(s, "osf", out_sample_fmt, 0);
+ av_opt_set_int(s, "osr", out_sample_rate, 0);
+ av_opt_set_int(s, "icl", in_ch_layout, 0);
+ av_opt_set_int(s, "isf", in_sample_fmt, 0);
+ av_opt_set_int(s, "isr", in_sample_rate, 0);
+ s->channel_map = channel_map;
s-> in.ch_count= av_get_channel_layout_nb_channels(s-> in_ch_layout);
s->out.ch_count= av_get_channel_layout_nb_channels(s->out_ch_layout);
s->int_sample_fmt = AV_SAMPLE_FMT_S16;
free_temp(&s->midbuf);
free_temp(&s->preout);
free_temp(&s->in_buffer);
- swr_audio_convert_free(&s-> in_convert);
- swr_audio_convert_free(&s->out_convert);
- swr_audio_convert_free(&s->full_convert);
+ swri_audio_convert_free(&s-> in_convert);
+ swri_audio_convert_free(&s->out_convert);
+ swri_audio_convert_free(&s->full_convert);
swr_resample_free(&s->resample);
}
free_temp(&s->midbuf);
free_temp(&s->preout);
free_temp(&s->in_buffer);
- swr_audio_convert_free(&s-> in_convert);
- swr_audio_convert_free(&s->out_convert);
- swr_audio_convert_free(&s->full_convert);
+ swri_audio_convert_free(&s-> in_convert);
+ swri_audio_convert_free(&s->out_convert);
+ swri_audio_convert_free(&s->full_convert);
s-> in.planar= s-> in_sample_fmt >= 0x100;
s->out.planar= s->out_sample_fmt >= 0x100;
return -1;
}
- if(s-> in.ch_count && s->in.ch_count != av_get_channel_layout_nb_channels(s-> in_ch_layout)){
- av_log(s, AV_LOG_WARNING, "Input channel layout has a different number of channels than there actually is, ignoring layout\n");
+ if(!s->used_ch_count)
+ s->used_ch_count= s->in.ch_count;
+
+ if(s->used_ch_count && s-> in_ch_layout && s->used_ch_count != av_get_channel_layout_nb_channels(s-> in_ch_layout)){
+ av_log(s, AV_LOG_WARNING, "Input channel layout has a different number of channels than the number of used channels, ignoring layout\n");
s-> in_ch_layout= 0;
}
if(!s-> in_ch_layout)
- s-> in_ch_layout= av_get_default_channel_layout(s->in.ch_count);
+ s-> in_ch_layout= av_get_default_channel_layout(s->used_ch_count);
if(!s->out_ch_layout)
s->out_ch_layout= av_get_default_channel_layout(s->out.ch_count);
- s->rematrix= s->out_ch_layout !=s->in_ch_layout;
+ s->rematrix= s->out_ch_layout !=s->in_ch_layout || s->rematrix_volume!=1.0;
#define RSC 1 //FIXME finetune
if(!s-> in.ch_count)
s-> in.ch_count= av_get_channel_layout_nb_channels(s-> in_ch_layout);
+ if(!s->used_ch_count)
+ s->used_ch_count= s->in.ch_count;
if(!s->out.ch_count)
s->out.ch_count= av_get_channel_layout_nb_channels(s->out_ch_layout);
av_assert0(s-> in.ch_count);
+av_assert0(s->used_ch_count);
av_assert0(s->out.ch_count);
s->resample_first= RSC*s->out.ch_count/s->in.ch_count - RSC < s->out_sample_rate/(float)s-> in_sample_rate - 1.0;
- s-> in.bps= av_get_bits_per_sample_fmt(s-> in_sample_fmt)/8;
- s->int_bps= av_get_bits_per_sample_fmt(s->int_sample_fmt)/8;
- s->out.bps= av_get_bits_per_sample_fmt(s->out_sample_fmt)/8;
+ s-> in.bps= av_get_bytes_per_sample(s-> in_sample_fmt);
+ s->int_bps= av_get_bytes_per_sample(s->int_sample_fmt);
+ s->out.bps= av_get_bytes_per_sample(s->out_sample_fmt);
- if(!s->resample && !s->rematrix){
- s->full_convert = swr_audio_convert_alloc(s->out_sample_fmt,
- s-> in_sample_fmt, s-> in.ch_count, 0);
+ if(!s->resample && !s->rematrix && !s->channel_map){
+ s->full_convert = swri_audio_convert_alloc(s->out_sample_fmt,
+ s-> in_sample_fmt, s-> in.ch_count, NULL, 0);
return 0;
}
- s->in_convert = swr_audio_convert_alloc(s->int_sample_fmt,
- s-> in_sample_fmt, s-> in.ch_count, 0);
- s->out_convert= swr_audio_convert_alloc(s->out_sample_fmt,
- s->int_sample_fmt, s->out.ch_count, 0);
+ s->in_convert = swri_audio_convert_alloc(s->int_sample_fmt,
+ s-> in_sample_fmt, s->used_ch_count, s->channel_map, 0);
+ s->out_convert= swri_audio_convert_alloc(s->out_sample_fmt,
+ s->int_sample_fmt, s->out.ch_count, NULL, 0);
s->postin= s->in;
s->preout= s->out;
s->midbuf= s->in;
s->in_buffer= s->in;
+ if(s->channel_map){
+ s->postin.ch_count=
+ s->midbuf.ch_count=
+ s->in_buffer.ch_count= s->used_ch_count;
+ }
if(!s->resample_first){
s->midbuf.ch_count= s->out.ch_count;
s->in_buffer.ch_count = s->out.ch_count;
int swr_convert(struct SwrContext *s, uint8_t *out_arg[SWR_CH_MAX], int out_count,
const uint8_t *in_arg [SWR_CH_MAX], int in_count){
AudioData *postin, *midbuf, *preout;
- int ret, i/*, in_max*/;
+ int ret/*, in_max*/;
AudioData * in= &s->in;
AudioData *out= &s->out;
AudioData preout_tmp, midbuf_tmp;
out_count = in_count;
}
- fill_audiodata(in , in_arg);
+ if(!in_arg){
+ if(s->in_buffer_count){
+ AudioData *a= &s->in_buffer;
+ int i, j, ret;
+ if((ret=realloc_audio(a, s->in_buffer_index + 2*s->in_buffer_count)) < 0)
+ return ret;
+ av_assert0(a->planar);
+ for(i=0; i<a->ch_count; i++){
+ for(j=0; j<s->in_buffer_count; j++){
+ memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j )*a->bps,
+ a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
+ }
+ }
+ s->in_buffer_count += (s->in_buffer_count+1)/2;
+ s->resample_in_constraint = 0;
+ }else{
+ return 0;
+ }
+ }else
+ fill_audiodata(in , (void*)in_arg);
fill_audiodata(out, out_arg);
if(s->full_convert){
av_assert0(!s->resample);
- swr_audio_convert(s->full_convert, out, in, in_count);
+ swri_audio_convert(s->full_convert, out, in, in_count);
return out_count;
}
if((ret=realloc_audio(&s->postin, in_count))<0)
return ret;
if(s->resample_first){
- av_assert0(s->midbuf.ch_count == s-> in.ch_count);
+ av_assert0(s->midbuf.ch_count == s->used_ch_count);
if((ret=realloc_audio(&s->midbuf, out_count))<0)
return ret;
}else{
}
if(in != postin){
- swr_audio_convert(s->in_convert, postin, in, in_count);
+ swri_audio_convert(s->in_convert, postin, in, in_count);
}
if(s->resample_first){
if(preout != out){
//FIXME packed doesnt need more than 1 chan here!
- swr_audio_convert(s->out_convert, out, preout, out_count);
+ swri_audio_convert(s->out_convert, out, preout, out_count);
}
+ if(!in_arg)
+ s->in_buffer_count = 0;
return out_count;
}