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