FFmpeg: libavformat/sbgdec.c Source File

FFmpeg

[フレーム]

libavformat

sbgdec.c

Go to the documentation of this file.

1 /*

2 * SBG (SBaGen) file format decoder

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 */

22 #include <stdio.h>

23 #include <stdlib.h>

24 #include <time.h>

25 #include "libavutil/channel_layout.h"

26 #include "libavutil/intreadwrite.h"

27 #include "libavutil/log.h"

28 #include "libavutil/opt.h"

29 #include "libavutil/time_internal.h"

30 #include "avformat.h"

31 #include "internal.h"

33 #define SBG_SCALE (1 << 16)

34 #define DAY (24 * 60 * 60)

35 #define DAY_TS ((int64_t)DAY * AV_TIME_BASE)

37 struct sbg_demuxer {

38 AVClass *class;

39 int sample_rate;

40 int frame_size;

41 int max_file_size;

42 };

44 struct sbg_string {

45 char *s;

46 char *e;

47 };

49 enum sbg_fade_type {

50 SBG_FADE_SILENCE = 0,

51 SBG_FADE_SAME = 1,

52 SBG_FADE_ADAPT = 3,

53 };

55 struct sbg_fade {

56 int8_t in, out, slide;

57 };

59 enum sbg_synth_type {

60 SBG_TYPE_NONE,

61 SBG_TYPE_SINE,

62 SBG_TYPE_NOISE,

63 SBG_TYPE_BELL,

64 SBG_TYPE_MIX,

65 SBG_TYPE_SPIN,

66 };

68 /* bell: freq constant, ampl decreases exponentially, can be approx lin */

70 struct sbg_timestamp {

71 int64_t t;

72 char type; /* 0 for relative, 'N' for now, 'T' for absolute */

73 };

75 struct sbg_script_definition {

76 char *name;

77 int name_len;

78 int elements, nb_elements;

79 char type; /* 'S' or 'B' */

80 };

82 struct sbg_script_synth {

83 int carrier;

84 int beat;

85 int vol;

86 enum sbg_synth_type type;

87 struct {

88 int l, r;

89 } ref;

90 };

92 struct sbg_script_tseq {

93 struct sbg_timestamp ts;

94 char *name;

95 int name_len;

96 int lock;

97 struct sbg_fade fade;

98 };

100 struct sbg_script_event {

101 int64_t ts;

102 int64_t ts_int, ts_trans, ts_next;

103 int elements, nb_elements;

104 struct sbg_fade fade;

105 };

106

107 struct sbg_script {

108 struct sbg_script_definition *def;

109 struct sbg_script_synth *synth;

110 struct sbg_script_tseq *tseq;

111 struct sbg_script_tseq *block_tseq;

112 struct sbg_script_event *events;

113 int nb_def;

114 int nb_tseq;

115 int nb_events;

116 int nb_synth;

117 int64_t start_ts;

118 int64_t end_ts;

119 int64_t opt_fade_time;

120 int64_t opt_duration;

121 char *opt_mix;

122 int sample_rate;

123 uint8_t opt_start_at_first;

124 uint8_t opt_end_at_last;

125 };

126

127 struct sbg_parser {

128 void *log;

129 char *script, *end;

130 char *cursor;

131 struct sbg_script scs;

132 struct sbg_timestamp current_time;

133 int nb_block_tseq;

134 int nb_def_max, nb_synth_max, nb_tseq_max, nb_block_tseq_max;

135 int line_no;

136 char err_msg[128];

137 };

138

139 enum ws_interval_type {

140 WS_SINE = MKTAG('S','I','N','E'),

141 WS_NOISE = MKTAG('N','O','I','S'),

142 };

143

144 struct ws_interval {

145 int64_t ts1, ts2;

146 enum ws_interval_type type;

147 uint32_t channels;

148 int32_t f1, f2;

149 int32_t a1, a2;

150 uint32_t phi;

151 };

152

153 struct ws_intervals {

154 struct ws_interval *inter;

155 int nb_inter;

156 int max_inter;

157 };

158

159 static void *alloc_array_elem(void **array, size_t elsize,

160 int *size, int *max_size)

161 {

162 void *ret;

163

164 if (*size == *max_size) {

165 int m = FFMAX(32, FFMIN(*max_size, INT_MAX / 2) * 2);

166 if (*size >= m)

167 return NULL;

168 *array = av_realloc_f(*array, m, elsize);

169 if (!*array)

170 return NULL;

171 *max_size = m;

172 }

173 ret = (char *)*array + elsize * *size;

174 memset(ret, 0, elsize);

175 (*size)++;

176 return ret;

177 }

178

179 static int str_to_time(const char *str, int64_t *rtime)

180 {

181 const char *cur = str;

182 char *end;

183 int hours, minutes;

184 double seconds = 0;

185 int64_t ts = 0;

186

187 if (*cur < '0' || *cur > '9')

188 return 0;

189 hours = strtol(cur, &end, 10);

190 if (end == cur || *end != ':' || end[1] < '0' || end[1] > '9')

191 return 0;

192 cur = end + 1;

193 minutes = strtol(cur, &end, 10);

194 if (end == cur)

195 return 0;

196 cur = end;

197 if (*end == ':'){

198 seconds = strtod(cur + 1, &end);

199 if (end > cur + 1)

200 cur = end;

201 ts = av_clipd(seconds * AV_TIME_BASE, INT64_MIN/2, INT64_MAX/2);

202 }

203 *rtime = av_sat_add64((hours * 3600LL + minutes * 60LL) * AV_TIME_BASE, ts);

204 return cur - str;

205 }

206

207 static inline int is_space(char c)

208 {

209 return c == ' ' || c == '\t' || c == '\r';

210 }

211

212 static inline int scale_double(void *log, double d, double m, int *r)

213 {

214 m *= d * SBG_SCALE;

215 if (m < INT_MIN || m >= INT_MAX) {

216 if (log)

217 av_log(log, AV_LOG_ERROR, "%g is too large\n", d);

218 return AVERROR(EDOM);

219 }

220 *r = m;

221 return 0;

222 }

223

224 static int lex_space(struct sbg_parser *p)

225 {

226 char *c = p->cursor;

227

228 while (p->cursor < p->end && is_space(*p->cursor))

229 p->cursor++;

230 return p->cursor > c;

231 }

232

233 static int lex_char(struct sbg_parser *p, char c)

234 {

235 int r = p->cursor < p->end && *p->cursor == c;

236

237 p->cursor += r;

238 return r;

239 }

240

241 static int lex_double(struct sbg_parser *p, double *r)

242 {

243 double d;

244 char *end;

245

246 if (p->cursor == p->end || is_space(*p->cursor) || *p->cursor == '\n')

247 return 0;

248 d = strtod(p->cursor, &end);

249 if (end > p->cursor) {

250 *r = d;

251 p->cursor = end;

252 return 1;

253 }

254 return 0;

255 }

256

257 static int lex_fixed(struct sbg_parser *p, const char *t, int l)

258 {

259 if (p->end - p->cursor < l || memcmp(p->cursor, t, l))

260 return 0;

261 p->cursor += l;

262 return 1;

263 }

264

265 static int lex_line_end(struct sbg_parser *p)

266 {

267 if (p->cursor < p->end && *p->cursor == '#') {

268 p->cursor++;

269 while (p->cursor < p->end && *p->cursor != '\n')

270 p->cursor++;

271 }

272 if (p->cursor == p->end)

273 /* simulate final LF for files lacking it */

274 return 1;

275 if (*p->cursor != '\n')

276 return 0;

277 p->cursor++;

278 p->line_no++;

279 lex_space(p);

280 return 1;

281 }

282

283 static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)

284 {

285 char *s = p->cursor, *c = s;

286

287 if (s == p->end || *s == '\n')

288 return 0;

289 while (c < p->end && *c != '\n' && !is_space(*c))

290 c++;

291 rs->s = s;

292 rs->e = p->cursor = c;

293 lex_space(p);

294 return 1;

295 }

296

297 static int lex_name(struct sbg_parser *p, struct sbg_string *rs)

298 {

299 char *s = p->cursor, *c = s;

300

301 while (c < p->end && ((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z')

302 || (*c >= '0' && *c <= '9') || *c == '_' || *c == '-'))

303 c++;

304 if (c == s)

305 return 0;

306 rs->s = s;

307 rs->e = p->cursor = c;

308 return 1;

309 }

310

311 static int lex_time(struct sbg_parser *p, int64_t *rt)

312 {

313 int r = str_to_time(p->cursor, rt);

314 p->cursor += r;

315 return r > 0;

316 }

317

318 #define FORWARD_ERROR(c) \

319 do { \

320 int errcode = c; \

321 if (errcode <= 0) \

322 return errcode ? errcode : AVERROR_INVALIDDATA; \

323 } while (0)

324

325 static int parse_immediate(struct sbg_parser *p)

326 {

327 snprintf(p->err_msg, sizeof(p->err_msg),

328 "immediate sequences not yet implemented");

329 return AVERROR_PATCHWELCOME;

330 }

331

332 static int parse_preprogrammed(struct sbg_parser *p)

333 {

334 snprintf(p->err_msg, sizeof(p->err_msg),

335 "preprogrammed sequences not yet implemented");

336 return AVERROR_PATCHWELCOME;

337 }

338

339 static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)

