FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/ffwavesynth.c
Date: 2022-11-28 23:49:43
Exec Total Coverage
Lines: 0 247 0.0%
Branches: 0 122 0.0%

Line Branch Exec Source
1 /*
2 * Wavesynth pseudo-codec
3 * Copyright (c) 2011 Nicolas George
4 *
5 * This file is part of FFmpeg.
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/log.h"
24 #include "avcodec.h"
25 #include "codec_internal.h"
26 #include "decode.h"
27
28
29 #define SIN_BITS 14
30 #define WS_MAX_CHANNELS 32
31 #define INF_TS 0x7FFFFFFFFFFFFFFF
32
33 #define PINK_UNIT 128
34
35 /*
36 Format of the extradata and packets
37
38 THIS INFORMATION IS NOT PART OF THE PUBLIC API OR ABI.
39 IT CAN CHANGE WITHOUT NOTIFICATION.
40
41 All numbers are in little endian.
42
43 The codec extradata define a set of intervals with uniform content.
44 Overlapping intervals are added together.
45
46 extradata:
47 uint32 number of intervals
48 ... intervals
49
50 interval:
51 int64 start timestamp; time_base must be 1/sample_rate;
52 start timestamps must be in ascending order
53 int64 end timestamp
54 uint32 type
55 uint32 channels mask
56 ... additional information, depends on type
57
58 sine interval (type fourcc "SINE"):
59 int32 start frequency, in 1/(1<<16) Hz
60 int32 end frequency
61 int32 start amplitude, 1<<16 is the full amplitude
62 int32 end amplitude
63 uint32 start phase, 0 is sin(0), 0x20000000 is sin(pi/2), etc.;
64 n | (1<<31) means to match the phase of previous channel #n
65
66 pink noise interval (type fourcc "NOIS"):
67 int32 start amplitude
68 int32 end amplitude
69
70 The input packets encode the time and duration of the requested segment.
71
72 packet:
73 int64 start timestamp
74 int32 duration
75
76 */
77
78 enum ws_interval_type {
79 WS_SINE = MKTAG('S','I','N','E'),
80 WS_NOISE = MKTAG('N','O','I','S'),
81 };
82
83 struct ws_interval {
84 int64_t ts_start, ts_end;
85 uint64_t phi0, dphi0, ddphi;
86 uint64_t amp0, damp;
87 uint64_t phi, dphi, amp;
88 uint32_t channels;
89 enum ws_interval_type type;
90 int next;
91 };
92
93 struct wavesynth_context {
94 int64_t cur_ts;
95 int64_t next_ts;
96 int32_t *sin;
97 struct ws_interval *inter;
98 uint32_t dither_state;
99 uint32_t pink_state;
100 int32_t pink_pool[PINK_UNIT];
101 unsigned pink_need, pink_pos;
102 int nb_inter;
103 int cur_inter;
104 int next_inter;
105 };
106
107 #define LCG_A 1284865837
108 #define LCG_C 4150755663
109 #define LCG_AI 849225893 /* A*AI = 1 [mod 1<<32] */
110
111 static uint32_t lcg_next(uint32_t *s)
112 {
113 *s = *s * LCG_A + LCG_C;
114 return *s;
115 }
116
117 static void lcg_seek(uint32_t *s, uint32_t dt)
118 {
119 uint32_t a, c, t = *s;
120
121 a = LCG_A;
122 c = LCG_C;
123 while (dt) {
124 if (dt & 1)
125 t = a * t + c;
126 c *= a + 1; /* coefficients for a double step */
127 a *= a;
128 dt >>= 1;
129 }
130 *s = t;
131 }
132
133 /* Emulate pink noise by summing white noise at the sampling frequency,
134 * white noise at half the sampling frequency (each value taken twice),
135 * etc., with a total of 8 octaves.
136 * This is known as the Voss-McCartney algorithm. */
137
138 static void pink_fill(struct wavesynth_context *ws)
139 {
140 int32_t vt[7] = { 0 }, v = 0;
141 int i, j;
142
143 ws->pink_pos = 0;
144 if (!ws->pink_need)
145 return;
146 for (i = 0; i < PINK_UNIT; i++) {
147 for (j = 0; j < 7; j++) {
148 if ((i >> j) & 1)
149 break;
150 v -= vt[j];
151 vt[j] = (int32_t)lcg_next(&ws->pink_state) >> 3;
152 v += vt[j];
153 }
154 ws->pink_pool[i] = v + ((int32_t)lcg_next(&ws->pink_state) >> 3);
155 }
156 lcg_next(&ws->pink_state); /* so we use exactly 256 steps */
157 }
158
159 /**
160 * @return (1<<64) * a / b, without overflow, if a < b
161 */
162 static uint64_t frac64(uint64_t a, uint64_t b)
163 {
164 uint64_t r = 0;
165 int i;
166
167 if (b < (uint64_t)1 << 32) { /* b small, use two 32-bits steps */
168 a <<= 32;
169 return ((a / b) << 32) | ((a % b) << 32) / b;
170 }
171 if (b < (uint64_t)1 << 48) { /* b medium, use four 16-bits steps */
172 for (i = 0; i < 4; i++) {
173 a <<= 16;
174 r = (r << 16) | (a / b);
175 a %= b;
176 }
177 return r;
178 }
179 for (i = 63; i >= 0; i--) {
180 if (a >= (uint64_t)1 << 63 || a << 1 >= b) {
181 r |= (uint64_t)1 << i;
182 a = (a << 1) - b;
183 } else {
184 a <<= 1;
185 }
186 }
187 return r;
188 }
189
190 static uint64_t phi_at(struct ws_interval *in, int64_t ts)
191 {
192 uint64_t dt = ts - (uint64_t)in->ts_start;
193 uint64_t dt2 = dt & 1 ? /* dt * (dt - 1) / 2 without overflow */
194 dt * ((dt - 1) >> 1) : (dt >> 1) * (dt - 1);
195 return in->phi0 + dt * in->dphi0 + dt2 * in->ddphi;
196 }
197
198 static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
199 {
200 int *last, i;
201 struct ws_interval *in;
202
203 last = &ws->cur_inter;
204 for (i = 0; i < ws->nb_inter; i++) {
205 in = &ws->inter[i];
206 if (ts < in->ts_start)
207 break;
208 if (ts >= in->ts_end)
209 continue;
210 *last = i;
211 last = &in->next;
212 in->phi = phi_at(in, ts);
213 in->dphi = in->dphi0 + (ts - in->ts_start) * in->ddphi;
214 in->amp = in->amp0 + (ts - in->ts_start) * in->damp;
215 }
216 ws->next_inter = i;
217 ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
218 *last = -1;
219 lcg_seek(&ws->dither_state, (uint32_t)ts - (uint32_t)ws->cur_ts);
220 if (ws->pink_need) {
221 uint64_t pink_ts_cur = (ws->cur_ts + (uint64_t)PINK_UNIT - 1) & ~(PINK_UNIT - 1);
222 uint64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
223 int pos = ts & (PINK_UNIT - 1);
224 lcg_seek(&ws->pink_state, (uint32_t)(pink_ts_next - pink_ts_cur) * 2);
225 if (pos) {
226 pink_fill(ws);
227 ws->pink_pos = pos;
228 } else {
229 ws->pink_pos = PINK_UNIT;
230 }
231 }
232 ws->cur_ts = ts;
233 }
234
235 static int wavesynth_parse_extradata(AVCodecContext *avc)
236 {
237 struct wavesynth_context *ws = avc->priv_data;
238 struct ws_interval *in;
239 uint8_t *edata, *edata_end;
240 int32_t f1, f2, a1, a2;
241 uint32_t phi;
242 int64_t dphi1, dphi2, dt, cur_ts = -0x8000000000000000;
243 int i;
244
245 if (avc->extradata_size < 4)
246 return AVERROR(EINVAL);
247 edata = avc->extradata;
248 edata_end = edata + avc->extradata_size;
249 ws->nb_inter = AV_RL32(edata);
250 edata += 4;
251 if (ws->nb_inter < 0 || (edata_end - edata) / 24 < ws->nb_inter)
252 return AVERROR(EINVAL);
253 ws->inter = av_calloc(ws->nb_inter, sizeof(*ws->inter));
254 if (!ws->inter)
255 return AVERROR(ENOMEM);
256 for (i = 0; i < ws->nb_inter; i++) {
257 in = &ws->inter[i];
258 if (edata_end - edata < 24)
259 return AVERROR(EINVAL);
260 in->ts_start = AV_RL64(edata + 0);
261 in->ts_end = AV_RL64(edata + 8);
262 in->type = AV_RL32(edata + 16);
263 in->channels = AV_RL32(edata + 20);
264 edata += 24;
265 if (in->ts_start < cur_ts ||
266 in->ts_end <= in->ts_start ||
267 (uint64_t)in->ts_end - in->ts_start > INT64_MAX
268 )
269 return AVERROR(EINVAL);
270 cur_ts = in->ts_start;
271 dt = in->ts_end - in->ts_start;
272 switch (in->type) {
273 case WS_SINE:
274 if (edata_end - edata < 20 || avc->sample_rate <= 0)
275 return AVERROR(EINVAL);
276 f1 = AV_RL32(edata + 0);
277 f2 = AV_RL32(edata + 4);
278 a1 = AV_RL32(edata + 8);
279 a2 = AV_RL32(edata + 12);
280 phi = AV_RL32(edata + 16);
281 edata += 20;
282 dphi1 = frac64(f1, (int64_t)avc->sample_rate << 16);
283 dphi2 = frac64(f2, (int64_t)avc->sample_rate << 16);
284 in->dphi0 = dphi1;
285 in->ddphi = (int64_t)(dphi2 - (uint64_t)dphi1) / dt;
286 if (phi & 0x80000000) {
287 phi &= ~0x80000000;
288 if (phi >= i)
289 return AVERROR(EINVAL);
290 in->phi0 = phi_at(&ws->inter[phi], in->ts_start);
291 } else {
292 in->phi0 = (uint64_t)phi << 33;
293 }
294 break;
295 case WS_NOISE:
296 if (edata_end - edata < 8)
297 return AVERROR(EINVAL);
298 a1 = AV_RL32(edata + 0);
299 a2 = AV_RL32(edata + 4);
300 edata += 8;
301 break;
302 default:
303 return AVERROR(EINVAL);
304 }
305 in->amp0 = (uint64_t)a1 << 32;
306 in->damp = (int64_t)(((uint64_t)a2 << 32) - ((uint64_t)a1 << 32)) / dt;
307 }
308 if (edata != edata_end)
309 return AVERROR(EINVAL);
310 return 0;
311 }
312
313 static av_cold int wavesynth_init(AVCodecContext *avc)
314 {
315 struct wavesynth_context *ws = avc->priv_data;
316 int i, r;
317
318 if (avc->ch_layout.nb_channels > WS_MAX_CHANNELS) {
319 av_log(avc, AV_LOG_ERROR,
320 "This implementation is limited to %d channels.\n",
321 WS_MAX_CHANNELS);
322 return AVERROR(EINVAL);
323 }
324 r = wavesynth_parse_extradata(avc);
325 if (r < 0) {
326 av_log(avc, AV_LOG_ERROR, "Invalid intervals definitions.\n");
327 return r;
328 }
329 ws->sin = av_malloc(sizeof(*ws->sin) << SIN_BITS);
330 if (!ws->sin)
331 return AVERROR(ENOMEM);
332 for (i = 0; i < 1 << SIN_BITS; i++)
333 ws->sin[i] = floor(32767 * sin(2 * M_PI * i / (1 << SIN_BITS)));
334 ws->dither_state = MKTAG('D','I','T','H');
335 for (i = 0; i < ws->nb_inter; i++)
336 ws->pink_need += ws->inter[i].type == WS_NOISE;
337 ws->pink_state = MKTAG('P','I','N','K');
338 ws->pink_pos = PINK_UNIT;
339 wavesynth_seek(ws, 0);
340 avc->sample_fmt = AV_SAMPLE_FMT_S16;
341 return 0;
342 }
343
344 static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
345 int32_t *channels)
346 {
347 int32_t amp, *cv;
348 unsigned val;
349 struct ws_interval *in;
350 int i, *last, pink;
351 uint32_t c, all_ch = 0;
352
353 i = ws->cur_inter;
354 last = &ws->cur_inter;
355 if (ws->pink_pos == PINK_UNIT)
356 pink_fill(ws);
357 pink = ws->pink_pool[ws->pink_pos++] >> 16;
358 while (i >= 0) {
359 in = &ws->inter[i];
360 i = in->next;
361 if (ts >= in->ts_end) {
362 *last = i;
363 continue;
364 }
365 last = &in->next;
366 amp = in->amp >> 32;
367 in->amp += in->damp;
368 switch (in->type) {
369 case WS_SINE:
370 val = amp * (unsigned)ws->sin[in->phi >> (64 - SIN_BITS)];
371 in->phi += in->dphi;
372 in->dphi += in->ddphi;
373 break;
374 case WS_NOISE:
375 val = amp * (unsigned)pink;
376 break;
377 default:
378 val = 0;
379 }
380 all_ch |= in->channels;
381 for (c = in->channels, cv = channels; c; c >>= 1, cv++)
382 if (c & 1)
383 *cv += (unsigned)val;
384 }
385 val = (int32_t)lcg_next(&ws->dither_state) >> 16;
386 for (c = all_ch, cv = channels; c; c >>= 1, cv++)
387 if (c & 1)
388 *cv += val;
389 }
390
391 static void wavesynth_enter_intervals(struct wavesynth_context *ws, int64_t ts)
392 {
393 int *last, i;
394 struct ws_interval *in;
395
396 last = &ws->cur_inter;
397 for (i = ws->cur_inter; i >= 0; i = ws->inter[i].next)
398 last = &ws->inter[i].next;
399 for (i = ws->next_inter; i < ws->nb_inter; i++) {
400 in = &ws->inter[i];
401 if (ts < in->ts_start)
402 break;
403 if (ts >= in->ts_end)
404 continue;
405 *last = i;
406 last = &in->next;
407 in->phi = in->phi0;
408 in->dphi = in->dphi0;
409 in->amp = in->amp0;
410 }
411 ws->next_inter = i;
412 ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
413 *last = -1;
414 }
415
416 static int wavesynth_decode(AVCodecContext *avc, AVFrame *frame,
417 int *rgot_frame, AVPacket *packet)
418 {
419 struct wavesynth_context *ws = avc->priv_data;
420 int64_t ts;
421 int duration;
422 int s, c, r;
423 int16_t *pcm;
424 int32_t channels[WS_MAX_CHANNELS];
425
426 *rgot_frame = 0;
427 if (packet->size != 12)
428 return AVERROR_INVALIDDATA;
429 ts = AV_RL64(packet->data);
430 if (ts != ws->cur_ts)
431 wavesynth_seek(ws, ts);
432 duration = AV_RL32(packet->data + 8);
433 if (duration <= 0)
434 return AVERROR(EINVAL);
435 frame->nb_samples = duration;
436 r = ff_get_buffer(avc, frame, 0);
437 if (r < 0)
438 return r;
439 pcm = (int16_t *)frame->data[0];
440 for (s = 0; s < duration; s++, ts+=(uint64_t)1) {
441 memset(channels, 0, avc->ch_layout.nb_channels * sizeof(*channels));
442 if (ts >= ws->next_ts)
443 wavesynth_enter_intervals(ws, ts);
444 wavesynth_synth_sample(ws, ts, channels);
445 for (c = 0; c < avc->ch_layout.nb_channels; c++)
446 *(pcm++) = channels[c] >> 16;
447 }
448 ws->cur_ts += (uint64_t)duration;
449 *rgot_frame = 1;
450 return packet->size;
451 }
452
453 static av_cold int wavesynth_close(AVCodecContext *avc)
454 {
455 struct wavesynth_context *ws = avc->priv_data;
456
457 av_freep(&ws->sin);
458 av_freep(&ws->inter);
459 return 0;
460 }
461
462 const FFCodec ff_ffwavesynth_decoder = {
463 .p.name = "wavesynth",
464 CODEC_LONG_NAME("Wave synthesis pseudo-codec"),
465 .p.type = AVMEDIA_TYPE_AUDIO,
466 .p.id = AV_CODEC_ID_FFWAVESYNTH,
467 .priv_data_size = sizeof(struct wavesynth_context),
468 .init = wavesynth_init,
469 .close = wavesynth_close,
470 FF_CODEC_DECODE_CB(wavesynth_decode),
471 .p.capabilities = AV_CODEC_CAP_DR1,
472 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
473 };
474