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