340 {

341 if (!lex_wsword(p, r)) {

342 snprintf(p->err_msg, sizeof(p->err_msg),

343 "option '%c' requires an argument", o);

344 return AVERROR_INVALIDDATA;

345 }

346 return 1;

347 }

348

349 static int parse_options(struct sbg_parser *p)

350 {

351 struct sbg_string ostr, oarg;

352 char mode = 0;

353 int r;

354 char *tptr;

355 double v;

356

357 if (p->cursor == p->end || *p->cursor != '-')

358 return 0;

359 while (lex_char(p, '-') && lex_wsword(p, &ostr)) {

360 for (; ostr.s < ostr.e; ostr.s++) {

361 char opt = *ostr.s;

362 switch (opt) {

363 case 'S':

364 p->scs.opt_start_at_first = 1;

365 break;

366 case 'E':

367 p->scs.opt_end_at_last = 1;

368 break;

369 case 'i':

370 mode = 'i';

371 break;

372 case 'p':

373 mode = 'p';

374 break;

375 case 'F':

376 FORWARD_ERROR(parse_optarg(p, opt, &oarg));

377 v = strtod(oarg.s, &tptr);

378 if (oarg.e != tptr) {

379 snprintf(p->err_msg, sizeof(p->err_msg),

380 "syntax error for option -F");

381 return AVERROR_INVALIDDATA;

382 }

383 p->scs.opt_fade_time = v * AV_TIME_BASE / 1000;

384 break;

385 case 'L':

386 FORWARD_ERROR(parse_optarg(p, opt, &oarg));

387 r = str_to_time(oarg.s, &p->scs.opt_duration);

388 if (oarg.e != oarg.s + r) {

389 snprintf(p->err_msg, sizeof(p->err_msg),

390 "syntax error for option -L");

391 return AVERROR_INVALIDDATA;

392 }

393 break;

394 case 'T':

395 FORWARD_ERROR(parse_optarg(p, opt, &oarg));

396 r = str_to_time(oarg.s, &p->scs.start_ts);

397 if (oarg.e != oarg.s + r) {

398 snprintf(p->err_msg, sizeof(p->err_msg),

399 "syntax error for option -T");

400 return AVERROR_INVALIDDATA;

401 }

402 break;

403 case 'm':

404 FORWARD_ERROR(parse_optarg(p, opt, &oarg));

405 tptr = av_malloc(oarg.e - oarg.s + 1);

406 if (!tptr)

407 return AVERROR(ENOMEM);

408 memcpy(tptr, oarg.s, oarg.e - oarg.s);

409 tptr[oarg.e - oarg.s] = 0;

410 av_free(p->scs.opt_mix);

411 p->scs.opt_mix = tptr;

412 break;

413 case 'q':

414 FORWARD_ERROR(parse_optarg(p, opt, &oarg));

415 v = strtod(oarg.s, &tptr);

416 if (oarg.e != tptr) {

417 snprintf(p->err_msg, sizeof(p->err_msg),

418 "syntax error for option -q");

419 return AVERROR_INVALIDDATA;

420 }

421 if (v != 1) {

422 snprintf(p->err_msg, sizeof(p->err_msg),

423 "speed factor other than 1 not supported");

424 return AVERROR_PATCHWELCOME;

425 }

426 break;

427 case 'r':

428 FORWARD_ERROR(parse_optarg(p, opt, &oarg));

429 r = strtol(oarg.s, &tptr, 10);

430 if (oarg.e != tptr) {

431 snprintf(p->err_msg, sizeof(p->err_msg),

432 "syntax error for option -r");

433 return AVERROR_INVALIDDATA;

434 }

435 if (r < 40) {

436 snprintf(p->err_msg, sizeof(p->err_msg),

437 "invalid sample rate");

438 return AVERROR_PATCHWELCOME;

439 }

440 p->scs.sample_rate = r;

441 break;

442 default:

443 snprintf(p->err_msg, sizeof(p->err_msg),

444 "unknown option: '%c'", *ostr.s);

445 return AVERROR_INVALIDDATA;

446 }

447 }

448 }

449 switch (mode) {

450 case 'i':

451 return parse_immediate(p);

452 case 'p':

453 return parse_preprogrammed(p);

454 case 0:

455 if (!lex_line_end(p))

456 return AVERROR_INVALIDDATA;

457 return 1;

458 }

459 return AVERROR_BUG;

460 }

461

462 static int parse_timestamp(struct sbg_parser *p,

463 struct sbg_timestamp *rts, int64_t *rrel)

464 {

465 int64_t abs = 0, rel = 0, dt;

466 char type = 0;

467 int r;

468

469 if (lex_fixed(p, "NOW", 3)) {

470 type = 'N';

471 r = 1;

472 } else {

473 r = lex_time(p, &abs);

474 if (r)

475 type = 'T';

476 }

477 while (lex_char(p, '+')) {

478 if (!lex_time(p, &dt))

479 return AVERROR_INVALIDDATA;

480 if (av_sat_add64(rel, dt) - dt != rel)

481 return AVERROR_INVALIDDATA;

482 rel += dt;

483 r = 1;

484 }

485 if (r) {

486 if (!lex_space(p))

487 return AVERROR_INVALIDDATA;

488 rts->type = type;

489 rts->t = abs;

490 *rrel = rel;

491 }

492 return r;

493 }

494

495 static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)

496 {

497 struct sbg_fade f = {0};

498

499 if (lex_char(p, '<'))

500 f.in = SBG_FADE_SILENCE;

501 else if (lex_char(p, '-'))

502 f.in = SBG_FADE_SAME;

503 else if (lex_char(p, '='))

504 f.in = SBG_FADE_ADAPT;

505 else

506 return 0;

507 if (lex_char(p, '>'))

508 f.out = SBG_FADE_SILENCE;

509 else if (lex_char(p, '-'))

510 f.out = SBG_FADE_SAME;

511 else if (lex_char(p, '='))

512 f.out = SBG_FADE_ADAPT;

513 else

514 return AVERROR_INVALIDDATA;

515 *fr = f;

516 return 1;

517 }

518

519 static int parse_time_sequence(struct sbg_parser *p, int inblock)

520 {

521 struct sbg_timestamp ts;

522 int64_t rel_ts;

523 int r;

524 struct sbg_fade fade = { SBG_FADE_SAME, SBG_FADE_SAME, 0 };

525 struct sbg_string name;

526 struct sbg_script_tseq *tseq;

527

528 r = parse_timestamp(p, &ts, &rel_ts);

529 if (!r)

530 return 0;

531 if (r < 0)

532 return r;

533 if (ts.type) {

534 if (inblock)

535 return AVERROR_INVALIDDATA;

536 p->current_time.type = ts.type;

537 p->current_time.t = ts.t;

538 } else if(!inblock && !p->current_time.type) {

539 snprintf(p->err_msg, sizeof(p->err_msg),

540 "relative time without previous absolute time");

541 return AVERROR_INVALIDDATA;

542 }

543 ts.type = p->current_time.type;

544

545 if (av_sat_add64(p->current_time.t, rel_ts) != p->current_time.t + (uint64_t)rel_ts)

546 return AVERROR_INVALIDDATA;

547 ts.t = p->current_time.t + rel_ts;

548 r = parse_fade(p, &fade);

549 if (r < 0)

550 return r;

551 lex_space(p);

552 if (!lex_name(p, &name))

553 return AVERROR_INVALIDDATA;

554 lex_space(p);

555 if (lex_fixed(p, "->", 2)) {

556 fade.slide = SBG_FADE_ADAPT;

557 lex_space(p);

558 }

559 if (!lex_line_end(p))

560 return AVERROR_INVALIDDATA;

561 tseq = inblock ?

562 alloc_array_elem((void **)&p->scs.block_tseq, sizeof(*tseq),

563 &p->nb_block_tseq, &p->nb_block_tseq_max) :

564 alloc_array_elem((void **)&p->scs.tseq, sizeof(*tseq),

565 &p->scs.nb_tseq, &p->nb_tseq_max);

566 if (!tseq)

567 return AVERROR(ENOMEM);

568 tseq->ts = ts;

569 tseq->name = name.s;

570 tseq->name_len = name.e - name.s;

571 tseq->fade = fade;

572 return 1;

573 }

574

575 static int parse_wave_def(struct sbg_parser *p, int wavenum)

576 {

577 snprintf(p->err_msg, sizeof(p->err_msg),

578 "waveform definitions not yet implemented");

579 return AVERROR_PATCHWELCOME;

580 }

581

582 static int parse_block_def(struct sbg_parser *p,

583 struct sbg_script_definition *def)

584 {

585 int r, tseq;

586

587 lex_space(p);

588 if (!lex_line_end(p))

589 return AVERROR_INVALIDDATA;

590 tseq = p->nb_block_tseq;

591 while (1) {

592 r = parse_time_sequence(p, 1);

593 if (r < 0)

594 return r;

595 if (!r)

596 break;

597 }

598 if (!lex_char(p, '}'))

599 return AVERROR_INVALIDDATA;

600 lex_space(p);

601 if (!lex_line_end(p))

602 return AVERROR_INVALIDDATA;

603 def->type = 'B';

604 def->elements = tseq;

605 def->nb_elements = p->nb_block_tseq - tseq;

606 if (!def->nb_elements)

607 return AVERROR_INVALIDDATA;

608 return 1;

609 }

610

611 static int parse_volume(struct sbg_parser *p, int *vol)

