2 * samplerate conversion for both audio and video
3 * Copyright (c) 2000 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * samplerate conversion for both audio and video
30 #include "audioconvert.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/samplefmt.h"
35 #if FF_API_AVCODEC_RESAMPLE
37 #define MAX_CHANNELS 8
39 struct AVResampleContext
;
41 static const char *context_to_name(void *ptr
)
43 return "audioresample";
46 static const AVOption options
[] = {{NULL
}};
47 static const AVClass audioresample_context_class
= {
48 "ReSampleContext", context_to_name
, options
, LIBAVUTIL_VERSION_INT
51 struct ReSampleContext
{
52 struct AVResampleContext
*resample_context
;
53 short *temp
[MAX_CHANNELS
];
57 int input_channels
, output_channels
, filter_channels
;
58 AVAudioConvert
*convert_ctx
[2];
59 enum AVSampleFormat sample_fmt
[2]; ///< input and output sample format
60 unsigned sample_size
[2]; ///< size of one sample in sample_fmt
61 short *buffer
[2]; ///< buffers used for conversion to S16
62 unsigned buffer_size
[2]; ///< sizes of allocated buffers
65 /* n1: number of samples */
66 static void stereo_to_mono(short *output
, short *input
, int n1
)
74 q
[0] = (p
[0] + p
[1]) >> 1;
75 q
[1] = (p
[2] + p
[3]) >> 1;
76 q
[2] = (p
[4] + p
[5]) >> 1;
77 q
[3] = (p
[6] + p
[7]) >> 1;
83 q
[0] = (p
[0] + p
[1]) >> 1;
90 /* n1: number of samples */
91 static void mono_to_stereo(short *output
, short *input
, int n1
)
100 v
= p
[0]; q
[0] = v
; q
[1] = v
;
101 v
= p
[1]; q
[2] = v
; q
[3] = v
;
102 v
= p
[2]; q
[4] = v
; q
[5] = v
;
103 v
= p
[3]; q
[6] = v
; q
[7] = v
;
109 v
= p
[0]; q
[0] = v
; q
[1] = v
;
117 5.1 to stereo input: [fl, fr, c, lfe, rl, rr]
118 - Left = front_left + rear_gain * rear_left + center_gain * center
119 - Right = front_right + rear_gain * rear_right + center_gain * center
120 Where rear_gain is usually around 0.5-1.0 and
121 center_gain is almost always 0.7 (-3 dB)
123 static void surround_to_stereo(short **output
, short *input
, int channels
, int samples
)
128 for (i
= 0; i
< samples
; i
++) {
137 l
= av_clip_int16(fl
+ (0.5 * rl
) + (0.7 * c
));
138 r
= av_clip_int16(fr
+ (0.5 * rr
) + (0.7 * c
));
144 /* increment input. */
149 static void deinterleave(short **output
, short *input
, int channels
, int samples
)
153 for (i
= 0; i
< samples
; i
++) {
154 for (j
= 0; j
< channels
; j
++) {
155 *output
[j
]++ = *input
++;
160 static void interleave(short *output
, short **input
, int channels
, int samples
)
164 for (i
= 0; i
< samples
; i
++) {
165 for (j
= 0; j
< channels
; j
++) {
166 *output
++ = *input
[j
]++;
171 static void ac3_5p1_mux(short *output
, short *input1
, short *input2
, int n
)
176 for (i
= 0; i
< n
; i
++) {
179 *output
++ = l
; /* left */
180 *output
++ = (l
/ 2) + (r
/ 2); /* center */
181 *output
++ = r
; /* right */
182 *output
++ = 0; /* left surround */
183 *output
++ = 0; /* right surroud */
184 *output
++ = 0; /* low freq */
188 #define SUPPORT_RESAMPLE(ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8) \
189 ch8<<7 | ch7<<6 | ch6<<5 | ch5<<4 | ch4<<3 | ch3<<2 | ch2<<1 | ch1<<0
191 static const uint8_t supported_resampling
[MAX_CHANNELS
] = {
192 // output ch: 1 2 3 4 5 6 7 8
193 SUPPORT_RESAMPLE(1, 1, 0, 0, 0, 0, 0, 0), // 1 input channel
194 SUPPORT_RESAMPLE(1, 1, 0, 0, 0, 1, 0, 0), // 2 input channels
195 SUPPORT_RESAMPLE(0, 0, 1, 0, 0, 0, 0, 0), // 3 input channels
196 SUPPORT_RESAMPLE(0, 0, 0, 1, 0, 0, 0, 0), // 4 input channels
197 SUPPORT_RESAMPLE(0, 0, 0, 0, 1, 0, 0, 0), // 5 input channels
198 SUPPORT_RESAMPLE(0, 1, 0, 0, 0, 1, 0, 0), // 6 input channels
199 SUPPORT_RESAMPLE(0, 0, 0, 0, 0, 0, 1, 0), // 7 input channels
200 SUPPORT_RESAMPLE(0, 0, 0, 0, 0, 0, 0, 1), // 8 input channels
203 ReSampleContext
*av_audio_resample_init(int output_channels
, int input_channels
,
204 int output_rate
, int input_rate
,
205 enum AVSampleFormat sample_fmt_out
,
206 enum AVSampleFormat sample_fmt_in
,
207 int filter_length
, int log2_phase_count
,
208 int linear
, double cutoff
)
212 if (input_channels
> MAX_CHANNELS
) {
213 av_log(NULL
, AV_LOG_ERROR
,
214 "Resampling with input channels greater than %d is unsupported.\n",
218 if (!(supported_resampling
[input_channels
-1] & (1<<(output_channels
-1)))) {
220 av_log(NULL
, AV_LOG_ERROR
, "Unsupported audio resampling. Allowed "
221 "output channels for %d input channel%s", input_channels
,
222 input_channels
> 1 ? "s:" : ":");
223 for (i
= 0; i
< MAX_CHANNELS
; i
++)
224 if (supported_resampling
[input_channels
-1] & (1<<i
))
225 av_log(NULL
, AV_LOG_ERROR
, " %d", i
+ 1);
226 av_log(NULL
, AV_LOG_ERROR
, "\n");
230 s
= av_mallocz(sizeof(ReSampleContext
));
232 av_log(NULL
, AV_LOG_ERROR
, "Can't allocate memory for resample context.\n");
236 s
->ratio
= (float)output_rate
/ (float)input_rate
;
238 s
->input_channels
= input_channels
;
239 s
->output_channels
= output_channels
;
241 s
->filter_channels
= s
->input_channels
;
242 if (s
->output_channels
< s
->filter_channels
)
243 s
->filter_channels
= s
->output_channels
;
245 s
->sample_fmt
[0] = sample_fmt_in
;
246 s
->sample_fmt
[1] = sample_fmt_out
;
247 s
->sample_size
[0] = av_get_bytes_per_sample(s
->sample_fmt
[0]);
248 s
->sample_size
[1] = av_get_bytes_per_sample(s
->sample_fmt
[1]);
250 if (s
->sample_fmt
[0] != AV_SAMPLE_FMT_S16
) {
251 if (!(s
->convert_ctx
[0] = av_audio_convert_alloc(AV_SAMPLE_FMT_S16
, 1,
252 s
->sample_fmt
[0], 1, NULL
, 0))) {
253 av_log(s
, AV_LOG_ERROR
,
254 "Cannot convert %s sample format to s16 sample format\n",
255 av_get_sample_fmt_name(s
->sample_fmt
[0]));
261 if (s
->sample_fmt
[1] != AV_SAMPLE_FMT_S16
) {
262 if (!(s
->convert_ctx
[1] = av_audio_convert_alloc(s
->sample_fmt
[1], 1,
263 AV_SAMPLE_FMT_S16
, 1, NULL
, 0))) {
264 av_log(s
, AV_LOG_ERROR
,
265 "Cannot convert s16 sample format to %s sample format\n",
266 av_get_sample_fmt_name(s
->sample_fmt
[1]));
267 av_audio_convert_free(s
->convert_ctx
[0]);
273 s
->resample_context
= av_resample_init(output_rate
, input_rate
,
274 filter_length
, log2_phase_count
,
277 *(const AVClass
**)s
->resample_context
= &audioresample_context_class
;
282 /* resample audio. 'nb_samples' is the number of input samples */
283 /* XXX: optimize it ! */
284 int audio_resample(ReSampleContext
*s
, short *output
, short *input
, int nb_samples
)
287 short *bufin
[MAX_CHANNELS
];
288 short *bufout
[MAX_CHANNELS
];
289 short *buftmp2
[MAX_CHANNELS
], *buftmp3
[MAX_CHANNELS
];
290 short *output_bak
= NULL
;
293 if (s
->input_channels
== s
->output_channels
&& s
->ratio
== 1.0 && 0) {
295 memcpy(output
, input
, nb_samples
* s
->input_channels
* sizeof(short));
299 if (s
->sample_fmt
[0] != AV_SAMPLE_FMT_S16
) {
300 int istride
[1] = { s
->sample_size
[0] };
301 int ostride
[1] = { 2 };
302 const void *ibuf
[1] = { input
};
304 unsigned input_size
= nb_samples
* s
->input_channels
* 2;
306 if (!s
->buffer_size
[0] || s
->buffer_size
[0] < input_size
) {
307 av_free(s
->buffer
[0]);
308 s
->buffer_size
[0] = input_size
;
309 s
->buffer
[0] = av_malloc(s
->buffer_size
[0]);
311 av_log(s
->resample_context
, AV_LOG_ERROR
, "Could not allocate buffer\n");
316 obuf
[0] = s
->buffer
[0];
318 if (av_audio_convert(s
->convert_ctx
[0], obuf
, ostride
,
319 ibuf
, istride
, nb_samples
* s
->input_channels
) < 0) {
320 av_log(s
->resample_context
, AV_LOG_ERROR
,
321 "Audio sample format conversion failed\n");
325 input
= s
->buffer
[0];
328 lenout
= 2*s
->output_channels
*nb_samples
* s
->ratio
+ 16;
330 if (s
->sample_fmt
[1] != AV_SAMPLE_FMT_S16
) {
331 int out_size
= lenout
* av_get_bytes_per_sample(s
->sample_fmt
[1]) *
335 if (!s
->buffer_size
[1] || s
->buffer_size
[1] < out_size
) {
336 av_free(s
->buffer
[1]);
337 s
->buffer_size
[1] = out_size
;
338 s
->buffer
[1] = av_malloc(s
->buffer_size
[1]);
340 av_log(s
->resample_context
, AV_LOG_ERROR
, "Could not allocate buffer\n");
345 output
= s
->buffer
[1];
348 /* XXX: move those malloc to resample init code */
349 for (i
= 0; i
< s
->filter_channels
; i
++) {
350 bufin
[i
] = av_malloc_array((nb_samples
+ s
->temp_len
), sizeof(short));
351 bufout
[i
] = av_malloc_array(lenout
, sizeof(short));
353 if (!bufin
[i
] || !bufout
[i
]) {
354 av_log(s
->resample_context
, AV_LOG_ERROR
, "Could not allocate buffer\n");
359 memcpy(bufin
[i
], s
->temp
[i
], s
->temp_len
* sizeof(short));
360 buftmp2
[i
] = bufin
[i
] + s
->temp_len
;
363 if (s
->input_channels
== 2 && s
->output_channels
== 1) {
365 stereo_to_mono(buftmp2
[0], input
, nb_samples
);
366 } else if (s
->output_channels
>= 2 && s
->input_channels
== 1) {
367 buftmp3
[0] = bufout
[0];
368 memcpy(buftmp2
[0], input
, nb_samples
* sizeof(short));
369 } else if (s
->input_channels
== 6 && s
->output_channels
==2) {
370 buftmp3
[0] = bufout
[0];
371 buftmp3
[1] = bufout
[1];
372 surround_to_stereo(buftmp2
, input
, s
->input_channels
, nb_samples
);
373 } else if (s
->output_channels
>= s
->input_channels
&& s
->input_channels
>= 2) {
374 for (i
= 0; i
< s
->input_channels
; i
++) {
375 buftmp3
[i
] = bufout
[i
];
377 deinterleave(buftmp2
, input
, s
->input_channels
, nb_samples
);
380 memcpy(buftmp2
[0], input
, nb_samples
* sizeof(short));
383 nb_samples
+= s
->temp_len
;
385 /* resample each channel */
386 nb_samples1
= 0; /* avoid warning */
387 for (i
= 0; i
< s
->filter_channels
; i
++) {
389 int is_last
= i
+ 1 == s
->filter_channels
;
391 nb_samples1
= av_resample(s
->resample_context
, buftmp3
[i
], bufin
[i
],
392 &consumed
, nb_samples
, lenout
, is_last
);
393 s
->temp_len
= nb_samples
- consumed
;
394 s
->temp
[i
] = av_realloc_array(s
->temp
[i
], s
->temp_len
, sizeof(short));
395 memcpy(s
->temp
[i
], bufin
[i
] + consumed
, s
->temp_len
* sizeof(short));
398 if (s
->output_channels
== 2 && s
->input_channels
== 1) {
399 mono_to_stereo(output
, buftmp3
[0], nb_samples1
);
400 } else if (s
->output_channels
== 6 && s
->input_channels
== 2) {
401 ac3_5p1_mux(output
, buftmp3
[0], buftmp3
[1], nb_samples1
);
402 } else if ((s
->output_channels
== s
->input_channels
&& s
->input_channels
>= 2) ||
403 (s
->output_channels
== 2 && s
->input_channels
== 6)) {
404 interleave(output
, buftmp3
, s
->output_channels
, nb_samples1
);
407 if (s
->sample_fmt
[1] != AV_SAMPLE_FMT_S16
) {
408 int istride
[1] = { 2 };
409 int ostride
[1] = { s
->sample_size
[1] };
410 const void *ibuf
[1] = { output
};
411 void *obuf
[1] = { output_bak
};
413 if (av_audio_convert(s
->convert_ctx
[1], obuf
, ostride
,
414 ibuf
, istride
, nb_samples1
* s
->output_channels
) < 0) {
415 av_log(s
->resample_context
, AV_LOG_ERROR
,
416 "Audio sample format conversion failed\n");
422 for (i
= 0; i
< s
->filter_channels
; i
++) {
430 void audio_resample_close(ReSampleContext
*s
)
433 av_resample_close(s
->resample_context
);
434 for (i
= 0; i
< s
->filter_channels
; i
++)
435 av_freep(&s
->temp
[i
]);
436 av_freep(&s
->buffer
[0]);
437 av_freep(&s
->buffer
[1]);
438 av_audio_convert_free(s
->convert_ctx
[0]);
439 av_audio_convert_free(s
->convert_ctx
[1]);