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