FFmpeg coverage

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