612 {

613 double v;

614

615 if (!lex_char(p, '/'))

616 return 0;

617 if (!lex_double(p, &v))

618 return AVERROR_INVALIDDATA;

619 if (scale_double(p->log, v, 0.01, vol))

620 return AVERROR(ERANGE);

621 return 1;

622 }

623

624 static int parse_synth_channel_sine(struct sbg_parser *p,

625 struct sbg_script_synth *synth)

626 {

627 double carrierf, beatf;

628 int carrier, beat, vol;

629

630 if (!lex_double(p, &carrierf))

631 return 0;

632 if (!lex_double(p, &beatf))

633 beatf = 0;

634 FORWARD_ERROR(parse_volume(p, &vol));

635 if (scale_double(p->log, carrierf, 1, &carrier) < 0 ||

636 scale_double(p->log, beatf, 1, &beat) < 0)

637 return AVERROR(EDOM);

638 synth->type = SBG_TYPE_SINE;

639 synth->carrier = carrier;

640 synth->beat = beat;

641 synth->vol = vol;

642 return 1;

643 }

644

645 static int parse_synth_channel_pink(struct sbg_parser *p,

646 struct sbg_script_synth *synth)

647 {

648 int vol;

649

650 if (!lex_fixed(p, "pink", 4))

651 return 0;

652 FORWARD_ERROR(parse_volume(p, &vol));

653 synth->type = SBG_TYPE_NOISE;

654 synth->vol = vol;

655 return 1;

656 }

657

658 static int parse_synth_channel_bell(struct sbg_parser *p,

659 struct sbg_script_synth *synth)

660 {

661 double carrierf;

662 int carrier, vol;

663

664 if (!lex_fixed(p, "bell", 4))

665 return 0;

666 if (!lex_double(p, &carrierf))

667 return AVERROR_INVALIDDATA;

668 FORWARD_ERROR(parse_volume(p, &vol));

669 if (scale_double(p->log, carrierf, 1, &carrier) < 0)

670 return AVERROR(EDOM);

671 synth->type = SBG_TYPE_BELL;

672 synth->carrier = carrier;

673 synth->vol = vol;

674 return 1;

675 }

676

677 static int parse_synth_channel_mix(struct sbg_parser *p,

678 struct sbg_script_synth *synth)

679 {

680 int vol;

681

682 if (!lex_fixed(p, "mix", 3))

683 return 0;

684 FORWARD_ERROR(parse_volume(p, &vol));

685 synth->type = SBG_TYPE_MIX;

686 synth->vol = vol;

687 return 1;

688 }

689

690 static int parse_synth_channel_spin(struct sbg_parser *p,

691 struct sbg_script_synth *synth)

692 {

693 double carrierf, beatf;

694 int carrier, beat, vol;

695

696 if (!lex_fixed(p, "spin:", 5))

697 return 0;

698 if (!lex_double(p, &carrierf))

699 return AVERROR_INVALIDDATA;

700 if (!lex_double(p, &beatf))

701 return AVERROR_INVALIDDATA;

702 FORWARD_ERROR(parse_volume(p, &vol));

703 if (scale_double(p->log, carrierf, 1, &carrier) < 0 ||

704 scale_double(p->log, beatf, 1, &beat) < 0)

705 return AVERROR(EDOM);

706 synth->type = SBG_TYPE_SPIN;

707 synth->carrier = carrier;

708 synth->beat = beat;

709 synth->vol = vol;

710 return 1;

711 }

712

713 static int parse_synth_channel(struct sbg_parser *p)

714 {

715 int r;

716 struct sbg_script_synth *synth;

717

718 synth = alloc_array_elem((void **)&p->scs.synth, sizeof(*synth),

719 &p->scs.nb_synth, &p->nb_synth_max);

720 if (!synth)

721 return AVERROR(ENOMEM);

722 r = lex_char(p, '-');

723 if (!r)

724 r = parse_synth_channel_pink(p, synth);

725 if (!r)

726 r = parse_synth_channel_bell(p, synth);

727 if (!r)

728 r = parse_synth_channel_mix(p, synth);

729 if (!r)

730 r = parse_synth_channel_spin(p, synth);

731 /* Unimplemented: wave%d:%f%f/vol (carrier, beat) */

732 if (!r)

733 r = parse_synth_channel_sine(p, synth);

734 if (r <= 0)

735 p->scs.nb_synth--;

736 return r;

737 }

738

739 static int parse_synth_def(struct sbg_parser *p,

740 struct sbg_script_definition *def)

741 {

742 int r, synth;

743

744 synth = p->scs.nb_synth;

745 while (1) {

746 r = parse_synth_channel(p);

747 if (r < 0)

748 return r;

749 if (!r || !lex_space(p))

750 break;

751 }

752 lex_space(p);

753 if (synth == p->scs.nb_synth)

754 return AVERROR_INVALIDDATA;

755 if (!lex_line_end(p))

756 return AVERROR_INVALIDDATA;

757 def->type = 'S';

758 def->elements = synth;

759 def->nb_elements = p->scs.nb_synth - synth;

760 return 1;

761 }

762

763 static int parse_named_def(struct sbg_parser *p)

764 {

765 char *cursor_save = p->cursor;

766 struct sbg_string name;

767 struct sbg_script_definition *def;

768

769 if (!lex_name(p, &name) || !lex_char(p, ':') || !lex_space(p)) {

770 p->cursor = cursor_save;

771 return 0;

772 }

773 if (name.e - name.s == 6 && !memcmp(name.s, "wave", 4) &&

774 name.s[4] >= '0' && name.s[4] <= '9' &&

775 name.s[5] >= '0' && name.s[5] <= '9') {

776 int wavenum = (name.s[4] - '0') * 10 + (name.s[5] - '0');

777 return parse_wave_def(p, wavenum);

778 }

779 def = alloc_array_elem((void **)&p->scs.def, sizeof(*def),

780 &p->scs.nb_def, &p->nb_def_max);

781 if (!def)

782 return AVERROR(ENOMEM);

783 def->name = name.s;

784 def->name_len = name.e - name.s;

785 if (lex_char(p, '{'))

786 return parse_block_def(p, def);

787 return parse_synth_def(p, def);

788 }

789

790 static void free_script(struct sbg_script *s)

791 {

792 av_freep(&s->def);

793 av_freep(&s->synth);

794 av_freep(&s->tseq);

795 av_freep(&s->block_tseq);

796 av_freep(&s->events);

797 av_freep(&s->opt_mix);

798 }

799

800 static int parse_script(void *log, char *script, int script_len,

801 struct sbg_script *rscript)

802 {

803 struct sbg_parser sp = {

804 .log = log,

805 .script = script,

806 .end = script + script_len,

807 .cursor = script,

808 .line_no = 1,

809 .err_msg = "",

810 .scs = {

811 /* default values */

812 .start_ts = AV_NOPTS_VALUE,

813 .sample_rate = 44100,

814 .opt_fade_time = 60 * AV_TIME_BASE,

815 },

816 };

817 int r;

818

819 lex_space(&sp);

820 while (sp.cursor < sp.end) {

821 r = parse_options(&sp);

822 if (r < 0)

823 goto fail;

824 if (!r && !lex_line_end(&sp))

825 break;

826 }

827 while (sp.cursor < sp.end) {

828 r = parse_named_def(&sp);

829 if (!r)

830 r = parse_time_sequence(&sp, 0);

831 if (!r)

832 r = lex_line_end(&sp) ? 1 : AVERROR_INVALIDDATA;

833 if (r < 0)

834 goto fail;

835 }

836 *rscript = sp.scs;

837 return 1;

838 fail:

839 free_script(&sp.scs);

840 if (!*sp.err_msg)

841 if (r == AVERROR_INVALIDDATA)

842 snprintf(sp.err_msg, sizeof(sp.err_msg), "syntax error");

843 if (log && *sp.err_msg) {

844 const char *ctx = sp.cursor;

845 const char *ectx = av_x_if_null(memchr(ctx, '\n', sp.end - sp.cursor),

846 sp.end);

847 int lctx = ectx - ctx;

848 const char *quote = "\"";

849 if (lctx > 0 && ctx[lctx - 1] == '\r')

850 lctx--;

851 if (lctx == 0) {

852 ctx = "the end of line";

853 lctx = strlen(ctx);

854 quote = "";

855 }

856 av_log(log, AV_LOG_ERROR, "Error line %d: %s near %s%.*s%s.\n",

857 sp.line_no, sp.err_msg, quote, lctx, ctx, quote);

858 }

859 return r;

860 }

861

862 static int read_whole_file(AVIOContext *io, int max_size, char **rbuf)

863 {

864 char *buf = NULL;

865 int size = 0, bufsize = 0, r;

866

867 while (1) {

868 if (bufsize - size < 1024) {

869 bufsize = FFMIN(FFMAX(2 * bufsize, 8192), max_size);

870 if (bufsize - size < 2) {

871 size = AVERROR(EFBIG);

872 goto fail;

873 }

874 buf = av_realloc_f(buf, bufsize, 1);

875 if (!buf) {

876 size = AVERROR(ENOMEM);

877 goto fail;

878 }

879 }

880 r = avio_read(io, buf, bufsize - size - 1);

881 if (r == AVERROR_EOF)

882 break;

883 if (r < 0)

884 goto fail;

885 size += r;

886 }

887 buf[size] = 0;

888 *rbuf = buf;

889 return size;

890 fail:

891 av_free(buf);

892 return size;

893 }

