1 |
|
|
/* |
2 |
|
|
* Opus decoder |
3 |
|
|
* Copyright (c) 2012 Andrew D'Addesio |
4 |
|
|
* Copyright (c) 2013-2014 Mozilla Corporation |
5 |
|
|
* |
6 |
|
|
* This file is part of FFmpeg. |
7 |
|
|
* |
8 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
9 |
|
|
* modify it under the terms of the GNU Lesser General Public |
10 |
|
|
* License as published by the Free Software Foundation; either |
11 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
12 |
|
|
* |
13 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
14 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 |
|
|
* Lesser General Public License for more details. |
17 |
|
|
* |
18 |
|
|
* You should have received a copy of the GNU Lesser General Public |
19 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
20 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
21 |
|
|
*/ |
22 |
|
|
|
23 |
|
|
/** |
24 |
|
|
* @file |
25 |
|
|
* Opus decoder |
26 |
|
|
* @author Andrew D'Addesio, Anton Khirnov |
27 |
|
|
* |
28 |
|
|
* Codec homepage: http://opus-codec.org/ |
29 |
|
|
* Specification: http://tools.ietf.org/html/rfc6716 |
30 |
|
|
* Ogg Opus specification: https://tools.ietf.org/html/draft-ietf-codec-oggopus-03 |
31 |
|
|
* |
32 |
|
|
* Ogg-contained .opus files can be produced with opus-tools: |
33 |
|
|
* http://git.xiph.org/?p=opus-tools.git |
34 |
|
|
*/ |
35 |
|
|
|
36 |
|
|
#include <stdint.h> |
37 |
|
|
|
38 |
|
|
#include "libavutil/attributes.h" |
39 |
|
|
#include "libavutil/audio_fifo.h" |
40 |
|
|
#include "libavutil/channel_layout.h" |
41 |
|
|
#include "libavutil/opt.h" |
42 |
|
|
|
43 |
|
|
#include "libswresample/swresample.h" |
44 |
|
|
|
45 |
|
|
#include "avcodec.h" |
46 |
|
|
#include "get_bits.h" |
47 |
|
|
#include "internal.h" |
48 |
|
|
#include "mathops.h" |
49 |
|
|
#include "opus.h" |
50 |
|
|
#include "opustab.h" |
51 |
|
|
#include "opus_celt.h" |
52 |
|
|
|
53 |
|
|
static const uint16_t silk_frame_duration_ms[16] = { |
54 |
|
|
10, 20, 40, 60, |
55 |
|
|
10, 20, 40, 60, |
56 |
|
|
10, 20, 40, 60, |
57 |
|
|
10, 20, |
58 |
|
|
10, 20, |
59 |
|
|
}; |
60 |
|
|
|
61 |
|
|
/* number of samples of silence to feed to the resampler |
62 |
|
|
* at the beginning */ |
63 |
|
|
static const int silk_resample_delay[] = { |
64 |
|
|
4, 8, 11, 11, 11 |
65 |
|
|
}; |
66 |
|
|
|
67 |
|
26219 |
static int get_silk_samplerate(int config) |
68 |
|
|
{ |
69 |
✓✓ |
26219 |
if (config < 4) |
70 |
|
1551 |
return 8000; |
71 |
✓✓ |
24668 |
else if (config < 8) |
72 |
|
1222 |
return 12000; |
73 |
|
23446 |
return 16000; |
74 |
|
|
} |
75 |
|
|
|
76 |
|
68 |
static void opus_fade(float *out, |
77 |
|
|
const float *in1, const float *in2, |
78 |
|
|
const float *window, int len) |
79 |
|
|
{ |
80 |
|
|
int i; |
81 |
✓✓ |
7268 |
for (i = 0; i < len; i++) |
82 |
|
7200 |
out[i] = in2[i] * window[i] + in1[i] * (1.0 - window[i]); |
83 |
|
68 |
} |
84 |
|
|
|
85 |
|
17 |
static int opus_flush_resample(OpusStreamContext *s, int nb_samples) |
86 |
|
|
{ |
87 |
|
17 |
int celt_size = av_audio_fifo_size(s->celt_delay); |
88 |
|
|
int ret, i; |
89 |
|
17 |
ret = swr_convert(s->swr, |
90 |
|
17 |
(uint8_t**)s->cur_out, nb_samples, |
91 |
|
|
NULL, 0); |
92 |
✗✓ |
17 |
if (ret < 0) |
93 |
|
|
return ret; |
94 |
✗✓ |
17 |
else if (ret != nb_samples) { |
95 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Wrong number of flushed samples: %d\n", |
96 |
|
|
ret); |
97 |
|
|
return AVERROR_BUG; |
98 |
|
|
} |
99 |
|
|
|
100 |
✗✓ |
17 |
if (celt_size) { |
101 |
|
|
if (celt_size != nb_samples) { |
102 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Wrong number of CELT delay samples.\n"); |
103 |
|
|
return AVERROR_BUG; |
104 |
|
|
} |
105 |
|
|
av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples); |
106 |
|
|
for (i = 0; i < s->output_channels; i++) { |
107 |
|
|
s->fdsp->vector_fmac_scalar(s->cur_out[i], |
108 |
|
|
s->celt_output[i], 1.0, |
109 |
|
|
nb_samples); |
110 |
|
|
} |
111 |
|
|
} |
112 |
|
|
|
113 |
✓✓ |
17 |
if (s->redundancy_idx) { |
114 |
✓✓ |
12 |
for (i = 0; i < s->output_channels; i++) |
115 |
|
8 |
opus_fade(s->cur_out[i], s->cur_out[i], |
116 |
|
8 |
s->redundancy_output[i] + 120 + s->redundancy_idx, |
117 |
|
8 |
ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx); |
118 |
|
4 |
s->redundancy_idx = 0; |
119 |
|
|
} |
120 |
|
|
|
121 |
|
17 |
s->cur_out[0] += nb_samples; |
122 |
|
17 |
s->cur_out[1] += nb_samples; |
123 |
|
17 |
s->remaining_out_size -= nb_samples * sizeof(float); |
124 |
|
|
|
125 |
|
17 |
return 0; |
126 |
|
|
} |
127 |
|
|
|
128 |
|
32 |
static int opus_init_resample(OpusStreamContext *s) |
129 |
|
|
{ |
130 |
|
|
static const float delay[16] = { 0.0 }; |
131 |
|
32 |
const uint8_t *delayptr[2] = { (uint8_t*)delay, (uint8_t*)delay }; |
132 |
|
|
int ret; |
133 |
|
|
|
134 |
|
32 |
av_opt_set_int(s->swr, "in_sample_rate", s->silk_samplerate, 0); |
135 |
|
32 |
ret = swr_init(s->swr); |
136 |
✗✓ |
32 |
if (ret < 0) { |
137 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Error opening the resampler.\n"); |
138 |
|
|
return ret; |
139 |
|
|
} |
140 |
|
|
|
141 |
|
32 |
ret = swr_convert(s->swr, |
142 |
|
|
NULL, 0, |
143 |
|
32 |
delayptr, silk_resample_delay[s->packet.bandwidth]); |
144 |
✗✓ |
32 |
if (ret < 0) { |
145 |
|
|
av_log(s->avctx, AV_LOG_ERROR, |
146 |
|
|
"Error feeding initial silence to the resampler.\n"); |
147 |
|
|
return ret; |
148 |
|
|
} |
149 |
|
|
|
150 |
|
32 |
return 0; |
151 |
|
|
} |
152 |
|
|
|
153 |
|
30 |
static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size) |
154 |
|
|
{ |
155 |
|
30 |
int ret = ff_opus_rc_dec_init(&s->redundancy_rc, data, size); |
156 |
✗✓ |
30 |
if (ret < 0) |
157 |
|
|
goto fail; |
158 |
|
30 |
ff_opus_rc_dec_raw_init(&s->redundancy_rc, data + size, size); |
159 |
|
|
|
160 |
|
30 |
ret = ff_celt_decode_frame(s->celt, &s->redundancy_rc, |
161 |
|
30 |
s->redundancy_output, |
162 |
|
30 |
s->packet.stereo + 1, 240, |
163 |
|
30 |
0, ff_celt_band_end[s->packet.bandwidth]); |
164 |
✗✓ |
30 |
if (ret < 0) |
165 |
|
|
goto fail; |
166 |
|
|
|
167 |
|
30 |
return 0; |
168 |
|
|
fail: |
169 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Error decoding the redundancy frame.\n"); |
170 |
|
|
return ret; |
171 |
|
|
} |
172 |
|
|
|
173 |
|
34393 |
static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size) |
174 |
|
|
{ |
175 |
|
34393 |
int samples = s->packet.frame_duration; |
176 |
|
34393 |
int redundancy = 0; |
177 |
|
|
int redundancy_size, redundancy_pos; |
178 |
|
|
int ret, i, consumed; |
179 |
|
34393 |
int delayed_samples = s->delayed_samples; |
180 |
|
|
|
181 |
|
34393 |
ret = ff_opus_rc_dec_init(&s->rc, data, size); |
182 |
✗✓ |
34393 |
if (ret < 0) |
183 |
|
|
return ret; |
184 |
|
|
|
185 |
|
|
/* decode the silk frame */ |
186 |
✓✓✓✓
|
34393 |
if (s->packet.mode == OPUS_MODE_SILK || s->packet.mode == OPUS_MODE_HYBRID) { |
187 |
✓✓ |
9471 |
if (!swr_is_initialized(s->swr)) { |
188 |
|
32 |
ret = opus_init_resample(s); |
189 |
✗✓ |
32 |
if (ret < 0) |
190 |
|
|
return ret; |
191 |
|
|
} |
192 |
|
|
|
193 |
|
9471 |
samples = ff_silk_decode_superframe(s->silk, &s->rc, s->silk_output, |
194 |
|
9471 |
FFMIN(s->packet.bandwidth, OPUS_BANDWIDTH_WIDEBAND), |
195 |
|
9471 |
s->packet.stereo + 1, |
196 |
|
9471 |
silk_frame_duration_ms[s->packet.config]); |
197 |
✗✓ |
9471 |
if (samples < 0) { |
198 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Error decoding a SILK frame.\n"); |
199 |
|
|
return samples; |
200 |
|
|
} |
201 |
|
9471 |
samples = swr_convert(s->swr, |
202 |
|
9471 |
(uint8_t**)s->cur_out, s->packet.frame_duration, |
203 |
|
9471 |
(const uint8_t**)s->silk_output, samples); |
204 |
✗✓ |
9471 |
if (samples < 0) { |
205 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n"); |
206 |
|
|
return samples; |
207 |
|
|
} |
208 |
|
|
av_assert2((samples & 7) == 0); |
209 |
|
9471 |
s->delayed_samples += s->packet.frame_duration - samples; |
210 |
|
|
} else |
211 |
|
24922 |
ff_silk_flush(s->silk); |
212 |
|
|
|
213 |
|
|
// decode redundancy information |
214 |
|
34393 |
consumed = opus_rc_tell(&s->rc); |
215 |
✓✓✓✓
|
34393 |
if (s->packet.mode == OPUS_MODE_HYBRID && consumed + 37 <= size * 8) |
216 |
|
4904 |
redundancy = ff_opus_rc_dec_log(&s->rc, 12); |
217 |
✓✓✓✓
|
29489 |
else if (s->packet.mode == OPUS_MODE_SILK && consumed + 17 <= size * 8) |
218 |
|
14 |
redundancy = 1; |
219 |
|
|
|
220 |
✓✓ |
34393 |
if (redundancy) { |
221 |
|
30 |
redundancy_pos = ff_opus_rc_dec_log(&s->rc, 1); |
222 |
|
|
|
223 |
✓✓ |
30 |
if (s->packet.mode == OPUS_MODE_HYBRID) |
224 |
|
16 |
redundancy_size = ff_opus_rc_dec_uint(&s->rc, 256) + 2; |
225 |
|
|
else |
226 |
|
14 |
redundancy_size = size - (consumed + 7) / 8; |
227 |
|
30 |
size -= redundancy_size; |
228 |
✗✓ |
30 |
if (size < 0) { |
229 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Invalid redundancy frame size.\n"); |
230 |
|
|
return AVERROR_INVALIDDATA; |
231 |
|
|
} |
232 |
|
|
|
233 |
✓✓ |
30 |
if (redundancy_pos) { |
234 |
|
14 |
ret = opus_decode_redundancy(s, data + size, redundancy_size); |
235 |
✗✓ |
14 |
if (ret < 0) |
236 |
|
|
return ret; |
237 |
|
14 |
ff_celt_flush(s->celt); |
238 |
|
|
} |
239 |
|
|
} |
240 |
|
|
|
241 |
|
|
/* decode the CELT frame */ |
242 |
✓✓✓✓
|
64253 |
if (s->packet.mode == OPUS_MODE_CELT || s->packet.mode == OPUS_MODE_HYBRID) { |
243 |
|
29860 |
float *out_tmp[2] = { s->cur_out[0], s->cur_out[1] }; |
244 |
|
59720 |
float **dst = (s->packet.mode == OPUS_MODE_CELT) ? |
245 |
✓✓ |
29860 |
out_tmp : s->celt_output; |
246 |
|
29860 |
int celt_output_samples = samples; |
247 |
|
29860 |
int delay_samples = av_audio_fifo_size(s->celt_delay); |
248 |
|
|
|
249 |
✗✓ |
29860 |
if (delay_samples) { |
250 |
|
|
if (s->packet.mode == OPUS_MODE_HYBRID) { |
251 |
|
|
av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, delay_samples); |
252 |
|
|
|
253 |
|
|
for (i = 0; i < s->output_channels; i++) { |
254 |
|
|
s->fdsp->vector_fmac_scalar(out_tmp[i], s->celt_output[i], 1.0, |
255 |
|
|
delay_samples); |
256 |
|
|
out_tmp[i] += delay_samples; |
257 |
|
|
} |
258 |
|
|
celt_output_samples -= delay_samples; |
259 |
|
|
} else { |
260 |
|
|
av_log(s->avctx, AV_LOG_WARNING, |
261 |
|
|
"Spurious CELT delay samples present.\n"); |
262 |
|
|
av_audio_fifo_drain(s->celt_delay, delay_samples); |
263 |
|
|
if (s->avctx->err_recognition & AV_EF_EXPLODE) |
264 |
|
|
return AVERROR_BUG; |
265 |
|
|
} |
266 |
|
|
} |
267 |
|
|
|
268 |
|
29860 |
ff_opus_rc_dec_raw_init(&s->rc, data + size, size); |
269 |
|
|
|
270 |
|
29860 |
ret = ff_celt_decode_frame(s->celt, &s->rc, dst, |
271 |
|
29860 |
s->packet.stereo + 1, |
272 |
|
|
s->packet.frame_duration, |
273 |
|
29860 |
(s->packet.mode == OPUS_MODE_HYBRID) ? 17 : 0, |
274 |
✓✓ |
29860 |
ff_celt_band_end[s->packet.bandwidth]); |
275 |
✗✓ |
29860 |
if (ret < 0) |
276 |
|
|
return ret; |
277 |
|
|
|
278 |
✓✓ |
29860 |
if (s->packet.mode == OPUS_MODE_HYBRID) { |
279 |
|
4938 |
int celt_delay = s->packet.frame_duration - celt_output_samples; |
280 |
|
4938 |
void *delaybuf[2] = { s->celt_output[0] + celt_output_samples, |
281 |
|
4938 |
s->celt_output[1] + celt_output_samples }; |
282 |
|
|
|
283 |
✓✓ |
14814 |
for (i = 0; i < s->output_channels; i++) { |
284 |
|
9876 |
s->fdsp->vector_fmac_scalar(out_tmp[i], |
285 |
|
9876 |
s->celt_output[i], 1.0, |
286 |
|
|
celt_output_samples); |
287 |
|
|
} |
288 |
|
|
|
289 |
|
4938 |
ret = av_audio_fifo_write(s->celt_delay, delaybuf, celt_delay); |
290 |
✗✓ |
4938 |
if (ret < 0) |
291 |
|
|
return ret; |
292 |
|
|
} |
293 |
|
|
} else |
294 |
|
4533 |
ff_celt_flush(s->celt); |
295 |
|
|
|
296 |
✗✓ |
34393 |
if (s->redundancy_idx) { |
297 |
|
|
for (i = 0; i < s->output_channels; i++) |
298 |
|
|
opus_fade(s->cur_out[i], s->cur_out[i], |
299 |
|
|
s->redundancy_output[i] + 120 + s->redundancy_idx, |
300 |
|
|
ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx); |
301 |
|
|
s->redundancy_idx = 0; |
302 |
|
|
} |
303 |
✓✓ |
34393 |
if (redundancy) { |
304 |
✓✓ |
30 |
if (!redundancy_pos) { |
305 |
|
16 |
ff_celt_flush(s->celt); |
306 |
|
16 |
ret = opus_decode_redundancy(s, data + size, redundancy_size); |
307 |
✗✓ |
16 |
if (ret < 0) |
308 |
|
|
return ret; |
309 |
|
|
|
310 |
✓✓ |
48 |
for (i = 0; i < s->output_channels; i++) { |
311 |
|
32 |
opus_fade(s->cur_out[i] + samples - 120 + delayed_samples, |
312 |
|
32 |
s->cur_out[i] + samples - 120 + delayed_samples, |
313 |
|
32 |
s->redundancy_output[i] + 120, |
314 |
|
|
ff_celt_window2, 120 - delayed_samples); |
315 |
✓✓ |
32 |
if (delayed_samples) |
316 |
|
8 |
s->redundancy_idx = 120 - delayed_samples; |
317 |
|
|
} |
318 |
|
|
} else { |
319 |
✓✓ |
42 |
for (i = 0; i < s->output_channels; i++) { |
320 |
|
28 |
memcpy(s->cur_out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float)); |
321 |
|
28 |
opus_fade(s->cur_out[i] + 120 + delayed_samples, |
322 |
|
28 |
s->redundancy_output[i] + 120, |
323 |
|
28 |
s->cur_out[i] + 120 + delayed_samples, |
324 |
|
|
ff_celt_window2, 120); |
325 |
|
|
} |
326 |
|
|
} |
327 |
|
|
} |
328 |
|
|
|
329 |
|
34393 |
return samples; |
330 |
|
|
} |
331 |
|
|
|
332 |
|
26220 |
static int opus_decode_subpacket(OpusStreamContext *s, |
333 |
|
|
const uint8_t *buf, int buf_size, |
334 |
|
|
int nb_samples) |
335 |
|
|
{ |
336 |
|
26220 |
int output_samples = 0; |
337 |
|
26220 |
int flush_needed = 0; |
338 |
|
|
int i, j, ret; |
339 |
|
|
|
340 |
|
26220 |
s->cur_out[0] = s->out[0]; |
341 |
|
26220 |
s->cur_out[1] = s->out[1]; |
342 |
|
26220 |
s->remaining_out_size = s->out_size; |
343 |
|
|
|
344 |
|
|
/* check if we need to flush the resampler */ |
345 |
✓✓ |
26220 |
if (swr_is_initialized(s->swr)) { |
346 |
✓✓ |
9012 |
if (buf) { |
347 |
|
|
int64_t cur_samplerate; |
348 |
|
9011 |
av_opt_get_int(s->swr, "in_sample_rate", 0, &cur_samplerate); |
349 |
✓✓✓✓
|
9011 |
flush_needed = (s->packet.mode == OPUS_MODE_CELT) || (cur_samplerate != s->silk_samplerate); |
350 |
|
|
} else { |
351 |
|
1 |
flush_needed = !!s->delayed_samples; |
352 |
|
|
} |
353 |
|
|
} |
354 |
|
|
|
355 |
✓✓✗✓
|
26220 |
if (!buf && !flush_needed) |
356 |
|
|
return 0; |
357 |
|
|
|
358 |
|
|
/* use dummy output buffers if the channel is not mapped to anything */ |
359 |
✓✗ |
26220 |
if (!s->cur_out[0] || |
360 |
✓✓✗✓
|
26220 |
(s->output_channels == 2 && !s->cur_out[1])) { |
361 |
|
|
av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size, |
362 |
|
|
s->remaining_out_size); |
363 |
|
|
if (!s->out_dummy) |
364 |
|
|
return AVERROR(ENOMEM); |
365 |
|
|
if (!s->cur_out[0]) |
366 |
|
|
s->cur_out[0] = s->out_dummy; |
367 |
|
|
if (!s->cur_out[1]) |
368 |
|
|
s->cur_out[1] = s->out_dummy; |
369 |
|
|
} |
370 |
|
|
|
371 |
|
|
/* flush the resampler if necessary */ |
372 |
✓✓ |
26220 |
if (flush_needed) { |
373 |
|
17 |
ret = opus_flush_resample(s, s->delayed_samples); |
374 |
✗✓ |
17 |
if (ret < 0) { |
375 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Error flushing the resampler.\n"); |
376 |
|
|
return ret; |
377 |
|
|
} |
378 |
|
17 |
swr_close(s->swr); |
379 |
|
17 |
output_samples += s->delayed_samples; |
380 |
|
17 |
s->delayed_samples = 0; |
381 |
|
|
|
382 |
✓✓ |
17 |
if (!buf) |
383 |
|
1 |
goto finish; |
384 |
|
|
} |
385 |
|
|
|
386 |
|
|
/* decode all the frames in the packet */ |
387 |
✓✓ |
60612 |
for (i = 0; i < s->packet.frame_count; i++) { |
388 |
|
34393 |
int size = s->packet.frame_size[i]; |
389 |
|
34393 |
int samples = opus_decode_frame(s, buf + s->packet.frame_offset[i], size); |
390 |
|
|
|
391 |
✗✓ |
34393 |
if (samples < 0) { |
392 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Error decoding an Opus frame.\n"); |
393 |
|
|
if (s->avctx->err_recognition & AV_EF_EXPLODE) |
394 |
|
|
return samples; |
395 |
|
|
|
396 |
|
|
for (j = 0; j < s->output_channels; j++) |
397 |
|
|
memset(s->cur_out[j], 0, s->packet.frame_duration * sizeof(float)); |
398 |
|
|
samples = s->packet.frame_duration; |
399 |
|
|
} |
400 |
|
34393 |
output_samples += samples; |
401 |
|
|
|
402 |
✓✓ |
100113 |
for (j = 0; j < s->output_channels; j++) |
403 |
|
65720 |
s->cur_out[j] += samples; |
404 |
|
34393 |
s->remaining_out_size -= samples * sizeof(float); |
405 |
|
|
} |
406 |
|
|
|
407 |
|
26219 |
finish: |
408 |
|
26220 |
s->cur_out[0] = s->cur_out[1] = NULL; |
409 |
|
26220 |
s->remaining_out_size = 0; |
410 |
|
|
|
411 |
|
26220 |
return output_samples; |
412 |
|
|
} |
413 |
|
|
|
414 |
|
21636 |
static int opus_decode_packet(AVCodecContext *avctx, void *data, |
415 |
|
|
int *got_frame_ptr, AVPacket *avpkt) |
416 |
|
|
{ |
417 |
|
21636 |
OpusContext *c = avctx->priv_data; |
418 |
|
21636 |
AVFrame *frame = data; |
419 |
|
21636 |
const uint8_t *buf = avpkt->data; |
420 |
|
21636 |
int buf_size = avpkt->size; |
421 |
|
21636 |
int coded_samples = 0; |
422 |
|
21636 |
int decoded_samples = INT_MAX; |
423 |
|
21636 |
int delayed_samples = 0; |
424 |
|
|
int i, ret; |
425 |
|
|
|
426 |
|
|
/* calculate the number of delayed samples */ |
427 |
✓✓ |
47872 |
for (i = 0; i < c->nb_streams; i++) { |
428 |
|
26236 |
OpusStreamContext *s = &c->streams[i]; |
429 |
|
26236 |
s->out[0] = |
430 |
|
26236 |
s->out[1] = NULL; |
431 |
✓✗ |
26236 |
delayed_samples = FFMAX(delayed_samples, |
432 |
|
|
s->delayed_samples + av_audio_fifo_size(s->sync_buffer)); |
433 |
|
|
} |
434 |
|
|
|
435 |
|
|
/* decode the header of the first sub-packet to find out the sample count */ |
436 |
✓✓ |
21636 |
if (buf) { |
437 |
|
21622 |
OpusPacket *pkt = &c->streams[0].packet; |
438 |
|
21622 |
ret = ff_opus_parse_packet(pkt, buf, buf_size, c->nb_streams > 1); |
439 |
✗✓ |
21622 |
if (ret < 0) { |
440 |
|
|
av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n"); |
441 |
|
|
return ret; |
442 |
|
|
} |
443 |
|
21622 |
coded_samples += pkt->frame_count * pkt->frame_duration; |
444 |
|
21622 |
c->streams[0].silk_samplerate = get_silk_samplerate(pkt->config); |
445 |
|
|
} |
446 |
|
|
|
447 |
|
21636 |
frame->nb_samples = coded_samples + delayed_samples; |
448 |
|
|
|
449 |
|
|
/* no input or buffered data => nothing to do */ |
450 |
✓✓ |
21636 |
if (!frame->nb_samples) { |
451 |
|
13 |
*got_frame_ptr = 0; |
452 |
|
13 |
return 0; |
453 |
|
|
} |
454 |
|
|
|
455 |
|
|
/* setup the data buffers */ |
456 |
|
21623 |
ret = ff_get_buffer(avctx, frame, 0); |
457 |
✗✓ |
21623 |
if (ret < 0) |
458 |
|
|
return ret; |
459 |
|
21623 |
frame->nb_samples = 0; |
460 |
|
|
|
461 |
✓✓ |
70997 |
for (i = 0; i < avctx->channels; i++) { |
462 |
|
49374 |
ChannelMap *map = &c->channel_maps[i]; |
463 |
✓✗ |
49374 |
if (!map->copy) |
464 |
|
49374 |
c->streams[map->stream_idx].out[map->channel_idx] = (float*)frame->extended_data[i]; |
465 |
|
|
} |
466 |
|
|
|
467 |
|
|
/* read the data from the sync buffers */ |
468 |
✓✓ |
47843 |
for (i = 0; i < c->nb_streams; i++) { |
469 |
|
26220 |
OpusStreamContext *s = &c->streams[i]; |
470 |
|
26220 |
float **out = s->out; |
471 |
|
26220 |
int sync_size = av_audio_fifo_size(s->sync_buffer); |
472 |
|
|
|
473 |
|
|
float sync_dummy[32]; |
474 |
✓✓ |
26220 |
int out_dummy = (!out[0]) | ((!out[1]) << 1); |
475 |
|
|
|
476 |
✗✓ |
26220 |
if (!out[0]) |
477 |
|
|
out[0] = sync_dummy; |
478 |
✓✓ |
26220 |
if (!out[1]) |
479 |
|
3066 |
out[1] = sync_dummy; |
480 |
✓✓✗✓
|
26220 |
if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy)) |
481 |
|
|
return AVERROR_BUG; |
482 |
|
|
|
483 |
|
26220 |
ret = av_audio_fifo_read(s->sync_buffer, (void**)out, sync_size); |
484 |
✗✓ |
26220 |
if (ret < 0) |
485 |
|
|
return ret; |
486 |
|
|
|
487 |
✗✓ |
26220 |
if (out_dummy & 1) |
488 |
|
|
out[0] = NULL; |
489 |
|
|
else |
490 |
|
26220 |
out[0] += ret; |
491 |
✓✓ |
26220 |
if (out_dummy & 2) |
492 |
|
3066 |
out[1] = NULL; |
493 |
|
|
else |
494 |
|
23154 |
out[1] += ret; |
495 |
|
|
|
496 |
|
26220 |
s->out_size = frame->linesize[0] - ret * sizeof(float); |
497 |
|
|
} |
498 |
|
|
|
499 |
|
|
/* decode each sub-packet */ |
500 |
✓✓ |
47843 |
for (i = 0; i < c->nb_streams; i++) { |
501 |
|
26220 |
OpusStreamContext *s = &c->streams[i]; |
502 |
|
|
|
503 |
✓✓✓✗
|
26220 |
if (i && buf) { |
504 |
|
4597 |
ret = ff_opus_parse_packet(&s->packet, buf, buf_size, i != c->nb_streams - 1); |
505 |
✗✓ |
4597 |
if (ret < 0) { |
506 |
|
|
av_log(avctx, AV_LOG_ERROR, "Error parsing the packet header.\n"); |
507 |
|
|
return ret; |
508 |
|
|
} |
509 |
✗✓ |
4597 |
if (coded_samples != s->packet.frame_count * s->packet.frame_duration) { |
510 |
|
|
av_log(avctx, AV_LOG_ERROR, |
511 |
|
|
"Mismatching coded sample count in substream %d.\n", i); |
512 |
|
|
return AVERROR_INVALIDDATA; |
513 |
|
|
} |
514 |
|
|
|
515 |
|
4597 |
s->silk_samplerate = get_silk_samplerate(s->packet.config); |
516 |
|
|
} |
517 |
|
|
|
518 |
|
26220 |
ret = opus_decode_subpacket(&c->streams[i], buf, s->packet.data_size, |
519 |
|
|
coded_samples); |
520 |
✗✓ |
26220 |
if (ret < 0) |
521 |
|
|
return ret; |
522 |
|
26220 |
s->decoded_samples = ret; |
523 |
|
26220 |
decoded_samples = FFMIN(decoded_samples, ret); |
524 |
|
|
|
525 |
|
26220 |
buf += s->packet.packet_size; |
526 |
|
26220 |
buf_size -= s->packet.packet_size; |
527 |
|
|
} |
528 |
|
|
|
529 |
|
|
/* buffer the extra samples */ |
530 |
✓✓ |
47843 |
for (i = 0; i < c->nb_streams; i++) { |
531 |
|
26220 |
OpusStreamContext *s = &c->streams[i]; |
532 |
|
26220 |
int buffer_samples = s->decoded_samples - decoded_samples; |
533 |
✗✓ |
26220 |
if (buffer_samples) { |
534 |
|
|
float *buf[2] = { s->out[0] ? s->out[0] : (float*)frame->extended_data[0], |
535 |
|
|
s->out[1] ? s->out[1] : (float*)frame->extended_data[0] }; |
536 |
|
|
buf[0] += decoded_samples; |
537 |
|
|
buf[1] += decoded_samples; |
538 |
|
|
ret = av_audio_fifo_write(s->sync_buffer, (void**)buf, buffer_samples); |
539 |
|
|
if (ret < 0) |
540 |
|
|
return ret; |
541 |
|
|
} |
542 |
|
|
} |
543 |
|
|
|
544 |
✓✓ |
70997 |
for (i = 0; i < avctx->channels; i++) { |
545 |
|
49374 |
ChannelMap *map = &c->channel_maps[i]; |
546 |
|
|
|
547 |
|
|
/* handle copied channels */ |
548 |
✗✓ |
49374 |
if (map->copy) { |
549 |
|
|
memcpy(frame->extended_data[i], |
550 |
|
|
frame->extended_data[map->copy_idx], |
551 |
|
|
frame->linesize[0]); |
552 |
✗✓ |
49374 |
} else if (map->silence) { |
553 |
|
|
memset(frame->extended_data[i], 0, frame->linesize[0]); |
554 |
|
|
} |
555 |
|
|
|
556 |
✗✓✗✗
|
49374 |
if (c->gain_i && decoded_samples > 0) { |
557 |
|
|
c->fdsp->vector_fmul_scalar((float*)frame->extended_data[i], |
558 |
|
|
(float*)frame->extended_data[i], |
559 |
|
|
c->gain, FFALIGN(decoded_samples, 8)); |
560 |
|
|
} |
561 |
|
|
} |
562 |
|
|
|
563 |
|
21623 |
frame->nb_samples = decoded_samples; |
564 |
|
21623 |
*got_frame_ptr = !!decoded_samples; |
565 |
|
|
|
566 |
|
21623 |
return avpkt->size; |
567 |
|
|
} |
568 |
|
|
|
569 |
|
|
static av_cold void opus_decode_flush(AVCodecContext *ctx) |
570 |
|
|
{ |
571 |
|
|
OpusContext *c = ctx->priv_data; |
572 |
|
|
int i; |
573 |
|
|
|
574 |
|
|
for (i = 0; i < c->nb_streams; i++) { |
575 |
|
|
OpusStreamContext *s = &c->streams[i]; |
576 |
|
|
|
577 |
|
|
memset(&s->packet, 0, sizeof(s->packet)); |
578 |
|
|
s->delayed_samples = 0; |
579 |
|
|
|
580 |
|
|
av_audio_fifo_drain(s->celt_delay, av_audio_fifo_size(s->celt_delay)); |
581 |
|
|
swr_close(s->swr); |
582 |
|
|
|
583 |
|
|
av_audio_fifo_drain(s->sync_buffer, av_audio_fifo_size(s->sync_buffer)); |
584 |
|
|
|
585 |
|
|
ff_silk_flush(s->silk); |
586 |
|
|
ff_celt_flush(s->celt); |
587 |
|
|
} |
588 |
|
|
} |
589 |
|
|
|
590 |
|
31 |
static av_cold int opus_decode_close(AVCodecContext *avctx) |
591 |
|
|
{ |
592 |
|
31 |
OpusContext *c = avctx->priv_data; |
593 |
|
|
int i; |
594 |
|
|
|
595 |
✓✓ |
72 |
for (i = 0; i < c->nb_streams; i++) { |
596 |
|
41 |
OpusStreamContext *s = &c->streams[i]; |
597 |
|
|
|
598 |
|
41 |
ff_silk_free(&s->silk); |
599 |
|
41 |
ff_celt_free(&s->celt); |
600 |
|
|
|
601 |
|
41 |
av_freep(&s->out_dummy); |
602 |
|
41 |
s->out_dummy_allocated_size = 0; |
603 |
|
|
|
604 |
|
41 |
av_audio_fifo_free(s->sync_buffer); |
605 |
|
41 |
av_audio_fifo_free(s->celt_delay); |
606 |
|
41 |
swr_free(&s->swr); |
607 |
|
|
} |
608 |
|
|
|
609 |
|
31 |
av_freep(&c->streams); |
610 |
|
|
|
611 |
|
31 |
c->nb_streams = 0; |
612 |
|
|
|
613 |
|
31 |
av_freep(&c->channel_maps); |
614 |
|
31 |
av_freep(&c->fdsp); |
615 |
|
|
|
616 |
|
31 |
return 0; |
617 |
|
|
} |
618 |
|
|
|
619 |
|
31 |
static av_cold int opus_decode_init(AVCodecContext *avctx) |
620 |
|
|
{ |
621 |
|
31 |
OpusContext *c = avctx->priv_data; |
622 |
|
|
int ret, i, j; |
623 |
|
|
|
624 |
|
31 |
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; |
625 |
|
31 |
avctx->sample_rate = 48000; |
626 |
|
|
|
627 |
|
31 |
c->fdsp = avpriv_float_dsp_alloc(0); |
628 |
✗✓ |
31 |
if (!c->fdsp) |
629 |
|
|
return AVERROR(ENOMEM); |
630 |
|
|
|
631 |
|
|
/* find out the channel configuration */ |
632 |
|
31 |
ret = ff_opus_parse_extradata(avctx, c); |
633 |
✗✓ |
31 |
if (ret < 0) |
634 |
|
|
return ret; |
635 |
|
|
|
636 |
|
|
/* allocate and init each independent decoder */ |
637 |
|
31 |
c->streams = av_mallocz_array(c->nb_streams, sizeof(*c->streams)); |
638 |
✗✓ |
31 |
if (!c->streams) { |
639 |
|
|
c->nb_streams = 0; |
640 |
|
|
return AVERROR(ENOMEM); |
641 |
|
|
} |
642 |
|
|
|
643 |
✓✓ |
72 |
for (i = 0; i < c->nb_streams; i++) { |
644 |
|
41 |
OpusStreamContext *s = &c->streams[i]; |
645 |
|
|
uint64_t layout; |
646 |
|
|
|
647 |
✓✓ |
41 |
s->output_channels = (i < c->nb_stereo_streams) ? 2 : 1; |
648 |
|
|
|
649 |
|
41 |
s->avctx = avctx; |
650 |
|
|
|
651 |
✓✓ |
115 |
for (j = 0; j < s->output_channels; j++) { |
652 |
|
74 |
s->silk_output[j] = s->silk_buf[j]; |
653 |
|
74 |
s->celt_output[j] = s->celt_buf[j]; |
654 |
|
74 |
s->redundancy_output[j] = s->redundancy_buf[j]; |
655 |
|
|
} |
656 |
|
|
|
657 |
|
41 |
s->fdsp = c->fdsp; |
658 |
|
|
|
659 |
|
41 |
s->swr =swr_alloc(); |
660 |
✗✓ |
41 |
if (!s->swr) |
661 |
|
|
return AVERROR(ENOMEM); |
662 |
|
|
|
663 |
✓✓ |
41 |
layout = (s->output_channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO; |
664 |
|
41 |
av_opt_set_int(s->swr, "in_sample_fmt", avctx->sample_fmt, 0); |
665 |
|
41 |
av_opt_set_int(s->swr, "out_sample_fmt", avctx->sample_fmt, 0); |
666 |
|
41 |
av_opt_set_int(s->swr, "in_channel_layout", layout, 0); |
667 |
|
41 |
av_opt_set_int(s->swr, "out_channel_layout", layout, 0); |
668 |
|
41 |
av_opt_set_int(s->swr, "out_sample_rate", avctx->sample_rate, 0); |
669 |
|
41 |
av_opt_set_int(s->swr, "filter_size", 16, 0); |
670 |
|
|
|
671 |
|
41 |
ret = ff_silk_init(avctx, &s->silk, s->output_channels); |
672 |
✗✓ |
41 |
if (ret < 0) |
673 |
|
|
return ret; |
674 |
|
|
|
675 |
|
41 |
ret = ff_celt_init(avctx, &s->celt, s->output_channels, c->apply_phase_inv); |
676 |
✗✓ |
41 |
if (ret < 0) |
677 |
|
|
return ret; |
678 |
|
|
|
679 |
|
41 |
s->celt_delay = av_audio_fifo_alloc(avctx->sample_fmt, |
680 |
|
|
s->output_channels, 1024); |
681 |
✗✓ |
41 |
if (!s->celt_delay) |
682 |
|
|
return AVERROR(ENOMEM); |
683 |
|
|
|
684 |
|
41 |
s->sync_buffer = av_audio_fifo_alloc(avctx->sample_fmt, |
685 |
|
|
s->output_channels, 32); |
686 |
✗✓ |
41 |
if (!s->sync_buffer) |
687 |
|
|
return AVERROR(ENOMEM); |
688 |
|
|
} |
689 |
|
|
|
690 |
|
31 |
return 0; |
691 |
|
|
} |
692 |
|
|
|
693 |
|
|
#define OFFSET(x) offsetof(OpusContext, x) |
694 |
|
|
#define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM |
695 |
|
|
static const AVOption opus_options[] = { |
696 |
|
|
{ "apply_phase_inv", "Apply intensity stereo phase inversion", OFFSET(apply_phase_inv), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AD }, |
697 |
|
|
{ NULL }, |
698 |
|
|
}; |
699 |
|
|
|
700 |
|
|
static const AVClass opus_class = { |
701 |
|
|
.class_name = "Opus Decoder", |
702 |
|
|
.item_name = av_default_item_name, |
703 |
|
|
.option = opus_options, |
704 |
|
|
.version = LIBAVUTIL_VERSION_INT, |
705 |
|
|
}; |
706 |
|
|
|
707 |
|
|
AVCodec ff_opus_decoder = { |
708 |
|
|
.name = "opus", |
709 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("Opus"), |
710 |
|
|
.priv_class = &opus_class, |
711 |
|
|
.type = AVMEDIA_TYPE_AUDIO, |
712 |
|
|
.id = AV_CODEC_ID_OPUS, |
713 |
|
|
.priv_data_size = sizeof(OpusContext), |
714 |
|
|
.init = opus_decode_init, |
715 |
|
|
.close = opus_decode_close, |
716 |
|
|
.decode = opus_decode_packet, |
717 |
|
|
.flush = opus_decode_flush, |
718 |
|
|
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_CHANNEL_CONF, |
719 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, |
720 |
|
|
}; |