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"
31 #define SBG_SCALE (1 << 16)
32 #define DAY (24 * 60 * 60)
33 #define DAY_TS ((int64_t)DAY * AV_TIME_BASE)
54 int8_t in, out, slide;
66 /* bell: freq constant, ampl decreases exponentially, can be approx lin */
68 struct sbg_timestamp {
70 char type; /* 0 for relative, 'N' for now, 'T' for absolute */
73 struct sbg_script_definition {
76 int elements, nb_elements;
77 char type; /* 'S' or 'B' */
80 struct sbg_script_synth {
84 enum sbg_synth_type type;
90 struct sbg_script_tseq {
91 struct sbg_timestamp ts;
98 struct sbg_script_event {
100 int64_t ts_int, ts_trans, ts_next;
101 int elements, nb_elements;
102 struct sbg_fade fade;
106 struct sbg_script_definition *def;
107 struct sbg_script_synth *synth;
108 struct sbg_script_tseq *tseq;
109 struct sbg_script_tseq *block_tseq;
110 struct sbg_script_event *events;
117 int64_t opt_fade_time;
118 int64_t opt_duration;
121 uint8_t opt_start_at_first;
122 uint8_t opt_end_at_last;
129 struct sbg_script scs;
130 struct sbg_timestamp current_time;
132 int nb_def_max, nb_synth_max, nb_tseq_max, nb_block_tseq_max;
137 enum ws_interval_type {
138 WS_SINE = MKTAG('S','I','N','E'),
139 WS_NOISE = MKTAG('N','O','I','S'),
144 enum ws_interval_type type;
151 struct ws_intervals {
152 struct ws_interval *inter;
157 static void *alloc_array_elem(void **array, size_t elsize,
158 int *size, int *max_size)
162 if (*size == *max_size) {
163 int m = FFMAX(32, FFMIN(*max_size, INT_MAX / 2) * 2);
166 *array = av_realloc_f(*array, m, elsize);
171 ret = (char *)*array + elsize * *size;
172 memset(ret, 0, elsize);
177 static int str_to_time(const char *str, int64_t *rtime)
179 const char *cur = str;
184 if (*cur < '0' || *cur > '9')
186 hours = strtol(cur, &end, 10);
187 if (end == cur || *end != ':' || end[1] < '0' || end[1] > '9')
190 minutes = strtol(cur, &end, 10);
195 seconds = strtod(cur + 1, &end);
199 *rtime = (hours * 3600 + minutes * 60 + seconds) * AV_TIME_BASE;
203 static inline int is_space(char c)
205 return c == ' ' || c == '\t' || c == '\r';
208 static inline int scale_double(void *log, double d, double m, int *r)
211 if (m < INT_MIN || m >= INT_MAX) {
213 av_log(log, AV_LOG_ERROR, "%g is too large\n", d);
214 return AVERROR(EDOM);
220 static int lex_space(struct sbg_parser *p)
224 while (p->cursor < p->end && is_space(*p->cursor))
226 return p->cursor > c;
229 static int lex_char(struct sbg_parser *p, char c)
231 int r = p->cursor < p->end && *p->cursor == c;
237 static int lex_double(struct sbg_parser *p, double *r)
242 if (p->cursor == p->end || is_space(*p->cursor) || *p->cursor == '\n')
244 d = strtod(p->cursor, &end);
245 if (end > p->cursor) {
253 static int lex_fixed(struct sbg_parser *p, const char *t, int l)
255 if (p->end - p->cursor < l || memcmp(p->cursor, t, l))
261 static int lex_line_end(struct sbg_parser *p)
263 if (p->cursor < p->end && *p->cursor == '#') {
265 while (p->cursor < p->end && *p->cursor != '\n')
268 if (p->cursor == p->end)
269 /* simulate final LF for files lacking it */
271 if (*p->cursor != '\n')
279 static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)
281 char *s = p->cursor, *c = s;
283 if (s == p->end || *s == '\n')
285 while (c < p->end && *c != '\n' && !is_space(*c))
288 rs->e = p->cursor = c;
293 static int lex_name(struct sbg_parser *p, struct sbg_string *rs)
295 char *s = p->cursor, *c = s;
297 while (c < p->end && ((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z')
298 || (*c >= '0' && *c <= '9') || *c == '_' || *c == '-'))
303 rs->e = p->cursor = c;
307 static int lex_time(struct sbg_parser *p, int64_t *rt)
309 int r = str_to_time(p->cursor, rt);
314 #define FORWARD_ERROR(c) \
318 return errcode ? errcode : AVERROR_INVALIDDATA; \
321 static int parse_immediate(struct sbg_parser *p)
323 snprintf(p->err_msg, sizeof(p->err_msg),
324 "immediate sequences not yet implemented");
325 return AVERROR_PATCHWELCOME;
328 static int parse_preprogrammed(struct sbg_parser *p)
330 snprintf(p->err_msg, sizeof(p->err_msg),
331 "preprogrammed sequences not yet implemented");
332 return AVERROR_PATCHWELCOME;
335 static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)
337 if (!lex_wsword(p, r)) {
338 snprintf(p->err_msg, sizeof(p->err_msg),
339 "option '%c' requires an argument", o);
340 return AVERROR_INVALIDDATA;
345 static int parse_options(struct sbg_parser *p)
347 struct sbg_string ostr, oarg;
353 if (p->cursor == p->end || *p->cursor != '-')
355 while (lex_char(p, '-') && lex_wsword(p, &ostr)) {
356 for (; ostr.s < ostr.e; ostr.s++) {
360 p->scs.opt_start_at_first = 1;
363 p->scs.opt_end_at_last = 1;
372 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
373 v = strtod(oarg.s, &tptr);
374 if (oarg.e != tptr) {
375 snprintf(p->err_msg, sizeof(p->err_msg),
376 "syntax error for option -F");
377 return AVERROR_INVALIDDATA;
379 p->scs.opt_fade_time = v * AV_TIME_BASE / 1000;
382 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
383 r = str_to_time(oarg.s, &p->scs.opt_duration);
384 if (oarg.e != oarg.s + r) {
385 snprintf(p->err_msg, sizeof(p->err_msg),
386 "syntax error for option -L");
387 return AVERROR_INVALIDDATA;
391 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
392 r = str_to_time(oarg.s, &p->scs.start_ts);
393 if (oarg.e != oarg.s + r) {
394 snprintf(p->err_msg, sizeof(p->err_msg),
395 "syntax error for option -T");
396 return AVERROR_INVALIDDATA;
400 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
401 tptr = av_malloc(oarg.e - oarg.s + 1);
403 return AVERROR(ENOMEM);
404 memcpy(tptr, oarg.s, oarg.e - oarg.s);
405 tptr[oarg.e - oarg.s] = 0;
406 av_free(p->scs.opt_mix);
407 p->scs.opt_mix = tptr;
410 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
411 v = strtod(oarg.s, &tptr);
412 if (oarg.e != tptr) {
413 snprintf(p->err_msg, sizeof(p->err_msg),
414 "syntax error for option -q");
415 return AVERROR_INVALIDDATA;
418 snprintf(p->err_msg, sizeof(p->err_msg),
419 "speed factor other than 1 not supported");
420 return AVERROR_PATCHWELCOME;
424 FORWARD_ERROR(parse_optarg(p, opt, &oarg));
425 r = strtol(oarg.s, &tptr, 10);
426 if (oarg.e != tptr) {
427 snprintf(p->err_msg, sizeof(p->err_msg),
428 "syntax error for option -r");
429 return AVERROR_INVALIDDATA;
432 snprintf(p->err_msg, sizeof(p->err_msg),
433 "invalid sample rate");
434 return AVERROR_PATCHWELCOME;
436 p->scs.sample_rate = r;
439 snprintf(p->err_msg, sizeof(p->err_msg),
440 "unknown option: '%c'", *ostr.s);
441 return AVERROR_INVALIDDATA;
447 return parse_immediate(p);
449 return parse_preprogrammed(p);
451 if (!lex_line_end(p))
452 return AVERROR_INVALIDDATA;
458 static int parse_timestamp(struct sbg_parser *p,
459 struct sbg_timestamp *rts, int64_t *rrel)
461 int64_t abs = 0, rel = 0, dt;
465 if (lex_fixed(p, "NOW", 3)) {
469 r = lex_time(p, &abs);
473 while (lex_char(p, '+')) {
474 if (!lex_time(p, &dt))
475 return AVERROR_INVALIDDATA;
481 return AVERROR_INVALIDDATA;
489 static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)
493 if (lex_char(p, '<'))
494 f.in = SBG_FADE_SILENCE;
495 else if (lex_char(p, '-'))
496 f.in = SBG_FADE_SAME;
497 else if (lex_char(p, '='))
498 f.in = SBG_FADE_ADAPT;
501 if (lex_char(p, '>'))
502 f.out = SBG_FADE_SILENCE;
503 else if (lex_char(p, '-'))
504 f.out = SBG_FADE_SAME;
505 else if (lex_char(p, '='))
506 f.out = SBG_FADE_ADAPT;
508 return AVERROR_INVALIDDATA;
513 static int parse_time_sequence(struct sbg_parser *p, int inblock)
515 struct sbg_timestamp ts;
518 struct sbg_fade fade = { SBG_FADE_SAME, SBG_FADE_SAME, 0 };
519 struct sbg_string name;
520 struct sbg_script_tseq *tseq;
522 r = parse_timestamp(p, &ts, &rel_ts);
529 return AVERROR_INVALIDDATA;
530 p->current_time.type = ts.type;
531 p->current_time.t = ts.t;
532 } else if(!inblock && !p->current_time.type) {
533 snprintf(p->err_msg, sizeof(p->err_msg),
534 "relative time without previous absolute time");
535 return AVERROR_INVALIDDATA;
537 ts.type = p->current_time.type;
538 ts.t = p->current_time.t + rel_ts;
539 r = parse_fade(p, &fade);
543 if (!lex_name(p, &name))
544 return AVERROR_INVALIDDATA;
546 if (lex_fixed(p, "->", 2)) {
547 fade.slide = SBG_FADE_ADAPT;
550 if (!lex_line_end(p))
551 return AVERROR_INVALIDDATA;
553 alloc_array_elem((void **)&p->scs.block_tseq, sizeof(*tseq),
554 &p->nb_block_tseq, &p->nb_block_tseq_max) :
555 alloc_array_elem((void **)&p->scs.tseq, sizeof(*tseq),
556 &p->scs.nb_tseq, &p->nb_tseq_max);
558 return AVERROR(ENOMEM);
561 tseq->name_len = name.e - name.s;
566 static int parse_wave_def(struct sbg_parser *p, int wavenum)
568 snprintf(p->err_msg, sizeof(p->err_msg),
569 "waveform definitions not yet implemented");
570 return AVERROR_PATCHWELCOME;
573 static int parse_block_def(struct sbg_parser *p,
574 struct sbg_script_definition *def)
579 if (!lex_line_end(p))
580 return AVERROR_INVALIDDATA;
581 tseq = p->nb_block_tseq;
583 r = parse_time_sequence(p, 1);
589 if (!lex_char(p, '}'))
590 return AVERROR_INVALIDDATA;
592 if (!lex_line_end(p))
593 return AVERROR_INVALIDDATA;
595 def->elements = tseq;
596 def->nb_elements = p->nb_block_tseq - tseq;
597 if (!def->nb_elements)
598 return AVERROR_INVALIDDATA;
602 static int parse_volume(struct sbg_parser *p, int *vol)
606 if (!lex_char(p, '/'))
608 if (!lex_double(p, &v))
609 return AVERROR_INVALIDDATA;
610 if (scale_double(p->log, v, 0.01, vol))
611 return AVERROR(ERANGE);
615 static int parse_synth_channel_sine(struct sbg_parser *p,
616 struct sbg_script_synth *synth)
618 double carrierf, beatf;
619 int carrier, beat, vol;
621 if (!lex_double(p, &carrierf))
623 if (!lex_double(p, &beatf))
625 FORWARD_ERROR(parse_volume(p, &vol));
626 if (scale_double(p->log, carrierf, 1, &carrier) < 0 ||
627 scale_double(p->log, beatf, 1, &beat) < 0)
628 return AVERROR(EDOM);
629 synth->type = SBG_TYPE_SINE;
630 synth->carrier = carrier;
636 static int parse_synth_channel_pink(struct sbg_parser *p,
637 struct sbg_script_synth *synth)
641 if (!lex_fixed(p, "pink", 4))
643 FORWARD_ERROR(parse_volume(p, &vol));
644 synth->type = SBG_TYPE_NOISE;
649 static int parse_synth_channel_bell(struct sbg_parser *p,
650 struct sbg_script_synth *synth)
655 if (!lex_fixed(p, "bell", 4))
657 if (!lex_double(p, &carrierf))
658 return AVERROR_INVALIDDATA;
659 FORWARD_ERROR(parse_volume(p, &vol));
660 if (scale_double(p->log, carrierf, 1, &carrier) < 0)
661 return AVERROR(EDOM);
662 synth->type = SBG_TYPE_BELL;
663 synth->carrier = carrier;
668 static int parse_synth_channel_mix(struct sbg_parser *p,
669 struct sbg_script_synth *synth)
673 if (!lex_fixed(p, "mix", 3))
675 FORWARD_ERROR(parse_volume(p, &vol));
676 synth->type = SBG_TYPE_MIX;
681 static int parse_synth_channel_spin(struct sbg_parser *p,
682 struct sbg_script_synth *synth)
684 double carrierf, beatf;
685 int carrier, beat, vol;
687 if (!lex_fixed(p, "spin:", 5))
689 if (!lex_double(p, &carrierf))
690 return AVERROR_INVALIDDATA;
691 if (!lex_double(p, &beatf))
692 return AVERROR_INVALIDDATA;
693 FORWARD_ERROR(parse_volume(p, &vol));
694 if (scale_double(p->log, carrierf, 1, &carrier) < 0 ||
695 scale_double(p->log, beatf, 1, &beat) < 0)
696 return AVERROR(EDOM);
697 synth->type = SBG_TYPE_SPIN;
698 synth->carrier = carrier;
704 static int parse_synth_channel(struct sbg_parser *p)
707 struct sbg_script_synth *synth;
709 synth = alloc_array_elem((void **)&p->scs.synth, sizeof(*synth),
710 &p->scs.nb_synth, &p->nb_synth_max);
712 return AVERROR(ENOMEM);
713 r = lex_char(p, '-');
715 r = parse_synth_channel_pink(p, synth);
717 r = parse_synth_channel_bell(p, synth);
719 r = parse_synth_channel_mix(p, synth);
721 r = parse_synth_channel_spin(p, synth);
722 /* Unimplemented: wave%d:%f%f/vol (carrier, beat) */
724 r = parse_synth_channel_sine(p, synth);
730 static int parse_synth_def(struct sbg_parser *p,
731 struct sbg_script_definition *def)
735 synth = p->scs.nb_synth;
737 r = parse_synth_channel(p);
740 if (!r || !lex_space(p))
744 if (synth == p->scs.nb_synth)
745 return AVERROR_INVALIDDATA;
746 if (!lex_line_end(p))
747 return AVERROR_INVALIDDATA;
749 def->elements = synth;
750 def->nb_elements = p->scs.nb_synth - synth;
754 static int parse_named_def(struct sbg_parser *p)
756 char *cursor_save = p->cursor;
757 struct sbg_string name;
758 struct sbg_script_definition *def;
760 if (!lex_name(p, &name) || !lex_char(p, ':') || !lex_space(p)) {
761 p->cursor = cursor_save;
764 if (name.e - name.s == 6 && !memcmp(name.s, "wave", 4) &&
765 name.s[4] >= '0' && name.s[4] <= '9' &&
766 name.s[5] >= '0' && name.s[5] <= '9') {
767 int wavenum = (name.s[4] - '0') * 10 + (name.s[5] - '0');
768 return parse_wave_def(p, wavenum);
770 def = alloc_array_elem((void **)&p->scs.def, sizeof(*def),
771 &p->scs.nb_def, &p->nb_def_max);
773 return AVERROR(ENOMEM);
775 def->name_len = name.e - name.s;
776 if (lex_char(p, '{'))
777 return parse_block_def(p, def);
778 return parse_synth_def(p, def);
781 static void free_script(struct sbg_script *s)
786 av_freep(&s->block_tseq);
787 av_freep(&s->events);
788 av_freep(&s->opt_mix);
791 static int parse_script(void *log, char *script, int script_len,
792 struct sbg_script *rscript)
794 struct sbg_parser sp = {
797 .end = script + script_len,
803 .start_ts = AV_NOPTS_VALUE,
804 .sample_rate = 44100,
805 .opt_fade_time = 60 * AV_TIME_BASE,
811 while (sp.cursor < sp.end) {
812 r = parse_options(&sp);
815 if (!r && !lex_line_end(&sp))
818 while (sp.cursor < sp.end) {
819 r = parse_named_def(&sp);
821 r = parse_time_sequence(&sp, 0);
823 r = lex_line_end(&sp) ? 1 : AVERROR_INVALIDDATA;
830 free_script(&sp.scs);
832 if (r == AVERROR_INVALIDDATA)
833 snprintf(sp.err_msg, sizeof(sp.err_msg), "syntax error");
834 if (log && *sp.err_msg) {
835 const char *ctx = sp.cursor;
836 const char *ectx = av_x_if_null(memchr(ctx, '\n', sp.end - sp.cursor),
838 int lctx = ectx - ctx;
839 const char *quote = "\"";
840 if (lctx > 0 && ctx[lctx - 1] == '\r')
843 ctx = "the end of line";
847 av_log(log, AV_LOG_ERROR, "Error line %d: %s near %s%.*s%s.\n",
848 sp.line_no, sp.err_msg, quote, lctx, ctx, quote);
853 static int read_whole_file(AVIOContext *io, int max_size, char **rbuf)
856 int size = 0, bufsize = 0, r;
859 if (bufsize - size < 1024) {
860 bufsize = FFMIN(FFMAX(2 * bufsize, 8192), max_size);
861 if (bufsize - size < 2) {
862 size = AVERROR(EFBIG);
865 buf = av_realloc_f(buf, bufsize, 1);
867 size = AVERROR(ENOMEM);
871 r = avio_read(io, buf, bufsize - size - 1);
872 if (r == AVERROR_EOF)
886 static void expand_timestamps(void *log, struct sbg_script *s)
889 int64_t now, cur_ts, delta = 0;
891 for (i = 0; i < s->nb_tseq; i++)
892 nb_rel += s->tseq[i].ts.type == 'N';
893 if (nb_rel == s->nb_tseq) {
894 /* All ts are relative to NOW: consider NOW = 0 */
896 if (s->start_ts != AV_NOPTS_VALUE)
897 av_log(log, AV_LOG_WARNING,
898 "Start time ignored in a purely relative script.\n");
899 } else if (nb_rel == 0 && s->start_ts != AV_NOPTS_VALUE ||
900 s->opt_start_at_first) {
901 /* All ts are absolute and start time is specified */
902 if (s->start_ts == AV_NOPTS_VALUE)
903 s->start_ts = s->tseq[0].ts.t;
906 /* Mixed relative/absolute ts: expand */
910 av_log(log, AV_LOG_WARNING,
911 "Scripts with mixed absolute and relative timestamps can give "
912 "unexpected results (pause, seeking, time zone change).\n");
915 tm = localtime(&now0);
916 now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
918 av_log(log, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",
919 (int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);
921 for (i = 0; i < s->nb_tseq; i++) {
922 if (s->tseq[i].ts.type == 'N') {
923 s->tseq[i].ts.t += now;
924 s->tseq[i].ts.type = 'T'; /* not necessary */
928 if (s->start_ts == AV_NOPTS_VALUE)
929 s->start_ts = s->opt_start_at_first ? s->tseq[0].ts.t : now;
930 s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
931 AV_NOPTS_VALUE; /* may be overridden later by -E option */
933 for (i = 0; i < s->nb_tseq; i++) {
934 if (s->tseq[i].ts.t + delta < cur_ts)
936 cur_ts = s->tseq[i].ts.t += delta;
940 static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max,
941 int64_t t0, struct sbg_script_tseq *tseq)
944 struct sbg_script_definition *def;
945 struct sbg_script_tseq *be;
946 struct sbg_script_event *ev;
949 av_log(log, 16, "Recursion loop on \"%.*s\"\n",
950 tseq->name_len, tseq->name);
951 return AVERROR(EINVAL);
954 for (i = 0; i < s->nb_def; i++) {
955 if (s->def[i].name_len == tseq->name_len &&
956 !memcmp(s->def[i].name, tseq->name, tseq->name_len))
959 if (i >= s->nb_def) {
960 av_log(log, 16, "Tone-set \"%.*s\" not defined\n",
961 tseq->name_len, tseq->name);
962 return AVERROR(EINVAL);
965 if (def->type == 'B') {
966 be = s->block_tseq + def->elements;
967 for (i = 0; i < def->nb_elements; i++) {
968 r = expand_tseq(log, s, nb_ev_max, t0, &be[i]);
973 ev = alloc_array_elem((void **)&s->events, sizeof(*ev),
974 &s->nb_events, nb_ev_max);
976 ev->elements = def->elements;
977 ev->nb_elements = def->nb_elements;
978 ev->fade = tseq->fade;
984 static int expand_script(void *log, struct sbg_script *s)
986 int i, r, nb_events_max = 0;
988 expand_timestamps(log, s);
989 for (i = 0; i < s->nb_tseq; i++) {
990 r = expand_tseq(log, s, &nb_events_max, 0, &s->tseq[i]);
995 av_log(log, AV_LOG_ERROR, "No events in script\n");
996 return AVERROR_INVALIDDATA;
998 if (s->opt_end_at_last)
999 s->end_ts = s->events[s->nb_events - 1].ts;
1003 static int add_interval(struct ws_intervals *inter,
1004 enum ws_interval_type type, uint32_t channels, int ref,
1005 int64_t ts1, int32_t f1, int32_t a1,
1006 int64_t ts2, int32_t f2, int32_t a2)
1008 struct ws_interval *i, *ri;
1011 ri = &inter->inter[ref];
1012 /* ref and new intervals are constant, identical and adjacent */
1013 if (ri->type == type && ri->channels == channels &&
1014 ri->f1 == ri->f2 && ri->f2 == f1 && f1 == f2 &&
1015 ri->a1 == ri->a2 && ri->a2 == a1 && a1 == a2 &&
1021 i = alloc_array_elem((void **)&inter->inter, sizeof(*i),
1022 &inter->nb_inter, &inter->max_inter);
1024 return AVERROR(ENOMEM);
1028 i->channels = channels;
1033 i->phi = ref >= 0 ? ref | 0x80000000 : 0;
1034 return i - inter->inter;
1037 static int add_bell(struct ws_intervals *inter, struct sbg_script *s,
1038 int64_t ts1, int64_t ts2, int32_t f, int32_t a)
1040 /* SBaGen uses an exponential decrease every 50ms.
1041 We approximate it with piecewise affine segments. */
1042 int32_t cpoints[][2] = {
1052 int64_t dt = s->sample_rate / 20, ts3 = ts1, ts4;
1053 for (i = 0; i < FF_ARRAY_ELEMS(cpoints); i++) {
1054 ts4 = FFMIN(ts2, ts1 + cpoints[i][0] * dt);
1055 r = add_interval(inter, WS_SINE, 3, -1,
1056 ts3, f, a, ts4, f, cpoints[i][1]);
1065 static int generate_interval(void *log, struct sbg_script *s,
1066 struct ws_intervals *inter,
1067 int64_t ts1, int64_t ts2,
1068 struct sbg_script_synth *s1,
1069 struct sbg_script_synth *s2,
1074 if (ts2 <= ts1 || (s1->vol == 0 && s2->vol == 0))
1080 if (s1->beat == 0 && s2->beat == 0) {
1081 r = add_interval(inter, WS_SINE, 3, s1->ref.l,
1082 ts1, s1->carrier, s1->vol,
1083 ts2, s2->carrier, s2->vol);
1086 s2->ref.l = s2->ref.r = r;
1088 r = add_interval(inter, WS_SINE, 1, s1->ref.l,
1089 ts1, s1->carrier + s1->beat / 2, s1->vol,
1090 ts2, s2->carrier + s2->beat / 2, s2->vol);
1094 r = add_interval(inter, WS_SINE, 2, s1->ref.r,
1095 ts1, s1->carrier - s1->beat / 2, s1->vol,
1096 ts2, s2->carrier - s2->beat / 2, s2->vol);
1104 if (transition == 2) {
1105 r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);
1112 av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "
1113 "using pink noise instead.\n");
1115 case SBG_TYPE_NOISE:
1116 /* SBaGen's pink noise generator uses:
1117 - 1 band of white noise, mean square: 1/3;
1118 - 9 bands of subsampled white noise with linear
1119 interpolation, mean square: 2/3 each;
1120 with 1/10 weight each: the total mean square is 7/300.
1121 Our pink noise generator uses 8 bands of white noise with
1122 rectangular subsampling: the total mean square is 1/24.
1123 Therefore, to match SBaGen's volume, we must multiply vol by
1124 sqrt((7/300) / (1/24)) = sqrt(14/25) =~ 0.748
1126 r = add_interval(inter, WS_NOISE, 3, s1->ref.l,
1127 ts1, 0, s1->vol - s1->vol / 4,
1128 ts2, 0, s2->vol - s2->vol / 4);
1131 s2->ref.l = s2->ref.r = r;
1135 /* Unimplemented: silence; warning present elsewhere */
1137 av_log(log, AV_LOG_ERROR,
1138 "Type %d is not implemented\n", s1->type);
1139 return AVERROR_PATCHWELCOME;
1144 static int generate_plateau(void *log, struct sbg_script *s,
1145 struct ws_intervals *inter,
1146 struct sbg_script_event *ev1)
1148 int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;
1150 struct sbg_script_synth *s1;
1152 for (i = 0; i < ev1->nb_elements; i++) {
1153 s1 = &s->synth[ev1->elements + i];
1154 r = generate_interval(log, s, inter, ts1, ts2, s1, s1, 0);
1163 ts1 ts2 ts1 tsmid ts2
1168 ''''....____ ''....''
1170 compatible transition incompatible transition
1173 static int generate_transition(void *log, struct sbg_script *s,
1174 struct ws_intervals *inter,
1175 struct sbg_script_event *ev1,
1176 struct sbg_script_event *ev2)
1178 int64_t ts1 = ev1->ts_trans, ts2 = ev1->ts_next;
1179 /* (ts1 + ts2) / 2 without overflow */
1180 int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);
1181 enum sbg_fade_type type = ev1->fade.slide | (ev1->fade.out & ev2->fade.in);
1182 int nb_elements = FFMAX(ev1->nb_elements, ev2->nb_elements);
1183 struct sbg_script_synth *s1, *s2, s1mod, s2mod, smid;
1186 for (pass = 0; pass < 2; pass++) {
1187 /* pass = 0 -> compatible and first half of incompatible
1188 pass = 1 -> second half of incompatible
1189 Using two passes like that ensures that the intervals are generated
1190 in increasing order according to their start timestamp.
1191 Otherwise it would be necessary to sort them
1192 while keeping the mutual references.
1194 for (i = 0; i < nb_elements; i++) {
1195 s1 = i < ev1->nb_elements ? &s->synth[ev1->elements + i] : &s1mod;
1196 s2 = i < ev2->nb_elements ? &s->synth[ev2->elements + i] : &s2mod;
1197 s1mod = s1 != &s1mod ? *s1 : (struct sbg_script_synth){ 0 };
1198 s2mod = s2 != &s2mod ? *s2 : (struct sbg_script_synth){ 0 };
1199 if (ev1->fade.slide) {
1200 /* for slides, and only for slides, silence ("-") is equivalent
1201 to anything with volume 0 */
1202 if (s1mod.type == SBG_TYPE_NONE) {
1205 } else if (s2mod.type == SBG_TYPE_NONE) {
1210 if (s1mod.type == s2mod.type &&
1211 s1mod.type != SBG_TYPE_BELL &&
1212 (type == SBG_FADE_ADAPT ||
1213 (s1mod.carrier == s2mod.carrier &&
1214 s1mod.beat == s2mod.beat))) {
1215 /* compatible: single transition */
1217 r = generate_interval(log, s, inter,
1218 ts1, ts2, &s1mod, &s2mod, 3);
1221 s2->ref = s2mod.ref;
1224 /* incompatible: silence at midpoint */
1228 r = generate_interval(log, s, inter,
1229 ts1, tsmid, &s1mod, &smid, 1);
1235 r = generate_interval(log, s, inter,
1236 tsmid, ts2, &smid, &s2mod, 2);
1239 s2->ref = s2mod.ref;
1248 ev1 trats ev2 intts endts ev3
1253 '''....________________....''' '''...._______________
1255 \_________/\______________/\_________/\______________/\_________/\_____________/
1256 tr x->1 int1 tr 1->2 int2 tr 2->3 int3
1259 static int generate_intervals(void *log, struct sbg_script *s, int sample_rate,
1260 struct ws_intervals *inter)
1262 int64_t trans_time = s->opt_fade_time / 2;
1263 struct sbg_script_event ev0, *ev1, *ev2;
1267 /* SBaGen handles the time before and after the extremal events,
1268 and the corresponding transitions, as if the sequence were cyclic
1269 with a 24-hours period. */
1270 period = s->events[s->nb_events - 1].ts - s->events[0].ts;
1271 period = (period + (DAY_TS - 1)) / DAY_TS * DAY_TS;
1272 period = FFMAX(period, DAY_TS);
1274 /* Prepare timestamps for transitions */
1275 for (i = 0; i < s->nb_events; i++) {
1276 ev1 = &s->events[i];
1277 ev2 = &s->events[(i + 1) % s->nb_events];
1278 ev1->ts_int = ev1->ts;
1279 ev1->ts_trans = ev1->fade.slide ? ev1->ts
1280 : ev2->ts + (ev1 < ev2 ? 0 : period);
1282 for (i = 0; i < s->nb_events; i++) {
1283 ev1 = &s->events[i];
1284 ev2 = &s->events[(i + 1) % s->nb_events];
1285 if (!ev1->fade.slide) {
1286 ev1->ts_trans = FFMAX(ev1->ts_int, ev1->ts_trans - trans_time);
1287 ev2->ts_int = FFMIN(ev2->ts_trans, ev2->ts_int + trans_time);
1289 ev1->ts_next = ev2->ts_int + (ev1 < ev2 ? 0 : period);
1292 /* Pseudo event before the first one */
1293 ev0 = s->events[s->nb_events - 1];
1294 ev0.ts_int -= period;
1295 ev0.ts_trans -= period;
1296 ev0.ts_next -= period;
1298 /* Convert timestamps */
1299 for (i = -1; i < s->nb_events; i++) {
1300 ev1 = i < 0 ? &ev0 : &s->events[i];
1301 ev1->ts_int = av_rescale(ev1->ts_int, sample_rate, AV_TIME_BASE);
1302 ev1->ts_trans = av_rescale(ev1->ts_trans, sample_rate, AV_TIME_BASE);
1303 ev1->ts_next = av_rescale(ev1->ts_next, sample_rate, AV_TIME_BASE);
1306 /* Generate intervals */
1307 for (i = 0; i < s->nb_synth; i++)
1308 s->synth[i].ref.l = s->synth[i].ref.r = -1;
1309 for (i = -1; i < s->nb_events; i++) {
1310 ev1 = i < 0 ? &ev0 : &s->events[i];
1311 ev2 = &s->events[(i + 1) % s->nb_events];
1312 r = generate_plateau(log, s, inter, ev1);
1315 r = generate_transition(log, s, inter, ev1, ev2);
1319 if (!inter->nb_inter)
1320 av_log(log, AV_LOG_WARNING, "Completely silent script.\n");
1324 static int encode_intervals(struct sbg_script *s, AVCodecContext *avc,
1325 struct ws_intervals *inter)
1327 int i, edata_size = 4;
1330 for (i = 0; i < inter->nb_inter; i++) {
1331 edata_size += inter->inter[i].type == WS_SINE ? 44 :
1332 inter->inter[i].type == WS_NOISE ? 32 : 0;
1334 return AVERROR(ENOMEM);
1336 edata = av_malloc(edata_size);
1338 return AVERROR(ENOMEM);
1339 avc->extradata = edata;
1340 avc->extradata_size = edata_size;
1342 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
1343 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
1344 ADD_EDATA32(inter->nb_inter);
1345 for (i = 0; i < inter->nb_inter; i++) {
1346 ADD_EDATA64(inter->inter[i].ts1);
1347 ADD_EDATA64(inter->inter[i].ts2);
1348 ADD_EDATA32(inter->inter[i].type);
1349 ADD_EDATA32(inter->inter[i].channels);
1350 switch (inter->inter[i].type) {
1352 ADD_EDATA32(inter->inter[i].f1);
1353 ADD_EDATA32(inter->inter[i].f2);
1354 ADD_EDATA32(inter->inter[i].a1);
1355 ADD_EDATA32(inter->inter[i].a2);
1356 ADD_EDATA32(inter->inter[i].phi);
1359 ADD_EDATA32(inter->inter[i].a1);
1360 ADD_EDATA32(inter->inter[i].a2);
1364 if (edata != avc->extradata + edata_size)
1369 static av_cold int sbg_read_probe(AVProbeData *p)
1372 struct sbg_script script = { 0 };
1374 r = parse_script(NULL, p->buf, p->buf_size, &script);
1375 score = r < 0 || !script.nb_def || !script.nb_tseq ? 0 :
1376 AVPROBE_SCORE_MAX / 3;
1377 free_script(&script);
1381 static av_cold int sbg_read_header(AVFormatContext *avf)
1383 struct sbg_demuxer *sbg = avf->priv_data;
1386 struct sbg_script script = { 0 };
1388 struct ws_intervals inter = { 0 };
1390 r = read_whole_file(avf->pb, sbg->max_file_size, &buf);
1393 r = parse_script(avf, buf, r, &script);
1396 if (!sbg->sample_rate)
1397 sbg->sample_rate = script.sample_rate;
1399 script.sample_rate = sbg->sample_rate;
1400 if (!sbg->frame_size)
1401 sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);
1403 av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "
1404 "-m is ignored and mix channels will be silent.\n");
1405 r = expand_script(avf, &script);
1409 r = generate_intervals(avf, &script, sbg->sample_rate, &inter);
1413 st = avformat_new_stream(avf, NULL);
1415 return AVERROR(ENOMEM);
1416 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
1417 st->codec->codec_id = AV_CODEC_ID_FFWAVESYNTH;
1418 st->codec->channels = 2;
1419 st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
1420 st->codec->sample_rate = sbg->sample_rate;
1421 st->codec->frame_size = sbg->frame_size;
1422 avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
1423 st->probe_packets = 0;
1424 st->start_time = av_rescale(script.start_ts,
1425 sbg->sample_rate, AV_TIME_BASE);
1426 st->duration = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
1427 av_rescale(script.end_ts - script.start_ts,
1428 sbg->sample_rate, AV_TIME_BASE);
1429 st->cur_dts = st->start_time;
1430 r = encode_intervals(&script, st->codec, &inter);
1434 av_free(inter.inter);
1435 free_script(&script);
1439 av_free(inter.inter);
1440 free_script(&script);
1445 static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
1449 ts = avf->streams[0]->cur_dts;
1450 end_ts = ts + avf->streams[0]->codec->frame_size;
1451 if (avf->streams[0]->duration != AV_NOPTS_VALUE)
1452 end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,
1456 if (av_new_packet(packet, 12) < 0)
1457 return AVERROR(ENOMEM);
1458 packet->dts = packet->pts = ts;
1459 packet->duration = end_ts - ts;
1460 AV_WL64(packet->data + 0, ts);
1461 AV_WL32(packet->data + 8, packet->duration);
1462 return packet->size;
1465 static int sbg_read_seek2(AVFormatContext *avf, int stream_index,
1466 int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1468 if (flags || stream_index > 0)
1469 return AVERROR(EINVAL);
1470 if (stream_index < 0)
1471 ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);
1472 avf->streams[0]->cur_dts = ts;
1476 static int sbg_read_seek(AVFormatContext *avf, int stream_index,
1477 int64_t ts, int flags)
1479 return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);
1482 static const AVOption sbg_options[] = {
1483 { "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),
1484 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1485 AV_OPT_FLAG_DECODING_PARAM },
1486 { "frame_size", "", offsetof(struct sbg_demuxer, frame_size),
1487 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1488 AV_OPT_FLAG_DECODING_PARAM },
1489 { "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),
1490 AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,
1491 AV_OPT_FLAG_DECODING_PARAM },
1495 static const AVClass sbg_demuxer_class = {
1496 .class_name = "sbg_demuxer",
1497 .item_name = av_default_item_name,
1498 .option = sbg_options,
1499 .version = LIBAVUTIL_VERSION_INT,
1502 AVInputFormat ff_sbg_demuxer = {
1504 .long_name = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),
1505 .priv_data_size = sizeof(struct sbg_demuxer),
1506 .read_probe = sbg_read_probe,
1507 .read_header = sbg_read_header,
1508 .read_packet = sbg_read_packet,
1509 .read_seek = sbg_read_seek,
1510 .read_seek2 = sbg_read_seek2,
1511 .extensions = "sbg",
1512 .priv_class = &sbg_demuxer_class,