FFmpeg  4.3.9
sbgdec.c
Go to the documentation of this file.
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"
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;
41 };
42 
43 struct sbg_string {
44  char *s;
45  char *e;
46 };
47 
52 };
53 
54 struct sbg_fade {
55  int8_t in, out, slide;
56 };
57 
65 };
66 
67 /* bell: freq constant, ampl decreases exponentially, can be approx lin */
68 
69 struct sbg_timestamp {
71  char type; /* 0 for relative, 'N' for now, 'T' for absolute */
72 };
73 
75  char *name;
76  int name_len;
78  char type; /* 'S' or 'B' */
79 };
80 
82  int carrier;
83  int beat;
84  int vol;
86  struct {
87  int l, r;
88  } ref;
89 };
90 
92  struct sbg_timestamp ts;
93  char *name;
94  int name_len;
95  int lock;
96  struct sbg_fade fade;
97 };
98 
101  int64_t ts_int, ts_trans, ts_next;
103  struct sbg_fade fade;
104 };
105 
106 struct sbg_script {
112  int nb_def;
113  int nb_tseq;
115  int nb_synth;
120  char *opt_mix;
124 };
125 
126 struct sbg_parser {
127  void *log;
128  char *script, *end;
129  char *cursor;
130  struct sbg_script scs;
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 
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;
149  uint32_t phi;
150 };
151 
152 struct ws_intervals {
154  int nb_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 || p->scs.opt_duration < 0) {
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  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 
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 
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 
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 
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 int 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  if (s->start_ts > INT64_MAX - s->opt_duration)
937  return AVERROR_INVALIDDATA;
938 
939  s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
940  AV_NOPTS_VALUE; /* may be overridden later by -E option */
941  cur_ts = now;
942  for (i = 0; i < s->nb_tseq; i++) {
943  if (av_sat_add64(s->tseq[i].ts.t, delta) != s->tseq[i].ts.t + (uint64_t)delta)
944  return AVERROR_INVALIDDATA;
945  if (s->tseq[i].ts.t + delta < cur_ts)
946  delta += DAY_TS;
947  cur_ts = s->tseq[i].ts.t += delta;
948  }
949  return 0;
950 }
951 
952 static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max,
953  int64_t t0, struct sbg_script_tseq *tseq)
954 {
955  int i, r;
956  struct sbg_script_definition *def;
957  struct sbg_script_tseq *be;
958  struct sbg_script_event *ev;
959 
960  if (tseq->lock++) {
961  av_log(log, AV_LOG_ERROR, "Recursion loop on \"%.*s\"\n",
962  tseq->name_len, tseq->name);
963  return AVERROR(EINVAL);
964  }
965  if (t0 + (uint64_t)tseq->ts.t != av_sat_add64(t0, tseq->ts.t))
966  return AVERROR(EINVAL);
967 
968  t0 += tseq->ts.t;
969  for (i = 0; i < s->nb_def; i++) {
970  if (s->def[i].name_len == tseq->name_len &&
971  !memcmp(s->def[i].name, tseq->name, tseq->name_len))
972  break;
973  }
974  if (i >= s->nb_def) {
975  av_log(log, AV_LOG_ERROR, "Tone-set \"%.*s\" not defined\n",
976  tseq->name_len, tseq->name);
977  return AVERROR(EINVAL);
978  }
979  def = &s->def[i];
980  if (def->type == 'B') {
981  be = s->block_tseq + def->elements;
982  for (i = 0; i < def->nb_elements; i++) {
983  r = expand_tseq(log, s, nb_ev_max, t0, &be[i]);
984  if (r < 0)
985  return r;
986  }
987  } else {
988  ev = alloc_array_elem((void **)&s->events, sizeof(*ev),
989  &s->nb_events, nb_ev_max);
990  if (!ev)
991  return AVERROR(ENOMEM);
992  ev->ts = tseq->ts.t;
993  ev->elements = def->elements;
994  ev->nb_elements = def->nb_elements;
995  ev->fade = tseq->fade;
996  }
997  tseq->lock--;
998  return 0;
999 }
1000 
1001 static int expand_script(void *log, struct sbg_script *s)
1002 {
1003  int i, r, nb_events_max = 0;
1004 
1005  r = expand_timestamps(log, s);
1006  if (r < 0)
1007  return r;
1008  for (i = 0; i < s->nb_tseq; i++) {
1009  r = expand_tseq(log, s, &nb_events_max, 0, &s->tseq[i]);
1010  if (r < 0)
1011  return r;
1012  }
1013  if (!s->nb_events) {
1014  av_log(log, AV_LOG_ERROR, "No events in script\n");
1015  return AVERROR_INVALIDDATA;
1016  }
1017  if (s->opt_end_at_last)
1018  s->end_ts = s->events[s->nb_events - 1].ts;
1019  return 0;
1020 }
1021 
1022 static int add_interval(struct ws_intervals *inter,
1023  enum ws_interval_type type, uint32_t channels, int ref,
1024  int64_t ts1, int32_t f1, int32_t a1,
1025  int64_t ts2, int32_t f2, int32_t a2)
1026 {
1027  struct ws_interval *i, *ri;
1028 
1029  if (ref >= 0) {
1030  ri = &inter->inter[ref];
1031  /* ref and new intervals are constant, identical and adjacent */
1032  if (ri->type == type && ri->channels == channels &&
1033  ri->f1 == ri->f2 && ri->f2 == f1 && f1 == f2 &&
1034  ri->a1 == ri->a2 && ri->a2 == a1 && a1 == a2 &&
1035  ri->ts2 == ts1) {
1036  ri->ts2 = ts2;
1037  return ref;
1038  }
1039  }
1040  i = alloc_array_elem((void **)&inter->inter, sizeof(*i),
1041  &inter->nb_inter, &inter->max_inter);
1042  if (!i)
1043  return AVERROR(ENOMEM);
1044  i->ts1 = ts1;
1045  i->ts2 = ts2;
1046  i->type = type;
1047  i->channels = channels;
1048  i->f1 = f1;
1049  i->f2 = f2;
1050  i->a1 = a1;
1051  i->a2 = a2;
1052  i->phi = ref >= 0 ? ref | 0x80000000 : 0;
1053  return i - inter->inter;
1054 }
1055 
1056 static int add_bell(struct ws_intervals *inter, struct sbg_script *s,
1058 {
1059  /* SBaGen uses an exponential decrease every 50ms.
1060  We approximate it with piecewise affine segments. */
1061  int32_t cpoints[][2] = {
1062  { 2, a },
1063  { 4, a - a / 4 },
1064  { 8, a / 2 },
1065  { 16, a / 4 },
1066  { 25, a / 10 },
1067  { 50, a / 80 },
1068  { 75, 0 },
1069  };
1070  int i, r;
1071  int64_t dt = s->sample_rate / 20, ts3 = ts1, ts4;
1072  for (i = 0; i < FF_ARRAY_ELEMS(cpoints); i++) {
1073  ts4 = FFMIN(ts2, ts1 + cpoints[i][0] * dt);
1074  r = add_interval(inter, WS_SINE, 3, -1,
1075  ts3, f, a, ts4, f, cpoints[i][1]);
1076  if (r < 0)
1077  return r;
1078  ts3 = ts4;
1079  a = cpoints[i][1];
1080  }
1081  return 0;
1082 }
1083 
1084 static int generate_interval(void *log, struct sbg_script *s,
1085  struct ws_intervals *inter,
1087  struct sbg_script_synth *s1,
1088  struct sbg_script_synth *s2,
1089  int transition)
1090 {
1091  int r;
1092 
1093  if (ts2 <= ts1 || (s1->vol == 0 && s2->vol == 0))
1094  return 0;
1095  switch (s1->type) {
1096  case SBG_TYPE_NONE:
1097  break;
1098  case SBG_TYPE_SINE:
1099  if (s1->beat == 0 && s2->beat == 0) {
1100  r = add_interval(inter, WS_SINE, 3, s1->ref.l,
1101  ts1, s1->carrier, s1->vol,
1102  ts2, s2->carrier, s2->vol);
1103  if (r < 0)
1104  return r;
1105  s2->ref.l = s2->ref.r = r;
1106  } else {
1107  r = add_interval(inter, WS_SINE, 1, s1->ref.l,
1108  ts1, s1->carrier + s1->beat / 2, s1->vol,
1109  ts2, s2->carrier + s2->beat / 2, s2->vol);
1110  if (r < 0)
1111  return r;
1112  s2->ref.l = r;
1113  r = add_interval(inter, WS_SINE, 2, s1->ref.r,
1114  ts1, s1->carrier - s1->beat / 2, s1->vol,
1115  ts2, s2->carrier - s2->beat / 2, s2->vol);
1116  if (r < 0)
1117  return r;
1118  s2->ref.r = r;
1119  }
1120  break;
1121 
1122  case SBG_TYPE_BELL:
1123  if (transition == 2) {
1124  r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);
1125  if (r < 0)
1126  return r;
1127  }
1128  break;
1129 
1130  case SBG_TYPE_SPIN:
1131  av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "
1132  "using pink noise instead.\n");
1133  /* fall through */
1134  case SBG_TYPE_NOISE:
1135  /* SBaGen's pink noise generator uses:
1136  - 1 band of white noise, mean square: 1/3;
1137  - 9 bands of subsampled white noise with linear
1138  interpolation, mean square: 2/3 each;
1139  with 1/10 weight each: the total mean square is 7/300.
1140  Our pink noise generator uses 8 bands of white noise with
1141  rectangular subsampling: the total mean square is 1/24.
1142  Therefore, to match SBaGen's volume, we must multiply vol by
1143  sqrt((7/300) / (1/24)) = sqrt(14/25) =~ 0.748
1144  */
1145  r = add_interval(inter, WS_NOISE, 3, s1->ref.l,
1146  ts1, 0, s1->vol - s1->vol / 4,
1147  ts2, 0, s2->vol - s2->vol / 4);
1148  if (r < 0)
1149  return r;
1150  s2->ref.l = s2->ref.r = r;
1151  break;
1152 
1153  case SBG_TYPE_MIX:
1154  /* Unimplemented: silence; warning present elsewhere */
1155  default:
1156  av_log(log, AV_LOG_ERROR,
1157  "Type %d is not implemented\n", s1->type);
1158  return AVERROR_PATCHWELCOME;
1159  }
1160  return 0;
1161 }
1162 
1163 static int generate_plateau(void *log, struct sbg_script *s,
1164  struct ws_intervals *inter,
1165  struct sbg_script_event *ev1)
1166 {
1167  int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;
1168  int i, r;
1169  struct sbg_script_synth *s1;
1170 
1171  for (i = 0; i < ev1->nb_elements; i++) {
1172  s1 = &s->synth[ev1->elements + i];
1173  r = generate_interval(log, s, inter, ts1, ts2, s1, s1, 0);
1174  if (r < 0)
1175  return r;
1176  }
1177  return 0;
1178 }
1179 
1180 /*
1181 
1182  ts1 ts2 ts1 tsmid ts2
1183  | | | | |
1184  v v v | v
1185 ____ ____ v ____
1186  ''''.... ''.. ..''
1187  ''''....____ ''....''
1188 
1189  compatible transition incompatible transition
1190  */
1191 
1192 static int generate_transition(void *log, struct sbg_script *s,
1193  struct ws_intervals *inter,
1194  struct sbg_script_event *ev1,
1195  struct sbg_script_event *ev2)
1196 {
1197  int64_t ts1 = ev1->ts_trans, ts2 = ev1->ts_next;
1198  /* (ts1 + ts2) / 2 without overflow */
1199  int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);
1200  enum sbg_fade_type type = ev1->fade.slide | (ev1->fade.out & ev2->fade.in);
1201  int nb_elements = FFMAX(ev1->nb_elements, ev2->nb_elements);
1202  struct sbg_script_synth *s1, *s2, s1mod, s2mod, smid;
1203  int pass, i, r;
1204 
1205  for (pass = 0; pass < 2; pass++) {
1206  /* pass = 0 -> compatible and first half of incompatible
1207  pass = 1 -> second half of incompatible
1208  Using two passes like that ensures that the intervals are generated
1209  in increasing order according to their start timestamp.
1210  Otherwise it would be necessary to sort them
1211  while keeping the mutual references.
1212  */
1213  for (i = 0; i < nb_elements; i++) {
1214  s1 = i < ev1->nb_elements ? &s->synth[ev1->elements + i] : &s1mod;
1215  s2 = i < ev2->nb_elements ? &s->synth[ev2->elements + i] : &s2mod;
1216  s1mod = s1 != &s1mod ? *s1 : (struct sbg_script_synth){ 0 };
1217  s2mod = s2 != &s2mod ? *s2 : (struct sbg_script_synth){ 0 };
1218  if (ev1->fade.slide) {
1219  /* for slides, and only for slides, silence ("-") is equivalent
1220  to anything with volume 0 */
1221  if (s1mod.type == SBG_TYPE_NONE) {
1222  s1mod = s2mod;
1223  s1mod.vol = 0;
1224  } else if (s2mod.type == SBG_TYPE_NONE) {
1225  s2mod = s1mod;
1226  s2mod.vol = 0;
1227  }
1228  }
1229  if (s1mod.type == s2mod.type &&
1230  s1mod.type != SBG_TYPE_BELL &&
1231  (type == SBG_FADE_ADAPT ||
1232  (s1mod.carrier == s2mod.carrier &&
1233  s1mod.beat == s2mod.beat))) {
1234  /* compatible: single transition */
1235  if (!pass) {
1236  r = generate_interval(log, s, inter,
1237  ts1, ts2, &s1mod, &s2mod, 3);
1238  if (r < 0)
1239  return r;
1240  s2->ref = s2mod.ref;
1241  }
1242  } else {
1243  /* incompatible: silence at midpoint */
1244  if (!pass) {
1245  smid = s1mod;
1246  smid.vol = 0;
1247  r = generate_interval(log, s, inter,
1248  ts1, tsmid, &s1mod, &smid, 1);
1249  if (r < 0)
1250  return r;
1251  } else {
1252  smid = s2mod;
1253  smid.vol = 0;
1254  r = generate_interval(log, s, inter,
1255  tsmid, ts2, &smid, &s2mod, 2);
1256  if (r < 0)
1257  return r;
1258  s2->ref = s2mod.ref;
1259  }
1260  }
1261  }
1262  }
1263  return 0;
1264 }
1265 
1266 /*
1267  ev1 trats ev2 intts endts ev3
1268  | | | | | |
1269  v v v v v v
1270  ________________
1271 .... .... ....
1272  '''....________________....''' '''...._______________
1273 
1274 \_________/\______________/\_________/\______________/\_________/\_____________/
1275  tr x->1 int1 tr 1->2 int2 tr 2->3 int3
1276  */
1277 
1278 static int generate_intervals(void *log, struct sbg_script *s, int sample_rate,
1279  struct ws_intervals *inter)
1280 {
1281  int64_t trans_time = s->opt_fade_time / 2;
1282  struct sbg_script_event ev0, *ev1, *ev2;
1283  int64_t period;
1284  int i, r;
1285 
1286  /* SBaGen handles the time before and after the extremal events,
1287  and the corresponding transitions, as if the sequence were cyclic
1288  with a 24-hours period. */
1289  period = s->events[s->nb_events - 1].ts - (uint64_t)s->events[0].ts;
1290  if (period < 0)
1291  return AVERROR_INVALIDDATA;
1292 
1293  period = (period + (DAY_TS - 1)) / DAY_TS * DAY_TS;
1294  period = FFMAX(period, DAY_TS);
1295 
1296  /* Prepare timestamps for transitions */
1297  for (i = 0; i < s->nb_events; i++) {
1298  ev1 = &s->events[i];
1299  ev2 = &s->events[(i + 1) % s->nb_events];
1300  ev1->ts_int = ev1->ts;
1301 
1302  if (!ev1->fade.slide && ev1 >= ev2 && ev2->ts > INT64_MAX - period)
1303  return AVERROR_INVALIDDATA;
1304 
1305  ev1->ts_trans = ev1->fade.slide ? ev1->ts
1306  : ev2->ts + (ev1 < ev2 ? 0 : period);
1307  }
1308  for (i = 0; i < s->nb_events; i++) {
1309  ev1 = &s->events[i];
1310  ev2 = &s->events[(i + 1) % s->nb_events];
1311  if (!ev1->fade.slide) {
1312  ev1->ts_trans = FFMAX(ev1->ts_int, ev1->ts_trans - trans_time);
1313  ev2->ts_int = FFMIN(ev2->ts_trans, ev2->ts_int + trans_time);
1314  }
1315  ev1->ts_next = ev2->ts_int + (ev1 < ev2 ? 0 : period);
1316  }
1317 
1318  /* Pseudo event before the first one */
1319  ev0 = s->events[s->nb_events - 1];
1320  if (av_sat_sub64(ev0.ts_int, period) != (uint64_t)ev0.ts_int - period)
1321  return AVERROR_INVALIDDATA;
1322  ev0.ts_int -= period;
1323  ev0.ts_trans -= period;
1324  ev0.ts_next -= period;
1325 
1326  /* Convert timestamps */
1327  for (i = -1; i < s->nb_events; i++) {
1328  ev1 = i < 0 ? &ev0 : &s->events[i];
1329  ev1->ts_int = av_rescale(ev1->ts_int, sample_rate, AV_TIME_BASE);
1330  ev1->ts_trans = av_rescale(ev1->ts_trans, sample_rate, AV_TIME_BASE);
1331  ev1->ts_next = av_rescale(ev1->ts_next, sample_rate, AV_TIME_BASE);
1332  }
1333 
1334  /* Generate intervals */
1335  for (i = 0; i < s->nb_synth; i++)
1336  s->synth[i].ref.l = s->synth[i].ref.r = -1;
1337  for (i = -1; i < s->nb_events; i++) {
1338  ev1 = i < 0 ? &ev0 : &s->events[i];
1339  ev2 = &s->events[(i + 1) % s->nb_events];
1340  r = generate_plateau(log, s, inter, ev1);
1341  if (r < 0)
1342  return r;
1343  r = generate_transition(log, s, inter, ev1, ev2);
1344  if (r < 0)
1345  return r;
1346  }
1347  if (!inter->nb_inter)
1348  av_log(log, AV_LOG_WARNING, "Completely silent script.\n");
1349  return 0;
1350 }
1351 
1353  struct ws_intervals *inter)
1354 {
1355  int i, edata_size = 4, ret;
1356  uint8_t *edata;
1357 
1358  for (i = 0; i < inter->nb_inter; i++) {
1359  edata_size += inter->inter[i].type == WS_SINE ? 44 :
1360  inter->inter[i].type == WS_NOISE ? 32 : 0;
1361  if (edata_size < 0)
1362  return AVERROR(ENOMEM);
1363  }
1364  if ((ret = ff_alloc_extradata(par, edata_size)) < 0)
1365  return ret;
1366  edata = par->extradata;
1367 
1368 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)
1369 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)
1370  ADD_EDATA32(inter->nb_inter);
1371  for (i = 0; i < inter->nb_inter; i++) {
1372  ADD_EDATA64(inter->inter[i].ts1);
1373  ADD_EDATA64(inter->inter[i].ts2);
1374  ADD_EDATA32(inter->inter[i].type);
1375  ADD_EDATA32(inter->inter[i].channels);
1376  switch (inter->inter[i].type) {
1377  case WS_SINE:
1378  ADD_EDATA32(inter->inter[i].f1);
1379  ADD_EDATA32(inter->inter[i].f2);
1380  ADD_EDATA32(inter->inter[i].a1);
1381  ADD_EDATA32(inter->inter[i].a2);
1382  ADD_EDATA32(inter->inter[i].phi);
1383  break;
1384  case WS_NOISE:
1385  ADD_EDATA32(inter->inter[i].a1);
1386  ADD_EDATA32(inter->inter[i].a2);
1387  break;
1388  }
1389  }
1390  if (edata != par->extradata + edata_size)
1391  return AVERROR_BUG;
1392  return 0;
1393 }
1394 
1395 static av_cold int sbg_read_probe(const AVProbeData *p)
1396 {
1397  int r, score;
1398  struct sbg_script script = { 0 };
1399 
1400  r = parse_script(NULL, p->buf, p->buf_size, &script);
1401  score = r < 0 || !script.nb_def || !script.nb_tseq ? 0 :
1402  AVPROBE_SCORE_MAX / 3;
1403  free_script(&script);
1404  return score;
1405 }
1406 
1408 {
1409  struct sbg_demuxer *sbg = avf->priv_data;
1410  int r;
1411  char *buf = NULL;
1412  struct sbg_script script = { 0 };
1413  AVStream *st;
1414  struct ws_intervals inter = { 0 };
1415 
1416  r = read_whole_file(avf->pb, sbg->max_file_size, &buf);
1417  if (r < 0)
1418  goto fail;
1419  r = parse_script(avf, buf, r, &script);
1420  if (r < 0)
1421  goto fail;
1422  if (!sbg->sample_rate)
1423  sbg->sample_rate = script.sample_rate;
1424  else
1425  script.sample_rate = sbg->sample_rate;
1426  if (!sbg->frame_size)
1427  sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);
1428  if (script.opt_mix)
1429  av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "
1430  "-m is ignored and mix channels will be silent.\n");
1431  r = expand_script(avf, &script);
1432  if (r < 0)
1433  goto fail;
1434  av_freep(&buf);
1435  r = generate_intervals(avf, &script, sbg->sample_rate, &inter);
1436  if (r < 0)
1437  goto fail;
1438 
1439  if (script.end_ts != AV_NOPTS_VALUE && script.end_ts < script.start_ts) {
1440  r = AVERROR_INVALIDDATA;
1441  goto fail;
1442  }
1443 
1444  st = avformat_new_stream(avf, NULL);
1445  if (!st)
1446  return AVERROR(ENOMEM);
1449  st->codecpar->channels = 2;
1451  st->codecpar->sample_rate = sbg->sample_rate;
1452  st->codecpar->frame_size = sbg->frame_size;
1453  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
1454  st->probe_packets = 0;
1455  st->start_time = av_rescale(script.start_ts,
1456  sbg->sample_rate, AV_TIME_BASE);
1457  st->duration = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
1458  av_rescale(script.end_ts - script.start_ts,
1459  sbg->sample_rate, AV_TIME_BASE);
1460  st->cur_dts = st->start_time;
1461  r = encode_intervals(&script, st->codecpar, &inter);
1462  if (r < 0)
1463  goto fail;
1464 
1465  av_free(inter.inter);
1466  free_script(&script);
1467  return 0;
1468 
1469 fail:
1470  av_free(inter.inter);
1471  free_script(&script);
1472  av_free(buf);
1473  return r;
1474 }
1475 
1476 static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
1477 {
1478  int64_t ts, end_ts;
1479  int ret;
1480 
1481  ts = avf->streams[0]->cur_dts;
1482  end_ts = ts + avf->streams[0]->codecpar->frame_size;
1483  if (avf->streams[0]->duration != AV_NOPTS_VALUE)
1484  end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,
1485  end_ts);
1486  if (end_ts <= ts)
1487  return AVERROR_EOF;
1488  if ((ret = av_new_packet(packet, 12)) < 0)
1489  return ret;
1490  packet->dts = packet->pts = ts;
1491  packet->duration = end_ts - ts;
1492  AV_WL64(packet->data + 0, ts);
1493  AV_WL32(packet->data + 8, packet->duration);
1494  return packet->size;
1495 }
1496 
1497 static int sbg_read_seek2(AVFormatContext *avf, int stream_index,
1498  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1499 {
1500  if (flags || stream_index > 0)
1501  return AVERROR(EINVAL);
1502  if (stream_index < 0)
1503  ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);
1504  avf->streams[0]->cur_dts = ts;
1505  return 0;
1506 }
1507 
1508 static int sbg_read_seek(AVFormatContext *avf, int stream_index,
1509  int64_t ts, int flags)
1510 {
1511  return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);
1512 }
1513 
1514 static const AVOption sbg_options[] = {
1515  { "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),
1516  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1518  { "frame_size", "", offsetof(struct sbg_demuxer, frame_size),
1519  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
1520  AV_OPT_FLAG_DECODING_PARAM },
1521  { "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),
1522  AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,
1523  AV_OPT_FLAG_DECODING_PARAM },
1524  { NULL },
1525 };
1526 
1527 static const AVClass sbg_demuxer_class = {
1528  .class_name = "sbg_demuxer",
1529  .item_name = av_default_item_name,
1530  .option = sbg_options,
1531  .version = LIBAVUTIL_VERSION_INT,
1532 };
1533 
1535  .name = "sbg",
1536  .long_name = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),
1537  .priv_data_size = sizeof(struct sbg_demuxer),
1538  .read_probe = sbg_read_probe,
1539  .read_header = sbg_read_header,
1540  .read_packet = sbg_read_packet,
1541  .read_seek = sbg_read_seek,
1542  .read_seek2 = sbg_read_seek2,
1543  .extensions = "sbg",
1544  .priv_class = &sbg_demuxer_class,
1545 };
int64_t ts_trans
Definition: sbgdec.c:101
char * cursor
Definition: sbgdec.c:129
#define NULL
Definition: coverity.c:32
char * opt_mix
Definition: sbgdec.c:120
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int sample_rate
Definition: sbgdec.c:121
static int parse_synth_channel_bell(struct sbg_parser *p, struct sbg_script_synth *synth)
Definition: sbgdec.c:655
static av_cold int sbg_read_header(AVFormatContext *avf)
Definition: sbgdec.c:1407
int size
#define av_realloc_f(p, o, n)
AVOption.
Definition: opt.h:246
static int generate_transition(void *log, struct sbg_script *s, struct ws_intervals *inter, struct sbg_script_event *ev1, struct sbg_script_event *ev2)
Definition: sbgdec.c:1192
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int64_t end_ts
Definition: sbgdec.c:117
struct sbg_script_event * events
Definition: sbgdec.c:111
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4948
uint32_t channels
Definition: ffwavesynth.c:87
uint8_t opt_start_at_first
Definition: sbgdec.c:122
int probe_packets
Number of packets to buffer for codec probing.
Definition: avformat.h:1086
static int parse_immediate(struct sbg_parser *p)
Definition: sbgdec.c:324
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
ws_interval_type
Definition: ffwavesynth.c:77
int nb_synth_max
Definition: sbgdec.c:133
int size
Definition: packet.h:356
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static int parse_timestamp(struct sbg_parser *p, struct sbg_timestamp *rts, int64_t *rrel)
Definition: sbgdec.c:461
static const AVOption sbg_options[]
Definition: sbgdec.c:1514
static int add_bell(struct ws_intervals *inter, struct sbg_script *s, int64_t ts1, int64_t ts2, int32_t f, int32_t a)
Definition: sbgdec.c:1056
char type
Definition: sbgdec.c:71
#define a1
Definition: regdef.h:47
#define AV_CH_LAYOUT_STEREO
struct sbg_script_synth::@278 ref
char * script
Definition: sbgdec.c:128
static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max, int64_t t0, struct sbg_script_tseq *tseq)
Definition: sbgdec.c:952
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
static int parse_volume(struct sbg_parser *p, int *vol)
Definition: sbgdec.c:608
int8_t in
Definition: sbgdec.c:55
#define DAY
Definition: sbgdec.c:33
int frame_size
Audio only.
Definition: codec_par.h:181
static int parse_synth_channel(struct sbg_parser *p)
Definition: sbgdec.c:710
Format I/O context.
Definition: avformat.h:1351
static int scale_double(void *log, double d, double m, int *r)
Definition: sbgdec.c:211
int64_t cur_dts
Definition: avformat.h:1079
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define SBG_SCALE
Definition: sbgdec.c:32
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
static av_cold int sbg_read_probe(const AVProbeData *p)
Definition: sbgdec.c:1395
float delta
AVOptions.
int32_t f1
Definition: sbgdec.c:147
#define f(width, name)
Definition: cbs_vp9.c:255
static int sbg_read_seek(AVFormatContext *avf, int stream_index, int64_t ts, int flags)
Definition: sbgdec.c:1508
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int nb_events
Definition: sbgdec.c:114
int64_t ts1
Definition: sbgdec.c:144
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4526
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
int nb_tseq
Definition: sbgdec.c:113
#define t0
Definition: regdef.h:28
double strtod(const char *, char **)
static int parse_named_def(struct sbg_parser *p)
Definition: sbgdec.c:760
uint8_t * data
Definition: packet.h:355
#define AVERROR_EOF
End of file.
Definition: error.h:55
int64_t opt_duration
Definition: sbgdec.c:119
static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)
Definition: sbgdec.c:282
int nb_block_tseq
Definition: sbgdec.c:132
enum ws_interval_type type
Definition: ffwavesynth.c:88
channels
Definition: aptx.h:33
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
sbg_synth_type
Definition: sbgdec.c:58
int nb_def
Definition: sbgdec.c:112
static void free_script(struct sbg_script *s)
Definition: sbgdec.c:787
struct sbg_timestamp ts
Definition: sbgdec.c:92
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
struct sbg_fade fade
Definition: sbgdec.c:103
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
#define AV_WL64(p, v)
Definition: intreadwrite.h:440
int line_no
Definition: sbgdec.c:134
int nb_synth
Definition: sbgdec.c:115
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define s2
Definition: regdef.h:39
int frame_size
Definition: sbgdec.c:39
static BenchmarkTimeStamps current_time
Definition: ffmpeg.c:142
#define AVERROR(e)
Definition: error.h:43
struct sbg_script_synth * synth
Definition: sbgdec.c:108
static void fade(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, int width, int height, int alpha, int beta)
Definition: vp8.c:496
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
const char * r
Definition: vf_curves.c:114
struct ws_interval * inter
Definition: sbgdec.c:153
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
static int lex_double(struct sbg_parser *p, double *r)
Definition: sbgdec.c:240
int nb_block_tseq_max
Definition: sbgdec.c:133
int max_inter
Definition: sbgdec.c:155
int32_t a1
Definition: sbgdec.c:148
int64_t start_ts
Definition: sbgdec.c:116
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:123
static int parse_synth_channel_pink(struct sbg_parser *p, struct sbg_script_synth *synth)
Definition: sbgdec.c:642
#define pass
Definition: fft_template.c:609
int64_t ts
Definition: sbgdec.c:100
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
int64_t opt_fade_time
Definition: sbgdec.c:118
static int read_whole_file(AVIOContext *io, int max_size, char **rbuf)
Definition: sbgdec.c:859
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3328
uint64_t phi
Definition: ffwavesynth.c:86
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
struct sbg_script_definition * def
Definition: sbgdec.c:107
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
static int parse_block_def(struct sbg_parser *p, struct sbg_script_definition *def)
Definition: sbgdec.c:579
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
static int parse_synth_channel_mix(struct sbg_parser *p, struct sbg_script_synth *synth)
Definition: sbgdec.c:674
struct sbg_fade fade
Definition: sbgdec.c:96
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define a2
Definition: regdef.h:48
static void * alloc_array_elem(void **array, size_t elsize, int *size, int *max_size)
Definition: sbgdec.c:158
#define s(width, name)
Definition: cbs_vp9.c:257
enum sbg_synth_type type
Definition: sbgdec.c:85
struct sbg_timestamp current_time
Definition: sbgdec.c:131
#define DAY_TS
Definition: sbgdec.c:34
char * end
Definition: sbgdec.c:128
#define FF_ARRAY_ELEMS(a)
static int encode_intervals(struct sbg_script *s, AVCodecParameters *par, struct ws_intervals *inter)
Definition: sbgdec.c:1352
static int generate_intervals(void *log, struct sbg_script *s, int sample_rate, struct ws_intervals *inter)
Definition: sbgdec.c:1278
Stream structure.
Definition: avformat.h:876
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)
Definition: sbgdec.c:1476
static int parse_synth_def(struct sbg_parser *p, struct sbg_script_definition *def)
Definition: sbgdec.c:736
static int parse_wave_def(struct sbg_parser *p, int wavenum)
Definition: sbgdec.c:572
struct sbg_script_tseq * tseq
Definition: sbgdec.c:109
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
static int is_space(char c)
Definition: sbgdec.c:206
int nb_tseq_max
Definition: sbgdec.c:133
char * s
Definition: sbgdec.c:44
static int lex_char(struct sbg_parser *p, char c)
Definition: sbgdec.c:232
struct sbg_script_tseq * block_tseq
Definition: sbgdec.c:110
#define abs(x)
Definition: cuda_runtime.h:35
static int expand_timestamps(void *log, struct sbg_script *s)
Definition: sbgdec.c:892
long long int64_t
Definition: coverity.c:34
static int lex_space(struct sbg_parser *p)
Definition: sbgdec.c:223
int max_file_size
Definition: sbgdec.c:40
static int add_interval(struct ws_intervals *inter, enum ws_interval_type type, uint32_t channels, int ref, int64_t ts1, int32_t f1, int32_t a1, int64_t ts2, int32_t f2, int32_t a2)
Definition: sbgdec.c:1022
int64_t ts_next
Definition: sbgdec.c:101
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
#define FORWARD_ERROR(c)
Definition: sbgdec.c:317
cl_device_type type
int sample_rate
Definition: sbgdec.c:38
#define s1
Definition: regdef.h:38
#define snprintf
Definition: snprintf.h:34
int8_t out
Definition: sbgdec.c:55
int64_t t
Definition: sbgdec.c:70
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int nb_def_max
Definition: sbgdec.c:133
static const AVClass sbg_demuxer_class
Definition: sbgdec.c:1527
static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)
Definition: sbgdec.c:492
char err_msg[128]
Definition: sbgdec.c:135
#define flags(name, subs,...)
Definition: cbs_av1.c:576
static int parse_preprogrammed(struct sbg_parser *p)
Definition: sbgdec.c:331
static int generate_plateau(void *log, struct sbg_script *s, struct ws_intervals *inter, struct sbg_script_event *ev1)
Definition: sbgdec.c:1163
uint32_t phi
Definition: sbgdec.c:149
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
int sample_rate
Audio only.
Definition: codec_par.h:170
static int parse_synth_channel_sine(struct sbg_parser *p, struct sbg_script_synth *synth)
Definition: sbgdec.c:621
#define ADD_EDATA32(v)
struct sbg_script scs
Definition: sbgdec.c:130
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
static int parse_synth_channel_spin(struct sbg_parser *p, struct sbg_script_synth *synth)
Definition: sbgdec.c:687
int name_len
Definition: sbgdec.c:94
static int parse_time_sequence(struct sbg_parser *p, int inblock)
Definition: sbgdec.c:516
Main libavformat public API header.
static int sbg_read_seek2(AVFormatContext *avf, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Definition: sbgdec.c:1497
static int str_to_time(const char *str, int64_t *rtime)
Definition: sbgdec.c:178
static int lex_line_end(struct sbg_parser *p)
Definition: sbgdec.c:264
if(ret< 0)
Definition: vf_mcdeint.c:279
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int nb_inter
Definition: sbgdec.c:154
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:915
static double c[64]
static int expand_script(void *log, struct sbg_script *s)
Definition: sbgdec.c:1001
sbg_fade_type
Definition: sbgdec.c:48
static int generate_interval(void *log, struct sbg_script *s, struct ws_intervals *inter, int64_t ts1, int64_t ts2, struct sbg_script_synth *s1, struct sbg_script_synth *s2, int transition)
Definition: sbgdec.c:1084
#define localtime_r
Definition: time_internal.h:46
void * log
Definition: sbgdec.c:127
static int parse_script(void *log, char *script, int script_len, struct sbg_script *rscript)
Definition: sbgdec.c:797
#define ADD_EDATA64(v)
AVInputFormat ff_sbg_demuxer
Definition: sbgdec.c:1534
int32_t f2
Definition: sbgdec.c:147
int64_t ts_int
Definition: sbgdec.c:101
#define av_free(p)
uint8_t opt_end_at_last
Definition: sbgdec.c:123
void * priv_data
Format private data.
Definition: avformat.h:1379
static int parse_options(struct sbg_parser *p)
Definition: sbgdec.c:348
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int channels
Audio only.
Definition: codec_par.h:166
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:354
int32_t a2
Definition: sbgdec.c:148
FILE * out
Definition: movenc.c:54
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
static int lex_name(struct sbg_parser *p, struct sbg_string *rs)
Definition: sbgdec.c:296
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)
Definition: sbgdec.c:338
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
static int lex_fixed(struct sbg_parser *p, const char *t, int l)
Definition: sbgdec.c:256
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
int64_t ts2
Definition: sbgdec.c:144
#define MKTAG(a, b, c, d)
Definition: common.h:406
This structure stores compressed data.
Definition: packet.h:332
char * name
Definition: sbgdec.c:93
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
for(j=16;j >0;--j)
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static int lex_time(struct sbg_parser *p, int64_t *rt)
Definition: sbgdec.c:310
int8_t slide
Definition: sbgdec.c:55
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
char * e
Definition: sbgdec.c:45