894

895 static int expand_timestamps(void *log, struct sbg_script *s)

896 {

897 int i, nb_rel = 0;

898 int64_t now, cur_ts, delta = 0;

899

900 for (i = 0; i < s->nb_tseq; i++)

901 nb_rel += s->tseq[i].ts.type == 'N';

902 if (nb_rel == s->nb_tseq) {

903 /* All ts are relative to NOW: consider NOW = 0 */

904 now = 0;

905 if (s->start_ts != AV_NOPTS_VALUE)

906 av_log(log, AV_LOG_WARNING,

907 "Start time ignored in a purely relative script.\n");

908 } else if (nb_rel == 0 && s->start_ts != AV_NOPTS_VALUE ||

909 s->opt_start_at_first) {

910 /* All ts are absolute and start time is specified */

911 if (s->start_ts == AV_NOPTS_VALUE)

912 s->start_ts = s->tseq[0].ts.t;

913 now = s->start_ts;

914 } else {

915 /* Mixed relative/absolute ts: expand */

916 time_t now0;

917 struct tm *tm, tmpbuf;

918

919 av_log(log, AV_LOG_WARNING,

920 "Scripts with mixed absolute and relative timestamps can give "

921 "unexpected results (pause, seeking, time zone change).\n");

922 #undef time

923 time(&now0);

924 tm = localtime_r(&now0, &tmpbuf);

925 now = tm ? tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec :

926 now0 % DAY;

927 av_log(log, AV_LOG_INFO, "Using %02d:%02d:%02d as NOW.\n",

928 (int)(now / 3600), (int)(now / 60) % 60, (int)now % 60);

929 now *= AV_TIME_BASE;

930 for (i = 0; i < s->nb_tseq; i++) {

931 if (s->tseq[i].ts.type == 'N') {

932 s->tseq[i].ts.t += now;

933 s->tseq[i].ts.type = 'T'; /* not necessary */

934 }

935 }

936 }

937 if (s->start_ts == AV_NOPTS_VALUE)

938 s->start_ts = (s->opt_start_at_first && s->tseq) ? s->tseq[0].ts.t : now;

939 if (s->start_ts > INT64_MAX - s->opt_duration)

940 return AVERROR_INVALIDDATA;

941

942 s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :

943 AV_NOPTS_VALUE; /* may be overridden later by -E option */

944 cur_ts = now;

945 for (i = 0; i < s->nb_tseq; i++) {

946 if (av_sat_add64(s->tseq[i].ts.t, delta) != s->tseq[i].ts.t + (uint64_t)delta)

947 return AVERROR_INVALIDDATA;

948 if (s->tseq[i].ts.t + delta < cur_ts)

949 delta += DAY_TS;

950 cur_ts = s->tseq[i].ts.t += delta;

951 }

952 return 0;

953 }

954

955 static int expand_tseq(void *log, struct sbg_script *s, int *nb_ev_max,

956 int64_t t0, struct sbg_script_tseq *tseq)

957 {

958 int i, r;

959 struct sbg_script_definition *def;

960 struct sbg_script_tseq *be;

961 struct sbg_script_event *ev;

962

963 if (tseq->lock++) {

964 av_log(log, AV_LOG_ERROR, "Recursion loop on \"%.*s\"\n",

965 tseq->name_len, tseq->name);

966 return AVERROR(EINVAL);

967 }

968 if (t0 + (uint64_t)tseq->ts.t != av_sat_add64(t0, tseq->ts.t))

969 return AVERROR(EINVAL);

970

971 t0 += tseq->ts.t;

972 for (i = 0; i < s->nb_def; i++) {

973 if (s->def[i].name_len == tseq->name_len &&

974 !memcmp(s->def[i].name, tseq->name, tseq->name_len))

975 break;

976 }

977 if (i >= s->nb_def) {

978 av_log(log, AV_LOG_ERROR, "Tone-set \"%.*s\" not defined\n",

979 tseq->name_len, tseq->name);

980 return AVERROR(EINVAL);

981 }

982 def = &s->def[i];

983 if (def->type == 'B') {

984 be = s->block_tseq + def->elements;

985 for (i = 0; i < def->nb_elements; i++) {

986 r = expand_tseq(log, s, nb_ev_max, t0, &be[i]);

987 if (r < 0)

988 return r;

989 }

990 } else {

991 ev = alloc_array_elem((void **)&s->events, sizeof(*ev),

992 &s->nb_events, nb_ev_max);

993 if (!ev)

994 return AVERROR(ENOMEM);

995 ev->ts = tseq->ts.t;

996 ev->elements = def->elements;

997 ev->nb_elements = def->nb_elements;

998 ev->fade = tseq->fade;

999 }

1000 tseq->lock--;

1001 return 0;

1002 }

1003

1004 static int expand_script(void *log, struct sbg_script *s)

1005 {

1006 int i, r, nb_events_max = 0;

1007

1008 r = expand_timestamps(log, s);

1009 if (r < 0)

1010 return r;

1011 for (i = 0; i < s->nb_tseq; i++) {

1012 r = expand_tseq(log, s, &nb_events_max, 0, &s->tseq[i]);

1013 if (r < 0)

1014 return r;

1015 }

1016 if (!s->nb_events) {

1017 av_log(log, AV_LOG_ERROR, "No events in script\n");

1018 return AVERROR_INVALIDDATA;

1019 }

1020 if (s->opt_end_at_last)

1021 s->end_ts = s->events[s->nb_events - 1].ts;

1022 return 0;

1023 }

1024

1025 static int add_interval(struct ws_intervals *inter,

1026 enum ws_interval_type type, uint32_t channels, int ref,

1027 int64_t ts1, int32_t f1, int32_t a1,

1028 int64_t ts2, int32_t f2, int32_t a2)

1029 {

1030 struct ws_interval *i, *ri;

1031

1032 if (ref >= 0) {

1033 ri = &inter->inter[ref];

1034 /* ref and new intervals are constant, identical and adjacent */

1035 if (ri->type == type && ri->channels == channels &&

1036 ri->f1 == ri->f2 && ri->f2 == f1 && f1 == f2 &&

1037 ri->a1 == ri->a2 && ri->a2 == a1 && a1 == a2 &&

1038 ri->ts2 == ts1) {

1039 ri->ts2 = ts2;

1040 return ref;

1041 }

1042 }

1043 i = alloc_array_elem((void **)&inter->inter, sizeof(*i),

1044 &inter->nb_inter, &inter->max_inter);

1045 if (!i)

1046 return AVERROR(ENOMEM);

1047 i->ts1 = ts1;

1048 i->ts2 = ts2;

1049 i->type = type;

1050 i->channels = channels;

1051 i->f1 = f1;

1052 i->f2 = f2;

1053 i->a1 = a1;

1054 i->a2 = a2;

1055 i->phi = ref >= 0 ? ref | 0x80000000 : 0;

1056 return i - inter->inter;

1057 }

1058

1059 static int add_bell(struct ws_intervals *inter, struct sbg_script *s,

1060 int64_t ts1, int64_t ts2, int32_t f, int32_t a)

1061 {

1062 /* SBaGen uses an exponential decrease every 50ms.

1063 We approximate it with piecewise affine segments. */

1064 int32_t cpoints[][2] = {

1065 { 2, a },

1066 { 4, a - a / 4 },

1067 { 8, a / 2 },

1068 { 16, a / 4 },

1069 { 25, a / 10 },

1070 { 50, a / 80 },

1071 { 75, 0 },

1072 };

1073 int i, r;

1074 int64_t dt = s->sample_rate / 20, ts3 = ts1, ts4;

1075 for (i = 0; i < FF_ARRAY_ELEMS(cpoints); i++) {

1076 ts4 = FFMIN(ts2, ts1 + cpoints[i][0] * dt);

1077 r = add_interval(inter, WS_SINE, 3, -1,

1078 ts3, f, a, ts4, f, cpoints[i][1]);

1079 if (r < 0)

1080 return r;

1081 ts3 = ts4;

1082 a = cpoints[i][1];

1083 }

1084 return 0;

1085 }

1086

1087 static int generate_interval(void *log, struct sbg_script *s,

1088 struct ws_intervals *inter,

1089 int64_t ts1, int64_t ts2,

1090 struct sbg_script_synth *s1,

1091 struct sbg_script_synth *s2,

1092 int transition)

