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 = (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 void 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 (s->tseq[i].ts.t + delta < cur_ts)
944 cur_ts = s->tseq[i].ts.t += delta;
948 static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max,
949 int64_t t0, struct sbg_script_tseq *tseq)
952 struct sbg_script_definition *def;
953 struct sbg_script_tseq *be;
954 struct sbg_script_event *ev;
957 av_log(log, AV_LOG_ERROR, "Recursion loop on \"%.*s\"\n",
958 tseq->name_len, tseq->name);
959 return AVERROR(EINVAL);
962 for (i = 0; i < s->nb_def; i++) {
963 if (s->def[i].name_len == tseq->name_len &&
964 !memcmp(s->def[i].name, tseq->name, tseq->name_len))
967 if (i >= s->nb_def) {
968 av_log(log, AV_LOG_ERROR, "Tone-set \"%.*s\" not defined\n",
969 tseq->name_len, tseq->name);
970 return AVERROR(EINVAL);
973 if (def->type == 'B') {
974 be = s->block_tseq + def->elements;
975 for (i = 0; i < def->nb_elements; i++) {
976 r = expand_tseq(log, s, nb_ev_max, t0, &be[i]);
981 ev = alloc_array_elem((void **)&s->events, sizeof(*ev),
982 &s->nb_events, nb_ev_max);
984 return AVERROR(ENOMEM);
986 ev->elements = def->elements;
987 ev->nb_elements = def->nb_elements;
988 ev->fade = tseq->fade;
994 static int expand_script(void *log, struct sbg_script *s)
996 int i, r, nb_events_max = 0;
998 expand_timestamps(log, s);
999 for (i = 0; i < s->nb_tseq; i++) {
1000 r = expand_tseq(log, s, &nb_events_max, 0, &s->tseq[i]);
1004 if (!s->nb_events) {
1005 av_log(log, AV_LOG_ERROR, "No events in script\n");
1006 return AVERROR_INVALIDDATA;
1008 if (s->opt_end_at_last)
1009 s->end_ts = s->events[s->nb_events - 1].ts;
1013 static int add_interval(struct ws_intervals *inter,
1014 enum ws_interval_type type, uint32_t channels, int ref,
1015 int64_t ts1, int32_t f1, int32_t a1,
1016 int64_t ts2, int32_t f2, int32_t a2)
1018 struct ws_interval *i, *ri;
1021 ri = &inter->inter[ref];
1022 /* ref and new intervals are constant, identical and adjacent */
1023 if (ri->type == type && ri->channels == channels &&
1024 ri->f1 == ri->f2 && ri->f2 == f1 && f1 == f2 &&
1025 ri->a1 == ri->a2 && ri->a2 == a1 && a1 == a2 &&
1031 i = alloc_array_elem((void **)&inter->inter, sizeof(*i),
1032 &inter->nb_inter, &inter->max_inter);
1034 return AVERROR(ENOMEM);
1038 i->channels = channels;
1043 i->phi = ref >= 0 ? ref | 0x80000000 : 0;
1044 return i - inter->inter;
1047 static int add_bell(struct ws_intervals *inter, struct sbg_script *s,
1048 int64_t ts1, int64_t ts2, int32_t f, int32_t a)
1050 /* SBaGen uses an exponential decrease every 50ms.
1051 We approximate it with piecewise affine segments. */
1052 int32_t cpoints[][2] = {
1062 int64_t dt = s->sample_rate / 20, ts3 = ts1, ts4;
1063 for (i = 0; i < FF_ARRAY_ELEMS(cpoints); i++) {
1064 ts4 = FFMIN(ts2, ts1 + cpoints[i][0] * dt);
1065 r = add_interval(inter, WS_SINE, 3, -1,
1066 ts3, f, a, ts4, f, cpoints[i][1]);
1075 static int generate_interval(void *log, struct sbg_script *s,
1076 struct ws_intervals *inter,
1077 int64_t ts1, int64_t ts2,
1078 struct sbg_script_synth *s1,
1079 struct sbg_script_synth *s2,
1084 if (ts2 <= ts1 || (s1->vol == 0 && s2->vol == 0))
1090 if (s1->beat == 0 && s2->beat == 0) {
1091 r = add_interval(inter, WS_SINE, 3, s1->ref.l,
1092 ts1, s1->carrier, s1->vol,
1093 ts2, s2->carrier, s2->vol);
1096 s2->ref.l = s2->ref.r = r;
1098 r = add_interval(inter, WS_SINE, 1, s1->ref.l,
1099 ts1, s1->carrier + s1->beat / 2, s1->vol,
1100 ts2, s2->carrier + s2->beat / 2, s2->vol);
1104 r = add_interval(inter, WS_SINE, 2, s1->ref.r,
1105 ts1, s1->carrier - s1->beat / 2, s1->vol,
1106 ts2, s2->carrier - s2->beat / 2, s2->vol);
1114 if (transition == 2) {
1115 r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);
1122 av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "
1123 "using pink noise instead.\n");
1125 case SBG_TYPE_NOISE:
1126 /* SBaGen's pink noise generator uses:
1127 - 1 band of white noise, mean square: 1/3;
1128 - 9 bands of subsampled white noise with linear
1129 interpolation, mean square: 2/3 each;
1130 with 1/10 weight each: the total mean square is 7/300.
1131 Our pink noise generator uses 8 bands of white noise with
1132 rectangular subsampling: the total mean square is 1/24.
1133 Therefore, to match SBaGen's volume, we must multiply vol by
1134 sqrt((7/300) / (1/24)) = sqrt(14/25) =~ 0.748
1136 r = add_interval(inter, WS_NOISE, 3, s1->ref.l,
1137 ts1, 0, s1->vol - s1->vol / 4,
1138 ts2, 0, s2->vol - s2->vol / 4);
1141 s2->ref.l = s2->ref.r = r;
1145 /* Unimplemented: silence; warning present elsewhere */
1147 av_log(log, AV_LOG_ERROR,
1148 "Type %d is not implemented\n", s1->type);
1149 return AVERROR_PATCHWELCOME;
1154 static int generate_plateau(void *log, struct sbg_script *s,
1155 struct ws_intervals *inter,
1156 struct sbg_script_event *ev1)
1158 int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;
1160 struct sbg_script_synth *s1;
1162 for (i = 0; i < ev1->nb_elements; i++) {
1163 s1 = &s->synth[ev1->elements + i];
1164 r = generate_interval(log, s, inter, ts1, ts2, s1, s1, 0);
1173 ts1 ts2 ts1 tsmid ts2
1178 ''''....____ ''....''
1180 compatible transition incompatible transition
1183 static int generate_transition(void *log, struct sbg_script *s,
1184 struct ws_intervals *inter,
1185 struct sbg_script_event *ev1,
1186 struct sbg_script_event *ev2)
1188 int64_t ts1 = ev1->ts_trans, ts2 = ev1->ts_next;
1189 /* (ts1 + ts2) / 2 without overflow */
1190 int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);
1191 enum sbg_fade_type type = ev1->fade.slide | (ev1->fade.out & ev2->fade.in);
1192 int nb_elements = FFMAX(ev1->nb_elements, ev2->nb_elements);
1193 struct sbg_script_synth *s1, *s2, s1mod, s2mod, smid;
1196 for (pass = 0; pass < 2; pass++) {
1197 /* pass = 0 -> compatible and first half of incompatible
1198 pass = 1 -> second half of incompatible
1199 Using two passes like that ensures that the intervals are generated
1200 in increasing order according to their start timestamp.
1201 Otherwise it would be necessary to sort them
1202 while keeping the mutual references.
1204 for (i = 0; i < nb_elements; i++) {
1205 s1 = i < ev1->nb_elements ? &s->synth[ev1->elements + i] : &s1mod;
1206 s2 = i < ev2->nb_elements ? &s->synth[ev2->elements + i] : &s2mod;
1207 s1mod = s1 != &s1mod ? *s1 : (struct sbg_script_synth){ 0 };
1208 s2mod = s2 != &s2mod ? *s2 : (struct sbg_script_synth){ 0 };
1209 if (ev1->fade.slide) {
1210 /* for slides, and only for slides, silence ("-") is equivalent
1211 to anything with volume 0 */
1212 if (s1mod.type == SBG_TYPE_NONE) {
1215 } else if (s2mod.type == SBG_TYPE_NONE) {
1220 if (s1mod.type == s2mod.type &&
1221 s1mod.type != SBG_TYPE_BELL &&
1222 (type == SBG_FADE_ADAPT ||
1223 (s1mod.carrier == s2mod.carrier &&
1224 s1mod.beat == s2mod.beat))) {
1225 /* compatible: single transition */
1227 r = generate_interval(log, s, inter,
1228 ts1, ts2, &s1mod, &s2mod, 3);
1231 s2->ref = s2mod.ref;
1234 /* incompatible: silence at midpoint */
1238 r = generate_interval(log, s, inter,
1239 ts1, tsmid, &s1mod, &smid, 1);
1245 r = generate_interval(log, s, inter,
1246 tsmid, ts2, &smid, &s2mod, 2);
1249 s2->ref = s2mod.ref;
1258 ev1 trats ev2 intts endts ev3
1263 '''....________________....''' '''...._______________
1265 \_________/\______________/\_________/\______________/\_________/\_____________/
1266 tr x->1 int1 tr 1->2 int2 tr 2->3 int3
1269 static int generate_intervals(void *log, struct sbg_script *s, int sample_rate,
1270 struct ws_intervals *inter)
1272 int64_t trans_time = s->opt_fade_time / 2;
1273 struct sbg_script_event ev0, *ev1, *ev2;
1277 /* SBaGen handles the time before and after the extremal events,
1278 and the corresponding transitions, as if the sequence were cyclic
1279 with a 24-hours period. */
1280 period = s->events[s->nb_events - 1].ts - s->events[0].ts;
1281 period = (period + (DAY_TS - 1)) / DAY_TS * DAY_TS;
1282 period = FFMAX(period, DAY_TS);
1284 /* Prepare timestamps for transitions */
1285 for (i = 0; i < s->nb_events; i++) {
1286 ev1 = &s->events[i];
1287 ev2 = &s->events[(i + 1) % s->nb_events];
1288 ev1->ts_int = ev1->ts;
1289 ev1->ts_trans = ev1->fade.slide ? ev1->ts
1290 : ev2->ts + (ev1 < ev2 ? 0 : period);
1292 for (i = 0; i < s->nb_events; i++) {
1293 ev1 = &s->events[i];
1294 ev2 = &s->events[(i + 1) % s->nb_events];
1295 if (!ev1->fade.slide) {
1296 ev1->ts_trans = FFMAX(ev1->ts_int, ev1->ts_trans - trans_time);
1297 ev2->ts_int = FFMIN(ev2->ts_trans, ev2->ts_int + trans_time);
1299 ev1->ts_next = ev2->ts_int + (ev1 < ev2 ? 0 : period);
1302 /* Pseudo event before the first one */
1303 ev0 = s->events[s->nb_events - 1];
1304 ev0.ts_int -= period;
1305 ev0.ts_trans -= period;
1306 ev0.ts_next -= period;
1308 /* Convert timestamps */
1309 for (i = -1; i < s->nb_events; i++) {
1310 ev1 = i < 0 ? &ev0 : &s->events[i];
1311 ev1->ts_int = av_rescale(ev1->ts_int, sample_rate, AV_TIME_BASE);
1312 ev1->ts_trans = av_rescale(ev1->ts_trans, sample_rate, AV_TIME_BASE);
1313 ev1->ts_next = av_rescale(ev1->ts_next, sample_rate, AV_TIME_BASE);
1316 /* Generate intervals */
1317 for (i = 0; i < s->nb_synth; i++)
1318 s->synth[i].ref.l = s->synth[i].ref.r = -1;
1319 for (i = -1; i < s->nb_events; i++) {
1320 ev1 = i < 0 ? &ev0 : &s->events[i];
1321 ev2 = &s->events[(i + 1) % s->nb_events];
1322 r = generate_plateau(log, s, inter, ev1);
1325 r = generate_transition(log, s, inter, ev1, ev2);
1329 if (!inter->nb_inter)
1330 av_log(log, AV_LOG_WARNING, "Completely silent script.\n");
1334 static int encode_intervals(struct sbg_script *s, AVCodecParameters *par,
1335 struct ws_intervals *inter)
1337 int i, edata_size = 4, ret;
1340 for (i = 0; i < inter->nb_inter; i++) {
1341 edata_size += inter->inter[i].type == WS_SINE ? 44 :
1342 inter->inter[i].type == WS_NOISE ? 32 : 0;
1344 return AVERROR(ENOMEM);
1346 if ((ret = ff_alloc_extradata(par, edata_size)) < 0)
1348 edata = par->extradata;
1350 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
1351 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
1352 ADD_EDATA32(inter->nb_inter);
1353 for (i = 0; i < inter->nb_inter; i++) {
1354 ADD_EDATA64(inter->inter[i].ts1);
1355 ADD_EDATA64(inter->inter[i].ts2);
1356 ADD_EDATA32(inter->inter[i].type);
1357 ADD_EDATA32(inter->inter[i].channels);
1358 switch (inter->inter[i].type) {
1360 ADD_EDATA32(inter->inter[i].f1);
1361 ADD_EDATA32(inter->inter[i].f2);
1362 ADD_EDATA32(inter->inter[i].a1);
1363 ADD_EDATA32(inter->inter[i].a2);
1364 ADD_EDATA32(inter->inter[i].phi);
1367 ADD_EDATA32(inter->inter[i].a1);
1368 ADD_EDATA32(inter->inter[i].a2);
1372 if (edata != par->extradata + edata_size)
1377 static av_cold int sbg_read_probe(const AVProbeData *p)
1380 struct sbg_script script = { 0 };
1382 r = parse_script(NULL, p->buf, p->buf_size, &script);
1383 score = r < 0 || !script.nb_def || !script.nb_tseq ? 0 :
1384 AVPROBE_SCORE_MAX / 3;
1385 free_script(&script);
1389 static av_cold int sbg_read_header(AVFormatContext *avf)
1391 struct sbg_demuxer *sbg = avf->priv_data;
1394 struct sbg_script script = { 0 };
1396 struct ws_intervals inter = { 0 };
1398 r = read_whole_file(avf->pb, sbg->max_file_size, &buf);
1401 r = parse_script(avf, buf, r, &script);
1404 if (!sbg->sample_rate)
1405 sbg->sample_rate = script.sample_rate;
1407 script.sample_rate = sbg->sample_rate;
1408 if (!sbg->frame_size)
1409 sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);
1411 av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "
1412 "-m is ignored and mix channels will be silent.\n");
1413 r = expand_script(avf, &script);
1417 r = generate_intervals(avf, &script, sbg->sample_rate, &inter);
1421 if (script.end_ts != AV_NOPTS_VALUE && script.end_ts < script.start_ts) {
1422 r = AVERROR_INVALIDDATA;
1426 st = avformat_new_stream(avf, NULL);
1428 return AVERROR(ENOMEM);
1429 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
1430 st->codecpar->codec_id = AV_CODEC_ID_FFWAVESYNTH;
1431 st->codecpar->channels = 2;
1432 st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
1433 st->codecpar->sample_rate = sbg->sample_rate;
1434 st->codecpar->frame_size = sbg->frame_size;
1435 avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
1436 st->probe_packets = 0;
1437 st->start_time = av_rescale(script.start_ts,
1438 sbg->sample_rate, AV_TIME_BASE);
1439 st->duration = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
1440 av_rescale(script.end_ts - script.start_ts,
1441 sbg->sample_rate, AV_TIME_BASE);
1442 st->cur_dts = st->start_time;
1443 r = encode_intervals(&script, st->codecpar, &inter);
1447 av_free(inter.inter);
1448 free_script(&script);
1452 av_free(inter.inter);
1453 free_script(&script);
1458 static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
1463 ts = avf->streams[0]->cur_dts;
1464 end_ts = ts + avf->streams[0]->codecpar->frame_size;
1465 if (avf->streams[0]->duration != AV_NOPTS_VALUE)
1466 end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,
1470 if ((ret = av_new_packet(packet, 12)) < 0)
1472 packet->dts = packet->pts = ts;
1473 packet->duration = end_ts - ts;
1474 AV_WL64(packet->data + 0, ts);
1475 AV_WL32(packet->data + 8, packet->duration);
1476 return packet->size;
1479 static int sbg_read_seek2(AVFormatContext *avf, int stream_index,
1480 int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1482 if (flags || stream_index > 0)
1483 return AVERROR(EINVAL);
1484 if (stream_index < 0)
1485 ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);
1486 avf->streams[0]->cur_dts = ts;
1490 static int sbg_read_seek(AVFormatContext *avf, int stream_index,
1491 int64_t ts, int flags)
1493 return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);
1496 static const AVOption sbg_options[] = {
1497 { "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),
1498 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1499 AV_OPT_FLAG_DECODING_PARAM },
1500 { "frame_size", "", offsetof(struct sbg_demuxer, frame_size),
1501 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1502 AV_OPT_FLAG_DECODING_PARAM },
1503 { "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),
1504 AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,
1505 AV_OPT_FLAG_DECODING_PARAM },
1509 static const AVClass sbg_demuxer_class = {
1510 .class_name = "sbg_demuxer",
1511 .item_name = av_default_item_name,
1512 .option = sbg_options,
1513 .version = LIBAVUTIL_VERSION_INT,
1516 AVInputFormat ff_sbg_demuxer = {
1518 .long_name = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),
1519 .priv_data_size = sizeof(struct sbg_demuxer),
1520 .read_probe = sbg_read_probe,
1521 .read_header = sbg_read_header,
1522 .read_packet = sbg_read_packet,
1523 .read_seek = sbg_read_seek,
1524 .read_seek2 = sbg_read_seek2,
1525 .extensions = "sbg",
1526 .priv_class = &sbg_demuxer_class,