Merge commit 'e4dc1000d7bbbcb5b45cf9849fc5315f19578e37'
[ffmpeg.git] / libavformat / sbgdec.c
1 /*
2  * SBG (SBaGen) file format decoder
3  * Copyright (c) 2011 Nicolas George
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <time.h>
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/log.h"
27 #include "libavutil/opt.h"
28 #include "avformat.h"
29 #include "internal.h"
30
31 #define SBG_SCALE (1 << 16)
32 #define DAY (24 * 60 * 60)
33 #define DAY_TS ((int64_t)DAY * AV_TIME_BASE)
34
35 struct sbg_demuxer {
36     AVClass *class;
37     int sample_rate;
38     int frame_size;
39     int max_file_size;
40 };
41
42 struct sbg_string {
43     char *s;
44     char *e;
45 };
46
47 enum sbg_fade_type {
48     SBG_FADE_SILENCE = 0,
49     SBG_FADE_SAME    = 1,
50     SBG_FADE_ADAPT   = 3,
51 };
52
53 struct sbg_fade {
54     int8_t in, out, slide;
55 };
56
57 enum sbg_synth_type {
58     SBG_TYPE_NONE,
59     SBG_TYPE_SINE,
60     SBG_TYPE_NOISE,
61     SBG_TYPE_BELL,
62     SBG_TYPE_MIX,
63     SBG_TYPE_SPIN,
64 };
65
66 /* bell: freq constant, ampl decreases exponentially, can be approx lin */
67
68 struct sbg_timestamp {
69     int64_t t;
70     char type; /* 0 for relative, 'N' for now, 'T' for absolute */
71 };
72
73 struct sbg_script_definition {
74     char *name;
75     int name_len;
76     int elements, nb_elements;
77     char type; /* 'S' or 'B' */
78 };
79
80 struct sbg_script_synth {
81     int carrier;
82     int beat;
83     int vol;
84     enum sbg_synth_type type;
85     struct {
86         int l, r;
87     } ref;
88 };
89
90 struct sbg_script_tseq {
91     struct sbg_timestamp ts;
92     char *name;
93     int name_len;
94     int lock;
95     struct sbg_fade fade;
96 };
97
98 struct sbg_script_event {
99     int64_t ts;
100     int64_t ts_int, ts_trans, ts_next;
101     int elements, nb_elements;
102     struct sbg_fade fade;
103 };
104
105 struct sbg_script {
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;
111     int nb_def;
112     int nb_tseq;
113     int nb_events;
114     int nb_synth;
115     int64_t start_ts;
116     int64_t end_ts;
117     int64_t opt_fade_time;
118     int64_t opt_duration;
119     char *opt_mix;
120     int sample_rate;
121     uint8_t opt_start_at_first;
122     uint8_t opt_end_at_last;
123 };
124
125 struct sbg_parser {
126     void *log;
127     char *script, *end;
128     char *cursor;
129     struct sbg_script scs;
130     struct sbg_timestamp current_time;
131     int nb_block_tseq;
132     int nb_def_max, nb_synth_max, nb_tseq_max, nb_block_tseq_max;
133     int line_no;
134     char err_msg[128];
135 };
136
137 enum ws_interval_type {
138     WS_SINE  = MKTAG('S','I','N','E'),
139     WS_NOISE = MKTAG('N','O','I','S'),
140 };
141
142 struct ws_interval {
143     int64_t ts1, ts2;
144     enum ws_interval_type type;
145     uint32_t channels;
146     int32_t f1, f2;
147     int32_t a1, a2;
148     uint32_t phi;
149 };
150
151 struct ws_intervals {
152     struct ws_interval *inter;
153     int nb_inter;
154     int max_inter;
155 };
156
157 static void *alloc_array_elem(void **array, size_t elsize,
158                               int *size, int *max_size)
159 {
160     void *ret;
161
162     if (*size == *max_size) {
163         int m = FFMAX(32, FFMIN(*max_size, INT_MAX / 2) * 2);
164         if (*size >= m)
165             return NULL;
166         *array = av_realloc_f(*array, m, elsize);
167         if (!*array)
168             return NULL;
169         *max_size = m;
170     }
171     ret = (char *)*array + elsize * *size;
172     memset(ret, 0, elsize);
173     (*size)++;
174     return ret;
175 }
176
177 static int str_to_time(const char *str, int64_t *rtime)
178 {
179     const char *cur = str;
180     char *end;
181     int hours, minutes;
182     double seconds = 0;
183
184     if (*cur < '0' || *cur > '9')
185         return 0;
186     hours = strtol(cur, &end, 10);
187     if (end == cur || *end != ':' || end[1] < '0' || end[1] > '9')
188         return 0;
189     cur = end + 1;
190     minutes = strtol(cur, &end, 10);
191     if (end == cur)
192         return 0;
193     cur = end;
194     if (*end == ':'){
195         seconds = strtod(cur + 1, &end);
196         if (end > cur + 1)
197             cur = end;
198     }
199     *rtime = (hours * 3600 + minutes * 60 + seconds) * AV_TIME_BASE;
200     return cur - str;
201 }
202
203 static inline int is_space(char c)
204 {
205     return c == ' '  || c == '\t' || c == '\r';
206 }
207
208 static inline int scale_double(void *log, double d, double m, int *r)
209 {
210     m *= d * SBG_SCALE;
211     if (m < INT_MIN || m >= INT_MAX) {
212         if (log)
213             av_log(log, AV_LOG_ERROR, "%g is too large\n", d);
214         return AVERROR(EDOM);
215     }
216     *r = m;
217     return 0;
218 }
219
220 static int lex_space(struct sbg_parser *p)
221 {
222     char *c = p->cursor;
223
224     while (p->cursor < p->end && is_space(*p->cursor))
225         p->cursor++;
226     return p->cursor > c;
227 }
228
229 static int lex_char(struct sbg_parser *p, char c)
230 {
231     int r = p->cursor < p->end && *p->cursor == c;
232
233     p->cursor += r;
234     return r;
235 }
236
237 static int lex_double(struct sbg_parser *p, double *r)
238 {
239     double d;
240     char *end;
241
242     if (p->cursor == p->end || is_space(*p->cursor) || *p->cursor == '\n')
243         return 0;
244     d = strtod(p->cursor, &end);
245     if (end > p->cursor) {
246         *r = d;
247         p->cursor = end;
248         return 1;
249     }
250     return 0;
251 }
252
253 static int lex_fixed(struct sbg_parser *p, const char *t, int l)
254 {
255     if (p->end - p->cursor < l || memcmp(p->cursor, t, l))
256         return 0;
257     p->cursor += l;
258     return 1;
259 }
260
261 static int lex_line_end(struct sbg_parser *p)
262 {
263     if (p->cursor < p->end && *p->cursor == '#') {
264         p->cursor++;
265         while (p->cursor < p->end && *p->cursor != '\n')
266             p->cursor++;
267     }
268     if (p->cursor == p->end)
269         /* simulate final LF for files lacking it */
270         return 1;
271     if (*p->cursor != '\n')
272         return 0;
273     p->cursor++;
274     p->line_no++;
275     lex_space(p);
276     return 1;
277 }
278
279 static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)
280 {
281     char *s = p->cursor, *c = s;
282
283     if (s == p->end || *s == '\n')
284         return 0;
285     while (c < p->end && *c != '\n' && !is_space(*c))
286         c++;
287     rs->s = s;
288     rs->e = p->cursor = c;
289     lex_space(p);
290     return 1;
291 }
292
293 static int lex_name(struct sbg_parser *p, struct sbg_string *rs)
294 {
295     char *s = p->cursor, *c = s;
296
297     while (c < p->end && ((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z')
298            || (*c >= '0' && *c <= '9') || *c == '_' || *c == '-'))
299         c++;
300     if (c == s)
301         return 0;
302     rs->s = s;
303     rs->e = p->cursor = c;
304     return 1;
305 }
306
307 static int lex_time(struct sbg_parser *p, int64_t *rt)
308 {
309     int r = str_to_time(p->cursor, rt);
310     p->cursor += r;
311     return r > 0;
312 }
313
314 #define FORWARD_ERROR(c) \
315     do { \
316         int errcode = c; \
317         if (errcode <= 0) \
318             return errcode ? errcode : AVERROR_INVALIDDATA; \
319     } while(0);
320
321 static int parse_immediate(struct sbg_parser *p)
322 {
323     snprintf(p->err_msg, sizeof(p->err_msg),
324              "immediate sequences not yet implemented");
325     return AVERROR_PATCHWELCOME;
326 }
327
328 static int parse_preprogrammed(struct sbg_parser *p)
329 {
330     snprintf(p->err_msg, sizeof(p->err_msg),
331              "preprogrammed sequences not yet implemented");
332     return AVERROR_PATCHWELCOME;
333 }
334
335 static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)
336 {
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;
341     }
342     return 1;
343 }
344
345 static int parse_options(struct sbg_parser *p)
346 {
347     struct sbg_string ostr, oarg;
348     char mode = 0;
349     int r;
350     char *tptr;
351     double v;
352
353     if (p->cursor == p->end || *p->cursor != '-')
354         return 0;
355     while (lex_char(p, '-') && lex_wsword(p, &ostr)) {
356         for (; ostr.s < ostr.e; ostr.s++) {
357             char opt = *ostr.s;
358             switch (opt) {
359                 case 'S':
360                     p->scs.opt_start_at_first = 1;
361                     break;
362                 case 'E':
363                     p->scs.opt_end_at_last = 1;
364                     break;
365                 case 'i':
366                     mode = 'i';
367                     break;
368                 case 'p':
369                     mode = 'p';
370                     break;
371                 case 'F':
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;
378                     }
379                     p->scs.opt_fade_time = v * AV_TIME_BASE / 1000;
380                     break;
381                 case 'L':
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;
388                     }
389                     break;
390                 case 'T':
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;
397                     }
398                     break;
399                 case 'm':
400                     FORWARD_ERROR(parse_optarg(p, opt, &oarg));
401                     tptr = av_malloc(oarg.e - oarg.s + 1);
402                     if (!tptr)
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;
408                     break;
409                 case 'q':
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;
416                     }
417                     if (v != 1) {
418                         snprintf(p->err_msg, sizeof(p->err_msg),
419                                  "speed factor other than 1 not supported");
420                         return AVERROR_PATCHWELCOME;
421                     }
422                     break;
423                 case 'r':
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;
430                     }
431                     if (r < 40) {
432                         snprintf(p->err_msg, sizeof(p->err_msg),
433                                  "invalid sample rate");
434                         return AVERROR_PATCHWELCOME;
435                     }
436                     p->scs.sample_rate = r;
437                     break;
438                 default:
439                     snprintf(p->err_msg, sizeof(p->err_msg),
440                              "unknown option: '%c'", *ostr.s);
441                     return AVERROR_INVALIDDATA;
442             }
443         }
444     }
445     switch (mode) {
446         case 'i':
447             return parse_immediate(p);
448         case 'p':
449             return parse_preprogrammed(p);
450         case 0:
451             if (!lex_line_end(p))
452                 return AVERROR_INVALIDDATA;
453             return 1;
454     }
455     return AVERROR_BUG;
456 }
457
458 static int parse_timestamp(struct sbg_parser *p,
459                                struct sbg_timestamp *rts, int64_t *rrel)
460 {
461     int64_t abs = 0, rel = 0, dt;
462     char type = 0;
463     int r;
464
465     if (lex_fixed(p, "NOW", 3)) {
466         type = 'N';
467         r = 1;
468     } else {
469         r = lex_time(p, &abs);
470         if (r)
471             type = 'T';
472     }
473     while (lex_char(p, '+')) {
474         if (!lex_time(p, &dt))
475             return AVERROR_INVALIDDATA;
476         rel += dt;
477         r = 1;
478     }
479     if (r) {
480         if (!lex_space(p))
481             return AVERROR_INVALIDDATA;
482         rts->type = type;
483         rts->t    = abs;
484         *rrel     = rel;
485     }
486     return r;
487 }
488
489 static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)
490 {
491     struct sbg_fade f = {0};
492
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;
499     else
500         return 0;
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;
507     else
508         return AVERROR_INVALIDDATA;
509     *fr = f;
510     return 1;
511 }
512
513 static int parse_time_sequence(struct sbg_parser *p, int inblock)
514 {
515     struct sbg_timestamp ts;
516     int64_t rel_ts;
517     int r;
518     struct sbg_fade fade = { SBG_FADE_SAME, SBG_FADE_SAME, 0 };
519     struct sbg_string name;
520     struct sbg_script_tseq *tseq;
521
522     r = parse_timestamp(p, &ts, &rel_ts);
523     if (!r)
524         return 0;
525     if (r < 0)
526         return r;
527     if (ts.type) {
528         if (inblock)
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;
536     }
537     ts.type = p->current_time.type;
538     ts.t    = p->current_time.t + rel_ts;
539     r = parse_fade(p, &fade);
540     if (r < 0)
541         return r;
542     lex_space(p);
543     if (!lex_name(p, &name))
544         return AVERROR_INVALIDDATA;
545     lex_space(p);
546     if (lex_fixed(p, "->", 2)) {
547         fade.slide = SBG_FADE_ADAPT;
548         lex_space(p);
549     }
550     if (!lex_line_end(p))
551         return AVERROR_INVALIDDATA;
552     tseq = inblock ?
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);
557     if (!tseq)
558         return AVERROR(ENOMEM);
559     tseq->ts       = ts;
560     tseq->name     = name.s;
561     tseq->name_len = name.e - name.s;
562     tseq->fade     = fade;
563     return 1;
564 }
565
566 static int parse_wave_def(struct sbg_parser *p, int wavenum)
567 {
568     snprintf(p->err_msg, sizeof(p->err_msg),
569              "waveform definitions not yet implemented");
570     return AVERROR_PATCHWELCOME;
571 }
572
573 static int parse_block_def(struct sbg_parser *p,
574                            struct sbg_script_definition *def)
575 {
576     int r, tseq;
577
578     lex_space(p);
579     if (!lex_line_end(p))
580         return AVERROR_INVALIDDATA;
581     tseq = p->nb_block_tseq;
582     while (1) {
583         r = parse_time_sequence(p, 1);
584         if (r < 0)
585             return r;
586         if (!r)
587             break;
588     }
589     if (!lex_char(p, '}'))
590         return AVERROR_INVALIDDATA;
591     lex_space(p);
592     if (!lex_line_end(p))
593         return AVERROR_INVALIDDATA;
594     def->type        = 'B';
595     def->elements    = tseq;
596     def->nb_elements = p->nb_block_tseq - tseq;
597     if (!def->nb_elements)
598         return AVERROR_INVALIDDATA;
599     return 1;
600 }
601
602 static int parse_volume(struct sbg_parser *p, int *vol)
603 {
604     double v;
605
606     if (!lex_char(p, '/'))
607         return 0;
608     if (!lex_double(p, &v))
609         return AVERROR_INVALIDDATA;
610     if (scale_double(p->log, v, 0.01, vol))
611         return AVERROR(ERANGE);
612     return 1;
613 }
614
615 static int parse_synth_channel_sine(struct sbg_parser *p,
616                                     struct sbg_script_synth *synth)
617 {
618     double carrierf, beatf;
619     int carrier, beat, vol;
620
621     if (!lex_double(p, &carrierf))
622         return 0;
623     if (!lex_double(p, &beatf))
624         beatf = 0;
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;
631     synth->beat    = beat;
632     synth->vol     = vol;
633     return 1;
634 }
635
636 static int parse_synth_channel_pink(struct sbg_parser *p,
637                                     struct sbg_script_synth *synth)
638 {
639     int vol;
640
641     if (!lex_fixed(p, "pink", 4))
642         return 0;
643     FORWARD_ERROR(parse_volume(p, &vol));
644     synth->type    = SBG_TYPE_NOISE;
645     synth->vol     = vol;
646     return 1;
647 }
648
649 static int parse_synth_channel_bell(struct sbg_parser *p,
650                                     struct sbg_script_synth *synth)
651 {
652     double carrierf;
653     int carrier, vol;
654
655     if (!lex_fixed(p, "bell", 4))
656         return 0;
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;
664     synth->vol     = vol;
665     return 1;
666 }
667
668 static int parse_synth_channel_mix(struct sbg_parser *p,
669                                    struct sbg_script_synth *synth)
670 {
671     int vol;
672
673     if (!lex_fixed(p, "mix", 3))
674         return 0;
675     FORWARD_ERROR(parse_volume(p, &vol));
676     synth->type    = SBG_TYPE_MIX;
677     synth->vol     = vol;
678     return 1;
679 }
680
681 static int parse_synth_channel_spin(struct sbg_parser *p,
682                                     struct sbg_script_synth *synth)
683 {
684     double carrierf, beatf;
685     int carrier, beat, vol;
686
687     if (!lex_fixed(p, "spin:", 5))
688         return 0;
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;
699     synth->beat    = beat;
700     synth->vol     = vol;
701     return 1;
702 }
703
704 static int parse_synth_channel(struct sbg_parser *p)
705 {
706     int r;
707     struct sbg_script_synth *synth;
708
709     synth = alloc_array_elem((void **)&p->scs.synth, sizeof(*synth),
710                              &p->scs.nb_synth, &p->nb_synth_max);
711     if (!synth)
712         return AVERROR(ENOMEM);
713     r = lex_char(p, '-');
714     if (!r)
715         r = parse_synth_channel_pink(p, synth);
716     if (!r)
717         r = parse_synth_channel_bell(p, synth);
718     if (!r)
719         r = parse_synth_channel_mix(p, synth);
720     if (!r)
721         r = parse_synth_channel_spin(p, synth);
722     /* Unimplemented: wave%d:%f%f/vol (carrier, beat) */
723     if (!r)
724         r = parse_synth_channel_sine(p, synth);
725     if (r <= 0)
726         p->scs.nb_synth--;
727     return r;
728 }
729
730 static int parse_synth_def(struct sbg_parser *p,
731                            struct sbg_script_definition *def)
732 {
733     int r, synth;
734
735     synth = p->scs.nb_synth;
736     while (1) {
737         r = parse_synth_channel(p);
738         if (r < 0)
739             return r;
740         if (!r || !lex_space(p))
741             break;
742     }
743     lex_space(p);
744     if (synth == p->scs.nb_synth)
745         return AVERROR_INVALIDDATA;
746     if (!lex_line_end(p))
747         return AVERROR_INVALIDDATA;
748     def->type        = 'S';
749     def->elements    = synth;
750     def->nb_elements = p->scs.nb_synth - synth;
751     return 1;
752 }
753
754 static int parse_named_def(struct sbg_parser *p)
755 {
756     char *cursor_save = p->cursor;
757     struct sbg_string name;
758     struct sbg_script_definition *def;
759
760     if (!lex_name(p, &name) || !lex_char(p, ':') || !lex_space(p)) {
761         p->cursor = cursor_save;
762         return 0;
763     }
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);
769     }
770     def = alloc_array_elem((void **)&p->scs.def, sizeof(*def),
771                            &p->scs.nb_def, &p->nb_def_max);
772     if (!def)
773         return AVERROR(ENOMEM);
774     def->name     = name.s;
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);
779 }
780
781 static void free_script(struct sbg_script *s)
782 {
783     av_freep(&s->def);
784     av_freep(&s->synth);
785     av_freep(&s->tseq);
786     av_freep(&s->block_tseq);
787     av_freep(&s->events);
788     av_freep(&s->opt_mix);
789 }
790
791 static int parse_script(void *log, char *script, int script_len,
792                             struct sbg_script *rscript)
793 {
794     struct sbg_parser sp = {
795         .log     = log,
796         .script  = script,
797         .end     = script + script_len,
798         .cursor  = script,
799         .line_no = 1,
800         .err_msg = "",
801         .scs = {
802             /* default values */
803             .start_ts      = AV_NOPTS_VALUE,
804             .sample_rate   = 44100,
805             .opt_fade_time = 60 * AV_TIME_BASE,
806         },
807     };
808     int r;
809
810     lex_space(&sp);
811     while (sp.cursor < sp.end) {
812         r = parse_options(&sp);
813         if (r < 0)
814             goto fail;
815         if (!r && !lex_line_end(&sp))
816             break;
817     }
818     while (sp.cursor < sp.end) {
819         r = parse_named_def(&sp);
820         if (!r)
821             r = parse_time_sequence(&sp, 0);
822         if (!r)
823             r = lex_line_end(&sp) ? 1 : AVERROR_INVALIDDATA;
824         if (r < 0)
825             goto fail;
826     }
827     *rscript = sp.scs;
828     return 1;
829 fail:
830     free_script(&sp.scs);
831     if (!*sp.err_msg)
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),
837                                         sp.end);
838         int lctx = ectx - ctx;
839         const char *quote = "\"";
840         if (lctx > 0 && ctx[lctx - 1] == '\r')
841             lctx--;
842         if (lctx == 0) {
843             ctx = "the end of line";
844             lctx = strlen(ctx);
845             quote = "";
846         }
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);
849     }
850     return r;
851 }
852
853 static int read_whole_file(AVIOContext *io, int max_size, char **rbuf)
854 {
855     char *buf = NULL;
856     int size = 0, bufsize = 0, r;
857
858     while (1) {
859         if (bufsize - size < 1024) {
860             bufsize = FFMIN(FFMAX(2 * bufsize, 8192), max_size);
861             if (bufsize - size < 2) {
862                 size = AVERROR(EFBIG);
863                 goto fail;
864             }
865             buf = av_realloc_f(buf, bufsize, 1);
866             if (!buf) {
867                 size = AVERROR(ENOMEM);
868                 goto fail;
869             }
870         }
871         r = avio_read(io, buf, bufsize - size - 1);
872         if (r == AVERROR_EOF)
873             break;
874         if (r < 0)
875             goto fail;
876         size += r;
877     }
878     buf[size] = 0;
879     *rbuf = buf;
880     return size;
881 fail:
882     av_free(buf);
883     return size;
884 }
885
886 static void expand_timestamps(void *log, struct sbg_script *s)
887 {
888     int i, nb_rel = 0;
889     int64_t now, cur_ts, delta = 0;
890
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 */
895         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;
904         now = s->start_ts;
905     } else {
906         /* Mixed relative/absolute ts: expand */
907         time_t now0;
908         struct tm *tm;
909
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");
913 #undef time
914         time(&now0);
915         tm = localtime(&now0);
916         now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :
917                    now0 % DAY;
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);
920         now *= AV_TIME_BASE;
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 */
925             }
926         }
927     }
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 */
932     cur_ts = now;
933     for (i = 0; i < s->nb_tseq; i++) {
934         if (s->tseq[i].ts.t + delta < cur_ts)
935             delta += DAY_TS;
936         cur_ts = s->tseq[i].ts.t += delta;
937     }
938 }
939
940 static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max,
941                        int64_t t0, struct sbg_script_tseq *tseq)
942 {
943     int i, r;
944     struct sbg_script_definition *def;
945     struct sbg_script_tseq *be;
946     struct sbg_script_event *ev;
947
948     if (tseq->lock++) {
949         av_log(log, AV_LOG_ERROR, "Recursion loop on \"%.*s\"\n",
950                tseq->name_len, tseq->name);
951         return AVERROR(EINVAL);
952     }
953     t0 += tseq->ts.t;
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))
957             break;
958     }
959     if (i >= s->nb_def) {
960         av_log(log, AV_LOG_ERROR, "Tone-set \"%.*s\" not defined\n",
961                tseq->name_len, tseq->name);
962         return AVERROR(EINVAL);
963     }
964     def = &s->def[i];
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]);
969             if (r < 0)
970                 return r;
971         }
972     } else {
973         ev = alloc_array_elem((void **)&s->events, sizeof(*ev),
974                               &s->nb_events, nb_ev_max);
975         ev->ts          = tseq->ts.t;
976         ev->elements    = def->elements;
977         ev->nb_elements = def->nb_elements;
978         ev->fade        = tseq->fade;
979     }
980     tseq->lock--;
981     return 0;
982 }
983
984 static int expand_script(void *log, struct sbg_script *s)
985 {
986     int i, r, nb_events_max = 0;
987
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]);
991         if (r < 0)
992             return r;
993     }
994     if (!s->nb_events) {
995         av_log(log, AV_LOG_ERROR, "No events in script\n");
996         return AVERROR_INVALIDDATA;
997     }
998     if (s->opt_end_at_last)
999         s->end_ts = s->events[s->nb_events - 1].ts;
1000     return 0;
1001 }
1002
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)
1007 {
1008     struct ws_interval *i, *ri;
1009
1010     if (ref >= 0) {
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 &&
1016             ri->ts2 == ts1) {
1017             ri->ts2 = ts2;
1018             return ref;
1019         }
1020     }
1021     i = alloc_array_elem((void **)&inter->inter, sizeof(*i),
1022                          &inter->nb_inter, &inter->max_inter);
1023     if (!i)
1024         return AVERROR(ENOMEM);
1025     i->ts1      = ts1;
1026     i->ts2      = ts2;
1027     i->type     = type;
1028     i->channels = channels;
1029     i->f1       = f1;
1030     i->f2       = f2;
1031     i->a1       = a1;
1032     i->a2       = a2;
1033     i->phi      = ref >= 0 ? ref | 0x80000000 : 0;
1034     return i - inter->inter;
1035 }
1036
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)
1039 {
1040     /* SBaGen uses an exponential decrease every 50ms.
1041        We approximate it with piecewise affine segments. */
1042     int32_t cpoints[][2] = {
1043         {  2, a },
1044         {  4, a - a / 4 },
1045         {  8, a / 2 },
1046         { 16, a / 4 },
1047         { 25, a / 10 },
1048         { 50, a / 80 },
1049         { 75, 0 },
1050     };
1051     int i, r;
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]);
1057         if (r < 0)
1058             return r;
1059         ts3 = ts4;
1060         a = cpoints[i][1];
1061     }
1062     return 0;
1063 }
1064
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,
1070                              int transition)
1071 {
1072     int r;
1073
1074     if (ts2 <= ts1 || (s1->vol == 0 && s2->vol == 0))
1075         return 0;
1076     switch (s1->type) {
1077         case SBG_TYPE_NONE:
1078             break;
1079         case SBG_TYPE_SINE:
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);
1084                 if (r < 0)
1085                     return r;
1086                 s2->ref.l = s2->ref.r = r;
1087             } else {
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);
1091                 if (r < 0)
1092                     return r;
1093                 s2->ref.l = r;
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);
1097                 if (r < 0)
1098                     return r;
1099                 s2->ref.r = r;
1100             }
1101             break;
1102
1103         case SBG_TYPE_BELL:
1104             if (transition == 2) {
1105                 r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);
1106                 if (r < 0)
1107                     return r;
1108             }
1109             break;
1110
1111         case SBG_TYPE_SPIN:
1112             av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "
1113                                         "using pink noise instead.\n");
1114             /* fall through */
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
1125              */
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);
1129             if (r < 0)
1130                 return r;
1131             s2->ref.l = s2->ref.r = r;
1132             break;
1133
1134         case SBG_TYPE_MIX:
1135             /* Unimplemented: silence; warning present elsewhere */
1136         default:
1137             av_log(log, AV_LOG_ERROR,
1138                    "Type %d is not implemented\n", s1->type);
1139             return AVERROR_PATCHWELCOME;
1140     }
1141     return 0;
1142 }
1143
1144 static int generate_plateau(void *log, struct sbg_script *s,
1145                             struct ws_intervals *inter,
1146                             struct sbg_script_event *ev1)
1147 {
1148     int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;
1149     int i, r;
1150     struct sbg_script_synth *s1;
1151
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);
1155         if (r < 0)
1156             return r;
1157     }
1158     return 0;
1159 }
1160
1161 /*
1162
1163    ts1             ts2         ts1    tsmid    ts2
1164     |               |           |       |       |
1165     v               v           v       |       v
1166 ____                        ____        v       ____
1167     ''''....                    ''..        ..''
1168             ''''....____            ''....''
1169
1170   compatible transition      incompatible transition
1171  */
1172
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)
1177 {
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;
1184     int pass, i, r;
1185
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.
1193          */
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) {
1203                     s1mod = s2mod;
1204                     s1mod.vol = 0;
1205                 } else if (s2mod.type == SBG_TYPE_NONE) {
1206                     s2mod = s1mod;
1207                     s2mod.vol = 0;
1208                 }
1209             }
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 */
1216                 if (!pass) {
1217                     r = generate_interval(log, s, inter,
1218                                           ts1, ts2, &s1mod, &s2mod, 3);
1219                     if (r < 0)
1220                         return r;
1221                     s2->ref = s2mod.ref;
1222                 }
1223             } else {
1224                 /* incompatible: silence at midpoint */
1225                 if (!pass) {
1226                     smid = s1mod;
1227                     smid.vol = 0;
1228                     r = generate_interval(log, s, inter,
1229                                           ts1, tsmid, &s1mod, &smid, 1);
1230                     if (r < 0)
1231                         return r;
1232                 } else {
1233                     smid = s2mod;
1234                     smid.vol = 0;
1235                     r = generate_interval(log, s, inter,
1236                                           tsmid, ts2, &smid, &s2mod, 2);
1237                     if (r < 0)
1238                         return r;
1239                     s2->ref = s2mod.ref;
1240                 }
1241             }
1242         }
1243     }
1244     return 0;
1245 }
1246
1247 /*
1248     ev1                  trats ev2  intts           endts ev3
1249      |                     |    |     |               |    |
1250      v                     v    v     v               v    v
1251                                       ________________
1252 ....                              ....                ....
1253     '''....________________....'''                        '''...._______________
1254
1255 \_________/\______________/\_________/\______________/\_________/\_____________/
1256   tr x->1        int1        tr 1->2        int2        tr 2->3        int3
1257  */
1258
1259 static int generate_intervals(void *log, struct sbg_script *s, int sample_rate,
1260                               struct ws_intervals *inter)
1261 {
1262     int64_t trans_time = s->opt_fade_time / 2;
1263     struct sbg_script_event ev0, *ev1, *ev2;
1264     int64_t period;
1265     int i, r;
1266
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);
1273
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);
1281     }
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);
1288         }
1289         ev1->ts_next  = ev2->ts_int + (ev1 < ev2 ? 0 : period);
1290     }
1291
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;
1297
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);
1304     }
1305
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);
1313         if (r < 0)
1314             return r;
1315         r = generate_transition(log, s, inter, ev1, ev2);
1316         if (r < 0)
1317             return r;
1318     }
1319     if (!inter->nb_inter)
1320         av_log(log, AV_LOG_WARNING, "Completely silent script.\n");
1321     return 0;
1322 }
1323
1324 static int encode_intervals(struct sbg_script *s, AVCodecContext *avc,
1325                             struct ws_intervals *inter)
1326 {
1327     int i, edata_size = 4;
1328     uint8_t *edata;
1329
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;
1333         if (edata_size < 0)
1334             return AVERROR(ENOMEM);
1335     }
1336     if (ff_alloc_extradata(avc, edata_size))
1337         return AVERROR(ENOMEM);
1338     edata = avc->extradata;
1339
1340 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
1341 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
1342     ADD_EDATA32(inter->nb_inter);
1343     for (i = 0; i < inter->nb_inter; i++) {
1344         ADD_EDATA64(inter->inter[i].ts1);
1345         ADD_EDATA64(inter->inter[i].ts2);
1346         ADD_EDATA32(inter->inter[i].type);
1347         ADD_EDATA32(inter->inter[i].channels);
1348         switch (inter->inter[i].type) {
1349             case WS_SINE:
1350                 ADD_EDATA32(inter->inter[i].f1);
1351                 ADD_EDATA32(inter->inter[i].f2);
1352                 ADD_EDATA32(inter->inter[i].a1);
1353                 ADD_EDATA32(inter->inter[i].a2);
1354                 ADD_EDATA32(inter->inter[i].phi);
1355                 break;
1356             case WS_NOISE:
1357                 ADD_EDATA32(inter->inter[i].a1);
1358                 ADD_EDATA32(inter->inter[i].a2);
1359                 break;
1360         }
1361     }
1362     if (edata != avc->extradata + edata_size)
1363         return AVERROR_BUG;
1364     return 0;
1365 }
1366
1367 static av_cold int sbg_read_probe(AVProbeData *p)
1368 {
1369     int r, score;
1370     struct sbg_script script = { 0 };
1371
1372     r = parse_script(NULL, p->buf, p->buf_size, &script);
1373     score = r < 0 || !script.nb_def || !script.nb_tseq ? 0 :
1374             AVPROBE_SCORE_MAX / 3;
1375     free_script(&script);
1376     return score;
1377 }
1378
1379 static av_cold int sbg_read_header(AVFormatContext *avf)
1380 {
1381     struct sbg_demuxer *sbg = avf->priv_data;
1382     int r;
1383     char *buf = NULL;
1384     struct sbg_script script = { 0 };
1385     AVStream *st;
1386     struct ws_intervals inter = { 0 };
1387
1388     r = read_whole_file(avf->pb, sbg->max_file_size, &buf);
1389     if (r < 0)
1390         goto fail;
1391     r = parse_script(avf, buf, r, &script);
1392     if (r < 0)
1393         goto fail;
1394     if (!sbg->sample_rate)
1395         sbg->sample_rate = script.sample_rate;
1396     else
1397         script.sample_rate = sbg->sample_rate;
1398     if (!sbg->frame_size)
1399         sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);
1400     if (script.opt_mix)
1401         av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "
1402                "-m is ignored and mix channels will be silent.\n");
1403     r = expand_script(avf, &script);
1404     if (r < 0)
1405         goto fail;
1406     av_freep(&buf);
1407     r = generate_intervals(avf, &script, sbg->sample_rate, &inter);
1408     if (r < 0)
1409         goto fail;
1410
1411     st = avformat_new_stream(avf, NULL);
1412     if (!st)
1413         return AVERROR(ENOMEM);
1414     st->codec->codec_type     = AVMEDIA_TYPE_AUDIO;
1415     st->codec->codec_id       = AV_CODEC_ID_FFWAVESYNTH;
1416     st->codec->channels       = 2;
1417     st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
1418     st->codec->sample_rate    = sbg->sample_rate;
1419     st->codec->frame_size     = sbg->frame_size;
1420     avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
1421     st->probe_packets = 0;
1422     st->start_time    = av_rescale(script.start_ts,
1423                                    sbg->sample_rate, AV_TIME_BASE);
1424     st->duration      = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
1425                         av_rescale(script.end_ts - script.start_ts,
1426                                    sbg->sample_rate, AV_TIME_BASE);
1427     st->cur_dts       = st->start_time;
1428     r = encode_intervals(&script, st->codec, &inter);
1429     if (r < 0)
1430         goto fail;
1431
1432     av_free(inter.inter);
1433     free_script(&script);
1434     return 0;
1435
1436 fail:
1437     av_free(inter.inter);
1438     free_script(&script);
1439     av_free(buf);
1440     return r;
1441 }
1442
1443 static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
1444 {
1445     int64_t ts, end_ts;
1446
1447     ts = avf->streams[0]->cur_dts;
1448     end_ts = ts + avf->streams[0]->codec->frame_size;
1449     if (avf->streams[0]->duration != AV_NOPTS_VALUE)
1450         end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,
1451                        end_ts);
1452     if (end_ts <= ts)
1453         return AVERROR_EOF;
1454     if (av_new_packet(packet, 12) < 0)
1455         return AVERROR(ENOMEM);
1456     packet->dts = packet->pts = ts;
1457     packet->duration = end_ts - ts;
1458     AV_WL64(packet->data + 0, ts);
1459     AV_WL32(packet->data + 8, packet->duration);
1460     return packet->size;
1461 }
1462
1463 static int sbg_read_seek2(AVFormatContext *avf, int stream_index,
1464                           int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1465 {
1466     if (flags || stream_index > 0)
1467         return AVERROR(EINVAL);
1468     if (stream_index < 0)
1469         ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);
1470     avf->streams[0]->cur_dts = ts;
1471     return 0;
1472 }
1473
1474 static int sbg_read_seek(AVFormatContext *avf, int stream_index,
1475                          int64_t ts, int flags)
1476 {
1477     return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);
1478 }
1479
1480 static const AVOption sbg_options[] = {
1481     { "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),
1482       AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1483       AV_OPT_FLAG_DECODING_PARAM },
1484     { "frame_size", "", offsetof(struct sbg_demuxer, frame_size),
1485       AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1486       AV_OPT_FLAG_DECODING_PARAM },
1487     { "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),
1488       AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,
1489       AV_OPT_FLAG_DECODING_PARAM },
1490     { NULL },
1491 };
1492
1493 static const AVClass sbg_demuxer_class = {
1494     .class_name = "sbg_demuxer",
1495     .item_name  = av_default_item_name,
1496     .option     = sbg_options,
1497     .version    = LIBAVUTIL_VERSION_INT,
1498 };
1499
1500 AVInputFormat ff_sbg_demuxer = {
1501     .name           = "sbg",
1502     .long_name      = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),
1503     .priv_data_size = sizeof(struct sbg_demuxer),
1504     .read_probe     = sbg_read_probe,
1505     .read_header    = sbg_read_header,
1506     .read_packet    = sbg_read_packet,
1507     .read_seek      = sbg_read_seek,
1508     .read_seek2     = sbg_read_seek2,
1509     .extensions     = "sbg",
1510     .priv_class     = &sbg_demuxer_class,
1511 };