1093 {

1094 int r;

1095

1096 if (ts2 <= ts1 || (s1->vol == 0 && s2->vol == 0))

1097 return 0;

1098 switch (s1->type) {

1099 case SBG_TYPE_NONE:

1100 break;

1101 case SBG_TYPE_SINE:

1102 if (s1->beat == 0 && s2->beat == 0) {

1103 r = add_interval(inter, WS_SINE, 3, s1->ref.l,

1104 ts1, s1->carrier, s1->vol,

1105 ts2, s2->carrier, s2->vol);

1106 if (r < 0)

1107 return r;

1108 s2->ref.l = s2->ref.r = r;

1109 } else {

1110 r = add_interval(inter, WS_SINE, 1, s1->ref.l,

1111 ts1, s1->carrier + s1->beat / 2, s1->vol,

1112 ts2, s2->carrier + s2->beat / 2, s2->vol);

1113 if (r < 0)

1114 return r;

1115 s2->ref.l = r;

1116 r = add_interval(inter, WS_SINE, 2, s1->ref.r,

1117 ts1, s1->carrier - s1->beat / 2, s1->vol,

1118 ts2, s2->carrier - s2->beat / 2, s2->vol);

1119 if (r < 0)

1120 return r;

1121 s2->ref.r = r;

1122 }

1123 break;

1124

1125 case SBG_TYPE_BELL:

1126 if (transition == 2) {

1127 r = add_bell(inter, s, ts1, ts2, s1->carrier, s2->vol);

1128 if (r < 0)

1129 return r;

1130 }

1131 break;

1132

1133 case SBG_TYPE_SPIN:

1134 av_log(log, AV_LOG_WARNING, "Spinning noise not implemented, "

1135 "using pink noise instead.\n");

1136 /* fall through */

1137 case SBG_TYPE_NOISE:

1138 /* SBaGen's pink noise generator uses:

1139 - 1 band of white noise, mean square: 1/3;

1140 - 9 bands of subsampled white noise with linear

1141 interpolation, mean square: 2/3 each;

1142 with 1/10 weight each: the total mean square is 7/300.

1143 Our pink noise generator uses 8 bands of white noise with

1144 rectangular subsampling: the total mean square is 1/24.

1145 Therefore, to match SBaGen's volume, we must multiply vol by

1146 sqrt((7/300) / (1/24)) = sqrt(14/25) =~ 0.748

1147 */

1148 r = add_interval(inter, WS_NOISE, 3, s1->ref.l,

1149 ts1, 0, s1->vol - s1->vol / 4,

1150 ts2, 0, s2->vol - s2->vol / 4);

1151 if (r < 0)

1152 return r;

1153 s2->ref.l = s2->ref.r = r;

1154 break;

1155

1156 case SBG_TYPE_MIX:

1157 /* Unimplemented: silence; warning present elsewhere */

1158 default:

1159 av_log(log, AV_LOG_ERROR,

1160 "Type %d is not implemented\n", s1->type);

1161 return AVERROR_PATCHWELCOME;

1162 }

1163 return 0;

1164 }

1165

1166 static int generate_plateau(void *log, struct sbg_script *s,

1167 struct ws_intervals *inter,

1168 struct sbg_script_event *ev1)

1169 {

1170 int64_t ts1 = ev1->ts_int, ts2 = ev1->ts_trans;

1171 int i, r;

1172 struct sbg_script_synth *s1;

1173

1174 for (i = 0; i < ev1->nb_elements; i++) {

1175 s1 = &s->synth[ev1->elements + i];

1176 r = generate_interval(log, s, inter, ts1, ts2, s1, s1, 0);

1177 if (r < 0)

1178 return r;

1179 }

1180 return 0;

1181 }

1182

1183 /*

1184

1185 ts1 ts2 ts1 tsmid ts2

1186 | | | | |

1187 v v v | v

1188 ____ ____ v ____

1189 ''''.... ''.. ..''

1190 ''''....____ ''....''

1191

1192 compatible transition incompatible transition

1193 */

1194

1195 static int generate_transition(void *log, struct sbg_script *s,

1196 struct ws_intervals *inter,

1197 struct sbg_script_event *ev1,

1198 struct sbg_script_event *ev2)

1199 {

1200 int64_t ts1 = ev1->ts_trans, ts2 = ev1->ts_next;

1201 /* (ts1 + ts2) / 2 without overflow */

1202 int64_t tsmid = (ts1 >> 1) + (ts2 >> 1) + (ts1 & ts2 & 1);

1203 enum sbg_fade_type type = ev1->fade.slide | (ev1->fade.out & ev2->fade.in);

1204 int nb_elements = FFMAX(ev1->nb_elements, ev2->nb_elements);

1205 struct sbg_script_synth *s1, *s2, s1mod, s2mod, smid;

1206 int pass, i, r;

1207

1208 for (pass = 0; pass < 2; pass++) {

1209 /* pass = 0 -> compatible and first half of incompatible

1210 pass = 1 -> second half of incompatible

1211 Using two passes like that ensures that the intervals are generated

1212 in increasing order according to their start timestamp.

1213 Otherwise it would be necessary to sort them

1214 while keeping the mutual references.

1215 */

1216 for (i = 0; i < nb_elements; i++) {

1217 s1 = i < ev1->nb_elements ? &s->synth[ev1->elements + i] : &s1mod;

1218 s2 = i < ev2->nb_elements ? &s->synth[ev2->elements + i] : &s2mod;

1219 s1mod = s1 != &s1mod ? *s1 : (struct sbg_script_synth){ 0 };

1220 s2mod = s2 != &s2mod ? *s2 : (struct sbg_script_synth){ 0 };

1221 if (ev1->fade.slide) {

1222 /* for slides, and only for slides, silence ("-") is equivalent

1223 to anything with volume 0 */

1224 if (s1mod.type == SBG_TYPE_NONE) {

1225 s1mod = s2mod;

1226 s1mod.vol = 0;

1227 } else if (s2mod.type == SBG_TYPE_NONE) {

1228 s2mod = s1mod;

1229 s2mod.vol = 0;

1230 }

1231 }

1232 if (s1mod.type == s2mod.type &&

1233 s1mod.type != SBG_TYPE_BELL &&

1234 (type == SBG_FADE_ADAPT ||

1235 (s1mod.carrier == s2mod.carrier &&

1236 s1mod.beat == s2mod.beat))) {

1237 /* compatible: single transition */

1238 if (!pass) {

1239 r = generate_interval(log, s, inter,

1240 ts1, ts2, &s1mod, &s2mod, 3);

1241 if (r < 0)

1242 return r;

1243 s2->ref = s2mod.ref;

1244 }

1245 } else {

1246 /* incompatible: silence at midpoint */

1247 if (!pass) {

1248 smid = s1mod;

1249 smid.vol = 0;

1250 r = generate_interval(log, s, inter,

1251 ts1, tsmid, &s1mod, &smid, 1);

1252 if (r < 0)

1253 return r;

1254 } else {

1255 smid = s2mod;

1256 smid.vol = 0;

1257 r = generate_interval(log, s, inter,

1258 tsmid, ts2, &smid, &s2mod, 2);

1259 if (r < 0)

1260 return r;

1261 s2->ref = s2mod.ref;

1262 }

1263 }

1264 }

1265 }

1266 return 0;

1267 }

1268

1269 /*

1270 ev1 trats ev2 intts endts ev3

1271 | | | | | |

1272 v v v v v v

1273 ________________

1274 .... .... ....

1275 '''....________________....''' '''...._______________

1276

1277 \_________/\______________/\_________/\______________/\_________/\_____________/

1278 tr x->1 int1 tr 1->2 int2 tr 2->3 int3

1279 */

1280

1281 static int generate_intervals(void *log, struct sbg_script *s, int sample_rate,

1282 struct ws_intervals *inter)

1283 {

1284 int64_t trans_time = s->opt_fade_time / 2;

1285 struct sbg_script_event ev0, *ev1, *ev2;

1286 int64_t period;

1287 int i, r;

1288

1289 /* SBaGen handles the time before and after the extremal events,

1290 and the corresponding transitions, as if the sequence were cyclic

1291 with a 24-hours period. */

1292 period = s->events[s->nb_events - 1].ts - s->events[0].ts;

1293 period = (period + (DAY_TS - 1)) / DAY_TS * DAY_TS;

1294 period = FFMAX(period, DAY_TS);

1295

1296 /* Prepare timestamps for transitions */

1297 for (i = 0; i < s->nb_events; i++) {

1298 ev1 = &s->events[i];

1299 ev2 = &s->events[(i + 1) % s->nb_events];

1300 ev1->ts_int = ev1->ts;

1301

1302 if (!ev1->fade.slide && ev1 >= ev2 && ev2->ts > INT64_MAX - period)

1303 return AVERROR_INVALIDDATA;

1304

1305 ev1->ts_trans = ev1->fade.slide ? ev1->ts

1306 : ev2->ts + (ev1 < ev2 ? 0 : period);

1307 }

1308 for (i = 0; i < s->nb_events; i++) {

1309 ev1 = &s->events[i];

1310 ev2 = &s->events[(i + 1) % s->nb_events];

1311 if (!ev1->fade.slide) {

1312 ev1->ts_trans = FFMAX(ev1->ts_int, ev1->ts_trans - trans_time);

1313 ev2->ts_int = FFMIN(ev2->ts_trans, ev2->ts_int + trans_time);

1314 }

1315 ev1->ts_next = ev2->ts_int + (ev1 < ev2 ? 0 : period);

1316 }

1317

1318 /* Pseudo event before the first one */

1319 ev0 = s->events[s->nb_events - 1];

1320 ev0.ts_int -= period;

1321 ev0.ts_trans -= period;

1322 ev0.ts_next -= period;

1323

1324 /* Convert timestamps */

1325 for (i = -1; i < s->nb_events; i++) {

1326 ev1 = i < 0 ? &ev0 : &s->events[i];

1327 ev1->ts_int = av_rescale(ev1->ts_int, sample_rate, AV_TIME_BASE);

1328 ev1->ts_trans = av_rescale(ev1->ts_trans, sample_rate, AV_TIME_BASE);

1329 ev1->ts_next = av_rescale(ev1->ts_next, sample_rate, AV_TIME_BASE);

1330 }

1331

1332 /* Generate intervals */

1333 for (i = 0; i < s->nb_synth; i++)

1334 s->synth[i].ref.l = s->synth[i].ref.r = -1;

1335 for (i = -1; i < s->nb_events; i++) {

1336 ev1 = i < 0 ? &ev0 : &s->events[i];

1337 ev2 = &s->events[(i + 1) % s->nb_events];

1338 r = generate_plateau(log, s, inter, ev1);

1339 if (r < 0)

1340 return r;

1341 r = generate_transition(log, s, inter, ev1, ev2);

1342 if (r < 0)

1343 return r;

1344 }

1345 if (!inter->nb_inter)

1346 av_log(log, AV_LOG_WARNING, "Completely silent script.\n");

1347 return 0;

1348 }

