swr: minor fixes to get planar audio working
[ffmpeg.git] / libswresample / swresample.c
1 /*
2  * Copyright (C) 2011 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
26 #define  C30DB  M_SQRT2
27 #define  C15DB  1.189207115
28 #define C__0DB  1.0
29 #define C_15DB  0.840896415
30 #define C_30DB  M_SQRT1_2
31 #define C_45DB  0.594603558
32 #define C_60DB  0.5
33
34
35 //TODO split options array out?
36 #define OFFSET(x) offsetof(SwrContext,x)
37 static const AVOption options[]={
38 {"ich",  "input channel count", OFFSET( in.ch_count   ), FF_OPT_TYPE_INT, {.dbl=2}, 1, SWR_CH_MAX, 0},
39 {"och", "output channel count", OFFSET(out.ch_count   ), FF_OPT_TYPE_INT, {.dbl=2}, 1, SWR_CH_MAX, 0},
40 {"isr",  "input sample rate"  , OFFSET( in_sample_rate), FF_OPT_TYPE_INT, {.dbl=48000}, 1, INT_MAX, 0},
41 {"osr", "output sample rate"  , OFFSET(out_sample_rate), FF_OPT_TYPE_INT, {.dbl=48000}, 1, INT_MAX, 0},
42 //{"ip" ,  "input planar"       , OFFSET( in.planar     ), FF_OPT_TYPE_INT, {.dbl=0},    0,       1, 0},
43 //{"op" , "output planar"       , OFFSET(out.planar     ), FF_OPT_TYPE_INT, {.dbl=0},    0,       1, 0},
44 {"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},
45 {"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},
46 {"tsf", "internal sample format", OFFSET(int_sample_fmt ), FF_OPT_TYPE_INT, {.dbl=AV_SAMPLE_FMT_NONE}, -1, AV_SAMPLE_FMT_FLT, 0},
47 {"icl",  "input channel layout" , OFFSET( in_ch_layout), FF_OPT_TYPE_INT64, {.dbl=0}, 0, INT64_MAX, 0, "channel_layout"},
48 {"ocl",  "output channel layout", OFFSET(out_ch_layout), FF_OPT_TYPE_INT64, {.dbl=0}, 0, INT64_MAX, 0, "channel_layout"},
49 {"clev", "center mix level"     , OFFSET(clev)         , FF_OPT_TYPE_FLOAT, {.dbl=C_30DB}, 0, 4, 0},
50 {"slev", "sourround mix level"  , OFFSET(slev)         , FF_OPT_TYPE_FLOAT, {.dbl=C_30DB}, 0, 4, 0},
51 {"flags", NULL                  , OFFSET(flags)        , FF_OPT_TYPE_FLAGS, {.dbl=0}, 0,  UINT_MAX, 0, "flags"},
52 {"res", "force resampling", 0, FF_OPT_TYPE_CONST, {.dbl=SWR_FLAG_RESAMPLE}, INT_MIN, INT_MAX, 0, "flags"},
53
54 {0}
55 };
56
57 static const char* context_to_name(void* ptr) {
58     return "SWR";
59 }
60
61 static const AVClass av_class = { "SwrContext", context_to_name, options, LIBAVUTIL_VERSION_INT, OFFSET(log_level_offset), OFFSET(log_ctx) };
62
63 static int resample(SwrContext *s, AudioData *out_param, int out_count,
64                              const AudioData * in_param, int in_count);
65
66 SwrContext *swr_alloc(void){
67     SwrContext *s= av_mallocz(sizeof(SwrContext));
68     if(s){
69         s->av_class= &av_class;
70         av_opt_set_defaults2(s, 0, 0);
71     }
72     return s;
73 }
74
75 SwrContext *swr_alloc2(struct SwrContext *s, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
76                        int64_t  in_ch_layout, enum AVSampleFormat  in_sample_fmt, int  in_sample_rate,
77                        int log_offset, void *log_ctx){
78     if(!s) s= swr_alloc();
79     if(!s) return NULL;
80
81     s->log_level_offset= log_offset;
82     s->log_ctx= log_ctx;
83
84     av_set_int(s, "ocl", out_ch_layout);
85     av_set_int(s, "osf", out_sample_fmt);
86     av_set_int(s, "osr", out_sample_rate);
87     av_set_int(s, "icl", in_ch_layout);
88     av_set_int(s, "isf", in_sample_fmt);
89     av_set_int(s, "isr", in_sample_rate);
90
91     s-> in.ch_count= av_get_channel_layout_nb_channels(s-> in_ch_layout);
92     s->out.ch_count= av_get_channel_layout_nb_channels(s->out_ch_layout);
93     s->int_sample_fmt = AV_SAMPLE_FMT_S16;
94
95     return s;
96 }
97
98
99 static void free_temp(AudioData *a){
100     av_free(a->data);
101     memset(a, 0, sizeof(*a));
102 }
103
104 void swr_free(SwrContext **ss){
105     SwrContext *s= *ss;
106     if(s){
107         free_temp(&s->postin);
108         free_temp(&s->midbuf);
109         free_temp(&s->preout);
110         free_temp(&s->in_buffer);
111         swr_audio_convert_free(&s-> in_convert);
112         swr_audio_convert_free(&s->out_convert);
113         swr_resample_free(&s->resample);
114     }
115
116     av_freep(ss);
117 }
118
119 static int64_t guess_layout(int ch){
120     switch(ch){
121     case 1: return AV_CH_LAYOUT_MONO;
122     case 2: return AV_CH_LAYOUT_STEREO;
123     case 5: return AV_CH_LAYOUT_5POINT0;
124     case 6: return AV_CH_LAYOUT_5POINT1;
125     case 7: return AV_CH_LAYOUT_7POINT0;
126     case 8: return AV_CH_LAYOUT_7POINT1;
127     default: return 0;
128     }
129 }
130
131 int swr_init(SwrContext *s){
132     s->in_buffer_index= 0;
133     s->in_buffer_count= 0;
134     s->resample_in_constraint= 0;
135     free_temp(&s->postin);
136     free_temp(&s->midbuf);
137     free_temp(&s->preout);
138     free_temp(&s->in_buffer);
139     swr_audio_convert_free(&s-> in_convert);
140     swr_audio_convert_free(&s->out_convert);
141
142     s-> in.planar= s-> in_sample_fmt >= 0x100;
143     s->out.planar= s->out_sample_fmt >= 0x100;
144     s-> in_sample_fmt &= 0xFF;
145     s->out_sample_fmt &= 0xFF;
146
147     //We assume AVOptions checked the various values and the defaults where allowed
148     if(   s->int_sample_fmt != AV_SAMPLE_FMT_S16
149         &&s->int_sample_fmt != AV_SAMPLE_FMT_FLT){
150         av_log(s, AV_LOG_ERROR, "Requested sample format %s is not supported internally, only float & S16 is supported\n", av_get_sample_fmt_name(s->int_sample_fmt));
151         return AVERROR(EINVAL);
152     }
153
154     //FIXME should we allow/support using FLT on material that doesnt need it ?
155     if(s->in_sample_fmt <= AV_SAMPLE_FMT_S16 || s->int_sample_fmt==AV_SAMPLE_FMT_S16){
156         s->int_sample_fmt= AV_SAMPLE_FMT_S16;
157     }else
158         s->int_sample_fmt= AV_SAMPLE_FMT_FLT;
159
160
161     if (s->out_sample_rate!=s->in_sample_rate || (s->flags & SWR_FLAG_RESAMPLE)){
162         s->resample = swr_resample_init(s->resample, s->out_sample_rate, s->in_sample_rate, 16, 10, 0, 0.8);
163     }else
164         swr_resample_free(&s->resample);
165     if(s->int_sample_fmt != AV_SAMPLE_FMT_S16 && s->resample){
166         av_log(s, AV_LOG_ERROR, "Resampling only supported with internal s16 currently\n"); //FIXME
167         return -1;
168     }
169
170     if(!s-> in_ch_layout)
171         s-> in_ch_layout= guess_layout(s->in.ch_count);
172     if(!s->out_ch_layout)
173         s->out_ch_layout= guess_layout(s->out.ch_count);
174
175     s->rematrix= s->out_ch_layout  !=s->in_ch_layout;
176
177 #define RSC 1 //FIXME finetune
178     if(!s-> in.ch_count)
179         s-> in.ch_count= av_get_channel_layout_nb_channels(s-> in_ch_layout);
180     if(!s->out.ch_count)
181         s->out.ch_count= av_get_channel_layout_nb_channels(s->out_ch_layout);
182
183 av_assert0(s-> in.ch_count);
184 av_assert0(s->out.ch_count);
185     s->resample_first= RSC*s->out.ch_count/s->in.ch_count - RSC < s->out_sample_rate/(float)s-> in_sample_rate - 1.0;
186
187     s-> in.bps= av_get_bits_per_sample_fmt(s-> in_sample_fmt)/8;
188     s->int_bps= av_get_bits_per_sample_fmt(s->int_sample_fmt)/8;
189     s->out.bps= av_get_bits_per_sample_fmt(s->out_sample_fmt)/8;
190
191     s->in_convert = swr_audio_convert_alloc(s->int_sample_fmt,
192                                             s-> in_sample_fmt, s-> in.ch_count, 0);
193     s->out_convert= swr_audio_convert_alloc(s->out_sample_fmt,
194                                             s->int_sample_fmt, s->out.ch_count, 0);
195
196
197     s->postin= s->in;
198     s->preout= s->out;
199     s->midbuf= s->in;
200     s->in_buffer= s->in;
201     if(!s->resample_first){
202         s->midbuf.ch_count= s->out.ch_count;
203         s->in_buffer.ch_count = s->out.ch_count;
204     }
205
206     s->in_buffer.bps = s->postin.bps = s->midbuf.bps = s->preout.bps =  s->int_bps;
207     s->in_buffer.planar = s->postin.planar = s->midbuf.planar = s->preout.planar =  1;
208
209
210     if(s->rematrix && swr_rematrix_init(s)<0)
211         return -1;
212
213     return 0;
214 }
215
216 static int realloc_audio(AudioData *a, int count){
217     int i, countb;
218     AudioData old;
219
220     if(a->count >= count)
221         return 0;
222
223     count*=2;
224
225     countb= FFALIGN(count*a->bps, 32);
226     old= *a;
227
228     av_assert0(a->planar);
229     av_assert0(a->bps);
230     av_assert0(a->ch_count);
231
232     a->data= av_malloc(countb*a->ch_count);
233     if(!a->data)
234         return AVERROR(ENOMEM);
235     for(i=0; i<a->ch_count; i++){
236         a->ch[i]= a->data + i*(a->planar ? countb : a->bps);
237         if(a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);
238     }
239     av_free(old.data);
240     a->count= count;
241
242     return 1;
243 }
244
245 static void copy(AudioData *out, AudioData *in,
246                  int count){
247     av_assert0(out->planar == in->planar);
248     av_assert0(out->bps == in->bps);
249     av_assert0(out->ch_count == in->ch_count);
250     if(out->planar){
251         int ch;
252         for(ch=0; ch<out->ch_count; ch++)
253             memcpy(out->ch[ch], in->ch[ch], count*out->bps);
254     }else
255         memcpy(out->ch[0], in->ch[0], count*out->ch_count*out->bps);
256 }
257
258 static void fill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){
259     int i;
260     if(out->planar){
261         for(i=0; i<out->ch_count; i++)
262             out->ch[i]= in_arg[i];
263     }else{
264         for(i=0; i<out->ch_count; i++)
265             out->ch[i]= in_arg[0] + i*out->bps;
266     }
267 }
268
269 int swr_convert(struct SwrContext *s, uint8_t *out_arg[SWR_CH_MAX], int out_count,
270                          const uint8_t *in_arg [SWR_CH_MAX], int  in_count){
271     AudioData *postin, *midbuf, *preout;
272     int ret, i/*, in_max*/;
273     AudioData * in= &s->in;
274     AudioData *out= &s->out;
275     AudioData preout_tmp, midbuf_tmp;
276
277     if(!s->resample){
278         if(in_count > out_count)
279             return -1;
280         out_count = in_count;
281     }
282
283     fill_audiodata(in ,  in_arg);
284     fill_audiodata(out, out_arg);
285
286 //     in_max= out_count*(int64_t)s->in_sample_rate / s->out_sample_rate + resample_filter_taps;
287 //     in_count= FFMIN(in_count, in_in + 2 - s->hist_buffer_count);
288
289     if((ret=realloc_audio(&s->postin, in_count))<0)
290         return ret;
291     if(s->resample_first){
292         av_assert0(s->midbuf.ch_count ==  s-> in.ch_count);
293         if((ret=realloc_audio(&s->midbuf, out_count))<0)
294             return ret;
295     }else{
296         av_assert0(s->midbuf.ch_count ==  s->out.ch_count);
297         if((ret=realloc_audio(&s->midbuf,  in_count))<0)
298             return ret;
299     }
300     if((ret=realloc_audio(&s->preout, out_count))<0)
301         return ret;
302
303     postin= &s->postin;
304
305     midbuf_tmp= s->midbuf;
306     midbuf= &midbuf_tmp;
307     preout_tmp= s->preout;
308     preout= &preout_tmp;
309
310     if(s->int_sample_fmt == s-> in_sample_fmt && s->in.planar)
311         postin= in;
312
313     if(s->resample_first ? !s->resample : !s->rematrix)
314         midbuf= postin;
315
316     if(s->resample_first ? !s->rematrix : !s->resample)
317         preout= midbuf;
318
319     if(s->int_sample_fmt == s->out_sample_fmt && s->out.planar){
320         if(preout==in){
321             out_count= FFMIN(out_count, in_count); //TODO check at teh end if this is needed or redundant
322             av_assert0(s->in.planar); //we only support planar internally so it has to be, we support copying non planar though
323             copy(out, in, out_count);
324             return out_count;
325         }
326         else if(preout==postin) preout= midbuf= postin= out;
327         else if(preout==midbuf) preout= midbuf= out;
328         else                    preout= out;
329     }
330
331     if(in != postin){
332         swr_audio_convert(s->in_convert, postin, in, in_count);
333     }
334
335     if(s->resample_first){
336         if(postin != midbuf)
337             out_count= resample(s, midbuf, out_count, postin, in_count);
338         if(midbuf != preout)
339             swr_rematrix(s, preout, midbuf, out_count, preout==out);
340     }else{
341         if(postin != midbuf)
342             swr_rematrix(s, midbuf, postin, in_count, midbuf==out);
343         if(midbuf != preout)
344             out_count= resample(s, preout, out_count, midbuf, in_count);
345     }
346
347     if(preout != out){
348 //FIXME packed doesnt need more than 1 chan here!
349         swr_audio_convert(s->out_convert, out, preout, out_count);
350     }
351     return out_count;
352 }
353
354 /**
355  *
356  * out may be equal in.
357  */
358 static void buf_set(AudioData *out, AudioData *in, int count){
359     if(in->planar){
360         int ch;
361         for(ch=0; ch<out->ch_count; ch++)
362             out->ch[ch]= in->ch[ch] + count*out->bps;
363     }else
364         out->ch[0]= in->ch[0] + count*out->ch_count*out->bps;
365 }
366
367 /**
368  *
369  * @return number of samples output per channel
370  */
371 static int resample(SwrContext *s, AudioData *out_param, int out_count,
372                              const AudioData * in_param, int in_count){
373     AudioData in, out, tmp;
374     int ret_sum=0;
375     int border=0;
376
377     tmp=out=*out_param;
378     in =  *in_param;
379
380     do{
381         int ret, size, consumed;
382         if(!s->resample_in_constraint && s->in_buffer_count){
383             buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
384             ret= swr_multiple_resample(s->resample, &out, out_count, &tmp, s->in_buffer_count, &consumed);
385             out_count -= ret;
386             ret_sum += ret;
387             buf_set(&out, &out, ret);
388             s->in_buffer_count -= consumed;
389             s->in_buffer_index += consumed;
390
391             if(!in_count)
392                 break;
393             if(s->in_buffer_count <= border){
394                 buf_set(&in, &in, -s->in_buffer_count);
395                 in_count += s->in_buffer_count;
396                 s->in_buffer_count=0;
397                 s->in_buffer_index=0;
398                 border = 0;
399             }
400         }
401
402         if(in_count && !s->in_buffer_count){
403             s->in_buffer_index=0;
404             ret= swr_multiple_resample(s->resample, &out, out_count, &in, in_count, &consumed);
405             out_count -= ret;
406             ret_sum += ret;
407             buf_set(&out, &out, ret);
408             in_count -= consumed;
409             buf_set(&in, &in, consumed);
410         }
411
412         //TODO is this check sane considering the advanced copy avoidance below
413         size= s->in_buffer_index + s->in_buffer_count + in_count;
414         if(   size > s->in_buffer.count
415            && s->in_buffer_count + in_count <= s->in_buffer_index){
416             buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
417             copy(&s->in_buffer, &tmp, s->in_buffer_count);
418             s->in_buffer_index=0;
419         }else
420             if((ret=realloc_audio(&s->in_buffer, size)) < 0)
421                 return ret;
422
423         if(in_count){
424             int count= in_count;
425             if(s->in_buffer_count && s->in_buffer_count+2 < count && out_count) count= s->in_buffer_count+2;
426
427             buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
428             copy(&tmp, &in, /*in_*/count);
429             s->in_buffer_count += count;
430             in_count -= count;
431             border += count;
432             buf_set(&in, &in, count);
433             s->resample_in_constraint= 0;
434             if(s->in_buffer_count != count || in_count)
435                 continue;
436         }
437         break;
438     }while(1);
439
440     s->resample_in_constraint= !!out_count;
441
442     return ret_sum;
443 }