2 * SBG (SBaGen) file format decoder
3 * Copyright (c) 2011 Nicolas George
5 * This file is part of FFmpeg.
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.
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.
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
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/log.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/time_internal.h"
32 #define SBG_SCALE (1 << 16)
33 #define DAY (24 * 60 * 60)
34 #define DAY_TS ((int64_t)DAY * AV_TIME_BASE)
55 int8_t in, out, slide;
67 /* bell: freq constant, ampl decreases exponentially, can be approx lin */
69 struct sbg_timestamp {
71 char type; /* 0 for relative, 'N' for now, 'T' for absolute */
74 struct sbg_script_definition {
77 int elements, nb_elements;
78 char type; /* 'S' or 'B' */
81 struct sbg_script_synth {
85 enum sbg_synth_type type;
91 struct sbg_script_tseq {
92 struct sbg_timestamp ts;
99 struct sbg_script_event {
101 int64_t ts_int, ts_trans, ts_next;
102 int elements, nb_elements;
103 struct sbg_fade fade;
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;
118 int64_t opt_fade_time;
119 int64_t opt_duration;
122 uint8_t opt_start_at_first;
123 uint8_t opt_end_at_last;
130 struct sbg_script scs;
131 struct sbg_timestamp current_time;
133 int nb_def_max, nb_synth_max, nb_tseq_max, nb_block_tseq_max;
138 enum ws_interval_type {
139 WS_SINE = MKTAG('S','I','N','E'),
140 WS_NOISE = MKTAG('N','O','I','S'),
145 enum ws_interval_type type;
152 struct ws_intervals {
153 struct ws_interval *inter;
158 static void *alloc_array_elem(void **array, size_t elsize,
159 int *size, int *max_size)
163 if (*size == *max_size) {
164 int m = FFMAX(32, FFMIN(*max_size, INT_MAX / 2) * 2);
167 *array = av_realloc_f(*array, m, elsize);
172 ret = (char *)*array + elsize * *size;
173 memset(ret, 0, elsize);
178 static int str_to_time(const char *str, int64_t *rtime)
180 const char *cur = str;
186 if (*cur < '0' || *cur > '9')
188 hours = strtol(cur, &end, 10);
189 if (end == cur || *end != ':' || end[1] < '0' || end[1] > '9')
192 minutes = strtol(cur, &end, 10);
197 seconds = strtod(cur + 1, &end);
200 ts = av_clipd(seconds * AV_TIME_BASE, INT64_MIN/2, INT64_MAX/2);
202 *rtime = av_sat_add64((hours * 3600LL + minutes * 60LL) * AV_TIME_BASE, ts);
206 static inline int is_space(char c)
208 return c == ' ' || c == '\t' || c == '\r';
211 static inline int scale_double(void *log, double d, double m, int *r)
214 if (m < INT_MIN || m >= INT_MAX) {
216 av_log(log, AV_LOG_ERROR, "%g is too large\n", d);
217 return AVERROR(EDOM);
223 static int lex_space(struct sbg_parser *p)
227 while (p->cursor < p->end && is_space(*p->cursor))
229 return p->cursor > c;
232 static int lex_char(struct sbg_parser *p, char c)
234 int r = p->cursor < p->end && *p->cursor == c;
240 static int lex_double(struct sbg_parser *p, double *r)
245 if (p->cursor == p->end || is_space(*p->cursor) || *p->cursor == '\n')
247 d = strtod(p->cursor, &end);
248 if (end > p->cursor) {
256 static int lex_fixed(struct sbg_parser *p, const char *t, int l)
258 if (p->end - p->cursor < l || memcmp(p->cursor, t, l))
264 static int lex_line_end(struct sbg_parser *p)
266 if (p->cursor < p->end && *p->cursor == '#') {
268 while (p->cursor < p->end && *p->cursor != '\n')
271 if (p->cursor == p->end)
272 /* simulate final LF for files lacking it */
274 if (*p->cursor != '\n')
282 static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)
284 char *s = p->cursor, *c = s;
286 if (s == p->end || *s == '\n')
288 while (c < p->end && *c != '\n' && !is_space(*c))
291 rs->e = p->cursor = c;
296 static int lex_name(struct sbg_parser *p, struct sbg_string *rs)
298 char *s = p->cursor, *c = s;
300 while (c < p->end && ((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z')
301 || (*c >= '0' && *c <= '9') || *c == '_' || *c == '-'))
306 rs->e = p->cursor = c;
310 static int lex_time(struct sbg_parser *p, int64_t *rt)
312 int r = str_to_time(p->cursor, rt);
317 #define FORWARD_ERROR(c) \
321 return errcode ? errcode : AVERROR_INVALIDDATA; \
324 static int parse_immediate(struct sbg_parser *p)
326 snprintf(p->err_msg, sizeof(p->err_msg),
327 "immediate sequences not yet implemented");
328 return AVERROR_PATCHWELCOME;
331 static int parse_preprogrammed(struct sbg_parser *p)
333 snprintf(p->err_msg, sizeof(p->err_msg),
334 "preprogrammed sequences not yet implemented");
335 return AVERROR_PATCHWELCOME;
338 static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)
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;
348 static int parse_options(struct sbg_parser *p)
350 struct sbg_string ostr, oarg;
356 if (p->cursor == p->end || *p->cursor != '-')
358 while (lex_char(p, '-') && lex_wsword(p, &ostr)) {
359 for (; ostr.s < ostr.e; ostr.s++) {
363 p->scs.opt_start_at_first = 1;
366 p->scs.opt_end_at_last = 1;
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;
382 p->scs.opt_fade_time = v * AV_TIME_BASE / 1000;
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;
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;
403 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
404 tptr = av_malloc(oarg.e - oarg.s + 1);
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;
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;
421 snprintf(p->err_msg, sizeof(p->err_msg),
422 "speed factor other than 1 not supported");
423 return AVERROR_PATCHWELCOME;
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;
435 snprintf(p->err_msg, sizeof(p->err_msg),
436 "invalid sample rate");
437 return AVERROR_PATCHWELCOME;
439 p->scs.sample_rate = r;
442 snprintf(p->err_msg, sizeof(p->err_msg),
443 "unknown option: '%c'", *ostr.s);
444 return AVERROR_INVALIDDATA;
450 return parse_immediate(p);
452 return parse_preprogrammed(p);
454 if (!lex_line_end(p))
455 return AVERROR_INVALIDDATA;
461 static int parse_timestamp(struct sbg_parser *p,
462 struct sbg_timestamp *rts, int64_t *rrel)
464 int64_t abs = 0, rel = 0, dt;
468 if (lex_fixed(p, "NOW", 3)) {
472 r = lex_time(p, &abs);
476 while (lex_char(p, '+')) {
477 if (!lex_time(p, &dt))
478 return AVERROR_INVALIDDATA;
479 if (av_sat_add64(rel, dt) - dt != rel)
480 return AVERROR_INVALIDDATA;
486 return AVERROR_INVALIDDATA;
494 static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)
496 struct sbg_fade f = {0};
498 if (lex_char(p, '<'))
499 f.in = SBG_FADE_SILENCE;
500 else if (lex_char(p, '-'))
501 f.in = SBG_FADE_SAME;
502 else if (lex_char(p, '='))
503 f.in = SBG_FADE_ADAPT;
506 if (lex_char(p, '>'))
507 f.out = SBG_FADE_SILENCE;
508 else if (lex_char(p, '-'))
509 f.out = SBG_FADE_SAME;
510 else if (lex_char(p, '='))
511 f.out = SBG_FADE_ADAPT;
513 return AVERROR_INVALIDDATA;
518 static int parse_time_sequence(struct sbg_parser *p, int inblock)
520 struct sbg_timestamp ts;
523 struct sbg_fade fade = { SBG_FADE_SAME, SBG_FADE_SAME, 0 };
524 struct sbg_string name;
525 struct sbg_script_tseq *tseq;
527 r = parse_timestamp(p, &ts, &rel_ts);
534 return AVERROR_INVALIDDATA;
535 p->current_time.type = ts.type;
536 p->current_time.t = ts.t;
537 } else if(!inblock && !p->current_time.type) {
538 snprintf(p->err_msg, sizeof(p->err_msg),
539 "relative time without previous absolute time");
540 return AVERROR_INVALIDDATA;
542 ts.type = p->current_time.type;
544 if (av_sat_add64(p->current_time.t, rel_ts) != p->current_time.t + (uint64_t)rel_ts)
545 return AVERROR_INVALIDDATA;
546 ts.t = p->current_time.t + rel_ts;
547 r = parse_fade(p, &fade);
551 if (!lex_name(p, &name))
552 return AVERROR_INVALIDDATA;
554 if (lex_fixed(p, "->", 2)) {
555 fade.slide = SBG_FADE_ADAPT;
558 if (!lex_line_end(p))
559 return AVERROR_INVALIDDATA;
561 alloc_array_elem((void **)&p->scs.block_tseq, sizeof(*tseq),
562 &p->nb_block_tseq, &p->nb_block_tseq_max) :
563 alloc_array_elem((void **)&p->scs.tseq, sizeof(*tseq),
564 &p->scs.nb_tseq, &p->nb_tseq_max);
566 return AVERROR(ENOMEM);
569 tseq->name_len = name.e - name.s;
574 static int parse_wave_def(struct sbg_parser *p, int wavenum)
576 snprintf(p->err_msg, sizeof(p->err_msg),
577 "waveform definitions not yet implemented");
578 return AVERROR_PATCHWELCOME;
581 static int parse_block_def(struct sbg_parser *p,
582 struct sbg_script_definition *def)
587 if (!lex_line_end(p))
588 return AVERROR_INVALIDDATA;
589 tseq = p->nb_block_tseq;
591 r = parse_time_sequence(p, 1);
597 if (!lex_char(p, '}'))
598 return AVERROR_INVALIDDATA;
600 if (!lex_line_end(p))
601 return AVERROR_INVALIDDATA;
603 def->elements = tseq;
604 def->nb_elements = p->nb_block_tseq - tseq;
605 if (!def->nb_elements)
606 return AVERROR_INVALIDDATA;
610 static int parse_volume(struct sbg_parser *p, int *vol)
614 if (!lex_char(p, '/'))
616 if (!lex_double(p, &v))
617 return AVERROR_INVALIDDATA;
618 if (scale_double(p->log, v, 0.01, vol))
619 return AVERROR(ERANGE);
623 static int parse_synth_channel_sine(struct sbg_parser *p,
624 struct sbg_script_synth *synth)
626 double carrierf, beatf;
627 int carrier, beat, vol;
629 if (!lex_double(p, &carrierf))
631 if (!lex_double(p, &beatf))
633 FORWARD_ERROR(parse_volume(p, &vol));
634 if (scale_double(p->log, carrierf, 1, &carrier) < 0 ||
635 scale_double(p->log, beatf, 1, &beat) < 0)
636 return AVERROR(EDOM);
637 synth->type = SBG_TYPE_SINE;
638 synth->carrier = carrier;
644 static int parse_synth_channel_pink(struct sbg_parser *p,
645 struct sbg_script_synth *synth)
649 if (!lex_fixed(p, "pink", 4))
651 FORWARD_ERROR(parse_volume(p, &vol));
652 synth->type = SBG_TYPE_NOISE;
657 static int parse_synth_channel_bell(struct sbg_parser *p,
658 struct sbg_script_synth *synth)
663 if (!lex_fixed(p, "bell", 4))
665 if (!lex_double(p, &carrierf))
666 return AVERROR_INVALIDDATA;
667 FORWARD_ERROR(parse_volume(p, &vol));
668 if (scale_double(p->log, carrierf, 1, &carrier) < 0)
669 return AVERROR(EDOM);
670 synth->type = SBG_TYPE_BELL;
671 synth->carrier = carrier;
676 static int parse_synth_channel_mix(struct sbg_parser *p,
677 struct sbg_script_synth *synth)
681 if (!lex_fixed(p, "mix", 3))
683 FORWARD_ERROR(parse_volume(p, &vol));
684 synth->type = SBG_TYPE_MIX;
689 static int parse_synth_channel_spin(struct sbg_parser *p,
690 struct sbg_script_synth *synth)
692 double carrierf, beatf;
693 int carrier, beat, vol;
695 if (!lex_fixed(p, "spin:", 5))
697 if (!lex_double(p, &carrierf))
698 return AVERROR_INVALIDDATA;
699 if (!lex_double(p, &beatf))
700 return AVERROR_INVALIDDATA;
701 FORWARD_ERROR(parse_volume(p, &vol));
702 if (scale_double(p->log, carrierf, 1, &carrier) < 0 ||
703 scale_double(p->log, beatf, 1, &beat) < 0)
704 return AVERROR(EDOM);
705 synth->type = SBG_TYPE_SPIN;
706 synth->carrier = carrier;
712 static int parse_synth_channel(struct sbg_parser *p)
715 struct sbg_script_synth *synth;
717 synth = alloc_array_elem((void **)&p->scs.synth, sizeof(*synth),
718 &p->scs.nb_synth, &p->nb_synth_max);
720 return AVERROR(ENOMEM);
721 r = lex_char(p, '-');
723 r = parse_synth_channel_pink(p, synth);
725 r = parse_synth_channel_bell(p, synth);
727 r = parse_synth_channel_mix(p, synth);
729 r = parse_synth_channel_spin(p, synth);
730 /* Unimplemented: wave%d:%f%f/vol (carrier, beat) */
732 r = parse_synth_channel_sine(p, synth);
738 static int parse_synth_def(struct sbg_parser *p,
739 struct sbg_script_definition *def)
743 synth = p->scs.nb_synth;
745 r = parse_synth_channel(p);
748 if (!r || !lex_space(p))
752 if (synth == p->scs.nb_synth)
753 return AVERROR_INVALIDDATA;
754 if (!lex_line_end(p))
755 return AVERROR_INVALIDDATA;
757 def->elements = synth;
758 def->nb_elements = p->scs.nb_synth - synth;
762 static int parse_named_def(struct sbg_parser *p)
764 char *cursor_save = p->cursor;
765 struct sbg_string name;
766 struct sbg_script_definition *def;
768 if (!lex_name(p, &name) || !lex_char(p, ':') || !lex_space(p)) {
769 p->cursor = cursor_save;
772 if (name.e - name.s == 6 && !memcmp(name.s, "wave", 4) &&
773 name.s[4] >= '0' && name.s[4] <= '9' &&
774 name.s[5] >= '0' && name.s[5] <= '9') {
775 int wavenum = (name.s[4] - '0') * 10 + (name.s[5] - '0');
776 return parse_wave_def(p, wavenum);
778 def = alloc_array_elem((void **)&p->scs.def, sizeof(*def),
779 &p->scs.nb_def, &p->nb_def_max);
781 return AVERROR(ENOMEM);
783 def->name_len = name.e - name.s;
784 if (lex_char(p, '{'))
785 return parse_block_def(p, def);
786 return parse_synth_def(p, def);
789 static void free_script(struct sbg_script *s)
794 av_freep(&s->block_tseq);
795 av_freep(&s->events);
796 av_freep(&s->opt_mix);
799 static int parse_script(void *log, char *script, int script_len,
800 struct sbg_script *rscript)
802 struct sbg_parser sp = {
805 .end = script + script_len,
811 .start_ts = AV_NOPTS_VALUE,
812 .sample_rate = 44100,
813 .opt_fade_time = 60 * AV_TIME_BASE,
819 while (sp.cursor < sp.end) {
820 r = parse_options(&sp);
823 if (!r && !lex_line_end(&sp))
826 while (sp.cursor < sp.end) {
827 r = parse_named_def(&sp);
829 r = parse_time_sequence(&sp, 0);
831 r = lex_line_end(&sp) ? 1 : AVERROR_INVALIDDATA;
838 free_script(&sp.scs);
840 if (r == AVERROR_INVALIDDATA)
841 snprintf(sp.err_msg, sizeof(sp.err_msg), "syntax error");
842 if (log && *sp.err_msg) {
843 const char *ctx = sp.cursor;
844 const char *ectx = av_x_if_null(memchr(ctx, '\n', sp.end - sp.cursor),
846 int lctx = ectx - ctx;
847 const char *quote = "\"";
848 if (lctx > 0 && ctx[lctx - 1] == '\r')
851 ctx = "the end of line";
855 av_log(log, AV_LOG_ERROR, "Error line %d: %s near %s%.*s%s.\n",
856 sp.line_no, sp.err_msg, quote, lctx, ctx, quote);
861 static int read_whole_file(AVIOContext *io, int max_size, char **rbuf)
864 int size = 0, bufsize = 0, r;
867 if (bufsize - size < 1024) {
868 bufsize = FFMIN(FFMAX(2 * bufsize, 8192), max_size);
869 if (bufsize - size < 2) {
870 size = AVERROR(EFBIG);
873 buf = av_realloc_f(buf, bufsize, 1);
875 size = AVERROR(ENOMEM);
879 r = avio_read(io, buf, bufsize - size - 1);
880 if (r == AVERROR_EOF)
894 static int expand_timestamps(void *log, struct sbg_script *s)
897 int64_t now, cur_ts, delta = 0;
899 for (i = 0; i < s->nb_tseq; i++)
900 nb_rel += s->tseq[i].ts.type == 'N';
901 if (nb_rel == s->nb_tseq) {
902 /* All ts are relative to NOW: consider NOW = 0 */
904 if (s->start_ts != AV_NOPTS_VALUE)
905 av_log(log, AV_LOG_WARNING,
906 "Start time ignored in a purely relative script.\n");
907 } else if (nb_rel == 0 && s->start_ts != AV_NOPTS_VALUE ||
908 s->opt_start_at_first) {
909 /* All ts are absolute and start time is specified */
910 if (s->start_ts == AV_NOPTS_VALUE)
911 s->start_ts = s->tseq[0].ts.t;
914 /* Mixed relative/absolute ts: expand */
916 struct tm *tm, tmpbuf;
918 av_log(log, AV_LOG_WARNING,
919 "Scripts with mixed absolute and relative timestamps can give "
920 "unexpected results (pause, seeking, time zone change).\n");
923 tm = localtime_r(&now0, &tmpbuf);
924 now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
926 av_log(log, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",
927 (int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);
929 for (i = 0; i < s->nb_tseq; i++) {
930 if (s->tseq[i].ts.type == 'N') {
931 s->tseq[i].ts.t += now;
932 s->tseq[i].ts.type = 'T'; /* not necessary */
936 if (s->start_ts == AV_NOPTS_VALUE)
937 s->start_ts = (s->opt_start_at_first && s->tseq) ? s->tseq[0].ts.t : now;
938 s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
939 AV_NOPTS_VALUE; /* may be overridden later by -E option */
941 for (i = 0; i < s->nb_tseq; i++) {
942 if (av_sat_add64(s->tseq[i].ts.t, delta) != s->tseq[i].ts.t + (uint64_t)delta)
943 return AVERROR_INVALIDDATA;
944 if (s->tseq[i].ts.t + delta < cur_ts)
946 cur_ts = s->tseq[i].ts.t += delta;
951 static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max,
952 int64_t t0, struct sbg_script_tseq *tseq)
955 struct sbg_script_definition *def;
956 struct sbg_script_tseq *be;
957 struct sbg_script_event *ev;
960 av_log(log, AV_LOG_ERROR, "Recursion loop on \"%.*s\"\n",
961 tseq->name_len, tseq->name);
962 return AVERROR(EINVAL);
965 for (i = 0; i < s->nb_def; i++) {
966 if (s->def[i].name_len == tseq->name_len &&
967 !memcmp(s->def[i].name, tseq->name, tseq->name_len))
970 if (i >= s->nb_def) {
971 av_log(log, AV_LOG_ERROR, "Tone-set \"%.*s\" not defined\n",
972 tseq->name_len, tseq->name);
973 return AVERROR(EINVAL);
976 if (def->type == 'B') {
977 be = s->block_tseq + def->elements;
978 for (i = 0; i < def->nb_elements; i++) {
979 r = expand_tseq(log, s, nb_ev_max, t0, &be[i]);
984 ev = alloc_array_elem((void **)&s->events, sizeof(*ev),
985 &s->nb_events, nb_ev_max);
987 return AVERROR(ENOMEM);
989 ev->elements = def->elements;
990 ev->nb_elements = def->nb_elements;
991 ev->fade = tseq->fade;
997 static int expand_script(void *log, struct sbg_script *s)
999 int i, r, nb_events_max = 0;
1001 r = expand_timestamps(log, s);
1004 for (i = 0; i < s->nb_tseq; i++) {
1005 r = expand_tseq(log, s, &nb_events_max, 0, &s->tseq[i]);
1009 if (!s->nb_events) {
1010 av_log(log, AV_LOG_ERROR, "No events in script\n");
1011 return AVERROR_INVALIDDATA;
1013 if (s->opt_end_at_last)
1014 s->end_ts = s->events[s->nb_events - 1].ts;
1018 static int add_interval(struct ws_intervals *inter,
1019 enum ws_interval_type type, uint32_t channels, int ref,
1020 int64_t ts1, int32_t f1, int32_t a1,
1021 int64_t ts2, int32_t f2, int32_t a2)
1023 struct ws_interval *i, *ri;
1026 ri = &inter->inter[ref];
1027 /* ref and new intervals are constant, identical and adjacent */
1028 if (ri->type == type && ri->channels == channels &&
1029 ri->f1 == ri->f2 && ri->f2 == f1 && f1 == f2 &&
1030 ri->a1 == ri->a2 && ri->a2 == a1 && a1 == a2 &&
1036 i = alloc_array_elem((void **)&inter->inter, sizeof(*i),
1037 &inter->nb_inter, &inter->max_inter);
1039 return AVERROR(ENOMEM);
1043 i->channels = channels;
1048 i->phi = ref >= 0 ? ref | 0x80000000 : 0;
1049 return i - inter->inter;
1052 static int add_bell(struct ws_intervals *inter, struct sbg_script *s,
1053 int64_t ts1, int64_t ts2, int32_t f, int32_t a)
1055 /* SBaGen uses an exponential decrease every 50ms.
1056 We approximate it with piecewise affine segments. */
1057 int32_t cpoints[][2] = {
1067 int64_t dt = s->sample_rate / 20, ts3 = ts1, ts4;
1068 for (i = 0; i < FF_ARRAY_ELEMS(cpoints); i++) {
1069 ts4 = FFMIN(ts2, ts1 + cpoints[i][0] * dt);
1070 r = add_interval(inter, WS_SINE, 3, -1,
1071 ts3, f, a, ts4, f, cpoints[i][1]);
1080 static int generate_interval(void *log, struct sbg_script *s,
1081 struct ws_intervals *inter,
1082 int64_t ts1, int64_t ts2,
1083 struct sbg_script_synth *s1,
1084 struct sbg_script_synth *s2,
1089 if (ts2 <= ts1 || (s1->vol == 0 && s2->vol == 0))
1095 if (s1->beat == 0 && s2->beat == 0) {
1096 r = add_interval(inter, WS_SINE, 3, s1->ref.l,
1097 ts1, s1->carrier, s1->vol,
1098 ts2, s2->carrier, s2->vol);
1101 s2->ref.l = s2->ref.r = r;
1103 r = add_interval(inter, WS_SINE, 1, s1->ref.l,
1104 ts1, s1->carrier + s1->beat / 2, s1->vol,
1105 ts2, s2->carrier + s2->beat / 2, s2->vol);
1109 r = add_interval(inter, WS_SINE, 2, s1->ref.r,
1110 ts1, s1->carrier - s1->beat / 2, s1->vol,
1111 ts2, s2->carrier - s2->beat / 2, s2->vol);
1119 if (transition == 2) {
1120 r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);
1127 av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "
1128 "using pink noise instead.\n");
1130 case SBG_TYPE_NOISE:
1131 /* SBaGen's pink noise generator uses:
1132 - 1 band of white noise, mean square: 1/3;
1133 - 9 bands of subsampled white noise with linear
1134 interpolation, mean square: 2/3 each;
1135 with 1/10 weight each: the total mean square is 7/300.
1136 Our pink noise generator uses 8 bands of white noise with
1137 rectangular subsampling: the total mean square is 1/24.
1138 Therefore, to match SBaGen's volume, we must multiply vol by
1139 sqrt((7/300) / (1/24)) = sqrt(14/25) =~ 0.748
1141 r = add_interval(inter, WS_NOISE, 3, s1->ref.l,
1142 ts1, 0, s1->vol - s1->vol / 4,
1143 ts2, 0, s2->vol - s2->vol / 4);
1146 s2->ref.l = s2->ref.r = r;
1150 /* Unimplemented: silence; warning present elsewhere */
1152 av_log(log, AV_LOG_ERROR,
1153 "Type %d is not implemented\n", s1->type);
1154 return AVERROR_PATCHWELCOME;
1159 static int generate_plateau(void *log, struct sbg_script *s,
1160 struct ws_intervals *inter,
1161 struct sbg_script_event *ev1)
1163 int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;
1165 struct sbg_script_synth *s1;
1167 for (i = 0; i < ev1->nb_elements; i++) {
1168 s1 = &s->synth[ev1->elements + i];
1169 r = generate_interval(log, s, inter, ts1, ts2, s1, s1, 0);
1178 ts1 ts2 ts1 tsmid ts2
1183 ''''....____ ''....''
1185 compatible transition incompatible transition
1188 static int generate_transition(void *log, struct sbg_script *s,
1189 struct ws_intervals *inter,
1190 struct sbg_script_event *ev1,
1191 struct sbg_script_event *ev2)
1193 int64_t ts1 = ev1->ts_trans, ts2 = ev1->ts_next;
1194 /* (ts1 + ts2) / 2 without overflow */
1195 int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);
1196 enum sbg_fade_type type = ev1->fade.slide | (ev1->fade.out & ev2->fade.in);
1197 int nb_elements = FFMAX(ev1->nb_elements, ev2->nb_elements);
1198 struct sbg_script_synth *s1, *s2, s1mod, s2mod, smid;
1201 for (pass = 0; pass < 2; pass++) {
1202 /* pass = 0 -> compatible and first half of incompatible
1203 pass = 1 -> second half of incompatible
1204 Using two passes like that ensures that the intervals are generated
1205 in increasing order according to their start timestamp.
1206 Otherwise it would be necessary to sort them
1207 while keeping the mutual references.
1209 for (i = 0; i < nb_elements; i++) {
1210 s1 = i < ev1->nb_elements ? &s->synth[ev1->elements + i] : &s1mod;
1211 s2 = i < ev2->nb_elements ? &s->synth[ev2->elements + i] : &s2mod;
1212 s1mod = s1 != &s1mod ? *s1 : (struct sbg_script_synth){ 0 };
1213 s2mod = s2 != &s2mod ? *s2 : (struct sbg_script_synth){ 0 };
1214 if (ev1->fade.slide) {
1215 /* for slides, and only for slides, silence ("-") is equivalent
1216 to anything with volume 0 */
1217 if (s1mod.type == SBG_TYPE_NONE) {
1220 } else if (s2mod.type == SBG_TYPE_NONE) {
1225 if (s1mod.type == s2mod.type &&
1226 s1mod.type != SBG_TYPE_BELL &&
1227 (type == SBG_FADE_ADAPT ||
1228 (s1mod.carrier == s2mod.carrier &&
1229 s1mod.beat == s2mod.beat))) {
1230 /* compatible: single transition */
1232 r = generate_interval(log, s, inter,
1233 ts1, ts2, &s1mod, &s2mod, 3);
1236 s2->ref = s2mod.ref;
1239 /* incompatible: silence at midpoint */
1243 r = generate_interval(log, s, inter,
1244 ts1, tsmid, &s1mod, &smid, 1);
1250 r = generate_interval(log, s, inter,
1251 tsmid, ts2, &smid, &s2mod, 2);
1254 s2->ref = s2mod.ref;
1263 ev1 trats ev2 intts endts ev3
1268 '''....________________....''' '''...._______________
1270 \_________/\______________/\_________/\______________/\_________/\_____________/
1271 tr x->1 int1 tr 1->2 int2 tr 2->3 int3
1274 static int generate_intervals(void *log, struct sbg_script *s, int sample_rate,
1275 struct ws_intervals *inter)
1277 int64_t trans_time = s->opt_fade_time / 2;
1278 struct sbg_script_event ev0, *ev1, *ev2;
1282 /* SBaGen handles the time before and after the extremal events,
1283 and the corresponding transitions, as if the sequence were cyclic
1284 with a 24-hours period. */
1285 period = s->events[s->nb_events - 1].ts - s->events[0].ts;
1286 period = (period + (DAY_TS - 1)) / DAY_TS * DAY_TS;
1287 period = FFMAX(period, DAY_TS);
1289 /* Prepare timestamps for transitions */
1290 for (i = 0; i < s->nb_events; i++) {
1291 ev1 = &s->events[i];
1292 ev2 = &s->events[(i + 1) % s->nb_events];
1293 ev1->ts_int = ev1->ts;
1294 ev1->ts_trans = ev1->fade.slide ? ev1->ts
1295 : ev2->ts + (ev1 < ev2 ? 0 : period);
1297 for (i = 0; i < s->nb_events; i++) {
1298 ev1 = &s->events[i];
1299 ev2 = &s->events[(i + 1) % s->nb_events];
1300 if (!ev1->fade.slide) {
1301 ev1->ts_trans = FFMAX(ev1->ts_int, ev1->ts_trans - trans_time);
1302 ev2->ts_int = FFMIN(ev2->ts_trans, ev2->ts_int + trans_time);
1304 ev1->ts_next = ev2->ts_int + (ev1 < ev2 ? 0 : period);
1307 /* Pseudo event before the first one */
1308 ev0 = s->events[s->nb_events - 1];
1309 ev0.ts_int -= period;
1310 ev0.ts_trans -= period;
1311 ev0.ts_next -= period;
1313 /* Convert timestamps */
1314 for (i = -1; i < s->nb_events; i++) {
1315 ev1 = i < 0 ? &ev0 : &s->events[i];
1316 ev1->ts_int = av_rescale(ev1->ts_int, sample_rate, AV_TIME_BASE);
1317 ev1->ts_trans = av_rescale(ev1->ts_trans, sample_rate, AV_TIME_BASE);
1318 ev1->ts_next = av_rescale(ev1->ts_next, sample_rate, AV_TIME_BASE);
1321 /* Generate intervals */
1322 for (i = 0; i < s->nb_synth; i++)
1323 s->synth[i].ref.l = s->synth[i].ref.r = -1;
1324 for (i = -1; i < s->nb_events; i++) {
1325 ev1 = i < 0 ? &ev0 : &s->events[i];
1326 ev2 = &s->events[(i + 1) % s->nb_events];
1327 r = generate_plateau(log, s, inter, ev1);
1330 r = generate_transition(log, s, inter, ev1, ev2);
1334 if (!inter->nb_inter)
1335 av_log(log, AV_LOG_WARNING, "Completely silent script.\n");
1339 static int encode_intervals(struct sbg_script *s, AVCodecParameters *par,
1340 struct ws_intervals *inter)
1342 int i, edata_size = 4, ret;
1345 for (i = 0; i < inter->nb_inter; i++) {
1346 edata_size += inter->inter[i].type == WS_SINE ? 44 :
1347 inter->inter[i].type == WS_NOISE ? 32 : 0;
1349 return AVERROR(ENOMEM);
1351 if ((ret = ff_alloc_extradata(par, edata_size)) < 0)
1353 edata = par->extradata;
1355 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
1356 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
1357 ADD_EDATA32(inter->nb_inter);
1358 for (i = 0; i < inter->nb_inter; i++) {
1359 ADD_EDATA64(inter->inter[i].ts1);
1360 ADD_EDATA64(inter->inter[i].ts2);
1361 ADD_EDATA32(inter->inter[i].type);
1362 ADD_EDATA32(inter->inter[i].channels);
1363 switch (inter->inter[i].type) {
1365 ADD_EDATA32(inter->inter[i].f1);
1366 ADD_EDATA32(inter->inter[i].f2);
1367 ADD_EDATA32(inter->inter[i].a1);
1368 ADD_EDATA32(inter->inter[i].a2);
1369 ADD_EDATA32(inter->inter[i].phi);
1372 ADD_EDATA32(inter->inter[i].a1);
1373 ADD_EDATA32(inter->inter[i].a2);
1377 if (edata != par->extradata + edata_size)
1382 static av_cold int sbg_read_probe(const AVProbeData *p)
1385 struct sbg_script script = { 0 };
1387 r = parse_script(NULL, p->buf, p->buf_size, &script);
1388 score = r < 0 || !script.nb_def || !script.nb_tseq ? 0 :
1389 AVPROBE_SCORE_MAX / 3;
1390 free_script(&script);
1394 static av_cold int sbg_read_header(AVFormatContext *avf)
1396 struct sbg_demuxer *sbg = avf->priv_data;
1399 struct sbg_script script = { 0 };
1401 struct ws_intervals inter = { 0 };
1403 r = read_whole_file(avf->pb, sbg->max_file_size, &buf);
1406 r = parse_script(avf, buf, r, &script);
1409 if (!sbg->sample_rate)
1410 sbg->sample_rate = script.sample_rate;
1412 script.sample_rate = sbg->sample_rate;
1413 if (!sbg->frame_size)
1414 sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);
1416 av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "
1417 "-m is ignored and mix channels will be silent.\n");
1418 r = expand_script(avf, &script);
1422 r = generate_intervals(avf, &script, sbg->sample_rate, &inter);
1426 if (script.end_ts != AV_NOPTS_VALUE && script.end_ts < script.start_ts) {
1427 r = AVERROR_INVALIDDATA;
1431 st = avformat_new_stream(avf, NULL);
1433 return AVERROR(ENOMEM);
1434 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
1435 st->codecpar->codec_id = AV_CODEC_ID_FFWAVESYNTH;
1436 st->codecpar->channels = 2;
1437 st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
1438 st->codecpar->sample_rate = sbg->sample_rate;
1439 st->codecpar->frame_size = sbg->frame_size;
1440 avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
1441 st->probe_packets = 0;
1442 st->start_time = av_rescale(script.start_ts,
1443 sbg->sample_rate, AV_TIME_BASE);
1444 st->duration = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
1445 av_rescale(script.end_ts - script.start_ts,
1446 sbg->sample_rate, AV_TIME_BASE);
1447 st->cur_dts = st->start_time;
1448 r = encode_intervals(&script, st->codecpar, &inter);
1452 av_free(inter.inter);
1453 free_script(&script);
1457 av_free(inter.inter);
1458 free_script(&script);
1463 static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
1468 ts = avf->streams[0]->cur_dts;
1469 end_ts = ts + avf->streams[0]->codecpar->frame_size;
1470 if (avf->streams[0]->duration != AV_NOPTS_VALUE)
1471 end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,
1475 if ((ret = av_new_packet(packet, 12)) < 0)
1477 packet->dts = packet->pts = ts;
1478 packet->duration = end_ts - ts;
1479 AV_WL64(packet->data + 0, ts);
1480 AV_WL32(packet->data + 8, packet->duration);
1481 return packet->size;
1484 static int sbg_read_seek2(AVFormatContext *avf, int stream_index,
1485 int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1487 if (flags || stream_index > 0)
1488 return AVERROR(EINVAL);
1489 if (stream_index < 0)
1490 ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);
1491 avf->streams[0]->cur_dts = ts;
1495 static int sbg_read_seek(AVFormatContext *avf, int stream_index,
1496 int64_t ts, int flags)
1498 return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);
1501 static const AVOption sbg_options[] = {
1502 { "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),
1503 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1504 AV_OPT_FLAG_DECODING_PARAM },
1505 { "frame_size", "", offsetof(struct sbg_demuxer, frame_size),
1506 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1507 AV_OPT_FLAG_DECODING_PARAM },
1508 { "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),
1509 AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,
1510 AV_OPT_FLAG_DECODING_PARAM },
1514 static const AVClass sbg_demuxer_class = {
1515 .class_name = "sbg_demuxer",
1516 .item_name = av_default_item_name,
1517 .option = sbg_options,
1518 .version = LIBAVUTIL_VERSION_INT,
1521 AVInputFormat ff_sbg_demuxer = {
1523 .long_name = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),
1524 .priv_data_size = sizeof(struct sbg_demuxer),
1525 .read_probe = sbg_read_probe,
1526 .read_header = sbg_read_header,
1527 .read_packet = sbg_read_packet,
1528 .read_seek = sbg_read_seek,
1529 .read_seek2 = sbg_read_seek2,
1530 .extensions = "sbg",
1531 .priv_class = &sbg_demuxer_class,