1349

1350 static int encode_intervals(struct sbg_script *s, AVCodecParameters *par,

1351 struct ws_intervals *inter)

1352 {

1353 int i, edata_size = 4, ret;

1354 uint8_t *edata;

1355

1356 for (i = 0; i < inter->nb_inter; i++) {

1357 edata_size += inter->inter[i].type == WS_SINE ? 44 :

1358 inter->inter[i].type == WS_NOISE ? 32 : 0;

1359 if (edata_size < 0)

1360 return AVERROR(ENOMEM);

1361 }

1362 if ((ret = ff_alloc_extradata(par, edata_size)) < 0)

1363 return ret;

1364 edata = par->extradata;

1365

1366 #define ADD_EDATA32(v) do { AV_WL32(edata, (v)); edata += 4; } while(0)

1367 #define ADD_EDATA64(v) do { AV_WL64(edata, (v)); edata += 8; } while(0)

1368 ADD_EDATA32(inter->nb_inter);

1369 for (i = 0; i < inter->nb_inter; i++) {

1370 ADD_EDATA64(inter->inter[i].ts1);

1371 ADD_EDATA64(inter->inter[i].ts2);

1372 ADD_EDATA32(inter->inter[i].type);

1373 ADD_EDATA32(inter->inter[i].channels);

1374 switch (inter->inter[i].type) {

1375 case WS_SINE:

1376 ADD_EDATA32(inter->inter[i].f1);

1377 ADD_EDATA32(inter->inter[i].f2);

1378 ADD_EDATA32(inter->inter[i].a1);

1379 ADD_EDATA32(inter->inter[i].a2);

1380 ADD_EDATA32(inter->inter[i].phi);

1381 break;

1382 case WS_NOISE:

1383 ADD_EDATA32(inter->inter[i].a1);

1384 ADD_EDATA32(inter->inter[i].a2);

1385 break;

1386 }

1387 }

1388 if (edata != par->extradata + edata_size)

1389 return AVERROR_BUG;

1390 return 0;

1391 }

1392

1393 static av_cold int sbg_read_probe(const AVProbeData *p)

1394 {

1395 int r, score;

1396 struct sbg_script script = { 0 };

1397

1398 r = parse_script(NULL, p->buf, p->buf_size, &script);

1399 score = r < 0 || !script.nb_def || !script.nb_tseq ? 0 :

1400 AVPROBE_SCORE_MAX / 3;

1401 free_script(&script);

1402 return score;

1403 }

1404

1405 static av_cold int sbg_read_header(AVFormatContext *avf)

1406 {

1407 struct sbg_demuxer *sbg = avf->priv_data;

1408 int r;

1409 char *buf = NULL;

1410 struct sbg_script script = { 0 };

1411 AVStream *st;

1412 FFStream *sti;

1413 struct ws_intervals inter = { 0 };

1414

1415 r = read_whole_file(avf->pb, sbg->max_file_size, &buf);

1416 if (r < 0)

1417 goto fail;

1418 r = parse_script(avf, buf, r, &script);

1419 if (r < 0)

1420 goto fail;

1421 if (!sbg->sample_rate)

1422 sbg->sample_rate = script.sample_rate;

1423 else

1424 script.sample_rate = sbg->sample_rate;

1425 if (!sbg->frame_size)

1426 sbg->frame_size = FFMAX(1, sbg->sample_rate / 10);

1427 if (script.opt_mix)

1428 av_log(avf, AV_LOG_WARNING, "Mix feature not implemented: "

1429 "-m is ignored and mix channels will be silent.\n");

1430 r = expand_script(avf, &script);

1431 if (r < 0)

1432 goto fail;

1433 av_freep(&buf);

1434 r = generate_intervals(avf, &script, sbg->sample_rate, &inter);

1435 if (r < 0)

1436 goto fail;

1437

1438 if (script.end_ts != AV_NOPTS_VALUE && script.end_ts < script.start_ts) {

1439 r = AVERROR_INVALIDDATA;

1440 goto fail;

1441 }

1442

1443 st = avformat_new_stream(avf, NULL);

1444 if (!st)

1445 return AVERROR(ENOMEM);

1446 sti = ffstream(st);

1447 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

1448 st->codecpar->codec_id = AV_CODEC_ID_FFWAVESYNTH;

1449 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;

1450 st->codecpar->sample_rate = sbg->sample_rate;

1451 st->codecpar->frame_size = sbg->frame_size;

1452 avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);

1453 sti->probe_packets = 0;

1454 st->start_time = av_rescale(script.start_ts,

1455 sbg->sample_rate, AV_TIME_BASE);

1456 st->duration = script.end_ts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :

1457 av_rescale(script.end_ts - script.start_ts,

1458 sbg->sample_rate, AV_TIME_BASE);

1459 sti->cur_dts = st->start_time;

1460 r = encode_intervals(&script, st->codecpar, &inter);

1461 if (r < 0)

1462 goto fail;

1463

1464 av_free(inter.inter);

1465 free_script(&script);

1466 return 0;

1467

1468 fail:

1469 av_free(inter.inter);

1470 free_script(&script);

1471 av_free(buf);

1472 return r;

1473 }

1474

1475 static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)

1476 {

1477 int64_t ts, end_ts;

1478 int ret;

1479

1480 ts = ffstream(avf->streams[0])->cur_dts;

1481 end_ts = ts + avf->streams[0]->codecpar->frame_size;

1482 if (avf->streams[0]->duration != AV_NOPTS_VALUE)

1483 end_ts = FFMIN(avf->streams[0]->start_time + avf->streams[0]->duration,

1484 end_ts);

1485 if (end_ts <= ts)

1486 return AVERROR_EOF;

1487 if ((ret = av_new_packet(packet, 12)) < 0)

1488 return ret;

1489 packet->dts = packet->pts = ts;

1490 packet->duration = end_ts - ts;

1491 AV_WL64(packet->data + 0, ts);

1492 AV_WL32(packet->data + 8, packet->duration);

1493 return packet->size;

1494 }

1495

1496 static int sbg_read_seek2(AVFormatContext *avf, int stream_index,

1497 int64_t min_ts, int64_t ts, int64_t max_ts, int flags)

1498 {

1499 if (flags || stream_index > 0)

1500 return AVERROR(EINVAL);

1501 if (stream_index < 0)

1502 ts = av_rescale_q(ts, AV_TIME_BASE_Q, avf->streams[0]->time_base);

1503 ffstream(avf->streams[0])->cur_dts = ts;

1504 return 0;

1505 }

1506

1507 static int sbg_read_seek(AVFormatContext *avf, int stream_index,

1508 int64_t ts, int flags)

1509 {

1510 return sbg_read_seek2(avf, stream_index, ts, ts, ts, 0);

1511 }

1512

1513 static const AVOption sbg_options[] = {

1514 { "sample_rate", "", offsetof(struct sbg_demuxer, sample_rate),

1515 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,

1516 AV_OPT_FLAG_DECODING_PARAM },

1517 { "frame_size", "", offsetof(struct sbg_demuxer, frame_size),

1518 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,

1519 AV_OPT_FLAG_DECODING_PARAM },

1520 { "max_file_size", "", offsetof(struct sbg_demuxer, max_file_size),

1521 AV_OPT_TYPE_INT, { .i64 = 5000000 }, 0, INT_MAX,

1522 AV_OPT_FLAG_DECODING_PARAM },

1523 { NULL },

1524 };

1525

1526 static const AVClass sbg_demuxer_class = {

1527 .class_name = "sbg_demuxer",

1528 .item_name = av_default_item_name,

1529 .option = sbg_options,

1530 .version = LIBAVUTIL_VERSION_INT,

1531 };

1532

1533 const AVInputFormat ff_sbg_demuxer = {

1534 .name = "sbg",

1535 .long_name = NULL_IF_CONFIG_SMALL("SBaGen binaural beats script"),

1536 .priv_data_size = sizeof(struct sbg_demuxer),

1537 .read_probe = sbg_read_probe,

1538 .read_header = sbg_read_header,

1539 .read_packet = sbg_read_packet,

1540 .read_seek = sbg_read_seek,

1541 .read_seek2 = sbg_read_seek2,

1542 .extensions = "sbg",

1543 .priv_class = &sbg_demuxer_class,

1544 };

ws_interval::phi

uint64_t phi

Definition: ffwavesynth.c:87

sbg_script_synth::beat

int beat

Definition: sbgdec.c:84

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

sbg_parser::script

char * script

Definition: sbgdec.c:129

ws_interval::type

enum ws_interval_type type

Definition: ffwavesynth.c:89

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AVCodecParameters::extradata

