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