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