uint8_t * extradata

Extra binary data needed for initializing the decoder, codec-dependent.

Definition: codec_par.h:75

name

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 name

Definition: writing_filters.txt:88

parse_synth_channel

static int parse_synth_channel(struct sbg_parser *p)

Definition: sbgdec.c:713

const char * r

Definition: vf_curves.c:116

AVERROR

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

opt.h

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)

Add a new stream to a media file.

Definition: options.c:237

scale_double

static int scale_double(void *log, double d, double m, int *r)

Definition: sbgdec.c:212

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:57

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:426

str_to_time

static int str_to_time(const char *str, int64_t *rtime)

Definition: sbgdec.c:179

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:53

sbg_parser::nb_block_tseq

int nb_block_tseq

Definition: sbgdec.c:133

strtod

double strtod(const char *, char **)

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

sbg_script::nb_tseq

int nb_tseq

Definition: sbgdec.c:114

SBG_TYPE_NONE

@ SBG_TYPE_NONE

Definition: sbgdec.c:60

sbg_script_synth::carrier

int carrier

Definition: sbgdec.c:83

sbg_script_event::ts_next

int64_t ts_next

Definition: sbgdec.c:102

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:260

sbg_script_tseq::ts

struct sbg_timestamp ts

Definition: sbgdec.c:93

lex_char

static int lex_char(struct sbg_parser *p, char c)

Definition: sbgdec.c:233

parse_synth_channel_pink

static int parse_synth_channel_pink(struct sbg_parser *p, struct sbg_script_synth *synth)

Definition: sbgdec.c:645

expand_timestamps

static int expand_timestamps(void *log, struct sbg_script *s)

Definition: sbgdec.c:895

sbg_script::block_tseq

struct sbg_script_tseq * block_tseq

Definition: sbgdec.c:111

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1281

AVPacket::data

uint8_t * data

Definition: packet.h:374

sbg_script::end_ts

int64_t end_ts

Definition: sbgdec.c:118

AVOption

AVOption.

Definition: opt.h:251

#define t0

Definition: regdef.h:28

sbg_parser::current_time

struct sbg_timestamp current_time

Definition: sbgdec.c:132

sbg_script_synth::ref

struct sbg_script_synth::@291 ref

sbg_parser::log

void * log

Definition: sbgdec.c:128

lex_time

static int lex_time(struct sbg_parser *p, int64_t *rt)

Definition: sbgdec.c:311

sbg_fade::in

int8_t in

Definition: sbgdec.c:56

sbg_read_seek2

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:1496

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:392

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:354

ws_intervals::nb_inter

int nb_inter

Definition: sbgdec.c:155

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:456

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ws_intervals::inter

struct ws_interval * inter

Definition: sbgdec.c:154

sbg_script_definition::name

char * name

Definition: sbgdec.c:76

is_space

static int is_space(char c)

Definition: sbgdec.c:207

sample_rate

Definition: ffmpeg_filter.c:153

sbg_script_event

Definition: sbgdec.c:100

sbg_string

Definition: sbgdec.c:44

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

SBG_TYPE_NOISE

@ SBG_TYPE_NOISE

Definition: sbgdec.c:62

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:465

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:697

ff_sbg_demuxer

const AVInputFormat ff_sbg_demuxer

Definition: sbgdec.c:1533

sbg_parser

Definition: sbgdec.c:127

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:407

SBG_TYPE_SINE

@ SBG_TYPE_SINE

Definition: sbgdec.c:61

fail

#define fail()

Definition: checkasm.h:131

sbg_parser::err_msg

char err_msg[128]

Definition: sbgdec.c:136

sbg_script_tseq

Definition: sbgdec.c:92

sbg_read_packet

static int sbg_read_packet(AVFormatContext *avf, AVPacket *packet)

Definition: sbgdec.c:1475

sbg_script::opt_duration

int64_t opt_duration

Definition: sbgdec.c:120

sbg_script::nb_events

int nb_events

Definition: sbgdec.c:115

sbg_script_synth::r

int r

Definition: sbgdec.c:88

ws_interval::ts2

int64_t ts2

Definition: sbgdec.c:145

sbg_script_definition::type

char type

Definition: sbgdec.c:79

type

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 type

Definition: writing_filters.txt:86

sbg_timestamp::type

char type

Definition: sbgdec.c:72

sbg_fade

Definition: sbgdec.c:55

sbg_demuxer::max_file_size

int max_file_size

Definition: sbgdec.c:41

AVStream::duration

int64_t duration

Decoding: duration of the stream, in stream time base.

Definition: avformat.h:998

ws_interval::phi

uint32_t phi

Definition: sbgdec.c:150

AV_CODEC_ID_FFWAVESYNTH

@ AV_CODEC_ID_FFWAVESYNTH

Definition: codec_id.h:495

sbg_script::nb_def

int nb_def

Definition: sbgdec.c:113

sbg_script::synth

struct sbg_script_synth * synth

Definition: sbgdec.c:109

#define a1

Definition: regdef.h:47

sbg_script_synth

Definition: sbgdec.c:82

lex_space

static int lex_space(struct sbg_parser *p)

Definition: sbgdec.c:224

add_interval

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:1025

read_whole_file

static int read_whole_file(AVIOContext *io, int max_size, char **rbuf)

Definition: sbgdec.c:862

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

AVInputFormat

Definition: avformat.h:656

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

generate_plateau

static int generate_plateau(void *log, struct sbg_script *s, struct ws_intervals *inter, struct sbg_script_event *ev1)

Definition: sbgdec.c:1166

AVCodecParameters::frame_size

int frame_size

Audio only.

Definition: codec_par.h:188

expand_tseq

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:955

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:256

av_new_packet

int av_new_packet(AVPacket *pkt, int size)

Allocate the payload of a packet and initialize its fields with default values.

Definition: avpacket.c:97

ws_interval::f2

int32_t f2

Definition: sbgdec.c:148

parse_wave_def

static int parse_wave_def(struct sbg_parser *p, int wavenum)

Definition: sbgdec.c:575

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:661

sbg_script_definition

Definition: sbgdec.c:75

sbg_script_synth::type

enum sbg_synth_type type

Definition: sbgdec.c:86

FORWARD_ERROR

#define FORWARD_ERROR(c)

Definition: sbgdec.c:318

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:455

frame_size

int frame_size

Definition: mxfenc.c:2201

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

#define s1

Definition: regdef.h:38

sbg_script::opt_fade_time

int64_t opt_fade_time

Definition: sbgdec.c:119

lex_name

static int lex_name(struct sbg_parser *p, struct sbg_string *rs)

Definition: sbgdec.c:297

sbg_fade::out

int8_t out

Definition: sbgdec.c:56

ctx

AVFormatContext * ctx

Definition: movenc.c:48

parse_optarg

static int parse_optarg(struct sbg_parser *p, char o, struct sbg_string *r)

Definition: sbgdec.c:339

channels

Definition: aptx.h:32

av_rescale_q

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

sbg_options

static const AVOption sbg_options[]

Definition: sbgdec.c:1513

lex_fixed

static int lex_fixed(struct sbg_parser *p, const char *t, int l)

Definition: sbgdec.c:257

sbg_script_event::ts_trans

int64_t ts_trans

Definition: sbgdec.c:102

sbg_script::tseq

struct sbg_script_tseq * tseq

Definition: sbgdec.c:110

pass

#define pass

Definition: fft_template.c:608

sbg_script_definition::nb_elements

int nb_elements

Definition: sbgdec.c:78

SBG_TYPE_BELL

@ SBG_TYPE_BELL

Definition: sbgdec.c:63

sbg_read_seek

static int sbg_read_seek(AVFormatContext *avf, int stream_index, int64_t ts, int flags)

Definition: sbgdec.c:1507

time_internal.h

if(ret)

Definition: filter_design.txt:179

ws_interval::a2

int32_t a2

Definition: sbgdec.c:149

AVFormatContext

Format I/O context.

Definition: avformat.h:1213

av_realloc_f

#define av_realloc_f(p, o, n)

Definition: tableprint_vlc.h:32

parse_synth_channel_sine

static int parse_synth_channel_sine(struct sbg_parser *p, struct sbg_script_synth *synth)

Definition: sbgdec.c:624

internal.h

parse_synth_channel_spin

static int parse_synth_channel_spin(struct sbg_parser *p, struct sbg_script_synth *synth)

Definition: sbgdec.c:690

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1108

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

sbg_demuxer

Definition: sbgdec.c:37

generate_intervals

static int generate_intervals(void *log, struct sbg_script *s, int sample_rate, struct ws_intervals *inter)

Definition: sbgdec.c:1281

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

AVStream::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avformat.h:978

WS_NOISE

@ WS_NOISE

Definition: sbgdec.c:141

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

read_probe

static int read_probe(const AVProbeData *pd)

Definition: jvdec.c:55

sbg_script::def

struct sbg_script_definition * def

Definition: sbgdec.c:108

sbg_script_tseq::lock

int lock

Definition: sbgdec.c:96

SBG_TYPE_SPIN

@ SBG_TYPE_SPIN

Definition: sbgdec.c:65

period

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

Definition: writing_filters.txt:89

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1255

lex_wsword

static int lex_wsword(struct sbg_parser *p, struct sbg_string *rs)

Definition: sbgdec.c:283

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:453

parse_script

