FFmpeg
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 {
70  int64_t t;
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 
100  int64_t ts;
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;
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;
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) {
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 
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 
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 
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 
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 
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 
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);
1431  st->codecpar->channels = 2;
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,
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 
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 };
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:657
static av_cold int sbg_read_header(AVFormatContext *avf)
Definition: sbgdec.c:1389
#define av_realloc_f(p, o, n)
AVOption.
Definition: opt.h:248
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:1183
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#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:4905
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:1084
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:364
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
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
static const AVOption sbg_options[]
Definition: sbgdec.c:1496
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:1047
char type
Definition: sbgdec.c:71
GLint GLenum type
Definition: opengl_enc.c:104
#define a1
Definition: regdef.h:47
#define FF_ARRAY_ELEMS(a)
#define AV_CH_LAYOUT_STEREO
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:948
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:610
int8_t in
Definition: sbgdec.c:55
#define DAY
Definition: sbgdec.c:33
static void expand_timestamps(void *log, struct sbg_script *s)
Definition: sbgdec.c:894
int frame_size
Audio only.
Definition: codec_par.h:181
static int parse_synth_channel(struct sbg_parser *p)
Definition: sbgdec.c:712
Format I/O context.
Definition: avformat.h:1243
static int scale_double(void *log, double d, double m, int *r)
Definition: sbgdec.c:211
int64_t cur_dts
Definition: avformat.h:1077
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:1377
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:1490
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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:381
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4481
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1311
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:762
uint8_t * data
Definition: packet.h:363
#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
ptrdiff_t size
Definition: opengl_enc.c:100
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:637
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:789
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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define s2
Definition: regdef.h:39
int frame_size
Definition: sbgdec.c:39
static BenchmarkTimeStamps current_time
Definition: ffmpeg.c:143
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:492
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
const char * r
Definition: vf_curves.c:116
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:103
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
#define fail()
Definition: checkasm.h:133
static int parse_synth_channel_pink(struct sbg_parser *p, struct sbg_script_synth *synth)
Definition: sbgdec.c:644
#define pass
Definition: fft_template.c:603
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:861
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:3291
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:105
static int parse_block_def(struct sbg_parser *p, struct sbg_script_definition *def)
Definition: sbgdec.c:581
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:676
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
static int encode_intervals(struct sbg_script *s, AVCodecParameters *par, struct ws_intervals *inter)
Definition: sbgdec.c:1334
if(ret)
static int generate_intervals(void *log, struct sbg_script *s, int sample_rate, struct ws_intervals *inter)
Definition: sbgdec.c:1269
Stream structure.
Definition: avformat.h:884
#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:1458
static int parse_synth_def(struct sbg_parser *p, struct sbg_script_definition *def)
Definition: sbgdec.c:738
static int parse_wave_def(struct sbg_parser *p, int wavenum)
Definition: sbgdec.c:574
struct sbg_script_tseq * tseq
Definition: sbgdec.c:109
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1285
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 lex_space(struct sbg_parser *p)
Definition: sbgdec.c:223
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now.Options-------Then comes the options array.This is what will define the user accessible options.For example
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:1013
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)\n", 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:279
#define FORWARD_ERROR(c)
Definition: sbgdec.c:317
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:1509
static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)
Definition: sbgdec.c:494
char err_msg[128]
Definition: sbgdec.c:135
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:1154
uint32_t phi
Definition: sbgdec.c:149
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:933
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:623
#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:689
int name_len
Definition: sbgdec.c:94
static int parse_time_sequence(struct sbg_parser *p, int inblock)
Definition: sbgdec.c:518
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:1479
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
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:923
static int expand_script(void *log, struct sbg_script *s)
Definition: sbgdec.c:994
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:1075
#define av_clipd
Definition: common.h:173
#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:799
#define ADD_EDATA64(v)
AVInputFormat ff_sbg_demuxer
Definition: sbgdec.c:1516
int32_t f2
Definition: sbgdec.c:147
int64_t ts_int
Definition: sbgdec.c:101
#define av_free(p)
struct sbg_script_synth::@284 ref
uint8_t opt_end_at_last
Definition: sbgdec.c:123
void * priv_data
Format private data.
Definition: avformat.h:1271
static int parse_options(struct sbg_parser *p)
Definition: sbgdec.c:348
#define av_sat_add64
Definition: common.h:164
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:362
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:654
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:1049
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:913
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int64_t ts2
Definition: sbgdec.c:144
#define MKTAG(a, b, c, d)
Definition: common.h:478
This structure stores compressed data.
Definition: packet.h:340
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:356
for(j=16;j >0;--j)
int i
Definition: input.c:407
#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