WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavformat/sbgdec.c

Rev	Author	Line No.	Line
6147	serge	1	/*
		2	* SBG (SBaGen) file format decoder
		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
		23	#include
		24	#include
		25	#include "libavutil/intreadwrite.h"
		26	#include "libavutil/log.h"
		27	#include "libavutil/opt.h"
		28	#include "libavutil/time_internal.h"
		29	#include "avformat.h"
		30	#include "internal.h"
		31
		32	#define SBG_SCALE (1 << 16)
		33	#define DAY (24 * 60 * 60)
		34	#define DAY_TS ((int64_t)DAY * AV_TIME_BASE)
		35
		36	struct sbg_demuxer {
		37	AVClass *class;
		38	int sample_rate;
		39	int frame_size;
		40	int max_file_size;
		41	};
		42
		43	struct sbg_string {
		44	char *s;
		45	char *e;
		46	};
		47
		48	enum sbg_fade_type {
		49	SBG_FADE_SILENCE = 0,
		50	SBG_FADE_SAME = 1,
		51	SBG_FADE_ADAPT = 3,
		52	};
		53
		54	struct sbg_fade {
		55	int8_t in, out, slide;
		56	};
		57
		58	enum sbg_synth_type {
		59	SBG_TYPE_NONE,
		60	SBG_TYPE_SINE,
		61	SBG_TYPE_NOISE,
		62	SBG_TYPE_BELL,
		63	SBG_TYPE_MIX,
		64	SBG_TYPE_SPIN,
		65	};
		66
		67	/* bell: freq constant, ampl decreases exponentially, can be approx lin */
		68
		69	struct sbg_timestamp {
		70	int64_t t;
		71	char type; /* 0 for relative, 'N' for now, 'T' for absolute */
		72	};
		73
		74	struct sbg_script_definition {
		75	char *name;
		76	int name_len;
		77	int elements, nb_elements;
		78	char type; /* 'S' or 'B' */
		79	};
		80
		81	struct sbg_script_synth {
		82	int carrier;
		83	int beat;
		84	int vol;
		85	enum sbg_synth_type type;
		86	struct {
		87	int l, r;
		88	} ref;
		89	};
		90
		91	struct sbg_script_tseq {
		92	struct sbg_timestamp ts;
		93	char *name;
		94	int name_len;
		95	int lock;
		96	struct sbg_fade fade;
		97	};
		98
		99	struct sbg_script_event {
		100	int64_t ts;
		101	int64_t ts_int, ts_trans, ts_next;
		102	int elements, nb_elements;
		103	struct sbg_fade fade;
		104	};
		105
		106	struct sbg_script {
		107	struct sbg_script_definition *def;
		108	struct sbg_script_synth *synth;
		109	struct sbg_script_tseq *tseq;
		110	struct sbg_script_tseq *block_tseq;
		111	struct sbg_script_event *events;
		112	int nb_def;
		113	int nb_tseq;
		114	int nb_events;
		115	int nb_synth;
		116	int64_t start_ts;
		117	int64_t end_ts;
		118	int64_t opt_fade_time;
		119	int64_t opt_duration;
		120	char *opt_mix;
		121	int sample_rate;
		122	uint8_t opt_start_at_first;
		123	uint8_t opt_end_at_last;
		124	};
		125
		126	struct sbg_parser {
		127	void *log;
		128	char script, end;
		129	char *cursor;
		130	struct sbg_script scs;
		131	struct sbg_timestamp current_time;
		132	int nb_block_tseq;
		133	int nb_def_max, nb_synth_max, nb_tseq_max, nb_block_tseq_max;
		134	int line_no;
		135	char err_msg[128];
		136	};
		137
		138	enum ws_interval_type {
		139	WS_SINE = MKTAG('S','I','N','E'),
		140	WS_NOISE = MKTAG('N','O','I','S'),
		141	};
		142
		143	struct ws_interval {
		144	int64_t ts1, ts2;
		145	enum ws_interval_type type;
		146	uint32_t channels;
		147	int32_t f1, f2;
		148	int32_t a1, a2;
		149	uint32_t phi;
		150	};
		151
		152	struct ws_intervals {
		153	struct ws_interval *inter;
		154	int nb_inter;
		155	int max_inter;
		156	};
		157
		158	static void alloc_array_elem(void *array, size_t elsize,
		159	int size, int max_size)
		160	{
		161	void *ret;
		162
		163	if (size == max_size) {
		164	int m = FFMAX(32, FFMIN(max_size, INT_MAX / 2) 2);
		165	if (*size >= m)
		166	return NULL;
		167	array = av_realloc_f(array, m, elsize);
		168	if (!*array)
		169	return NULL;
		170	*max_size = m;
		171	}
		172	ret = (char )array + elsize * *size;
		173	memset(ret, 0, elsize);
		174	(*size)++;
		175	return ret;
		176	}
		177
		178	static int str_to_time(const char str, int64_t rtime)
		179	{
		180	const char *cur = str;
		181	char *end;
		182	int hours, minutes;
		183	double seconds = 0;
		184
		185	if (cur < '0' \|\| cur > '9')
		186	return 0;
		187	hours = strtol(cur, &end, 10);
		188	if (end == cur \|\| *end != ':' \|\| end[1] < '0' \|\| end[1] > '9')
		189	return 0;
		190	cur = end + 1;
		191	minutes = strtol(cur, &end, 10);
		192	if (end == cur)
		193	return 0;
		194	cur = end;
		195	if (*end == ':'){
		196	seconds = strtod(cur + 1, &end);
		197	if (end > cur + 1)
		198	cur = end;
		199	}
		200	rtime = (hours 3600 + minutes * 60 + seconds) * AV_TIME_BASE;
		201	return cur - str;
		202	}
		203
		204	static inline int is_space(char c)
		205	{
		206	return c == ' ' \|\| c == '\t' \|\| c == '\r';
		207	}
		208
		209	static inline int scale_double(void log, double d, double m, int r)
		210	{
		211	m = d SBG_SCALE;
		212	if (m < INT_MIN \|\| m >= INT_MAX) {
		213	if (log)
		214	av_log(log, AV_LOG_ERROR, "%g is too large\n", d);
		215	return AVERROR(EDOM);
		216	}
		217	*r = m;
		218	return 0;
		219	}
		220
		221	static int lex_space(struct sbg_parser *p)
		222	{
		223	char *c = p->cursor;
		224
		225	while (p->cursor < p->end && is_space(*p->cursor))
		226	p->cursor++;
		227	return p->cursor > c;
		228	}
		229
		230	static int lex_char(struct sbg_parser *p, char c)
		231	{
		232	int r = p->cursor < p->end && *p->cursor == c;
		233
		234	p->cursor += r;
		235	return r;
		236	}
		237
		238	static int lex_double(struct sbg_parser p, double r)
		239	{
		240	double d;
		241	char *end;
		242
		243	if (p->cursor == p->end \|\| is_space(p->cursor) \|\| p->cursor == '\n')
		244	return 0;
		245	d = strtod(p->cursor, &end);
		246	if (end > p->cursor) {
		247	*r = d;
		248	p->cursor = end;
		249	return 1;
		250	}
		251	return 0;
		252	}
		253
		254	static int lex_fixed(struct sbg_parser p, const char t, int l)
		255	{
		256	if (p->end - p->cursor < l \|\| memcmp(p->cursor, t, l))
		257	return 0;
		258	p->cursor += l;
		259	return 1;
		260	}
		261
		262	static int lex_line_end(struct sbg_parser *p)
		263	{
		264	if (p->cursor < p->end && *p->cursor == '#') {
		265	p->cursor++;
		266	while (p->cursor < p->end && *p->cursor != '\n')
		267	p->cursor++;
		268	}
		269	if (p->cursor == p->end)
		270	/* simulate final LF for files lacking it */
		271	return 1;
		272	if (*p->cursor != '\n')
		273	return 0;
		274	p->cursor++;
		275	p->line_no++;
		276	lex_space(p);
		277	return 1;
		278	}
		279
		280	static int lex_wsword(struct sbg_parser p, struct sbg_string rs)
		281	{
		282	char s = p->cursor, c = s;
		283
		284	if (s == p->end \|\| *s == '\n')
		285	return 0;
		286	while (c < p->end && c != '\n' && !is_space(c))
		287	c++;
		288	rs->s = s;
		289	rs->e = p->cursor = c;
		290	lex_space(p);
		291	return 1;
		292	}
		293
		294	static int lex_name(struct sbg_parser p, struct sbg_string rs)
		295	{
		296	char s = p->cursor, c = s;
		297
		298	while (c < p->end && ((c >= 'a' && c <= 'z') \|\| (c >= 'A' && c <= 'Z')
		299	\|\| (c >= '0' && c <= '9') \|\| c == '_' \|\| c == '-'))
		300	c++;
		301	if (c == s)
		302	return 0;
		303	rs->s = s;
		304	rs->e = p->cursor = c;
		305	return 1;
		306	}
		307
		308	static int lex_time(struct sbg_parser p, int64_t rt)
		309	{
		310	int r = str_to_time(p->cursor, rt);
		311	p->cursor += r;
		312	return r > 0;
		313	}
		314
		315	#define FORWARD_ERROR(c) \
		316	do { \
		317	int errcode = c; \
		318	if (errcode <= 0) \
		319	return errcode ? errcode : AVERROR_INVALIDDATA; \
		320	} while (0)
		321
		322	static int parse_immediate(struct sbg_parser *p)
		323	{
		324	snprintf(p->err_msg, sizeof(p->err_msg),
		325	"immediate sequences not yet implemented");
		326	return AVERROR_PATCHWELCOME;
		327	}
		328
		329	static int parse_preprogrammed(struct sbg_parser *p)
		330	{
		331	snprintf(p->err_msg, sizeof(p->err_msg),
		332	"preprogrammed sequences not yet implemented");
		333	return AVERROR_PATCHWELCOME;
		334	}
		335
		336	static int parse_optarg(struct sbg_parser p, char o, struct sbg_string r)
		337	{
		338	if (!lex_wsword(p, r)) {
		339	snprintf(p->err_msg, sizeof(p->err_msg),
		340	"option '%c' requires an argument", o);
		341	return AVERROR_INVALIDDATA;
		342	}
		343	return 1;
		344	}
		345
		346	static int parse_options(struct sbg_parser *p)
		347	{
		348	struct sbg_string ostr, oarg;
		349	char mode = 0;
		350	int r;
		351	char *tptr;
		352	double v;
		353
		354	if (p->cursor == p->end \|\| *p->cursor != '-')
		355	return 0;
		356	while (lex_char(p, '-') && lex_wsword(p, &ostr)) {
		357	for (; ostr.s < ostr.e; ostr.s++) {
		358	char opt = *ostr.s;
		359	switch (opt) {
		360	case 'S':
		361	p->scs.opt_start_at_first = 1;
		362	break;
		363	case 'E':
		364	p->scs.opt_end_at_last = 1;
		365	break;
		366	case 'i':
		367	mode = 'i';
		368	break;
		369	case 'p':
		370	mode = 'p';
		371	break;
		372	case 'F':
		373	FORWARD_ERROR(parse_optarg(p, opt, &oarg));
		374	v = strtod(oarg.s, &tptr);
		375	if (oarg.e != tptr) {
		376	snprintf(p->err_msg, sizeof(p->err_msg),
		377	"syntax error for option -F");
		378	return AVERROR_INVALIDDATA;
		379	}
		380	p->scs.opt_fade_time = v * AV_TIME_BASE / 1000;
		381	break;
		382	case 'L':
		383	FORWARD_ERROR(parse_optarg(p, opt, &oarg));
		384	r = str_to_time(oarg.s, &p->scs.opt_duration);
		385	if (oarg.e != oarg.s + r) {
		386	snprintf(p->err_msg, sizeof(p->err_msg),
		387	"syntax error for option -L");
		388	return AVERROR_INVALIDDATA;
		389	}
		390	break;
		391	case 'T':
		392	FORWARD_ERROR(parse_optarg(p, opt, &oarg));
		393	r = str_to_time(oarg.s, &p->scs.start_ts);
		394	if (oarg.e != oarg.s + r) {
		395	snprintf(p->err_msg, sizeof(p->err_msg),
		396	"syntax error for option -T");
		397	return AVERROR_INVALIDDATA;
		398	}
		399	break;
		400	case 'm':
		401	FORWARD_ERROR(parse_optarg(p, opt, &oarg));
		402	tptr = av_malloc(oarg.e - oarg.s + 1);
		403	if (!tptr)
		404	return AVERROR(ENOMEM);
		405	memcpy(tptr, oarg.s, oarg.e - oarg.s);
		406	tptr[oarg.e - oarg.s] = 0;
		407	av_free(p->scs.opt_mix);
		408	p->scs.opt_mix = tptr;
		409	break;
		410	case 'q':
		411	FORWARD_ERROR(parse_optarg(p, opt, &oarg));
		412	v = strtod(oarg.s, &tptr);
		413	if (oarg.e != tptr) {
		414	snprintf(p->err_msg, sizeof(p->err_msg),
		415	"syntax error for option -q");
		416	return AVERROR_INVALIDDATA;
		417	}
		418	if (v != 1) {
		419	snprintf(p->err_msg, sizeof(p->err_msg),
		420	"speed factor other than 1 not supported");
		421	return AVERROR_PATCHWELCOME;
		422	}
		423	break;
		424	case 'r':
		425	FORWARD_ERROR(parse_optarg(p, opt, &oarg));
		426	r = strtol(oarg.s, &tptr, 10);
		427	if (oarg.e != tptr) {
		428	snprintf(p->err_msg, sizeof(p->err_msg),
		429	"syntax error for option -r");
		430	return AVERROR_INVALIDDATA;
		431	}
		432	if (r < 40) {
		433	snprintf(p->err_msg, sizeof(p->err_msg),
		434	"invalid sample rate");
		435	return AVERROR_PATCHWELCOME;
		436	}
		437	p->scs.sample_rate = r;
		438	break;
		439	default:
		440	snprintf(p->err_msg, sizeof(p->err_msg),
		441	"unknown option: '%c'", *ostr.s);
		442	return AVERROR_INVALIDDATA;
		443	}
		444	}
		445	}
		446	switch (mode) {
		447	case 'i':
		448	return parse_immediate(p);
		449	case 'p':
		450	return parse_preprogrammed(p);
		451	case 0:
		452	if (!lex_line_end(p))
		453	return AVERROR_INVALIDDATA;
		454	return 1;
		455	}
		456	return AVERROR_BUG;
		457	}
		458
		459	static int parse_timestamp(struct sbg_parser *p,
		460	struct sbg_timestamp rts, int64_t rrel)
		461	{
		462	int64_t abs = 0, rel = 0, dt;
		463	char type = 0;
		464	int r;
		465
		466	if (lex_fixed(p, "NOW", 3)) {
		467	type = 'N';
		468	r = 1;
		469	} else {
		470	r = lex_time(p, &abs);
		471	if (r)
		472	type = 'T';
		473	}
		474	while (lex_char(p, '+')) {
		475	if (!lex_time(p, &dt))
		476	return AVERROR_INVALIDDATA;
		477	rel += dt;
		478	r = 1;
		479	}
		480	if (r) {
		481	if (!lex_space(p))
		482	return AVERROR_INVALIDDATA;
		483	rts->type = type;
		484	rts->t = abs;
		485	*rrel = rel;
		486	}
		487	return r;
		488	}
		489
		490	static int parse_fade(struct sbg_parser p, struct sbg_fade fr)
		491	{
		492	struct sbg_fade f = {0};
		493
		494	if (lex_char(p, '<'))
		495	f.in = SBG_FADE_SILENCE;
		496	else if (lex_char(p, '-'))
		497	f.in = SBG_FADE_SAME;
		498	else if (lex_char(p, '='))
		499	f.in = SBG_FADE_ADAPT;
		500	else
		501	return 0;
		502	if (lex_char(p, '>'))
		503	f.out = SBG_FADE_SILENCE;
		504	else if (lex_char(p, '-'))
		505	f.out = SBG_FADE_SAME;
		506	else if (lex_char(p, '='))
		507	f.out = SBG_FADE_ADAPT;
		508	else
		509	return AVERROR_INVALIDDATA;
		510	*fr = f;
		511	return 1;
		512	}
		513
		514	static int parse_time_sequence(struct sbg_parser *p, int inblock)
		515	{
		516	struct sbg_timestamp ts;
		517	int64_t rel_ts;
		518	int r;
		519	struct sbg_fade fade = { SBG_FADE_SAME, SBG_FADE_SAME, 0 };
		520	struct sbg_string name;
		521	struct sbg_script_tseq *tseq;
		522
		523	r = parse_timestamp(p, &ts, &rel_ts);
		524	if (!r)
		525	return 0;
		526	if (r < 0)
		527	return r;
		528	if (ts.type) {
		529	if (inblock)
		530	return AVERROR_INVALIDDATA;
		531	p->current_time.type = ts.type;
		532	p->current_time.t = ts.t;
		533	} else if(!inblock && !p->current_time.type) {
		534	snprintf(p->err_msg, sizeof(p->err_msg),
		535	"relative time without previous absolute time");
		536	return AVERROR_INVALIDDATA;
		537	}
		538	ts.type = p->current_time.type;
		539	ts.t = p->current_time.t + rel_ts;
		540	r = parse_fade(p, &fade);
		541	if (r < 0)
		542	return r;
		543	lex_space(p);
		544	if (!lex_name(p, &name))
		545	return AVERROR_INVALIDDATA;
		546	lex_space(p);
		547	if (lex_fixed(p, "->", 2)) {
		548	fade.slide = SBG_FADE_ADAPT;
		549	lex_space(p);
		550	}
		551	if (!lex_line_end(p))
		552	return AVERROR_INVALIDDATA;
		553	tseq = inblock ?
		554	alloc_array_elem((void *)&p->scs.block_tseq, sizeof(tseq),
		555	&p->nb_block_tseq, &p->nb_block_tseq_max) :
		556	alloc_array_elem((void *)&p->scs.tseq, sizeof(tseq),
		557	&p->scs.nb_tseq, &p->nb_tseq_max);
		558	if (!tseq)
		559	return AVERROR(ENOMEM);
		560	tseq->ts = ts;
		561	tseq->name = name.s;
		562	tseq->name_len = name.e - name.s;
		563	tseq->fade = fade;
		564	return 1;
		565	}
		566
		567	static int parse_wave_def(struct sbg_parser *p, int wavenum)
		568	{
		569	snprintf(p->err_msg, sizeof(p->err_msg),
		570	"waveform definitions not yet implemented");
		571	return AVERROR_PATCHWELCOME;
		572	}
		573
		574	static int parse_block_def(struct sbg_parser *p,
		575	struct sbg_script_definition *def)
		576	{
		577	int r, tseq;
		578
		579	lex_space(p);
		580	if (!lex_line_end(p))
		581	return AVERROR_INVALIDDATA;
		582	tseq = p->nb_block_tseq;
		583	while (1) {
		584	r = parse_time_sequence(p, 1);
		585	if (r < 0)
		586	return r;
		587	if (!r)
		588	break;
		589	}
		590	if (!lex_char(p, '}'))
		591	return AVERROR_INVALIDDATA;
		592	lex_space(p);
		593	if (!lex_line_end(p))
		594	return AVERROR_INVALIDDATA;
		595	def->type = 'B';
		596	def->elements = tseq;
		597	def->nb_elements = p->nb_block_tseq - tseq;
		598	if (!def->nb_elements)
		599	return AVERROR_INVALIDDATA;
		600	return 1;
		601	}
		602
		603	static int parse_volume(struct sbg_parser p, int vol)
		604	{
		605	double v;
		606
		607	if (!lex_char(p, '/'))
		608	return 0;
		609	if (!lex_double(p, &v))
		610	return AVERROR_INVALIDDATA;
		611	if (scale_double(p->log, v, 0.01, vol))
		612	return AVERROR(ERANGE);
		613	return 1;
		614	}
		615
		616	static int parse_synth_channel_sine(struct sbg_parser *p,
		617	struct sbg_script_synth *synth)
		618	{
		619	double carrierf, beatf;
		620	int carrier, beat, vol;
		621
		622	if (!lex_double(p, &carrierf))
		623	return 0;
		624	if (!lex_double(p, &beatf))
		625	beatf = 0;
		626	FORWARD_ERROR(parse_volume(p, &vol));
		627	if (scale_double(p->log, carrierf, 1, &carrier) < 0 \|\|
		628	scale_double(p->log, beatf, 1, &beat) < 0)
		629	return AVERROR(EDOM);
		630	synth->type = SBG_TYPE_SINE;
		631	synth->carrier = carrier;
		632	synth->beat = beat;
		633	synth->vol = vol;
		634	return 1;
		635	}
		636
		637	static int parse_synth_channel_pink(struct sbg_parser *p,
		638	struct sbg_script_synth *synth)
		639	{
		640	int vol;
		641
		642	if (!lex_fixed(p, "pink", 4))
		643	return 0;
		644	FORWARD_ERROR(parse_volume(p, &vol));
		645	synth->type = SBG_TYPE_NOISE;
		646	synth->vol = vol;
		647	return 1;
		648	}
		649
		650	static int parse_synth_channel_bell(struct sbg_parser *p,
		651	struct sbg_script_synth *synth)
		652	{
		653	double carrierf;
		654	int carrier, vol;
		655
		656	if (!lex_fixed(p, "bell", 4))
		657	return 0;
		658	if (!lex_double(p, &carrierf))
		659	return AVERROR_INVALIDDATA;
		660	FORWARD_ERROR(parse_volume(p, &vol));
		661	if (scale_double(p->log, carrierf, 1, &carrier) < 0)
		662	return AVERROR(EDOM);
		663	synth->type = SBG_TYPE_BELL;
		664	synth->carrier = carrier;
		665	synth->vol = vol;
		666	return 1;
		667	}
		668
		669	static int parse_synth_channel_mix(struct sbg_parser *p,
		670	struct sbg_script_synth *synth)
		671	{
		672	int vol;
		673
		674	if (!lex_fixed(p, "mix", 3))
		675	return 0;
		676	FORWARD_ERROR(parse_volume(p, &vol));
		677	synth->type = SBG_TYPE_MIX;
		678	synth->vol = vol;
		679	return 1;
		680	}
		681
		682	static int parse_synth_channel_spin(struct sbg_parser *p,
		683	struct sbg_script_synth *synth)
		684	{
		685	double carrierf, beatf;
		686	int carrier, beat, vol;
		687
		688	if (!lex_fixed(p, "spin:", 5))
		689	return 0;
		690	if (!lex_double(p, &carrierf))
		691	return AVERROR_INVALIDDATA;
		692	if (!lex_double(p, &beatf))
		693	return AVERROR_INVALIDDATA;
		694	FORWARD_ERROR(parse_volume(p, &vol));
		695	if (scale_double(p->log, carrierf, 1, &carrier) < 0 \|\|
		696	scale_double(p->log, beatf, 1, &beat) < 0)
		697	return AVERROR(EDOM);
		698	synth->type = SBG_TYPE_SPIN;
		699	synth->carrier = carrier;
		700	synth->beat = beat;
		701	synth->vol = vol;
		702	return 1;
		703	}
		704
		705	static int parse_synth_channel(struct sbg_parser *p)
		706	{
		707	int r;
		708	struct sbg_script_synth *synth;
		709
		710	synth = alloc_array_elem((void *)&p->scs.synth, sizeof(synth),
		711	&p->scs.nb_synth, &p->nb_synth_max);
		712	if (!synth)
		713	return AVERROR(ENOMEM);
		714	r = lex_char(p, '-');
		715	if (!r)
		716	r = parse_synth_channel_pink(p, synth);
		717	if (!r)
		718	r = parse_synth_channel_bell(p, synth);
		719	if (!r)
		720	r = parse_synth_channel_mix(p, synth);
		721	if (!r)
		722	r = parse_synth_channel_spin(p, synth);
		723	/* Unimplemented: wave%d:%f%f/vol (carrier, beat) */
		724	if (!r)
		725	r = parse_synth_channel_sine(p, synth);
		726	if (r <= 0)
		727	p->scs.nb_synth--;
		728	return r;
		729	}
		730
		731	static int parse_synth_def(struct sbg_parser *p,
		732	struct sbg_script_definition *def)
		733	{
		734	int r, synth;
		735
		736	synth = p->scs.nb_synth;
		737	while (1) {
		738	r = parse_synth_channel(p);
		739	if (r < 0)
		740	return r;
		741	if (!r \|\| !lex_space(p))
		742	break;
		743	}
		744	lex_space(p);
		745	if (synth == p->scs.nb_synth)
		746	return AVERROR_INVALIDDATA;
		747	if (!lex_line_end(p))
		748	return AVERROR_INVALIDDATA;
		749	def->type = 'S';
		750	def->elements = synth;
		751	def->nb_elements = p->scs.nb_synth - synth;
		752	return 1;
		753	}
		754
		755	static int parse_named_def(struct sbg_parser *p)
		756	{
		757	char *cursor_save = p->cursor;
		758	struct sbg_string name;
		759	struct sbg_script_definition *def;
		760
		761	if (!lex_name(p, &name) \|\| !lex_char(p, ':') \|\| !lex_space(p)) {
		762	p->cursor = cursor_save;
		763	return 0;
		764	}
		765	if (name.e - name.s == 6 && !memcmp(name.s, "wave", 4) &&
		766	name.s[4] >= '0' && name.s[4] <= '9' &&
		767	name.s[5] >= '0' && name.s[5] <= '9') {
		768	int wavenum = (name.s[4] - '0') * 10 + (name.s[5] - '0');
		769	return parse_wave_def(p, wavenum);
		770	}
		771	def = alloc_array_elem((void *)&p->scs.def, sizeof(def),
		772	&p->scs.nb_def, &p->nb_def_max);
		773	if (!def)
		774	return AVERROR(ENOMEM);
		775	def->name = name.s;
		776	def->name_len = name.e - name.s;
		777	if (lex_char(p, '{'))
		778	return parse_block_def(p, def);
		779	return parse_synth_def(p, def);
		780	}
		781
		782	static void free_script(struct sbg_script *s)
		783	{
		784	av_freep(&s->def);
		785	av_freep(&s->synth);
		786	av_freep(&s->tseq);
		787	av_freep(&s->block_tseq);
		788	av_freep(&s->events);
		789	av_freep(&s->opt_mix);
		790	}
		791
		792	static int parse_script(void log, char script, int script_len,
		793	struct sbg_script *rscript)
		794	{
		795	struct sbg_parser sp = {
		796	.log = log,
		797	.script = script,
		798	.end = script + script_len,
		799	.cursor = script,
		800	.line_no = 1,
		801	.err_msg = "",
		802	.scs = {
		803	/* default values */
		804	.start_ts = AV_NOPTS_VALUE,
		805	.sample_rate = 44100,
		806	.opt_fade_time = 60 * AV_TIME_BASE,
		807	},
		808	};
		809	int r;
		810
		811	lex_space(&sp);
		812	while (sp.cursor < sp.end) {
		813	r = parse_options(&sp);
		814	if (r < 0)
		815	goto fail;
		816	if (!r && !lex_line_end(&sp))
		817	break;
		818	}
		819	while (sp.cursor < sp.end) {
		820	r = parse_named_def(&sp);
		821	if (!r)
		822	r = parse_time_sequence(&sp, 0);
		823	if (!r)
		824	r = lex_line_end(&sp) ? 1 : AVERROR_INVALIDDATA;
		825	if (r < 0)
		826	goto fail;
		827	}
		828	*rscript = sp.scs;
		829	return 1;
		830	fail:
		831	free_script(&sp.scs);
		832	if (!*sp.err_msg)
		833	if (r == AVERROR_INVALIDDATA)
		834	snprintf(sp.err_msg, sizeof(sp.err_msg), "syntax error");
		835	if (log && *sp.err_msg) {
		836	const char *ctx = sp.cursor;
		837	const char *ectx = av_x_if_null(memchr(ctx, '\n', sp.end - sp.cursor),
		838	sp.end);
		839	int lctx = ectx - ctx;
		840	const char *quote = "\"";
		841	if (lctx > 0 && ctx[lctx - 1] == '\r')
		842	lctx--;
		843	if (lctx == 0) {
		844	ctx = "the end of line";
		845	lctx = strlen(ctx);
		846	quote = "";
		847	}
		848	av_log(log, AV_LOG_ERROR, "Error line %d: %s near %s%.*s%s.\n",
		849	sp.line_no, sp.err_msg, quote, lctx, ctx, quote);
		850	}
		851	return r;
		852	}
		853
		854	static int read_whole_file(AVIOContext io, int max_size, char *rbuf)
		855	{
		856	char *buf = NULL;
		857	int size = 0, bufsize = 0, r;
		858
		859	while (1) {
		860	if (bufsize - size < 1024) {
		861	bufsize = FFMIN(FFMAX(2 * bufsize, 8192), max_size);
		862	if (bufsize - size < 2) {
		863	size = AVERROR(EFBIG);
		864	goto fail;
		865	}
		866	buf = av_realloc_f(buf, bufsize, 1);
		867	if (!buf) {
		868	size = AVERROR(ENOMEM);
		869	goto fail;
		870	}
		871	}
		872	r = avio_read(io, buf, bufsize - size - 1);
		873	if (r == AVERROR_EOF)
		874	break;
		875	if (r < 0)
		876	goto fail;
		877	size += r;
		878	}
		879	buf[size] = 0;
		880	*rbuf = buf;
		881	return size;
		882	fail:
		883	av_free(buf);
		884	return size;
		885	}
		886
		887	static void expand_timestamps(void log, struct sbg_script s)
		888	{
		889	int i, nb_rel = 0;
		890	int64_t now, cur_ts, delta = 0;
		891
		892	for (i = 0; i < s->nb_tseq; i++)
		893	nb_rel += s->tseq[i].ts.type == 'N';
		894	if (nb_rel == s->nb_tseq) {
		895	/* All ts are relative to NOW: consider NOW = 0 */
		896	now = 0;
		897	if (s->start_ts != AV_NOPTS_VALUE)
		898	av_log(log, AV_LOG_WARNING,
		899	"Start time ignored in a purely relative script.\n");
		900	} else if (nb_rel == 0 && s->start_ts != AV_NOPTS_VALUE \|\|
		901	s->opt_start_at_first) {
		902	/* All ts are absolute and start time is specified */
		903	if (s->start_ts == AV_NOPTS_VALUE)
		904	s->start_ts = s->tseq[0].ts.t;
		905	now = s->start_ts;
		906	} else {
		907	/* Mixed relative/absolute ts: expand */
		908	time_t now0;
		909	struct tm *tm, tmpbuf;
		910
		911	av_log(log, AV_LOG_WARNING,
		912	"Scripts with mixed absolute and relative timestamps can give "
		913	"unexpected results (pause, seeking, time zone change).\n");
		914	#undef time
		915	time(&now0);
		916	tm = localtime_r(&now0, &tmpbuf);
		917	now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
		918	now0 % DAY;
		919	av_log(log, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",
		920	(int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);
		921	now *= AV_TIME_BASE;
		922	for (i = 0; i < s->nb_tseq; i++) {
		923	if (s->tseq[i].ts.type == 'N') {
		924	s->tseq[i].ts.t += now;
		925	s->tseq[i].ts.type = 'T'; /* not necessary */
		926	}
		927	}
		928	}
		929	if (s->start_ts == AV_NOPTS_VALUE)
		930	s->start_ts = s->opt_start_at_first ? s->tseq[0].ts.t : now;
		931	s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
		932	AV_NOPTS_VALUE; /* may be overridden later by -E option */
		933	cur_ts = now;
		934	for (i = 0; i < s->nb_tseq; i++) {
		935	if (s->tseq[i].ts.t + delta < cur_ts)
		936	delta += DAY_TS;
		937	cur_ts = s->tseq[i].ts.t += delta;
		938	}
		939	}
		940
		941	static int expand_tseq(void log, struct sbg_script s, int *nb_ev_max,
		942	int64_t t0, struct sbg_script_tseq *tseq)
		943	{
		944	int i, r;
		945	struct sbg_script_definition *def;
		946	struct sbg_script_tseq *be;
		947	struct sbg_script_event *ev;
		948
		949	if (tseq->lock++) {
		950	av_log(log, AV_LOG_ERROR, "Recursion loop on \"%.*s\"\n",
		951	tseq->name_len, tseq->name);
		952	return AVERROR(EINVAL);
		953	}
		954	t0 += tseq->ts.t;
		955	for (i = 0; i < s->nb_def; i++) {
		956	if (s->def[i].name_len == tseq->name_len &&
		957	!memcmp(s->def[i].name, tseq->name, tseq->name_len))
		958	break;
		959	}
		960	if (i >= s->nb_def) {
		961	av_log(log, AV_LOG_ERROR, "Tone-set \"%.*s\" not defined\n",
		962	tseq->name_len, tseq->name);
		963	return AVERROR(EINVAL);
		964	}
		965	def = &s->def[i];
		966	if (def->type == 'B') {
		967	be = s->block_tseq + def->elements;
		968	for (i = 0; i < def->nb_elements; i++) {
		969	r = expand_tseq(log, s, nb_ev_max, t0, &be[i]);
		970	if (r < 0)
		971	return r;
		972	}
		973	} else {
		974	ev = alloc_array_elem((void *)&s->events, sizeof(ev),
		975	&s->nb_events, nb_ev_max);
		976	if (!ev)
		977	return AVERROR(ENOMEM);
		978	ev->ts = tseq->ts.t;
		979	ev->elements = def->elements;
		980	ev->nb_elements = def->nb_elements;
		981	ev->fade = tseq->fade;
		982	}
		983	tseq->lock--;
		984	return 0;
		985	}
		986
		987	static int expand_script(void log, struct sbg_script s)
		988	{
		989	int i, r, nb_events_max = 0;
		990
		991	expand_timestamps(log, s);
		992	for (i = 0; i < s->nb_tseq; i++) {
		993	r = expand_tseq(log, s, &nb_events_max, 0, &s->tseq[i]);
		994	if (r < 0)
		995	return r;
		996	}
		997	if (!s->nb_events) {
		998	av_log(log, AV_LOG_ERROR, "No events in script\n");
		999	return AVERROR_INVALIDDATA;
		1000	}
		1001	if (s->opt_end_at_last)
		1002	s->end_ts = s->events[s->nb_events - 1].ts;
		1003	return 0;
		1004	}
		1005
		1006	static int add_interval(struct ws_intervals *inter,
		1007	enum ws_interval_type type, uint32_t channels, int ref,
		1008	int64_t ts1, int32_t f1, int32_t a1,
		1009	int64_t ts2, int32_t f2, int32_t a2)
		1010	{
		1011	struct ws_interval i, ri;
		1012
		1013	if (ref >= 0) {
		1014	ri = &inter->inter[ref];
		1015	/* ref and new intervals are constant, identical and adjacent */
		1016	if (ri->type == type && ri->channels == channels &&
		1017	ri->f1 == ri->f2 && ri->f2 == f1 && f1 == f2 &&
		1018	ri->a1 == ri->a2 && ri->a2 == a1 && a1 == a2 &&
		1019	ri->ts2 == ts1) {
		1020	ri->ts2 = ts2;
		1021	return ref;
		1022	}
		1023	}
		1024	i = alloc_array_elem((void *)&inter->inter, sizeof(i),
		1025	&inter->nb_inter, &inter->max_inter);
		1026	if (!i)
		1027	return AVERROR(ENOMEM);
		1028	i->ts1 = ts1;
		1029	i->ts2 = ts2;
		1030	i->type = type;
		1031	i->channels = channels;
		1032	i->f1 = f1;
		1033	i->f2 = f2;
		1034	i->a1 = a1;
		1035	i->a2 = a2;
		1036	i->phi = ref >= 0 ? ref \| 0x80000000 : 0;
		1037	return i - inter->inter;
		1038	}
		1039
		1040	static int add_bell(struct ws_intervals inter, struct sbg_script s,
		1041	int64_t ts1, int64_t ts2, int32_t f, int32_t a)
		1042	{
		1043	/* SBaGen uses an exponential decrease every 50ms.
		1044	We approximate it with piecewise affine segments. */
		1045	int32_t cpoints[][2] = {
		1046	{ 2, a },
		1047	{ 4, a - a / 4 },
		1048	{ 8, a / 2 },
		1049	{ 16, a / 4 },
		1050	{ 25, a / 10 },
		1051	{ 50, a / 80 },
		1052	{ 75, 0 },
		1053	};
		1054	int i, r;
		1055	int64_t dt = s->sample_rate / 20, ts3 = ts1, ts4;
		1056	for (i = 0; i < FF_ARRAY_ELEMS(cpoints); i++) {
		1057	ts4 = FFMIN(ts2, ts1 + cpoints[i][0] * dt);
		1058	r = add_interval(inter, WS_SINE, 3, -1,
		1059	ts3, f, a, ts4, f, cpoints[i][1]);
		1060	if (r < 0)
		1061	return r;
		1062	ts3 = ts4;
		1063	a = cpoints[i][1];
		1064	}
		1065	return 0;
		1066	}
		1067
		1068	static int generate_interval(void log, struct sbg_script s,
		1069	struct ws_intervals *inter,
		1070	int64_t ts1, int64_t ts2,
		1071	struct sbg_script_synth *s1,
		1072	struct sbg_script_synth *s2,
		1073	int transition)
		1074	{
		1075	int r;
		1076
		1077	if (ts2 <= ts1 \|\| (s1->vol == 0 && s2->vol == 0))
		1078	return 0;
		1079	switch (s1->type) {
		1080	case SBG_TYPE_NONE:
		1081	break;
		1082	case SBG_TYPE_SINE:
		1083	if (s1->beat == 0 && s2->beat == 0) {
		1084	r = add_interval(inter, WS_SINE, 3, s1->ref.l,
		1085	ts1, s1->carrier, s1->vol,
		1086	ts2, s2->carrier, s2->vol);
		1087	if (r < 0)
		1088	return r;
		1089	s2->ref.l = s2->ref.r = r;
		1090	} else {
		1091	r = add_interval(inter, WS_SINE, 1, s1->ref.l,
		1092	ts1, s1->carrier + s1->beat / 2, s1->vol,
		1093	ts2, s2->carrier + s2->beat / 2, s2->vol);
		1094	if (r < 0)
		1095	return r;
		1096	s2->ref.l = r;
		1097	r = add_interval(inter, WS_SINE, 2, s1->ref.r,
		1098	ts1, s1->carrier - s1->beat / 2, s1->vol,
		1099	ts2, s2->carrier - s2->beat / 2, s2->vol);
		1100	if (r < 0)
		1101	return r;
		1102	s2->ref.r = r;
		1103	}
		1104	break;
		1105
		1106	case SBG_TYPE_BELL:
		1107	if (transition == 2) {
		1108	r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);
		1109	if (r < 0)
		1110	return r;
		1111	}
		1112	break;
		1113
		1114	case SBG_TYPE_SPIN:
		1115	av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "
		1116	"using pink noise instead.\n");
		1117	/* fall through */
		1118	case SBG_TYPE_NOISE:
		1119	/* SBaGen's pink noise generator uses:
		1120	- 1 band of white noise, mean square: 1/3;
		1121	- 9 bands of subsampled white noise with linear
		1122	interpolation, mean square: 2/3 each;
		1123	with 1/10 weight each: the total mean square is 7/300.
		1124	Our pink noise generator uses 8 bands of white noise with
		1125	rectangular subsampling: the total mean square is 1/24.
		1126	Therefore, to match SBaGen's volume, we must multiply vol by
		1127	sqrt((7/300) / (1/24)) = sqrt(14/25) =~ 0.748
		1128	*/
		1129	r = add_interval(inter, WS_NOISE, 3, s1->ref.l,
		1130	ts1, 0, s1->vol - s1->vol / 4,
		1131	ts2, 0, s2->vol - s2->vol / 4);
		1132	if (r < 0)
		1133	return r;
		1134	s2->ref.l = s2->ref.r = r;
		1135	break;
		1136
		1137	case SBG_TYPE_MIX:
		1138	/* Unimplemented: silence; warning present elsewhere */
		1139	default:
		1140	av_log(log, AV_LOG_ERROR,
		1141	"Type %d is not implemented\n", s1->type);
		1142	return AVERROR_PATCHWELCOME;
		1143	}
		1144	return 0;
		1145	}
		1146
		1147	static int generate_plateau(void log, struct sbg_script s,
		1148	struct ws_intervals *inter,
		1149	struct sbg_script_event *ev1)
		1150	{
		1151	int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;
		1152	int i, r;
		1153	struct sbg_script_synth *s1;
		1154
		1155	for (i = 0; i < ev1->nb_elements; i++) {
		1156	s1 = &s->synth[ev1->elements + i];
		1157	r = generate_interval(log, s, inter, ts1, ts2, s1, s1, 0);
		1158	if (r < 0)
		1159	return r;
		1160	}
		1161	return 0;
		1162	}
		1163
		1164	/*
		1165
		1166	ts1 ts2 ts1 tsmid ts2
		1167	\| \| \| \| \|
		1168	v v v \| v
		1169	____ ____ v ____
		1170	''''.... ''.. ..''
		1171	''''....____ ''....''
		1172
		1173	compatible transition incompatible transition
		1174	*/
		1175
		1176	static int generate_transition(void log, struct sbg_script s,
		1177	struct ws_intervals *inter,
		1178	struct sbg_script_event *ev1,
		1179	struct sbg_script_event *ev2)
		1180	{
		1181	int64_t ts1 = ev1->ts_trans, ts2 = ev1->ts_next;
		1182	/* (ts1 + ts2) / 2 without overflow */
		1183	int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);
		1184	enum sbg_fade_type type = ev1->fade.slide \| (ev1->fade.out & ev2->fade.in);
		1185	int nb_elements = FFMAX(ev1->nb_elements, ev2->nb_elements);
		1186	struct sbg_script_synth s1, s2, s1mod, s2mod, smid;
		1187	int pass, i, r;
		1188
		1189	for (pass = 0; pass < 2; pass++) {
		1190	/* pass = 0 -> compatible and first half of incompatible
		1191	pass = 1 -> second half of incompatible
		1192	Using two passes like that ensures that the intervals are generated
		1193	in increasing order according to their start timestamp.
		1194	Otherwise it would be necessary to sort them
		1195	while keeping the mutual references.
		1196	*/
		1197	for (i = 0; i < nb_elements; i++) {
		1198	s1 = i < ev1->nb_elements ? &s->synth[ev1->elements + i] : &s1mod;
		1199	s2 = i < ev2->nb_elements ? &s->synth[ev2->elements + i] : &s2mod;
		1200	s1mod = s1 != &s1mod ? *s1 : (struct sbg_script_synth){ 0 };
		1201	s2mod = s2 != &s2mod ? *s2 : (struct sbg_script_synth){ 0 };
		1202	if (ev1->fade.slide) {
		1203	/* for slides, and only for slides, silence ("-") is equivalent
		1204	to anything with volume 0 */
		1205	if (s1mod.type == SBG_TYPE_NONE) {
		1206	s1mod = s2mod;
		1207	s1mod.vol = 0;
		1208	} else if (s2mod.type == SBG_TYPE_NONE) {
		1209	s2mod = s1mod;
		1210	s2mod.vol = 0;
		1211	}
		1212	}
		1213	if (s1mod.type == s2mod.type &&
		1214	s1mod.type != SBG_TYPE_BELL &&
		1215	(type == SBG_FADE_ADAPT \|\|
		1216	(s1mod.carrier == s2mod.carrier &&
		1217	s1mod.beat == s2mod.beat))) {
		1218	/* compatible: single transition */
		1219	if (!pass) {
		1220	r = generate_interval(log, s, inter,
		1221	ts1, ts2, &s1mod, &s2mod, 3);
		1222	if (r < 0)
		1223	return r;
		1224	s2->ref = s2mod.ref;
		1225	}
		1226	} else {
		1227	/* incompatible: silence at midpoint */
		1228	if (!pass) {
		1229	smid = s1mod;
		1230	smid.vol = 0;
		1231	r = generate_interval(log, s, inter,
		1232	ts1, tsmid, &s1mod, &smid, 1);
		1233	if (r < 0)
		1234	return r;
		1235	} else {
		1236	smid = s2mod;
		1237	smid.vol = 0;
		1238	r = generate_interval(log, s, inter,
		1239	tsmid, ts2, &smid, &s2mod, 2);
		1240	if (r < 0)
		1241	return r;
		1242	s2->ref = s2mod.ref;
		1243	}
		1244	}
		1245	}
		1246	}
		1247	return 0;
		1248	}
		1249
		1250	/*
		1251	ev1 trats ev2 intts endts ev3
		1252	\| \| \| \| \| \|
		1253	v v v v v v
		1254	________________
		1255	.... .... ....
		1256	'''....________________....''' '''...._______________
		1257
		1258	\_________/\______________/\_________/\______________/\_________/\_____________/
		1259	tr x->1 int1 tr 1->2 int2 tr 2->3 int3
		1260	*/
		1261
		1262	static int generate_intervals(void log, struct sbg_script s, int sample_rate,
		1263	struct ws_intervals *inter)
		1264	{
		1265	int64_t trans_time = s->opt_fade_time / 2;
		1266	struct sbg_script_event ev0, ev1, ev2;
		1267	int64_t period;
		1268	int i, r;
		1269
		1270	/* SBaGen handles the time before and after the extremal events,
		1271	and the corresponding transitions, as if the sequence were cyclic
		1272	with a 24-hours period. */
		1273	period = s->events[s->nb_events - 1].ts - s->events[0].ts;
		1274	period = (period + (DAY_TS - 1)) / DAY_TS * DAY_TS;
		1275	period = FFMAX(period, DAY_TS);
		1276
		1277	/* Prepare timestamps for transitions */
		1278	for (i = 0; i < s->nb_events; i++) {
		1279	ev1 = &s->events[i];
		1280	ev2 = &s->events[(i + 1) % s->nb_events];
		1281	ev1->ts_int = ev1->ts;
		1282	ev1->ts_trans = ev1->fade.slide ? ev1->ts
		1283	: ev2->ts + (ev1 < ev2 ? 0 : period);
		1284	}
		1285	for (i = 0; i < s->nb_events; i++) {
		1286	ev1 = &s->events[i];
		1287	ev2 = &s->events[(i + 1) % s->nb_events];
		1288	if (!ev1->fade.slide) {
		1289	ev1->ts_trans = FFMAX(ev1->ts_int, ev1->ts_trans - trans_time);
		1290	ev2->ts_int = FFMIN(ev2->ts_trans, ev2->ts_int + trans_time);
		1291	}
		1292	ev1->ts_next = ev2->ts_int + (ev1 < ev2 ? 0 : period);
		1293	}
		1294
		1295	/* Pseudo event before the first one */
		1296	ev0 = s->events[s->nb_events - 1];
		1297	ev0.ts_int -= period;
		1298	ev0.ts_trans -= period;
		1299	ev0.ts_next -= period;
		1300
		1301	/* Convert timestamps */
		1302	for (i = -1; i < s->nb_events; i++) {
		1303	ev1 = i < 0 ? &ev0 : &s->events[i];
		1304	ev1->ts_int = av_rescale(ev1->ts_int, sample_rate, AV_TIME_BASE);
		1305	ev1->ts_trans = av_rescale(ev1->ts_trans, sample_rate, AV_TIME_BASE);
		1306	ev1->ts_next = av_rescale(ev1->ts_next, sample_rate, AV_TIME_BASE);
		1307	}
		1308
		1309	/* Generate intervals */
		1310	for (i = 0; i < s->nb_synth; i++)
		1311	s->synth[i].ref.l = s->synth[i].ref.r = -1;
		1312	for (i = -1; i < s->nb_events; i++) {
		1313	ev1 = i < 0 ? &ev0 : &s->events[i];
		1314	ev2 = &s->events[(i + 1) % s->nb_events];
		1315	r = generate_plateau(log, s, inter, ev1);
		1316	if (r < 0)
		1317	return r;
		1318	r = generate_transition(log, s, inter, ev1, ev2);
		1319	if (r < 0)
		1320	return r;
		1321	}
		1322	if (!inter->nb_inter)
		1323	av_log(log, AV_LOG_WARNING, "Completely silent script.\n");
		1324	return 0;
		1325	}
		1326
		1327	static int encode_intervals(struct sbg_script s, AVCodecContext avc,
		1328	struct ws_intervals *inter)
		1329	{
		1330	int i, edata_size = 4;
		1331	uint8_t *edata;
		1332
		1333	for (i = 0; i < inter->nb_inter; i++) {
		1334	edata_size += inter->inter[i].type == WS_SINE ? 44 :
		1335	inter->inter[i].type == WS_NOISE ? 32 : 0;
		1336	if (edata_size < 0)
		1337	return AVERROR(ENOMEM);
		1338	}
		1339	if (ff_alloc_extradata(avc, edata_size))
		1340	return AVERROR(ENOMEM);
		1341	edata = avc->extradata;
		1342
		1343	#define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
		1344	#define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
		1345	ADD_EDATA32(inter->nb_inter);
		1346	for (i = 0; i < inter->nb_inter; i++) {
		1347	ADD_EDATA64(inter->inter[i].ts1);
		1348	ADD_EDATA64(inter->inter[i].ts2);
		1349	ADD_EDATA32(inter->inter[i].type);
		1350	ADD_EDATA32(inter->inter[i].channels);
		1351	switch (inter->inter[i].type) {
		1352	case WS_SINE:
		1353	ADD_EDATA32(inter->inter[i].f1);
		1354	ADD_EDATA32(inter->inter[i].f2);
		1355	ADD_EDATA32(inter->inter[i].a1);
		1356	ADD_EDATA32(inter->inter[i].a2);
		1357	ADD_EDATA32(inter->inter[i].phi);
		1358	break;
		1359	case WS_NOISE:
		1360	ADD_EDATA32(inter->inter[i].a1);
		1361	ADD_EDATA32(inter->inter[i].a2);
		1362	break;
		1363	}
		1364	}
		1365	if (edata != avc->extradata + edata_size)
		1366	return AVERROR_BUG;
		1367	return 0;
		1368	}
		1369
		1370	static av_cold int sbg_read_probe(AVProbeData *p)
		1371	{
		1372	int r, score;
		1373	struct sbg_script script = { 0 };
		1374
		1375	r = parse_script(NULL, p->buf, p->buf_size, &script);
		1376	score = r < 0 \|\| !script.nb_def \|\| !script.nb_tseq ? 0 :
		1377	AVPROBE_SCORE_MAX / 3;
		1378	free_script(&script);
		1379	return score;
		1380	}
		1381
		1382	static av_cold int sbg_read_header(AVFormatContext *avf)
		1383	{
		1384	struct sbg_demuxer *sbg = avf->priv_data;
		1385	int r;
		1386	char *buf = NULL;
		1387	struct sbg_script script = { 0 };
		1388	AVStream *st;
		1389	struct ws_intervals inter = { 0 };
		1390
		1391	r = read_whole_file(avf->pb, sbg->max_file_size, &buf);
		1392	if (r < 0)
		1393	goto fail;
		1394	r = parse_script(avf, buf, r, &script);
		1395	if (r < 0)
		1396	goto fail;
		1397	if (!sbg->sample_rate)
		1398	sbg->sample_rate = script.sample_rate;
		1399	else
		1400	script.sample_rate = sbg->sample_rate;
		1401	if (!sbg->frame_size)
		1402	sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);
		1403	if (script.opt_mix)
		1404	av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "
		1405	"-m is ignored and mix channels will be silent.\n");
		1406	r = expand_script(avf, &script);
		1407	if (r < 0)
		1408	goto fail;
		1409	av_freep(&buf);
		1410	r = generate_intervals(avf, &script, sbg->sample_rate, &inter);
		1411	if (r < 0)
		1412	goto fail;
		1413
		1414	st = avformat_new_stream(avf, NULL);
		1415	if (!st)
		1416	return AVERROR(ENOMEM);
		1417	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
		1418	st->codec->codec_id = AV_CODEC_ID_FFWAVESYNTH;
		1419	st->codec->channels = 2;
		1420	st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
		1421	st->codec->sample_rate = sbg->sample_rate;
		1422	st->codec->frame_size = sbg->frame_size;
		1423	avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
		1424	st->probe_packets = 0;
		1425	st->start_time = av_rescale(script.start_ts,
		1426	sbg->sample_rate, AV_TIME_BASE);
		1427	st->duration = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
		1428	av_rescale(script.end_ts - script.start_ts,
		1429	sbg->sample_rate, AV_TIME_BASE);
		1430	st->cur_dts = st->start_time;
		1431	r = encode_intervals(&script, st->codec, &inter);
		1432	if (r < 0)
		1433	goto fail;
		1434
		1435	av_free(inter.inter);
		1436	free_script(&script);
		1437	return 0;
		1438
		1439	fail:
		1440	av_free(inter.inter);
		1441	free_script(&script);
		1442	av_free(buf);
		1443	return r;
		1444	}
		1445
		1446	static int sbg_read_packet(AVFormatContext avf, AVPacket packet)
		1447	{
		1448	int64_t ts, end_ts;
		1449
		1450	ts = avf->streams[0]->cur_dts;
		1451	end_ts = ts + avf->streams[0]->codec->frame_size;
		1452	if (avf->streams[0]->duration != AV_NOPTS_VALUE)
		1453	end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,
		1454	end_ts);
		1455	if (end_ts <= ts)
		1456	return AVERROR_EOF;
		1457	if (av_new_packet(packet, 12) < 0)
		1458	return AVERROR(ENOMEM);
		1459	packet->dts = packet->pts = ts;
		1460	packet->duration = end_ts - ts;
		1461	AV_WL64(packet->data + 0, ts);
		1462	AV_WL32(packet->data + 8, packet->duration);
		1463	return packet->size;
		1464	}
		1465
		1466	static int sbg_read_seek2(AVFormatContext *avf, int stream_index,
		1467	int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
		1468	{
		1469	if (flags \|\| stream_index > 0)
		1470	return AVERROR(EINVAL);
		1471	if (stream_index < 0)
		1472	ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);
		1473	avf->streams[0]->cur_dts = ts;
		1474	return 0;
		1475	}
		1476
		1477	static int sbg_read_seek(AVFormatContext *avf, int stream_index,
		1478	int64_t ts, int flags)
		1479	{
		1480	return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);
		1481	}
		1482
		1483	static const AVOption sbg_options[] = {
		1484	{ "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),
		1485	AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
		1486	AV_OPT_FLAG_DECODING_PARAM },
		1487	{ "frame_size", "", offsetof(struct sbg_demuxer, frame_size),
		1488	AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
		1489	AV_OPT_FLAG_DECODING_PARAM },
		1490	{ "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),
		1491	AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,
		1492	AV_OPT_FLAG_DECODING_PARAM },
		1493	{ NULL },
		1494	};
		1495
		1496	static const AVClass sbg_demuxer_class = {
		1497	.class_name = "sbg_demuxer",
		1498	.item_name = av_default_item_name,
		1499	.option = sbg_options,
		1500	.version = LIBAVUTIL_VERSION_INT,
		1501	};
		1502
		1503	AVInputFormat ff_sbg_demuxer = {
		1504	.name = "sbg",
		1505	.long_name = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),
		1506	.priv_data_size = sizeof(struct sbg_demuxer),
		1507	.read_probe = sbg_read_probe,
		1508	.read_header = sbg_read_header,
		1509	.read_packet = sbg_read_packet,
		1510	.read_seek = sbg_read_seek,
		1511	.read_seek2 = sbg_read_seek2,
		1512	.extensions = "sbg",
		1513	.priv_class = &sbg_demuxer_class,
		1514	};

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavformat/sbgdec.c @ 7195 – Rev 6147