static int parse_script(void *log, char *script, int script_len, struct sbg_script *rscript)

Definition: sbgdec.c:800

sbg_demuxer_class

static const AVClass sbg_demuxer_class

Definition: sbgdec.c:1526

sbg_script::events

struct sbg_script_event * events

Definition: sbgdec.c:112

time.h

abs

#define abs(x)

Definition: cuda_runtime.h:35

sbg_script_event::fade

struct sbg_fade fade

Definition: sbgdec.c:104

parse_fade

static int parse_fade(struct sbg_parser *p, struct sbg_fade *fr)

Definition: sbgdec.c:495

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:212

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

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:177

#define s2

Definition: regdef.h:39

parse_named_def

static int parse_named_def(struct sbg_parser *p)

Definition: sbgdec.c:763

Definition: af_crystalizer.c:122

AVIOContext

Bytestream IO Context.

Definition: avio.h:162

AVPacket::size

int size

Definition: packet.h:375

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:290

FFStream

Definition: internal.h:197

sbg_fade_type

Definition: sbgdec.c:49

localtime_r

#define localtime_r

Definition: time_internal.h:46

sbg_script::nb_synth

int nb_synth

Definition: sbgdec.c:116

parse_synth_channel_bell

static int parse_synth_channel_bell(struct sbg_parser *p, struct sbg_script_synth *synth)

Definition: sbgdec.c:658

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

#define sp

Definition: regdef.h:63

sbg_script::opt_mix

char * opt_mix

Definition: sbgdec.c:121

add_bell

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:1059

ADD_EDATA64

#define ADD_EDATA64(v)

size

int size

Definition: twinvq_data.h:10344

ws_interval::channels

uint32_t channels

Definition: ffwavesynth.c:88

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

WS_SINE

@ WS_SINE

Definition: sbgdec.c:140

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:373

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:41

AV_WL64

#define AV_WL64(p, v)

Definition: intreadwrite.h:440

sbg_fade::slide

int8_t slide

Definition: sbgdec.c:56

parse_time_sequence

static int parse_time_sequence(struct sbg_parser *p, int inblock)

Definition: sbgdec.c:519

sbg_parser::end

char * end

Definition: sbgdec.c:129

FFStream::probe_packets

int probe_packets

Number of packets to buffer for codec probing.

Definition: internal.h:377

sbg_string::s

char * s

Definition: sbgdec.c:45

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

sbg_timestamp

Definition: sbgdec.c:70

sbg_read_header

static av_cold int sbg_read_header(AVFormatContext *avf)

Definition: sbgdec.c:1405

parse_block_def

static int parse_block_def(struct sbg_parser *p, struct sbg_script_definition *def)

Definition: sbgdec.c:582

log.h

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:367

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:254

sbg_synth_type

Definition: sbgdec.c:59

sbg_script_definition::name_len

int name_len

Definition: sbgdec.c:77

sbg_parser::cursor

char * cursor

Definition: sbgdec.c:130

sbg_script_event::ts

int64_t ts

Definition: sbgdec.c:101

#define a2

Definition: regdef.h:48

delta

float delta

Definition: vorbis_enc_data.h:430

AV_OPT_FLAG_DECODING_PARAM

#define AV_OPT_FLAG_DECODING_PARAM

a generic parameter which can be set by the user for demuxing or decoding

Definition: opt.h:282

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

SBG_FADE_SILENCE

@ SBG_FADE_SILENCE

Definition: sbgdec.c:50

sbg_demuxer::frame_size

int frame_size

Definition: sbgdec.c:40

sbg_script_synth::vol

int vol

Definition: sbgdec.c:85

parse_options

static int parse_options(struct sbg_parser *p)

Definition: sbgdec.c:349

ws_interval

Definition: ffwavesynth.c:83

parse_volume

static int parse_volume(struct sbg_parser *p, int *vol)

Definition: sbgdec.c:611

fade

static void fade(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, int width, int height, int alpha, int beta)

Definition: vp8.c:496

av_rescale

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

sbg_parser::nb_block_tseq_max

int nb_block_tseq_max

Definition: sbgdec.c:134

sbg_script_event::nb_elements

int nb_elements

Definition: sbgdec.c:103

parse_immediate

static int parse_immediate(struct sbg_parser *p)

Definition: sbgdec.c:325

ws_intervals::max_inter

int max_inter

Definition: sbgdec.c:156

sbg_demuxer::sample_rate

int sample_rate

Definition: sbgdec.c:39

ws_interval::f1

int32_t f1

Definition: sbgdec.c:148

array

static int array[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:111

parse_timestamp

static int parse_timestamp(struct sbg_parser *p, struct sbg_timestamp *rts, int64_t *rrel)

Definition: sbgdec.c:462

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:948

AVClass::class_name

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:71

parse_synth_def

static int parse_synth_def(struct sbg_parser *p, struct sbg_script_definition *def)

Definition: sbgdec.c:739

avformat.h

sbg_parser::line_no

int line_no

Definition: sbgdec.c:135

av_sat_add64

#define av_sat_add64

Definition: common.h:137

sbg_read_probe

static av_cold int sbg_read_probe(const AVProbeData *p)

Definition: sbgdec.c:1393

sbg_parser::nb_def_max

int nb_def_max

Definition: sbgdec.c:134

sbg_parser::nb_tseq_max

int nb_tseq_max

Definition: sbgdec.c:134

channel_layout.h

generate_transition

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:1195

sbg_script_tseq::name

char * name

Definition: sbgdec.c:94

sbg_script_event::ts_int

int64_t ts_int

Definition: sbgdec.c:102

sbg_script_synth::l

int l

Definition: sbgdec.c:88

mode

Definition: ebur128.h:83

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:225

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:641

DAY

#define DAY

Definition: sbgdec.c:34

DAY_TS

#define DAY_TS

Definition: sbgdec.c:35

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:112

sbg_script

Definition: sbgdec.c:107

sbg_script_definition::elements

int elements

Definition: sbgdec.c:78

SBG_SCALE

#define SBG_SCALE

Definition: sbgdec.c:33

SBG_FADE_ADAPT

@ SBG_FADE_ADAPT

Definition: sbgdec.c:52

sbg_script::opt_start_at_first

uint8_t opt_start_at_first

Definition: sbgdec.c:123

ws_intervals

Definition: sbgdec.c:153

sbg_script::opt_end_at_last

uint8_t opt_end_at_last

Definition: sbgdec.c:124

sbg_parser::scs

struct sbg_script scs

Definition: sbgdec.c:131

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

free_script

static void free_script(struct sbg_script *s)

Definition: sbgdec.c:790

sbg_script_event::elements

int elements

Definition: sbgdec.c:103

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:61

alloc_array_elem

static void * alloc_array_elem(void **array, size_t elsize, int *size, int *max_size)

Definition: sbgdec.c:159

AVPacket

This structure stores compressed data.

Definition: packet.h:351

sbg_script_tseq::name_len

int name_len

Definition: sbgdec.c:95

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

FFStream::cur_dts

int64_t cur_dts

Definition: internal.h:404

sbg_parser::nb_synth_max

int nb_synth_max

Definition: sbgdec.c:134

Definition: ffmpeg_filter.c:153

int32_t

Definition: audioconvert.c:56

convert_header.str

string str

Definition: convert_header.py:20

sbg_string::e

char * e

Definition: sbgdec.c:46

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:561

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:52

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

parse_preprogrammed

static int parse_preprogrammed(struct sbg_parser *p)

Definition: sbgdec.c:332

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

ws_interval::a1

int32_t a1

Definition: sbgdec.c:149

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

AVStream::start_time

int64_t start_time

Decoding: pts of the first frame of the stream in presentation order, in stream time base.

Definition: avformat.h:988

SBG_TYPE_MIX

@ SBG_TYPE_MIX

Definition: sbgdec.c:64

SBG_FADE_SAME

@ SBG_FADE_SAME

Definition: sbgdec.c:51

ws_interval::ts1

int64_t ts1

Definition: sbgdec.c:145

ADD_EDATA32

#define ADD_EDATA32(v)

sbg_script::start_ts

int64_t start_ts

Definition: sbgdec.c:117

encode_intervals

static int encode_intervals(struct sbg_script *s, AVCodecParameters *par, struct ws_intervals *inter)

Definition: sbgdec.c:1350

sbg_timestamp::t

int64_t t

Definition: sbgdec.c:71

snprintf

#define snprintf

Definition: snprintf.h:34

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1241

lex_line_end

static int lex_line_end(struct sbg_parser *p)

Definition: sbgdec.c:265

lex_double

static int lex_double(struct sbg_parser *p, double *r)

Definition: sbgdec.c:241

parse_synth_channel_mix

static int parse_synth_channel_mix(struct sbg_parser *p, struct sbg_script_synth *synth)

Definition: sbgdec.c:677

sbg_script::sample_rate

int sample_rate

Definition: sbgdec.c:122

av_clipd

Definition: af_crystalizer.c:132

av_x_if_null

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

ws_interval_type

Definition: ffwavesynth.c:78

sbg_script_tseq::fade

struct sbg_fade fade

Definition: sbgdec.c:97

ff_alloc_extradata

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:238

expand_script

static int expand_script(void *log, struct sbg_script *s)

Definition: sbgdec.c:1004

generate_interval

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:1087

Generated on Wed Aug 24 2022 21:42:19 for FFmpeg by doxygen 1.8.17