LCOV - code coverage report
Current view: top level - libavformat - sbgdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 243 851 28.6 %
Date: 2017-12-17 23:02:56 Functions: 27 48 56.2 %

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

Generated by: LCOV version 1.13