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