FFmpeg: libavformat/nutdec.c Source File

FFmpeg

[フレーム]

libavformat

nutdec.c

Go to the documentation of this file.

1 /*

2 * "NUT" Container Format demuxer

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include "libavutil/avstring.h"

24 #include "libavutil/avassert.h"

25 #include "libavutil/bswap.h"

26 #include "libavutil/dict.h"

27 #include "libavutil/mathematics.h"

28 #include "libavutil/tree.h"

29 #include "avio_internal.h"

30 #include "nut.h"

31 #include "riff.h"

33 #define NUT_MAX_STREAMS 256 /* arbitrary sanity check value */

35 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,

36 int64_t *pos_arg, int64_t pos_limit);

38 static int get_str(AVIOContext *bc, char *string, unsigned int maxlen)

39 {

40 unsigned int len = ffio_read_varlen(bc);

42 if (len && maxlen)

43 avio_read(bc, string, FFMIN(len, maxlen));

44 while (len > maxlen) {

45 avio_r8(bc);

46 len--;

47 }

49 if (maxlen)

50 string[FFMIN(len, maxlen - 1)] = 0;

52 if (maxlen == len)

53 return -1;

54 else

55 return 0;

56 }

58 static int64_t get_s(AVIOContext *bc)

59 {

60 int64_t v = ffio_read_varlen(bc) + 1;

62 if (v & 1)

63 return -(v >> 1);

64 else

65 return (v >> 1);

66 }

68 static uint64_t get_fourcc(AVIOContext *bc)

69 {

70 unsigned int len = ffio_read_varlen(bc);

72 if (len == 2)

73 return avio_rl16(bc);

74 else if (len == 4)

75 return avio_rl32(bc);

76 else {

77 av_log(NULL, AV_LOG_ERROR, "Unsupported fourcc length %d\n", len);

78 return -1;

79 }

80 }

82 #ifdef TRACE

83 static inline uint64_t get_v_trace(AVIOContext *bc, const char *file,

84 const char *func, int line)

85 {

86 uint64_t v = ffio_read_varlen(bc);

88 av_log(NULL, AV_LOG_DEBUG, "get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n",

89 v, v, file, func, line);

90 return v;

91 }

93 static inline int64_t get_s_trace(AVIOContext *bc, const char *file,

94 const char *func, int line)

95 {

96 int64_t v = get_s(bc);

98 av_log(NULL, AV_LOG_DEBUG, "get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n",

99 v, v, file, func, line);

100 return v;

101 }

102

103 static inline uint64_t get_4cc_trace(AVIOContext *bc, char *file,

104 char *func, int line)

105 {

106 uint64_t v = get_fourcc(bc);

107

108 av_log(NULL, AV_LOG_DEBUG, "get_fourcc %5"PRId64" / %"PRIX64" in %s %s:%d\n",

109 v, v, file, func, line);

110 return v;

111 }

112 #define ffio_read_varlen(bc) get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)

113 #define get_s(bc) get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)

114 #define get_fourcc(bc) get_4cc_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)

115 #endif

116

117 static int get_packetheader(NUTContext *nut, AVIOContext *bc,

118 int calculate_checksum, uint64_t startcode)

119 {

120 int64_t size;

121 // start = avio_tell(bc) - 8;

122

123 startcode = av_be2ne64(startcode);

124 startcode = ff_crc04C11DB7_update(0, (uint8_t*) &startcode, 8);

125

126 ffio_init_checksum(bc, ff_crc04C11DB7_update, startcode);

127 size = ffio_read_varlen(bc);

128 if (size > 4096)

129 avio_rb32(bc);

130 if (ffio_get_checksum(bc) && size > 4096)

131 return -1;

132

133 ffio_init_checksum(bc, calculate_checksum ? ff_crc04C11DB7_update : NULL, 0);

134

135 return size;

136 }

137

138 static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos)

139 {

140 uint64_t state = 0;

141

142 if (pos >= 0)

143 /* Note, this may fail if the stream is not seekable, but that should

144 * not matter, as in this case we simply start where we currently are */

145 avio_seek(bc, pos, SEEK_SET);

146 while (!url_feof(bc)) {

147 state = (state << 8) | avio_r8(bc);

148 if ((state >> 56) != 'N')

149 continue;

150 switch (state) {

151 case MAIN_STARTCODE:

152 case STREAM_STARTCODE:

153 case SYNCPOINT_STARTCODE:

154 case INFO_STARTCODE:

155 case INDEX_STARTCODE:

156 return state;

157 }

158 }

159

160 return 0;

161 }

162

163 /**

164 * Find the given startcode.

165 * @param code the startcode

166 * @param pos the start position of the search, or -1 if the current position

167 * @return the position of the startcode or -1 if not found

168 */

169 static int64_t find_startcode(AVIOContext *bc, uint64_t code, int64_t pos)

170 {

171 for (;;) {

172 uint64_t startcode = find_any_startcode(bc, pos);

173 if (startcode == code)

174 return avio_tell(bc) - 8;

175 else if (startcode == 0)

176 return -1;

177 pos = -1;

178 }

179 }

180

181 static int nut_probe(AVProbeData *p)

182 {

183 int i;

184 uint64_t code = 0;

185

186 for (i = 0; i < p->buf_size; i++) {

187 code = (code << 8) | p->buf[i];

188 if (code == MAIN_STARTCODE)

189 return AVPROBE_SCORE_MAX;

190 }

191 return 0;

192 }

193

194 #define GET_V(dst, check) \

195 do { \

196 tmp = ffio_read_varlen(bc); \

197 if (!(check)) { \

198 av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp); \

199 return -1; \

200 } \

201 dst = tmp; \

202 } while (0)

203

204 static int skip_reserved(AVIOContext *bc, int64_t pos)

205 {

206 pos -= avio_tell(bc);

207 if (pos < 0) {

208 avio_seek(bc, pos, SEEK_CUR);

209 return -1;

210 } else {

211 while (pos--)

212 avio_r8(bc);

213 return 0;

214 }

215 }

216

217 static int decode_main_header(NUTContext *nut)

218 {

219 AVFormatContext *s = nut->avf;

220 AVIOContext *bc = s->pb;

221 uint64_t tmp, end;

222 unsigned int stream_count;

223 int i, j, count;

224 int tmp_stream, tmp_mul, tmp_pts, tmp_size, tmp_res, tmp_head_idx;

225

226 end = get_packetheader(nut, bc, 1, MAIN_STARTCODE);

227 end += avio_tell(bc);

228

229 GET_V(tmp, tmp >= 2 && tmp <= 3);

230 GET_V(stream_count, tmp > 0 && tmp <= NUT_MAX_STREAMS);

231

232 nut->max_distance = ffio_read_varlen(bc);

233 if (nut->max_distance > 65536) {

234 av_log(s, AV_LOG_DEBUG, "max_distance %d\n", nut->max_distance);

235 nut->max_distance = 65536;

236 }

237

238 GET_V(nut->time_base_count, tmp > 0 && tmp < INT_MAX / sizeof(AVRational));

239 nut->time_base = av_malloc(nut->time_base_count * sizeof(AVRational));

240

241 for (i = 0; i < nut->time_base_count; i++) {

242 GET_V(nut->time_base[i].num, tmp > 0 && tmp < (1ULL << 31));

243 GET_V(nut->time_base[i].den, tmp > 0 && tmp < (1ULL << 31));

244 if (av_gcd(nut->time_base[i].num, nut->time_base[i].den) != 1) {

245 av_log(s, AV_LOG_ERROR, "time base invalid\n");

246 return AVERROR_INVALIDDATA;

247 }

248 }

249 tmp_pts = 0;

250 tmp_mul = 1;

251 tmp_stream = 0;

252 tmp_head_idx = 0;

253 for (i = 0; i < 256;) {

254 int tmp_flags = ffio_read_varlen(bc);

255 int tmp_fields = ffio_read_varlen(bc);

256

257 if (tmp_fields > 0)

258 tmp_pts = get_s(bc);

259 if (tmp_fields > 1)

260 tmp_mul = ffio_read_varlen(bc);

261 if (tmp_fields > 2)

262 tmp_stream = ffio_read_varlen(bc);

263 if (tmp_fields > 3)

264 tmp_size = ffio_read_varlen(bc);

265 else

266 tmp_size = 0;

267 if (tmp_fields > 4)

268 tmp_res = ffio_read_varlen(bc);

269 else

270 tmp_res = 0;

271 if (tmp_fields > 5)

272 count = ffio_read_varlen(bc);

273 else

274 count = tmp_mul - tmp_size;

275 if (tmp_fields > 6)

276 get_s(bc);

277 if (tmp_fields > 7)

278 tmp_head_idx = ffio_read_varlen(bc);

279

280 while (tmp_fields-- > 8)

281 ffio_read_varlen(bc);

282

283 if (count == 0 || i + count > 256) {

284 av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);

285 return AVERROR_INVALIDDATA;

286 }

287 if (tmp_stream >= stream_count) {

288 av_log(s, AV_LOG_ERROR, "illegal stream number\n");

289 return AVERROR_INVALIDDATA;

290 }

291

292 for (j = 0; j < count; j++, i++) {

293 if (i == 'N') {

294 nut->frame_code[i].flags = FLAG_INVALID;

295 j--;

296 continue;

297 }

298 nut->frame_code[i].flags = tmp_flags;

299 nut->frame_code[i].pts_delta = tmp_pts;

300 nut->frame_code[i].stream_id = tmp_stream;

301 nut->frame_code[i].size_mul = tmp_mul;

302 nut->frame_code[i].size_lsb = tmp_size + j;

303 nut->frame_code[i].reserved_count = tmp_res;

304 nut->frame_code[i].header_idx = tmp_head_idx;

305 }

306 }

307 av_assert0(nut->frame_code['N'].flags == FLAG_INVALID);

308

309 if (end > avio_tell(bc) + 4) {

310 int rem = 1024;

311 GET_V(nut->header_count, tmp < 128U);

312 nut->header_count++;

313 for (i = 1; i < nut->header_count; i++) {

314 uint8_t *hdr;

315 GET_V(nut->header_len[i], tmp > 0 && tmp < 256);

316 rem -= nut->header_len[i];

317 if (rem < 0) {

318 av_log(s, AV_LOG_ERROR, "invalid elision header\n");

319 return AVERROR_INVALIDDATA;

320 }

321 hdr = av_malloc(nut->header_len[i]);

322 if (!hdr)

323 return AVERROR(ENOMEM);

324 avio_read(bc, hdr, nut->header_len[i]);

325 nut->header[i] = hdr;

326 }

327 av_assert0(nut->header_len[0] == 0);

328 }

329

330 if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

331 av_log(s, AV_LOG_ERROR, "main header checksum mismatch\n");

332 return AVERROR_INVALIDDATA;

333 }

334

335 nut->stream = av_mallocz(sizeof(StreamContext) * stream_count);

336 for (i = 0; i < stream_count; i++)

337 avformat_new_stream(s, NULL);

338

339 return 0;

340 }

341

342 static int decode_stream_header(NUTContext *nut)

343 {

344 AVFormatContext *s = nut->avf;

345 AVIOContext *bc = s->pb;

346 StreamContext *stc;

347 int class, stream_id;

348 uint64_t tmp, end;

349 AVStream *st;

350

351 end = get_packetheader(nut, bc, 1, STREAM_STARTCODE);

352 end += avio_tell(bc);

353

354 GET_V(stream_id, tmp < s->nb_streams && !nut->stream[tmp].time_base);

355 stc = &nut->stream[stream_id];

356 st = s->streams[stream_id];

357 if (!st)

358 return AVERROR(ENOMEM);

359

360 class = ffio_read_varlen(bc);

361 tmp = get_fourcc(bc);

362 st->codec->codec_tag = tmp;

363 switch (class) {

364 case 0:

365 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

366 st->codec->codec_id = av_codec_get_id((const AVCodecTag * const []) {

367 ff_nut_video_tags,

368 ff_codec_bmp_tags,

369 0

370 },

371 tmp);

372 break;

373 case 1:

374 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

375 st->codec->codec_id = av_codec_get_id((const AVCodecTag * const []) {

376 ff_nut_audio_tags,

377 ff_codec_wav_tags,

378 0

379 },

380 tmp);

381 break;

382 case 2:

383 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

384 st->codec->codec_id = ff_codec_get_id(ff_nut_subtitle_tags, tmp);

385 break;

386 case 3:

387 st->codec->codec_type = AVMEDIA_TYPE_DATA;

388 st->codec->codec_id = ff_codec_get_id(ff_nut_data_tags, tmp);

389 break;

390 default:

391 av_log(s, AV_LOG_ERROR, "unknown stream class (%d)\n", class);

392 return -1;

393 }

394 if (class < 3 && st->codec->codec_id == AV_CODEC_ID_NONE)

395 av_log(s, AV_LOG_ERROR,

396 "Unknown codec tag '0x%04x' for stream number %d\n",

397 (unsigned int) tmp, stream_id);

398

399 GET_V(stc->time_base_id, tmp < nut->time_base_count);

400 GET_V(stc->msb_pts_shift, tmp < 16);

401 stc->max_pts_distance = ffio_read_varlen(bc);

402 GET_V(stc->decode_delay, tmp < 1000); // sanity limit, raise this if Moore's law is true

403 st->codec->has_b_frames = stc->decode_delay;

404 ffio_read_varlen(bc); // stream flags

405

406 GET_V(st->codec->extradata_size, tmp < (1 << 30));

407 if (st->codec->extradata_size) {

408 st->codec->extradata = av_mallocz(st->codec->extradata_size +

409 FF_INPUT_BUFFER_PADDING_SIZE);

410 avio_read(bc, st->codec->extradata, st->codec->extradata_size);

411 }

412

413 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

414 GET_V(st->codec->width, tmp > 0);

415 GET_V(st->codec->height, tmp > 0);

416 st->sample_aspect_ratio.num = ffio_read_varlen(bc);

417 st->sample_aspect_ratio.den = ffio_read_varlen(bc);

418 if ((!st->sample_aspect_ratio.num) != (!st->sample_aspect_ratio.den)) {

419 av_log(s, AV_LOG_ERROR, "invalid aspect ratio %d/%d\n",

420 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);

421 return -1;

422 }

423 ffio_read_varlen(bc); /* csp type */

424 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

425 GET_V(st->codec->sample_rate, tmp > 0);

426 ffio_read_varlen(bc); // samplerate_den

427 GET_V(st->codec->channels, tmp > 0);

428 }

429 if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

430 av_log(s, AV_LOG_ERROR,

431 "stream header %d checksum mismatch\n", stream_id);

432 return -1;

433 }

434 stc->time_base = &nut->time_base[stc->time_base_id];

435 avpriv_set_pts_info(s->streams[stream_id], 63, stc->time_base->num,

436 stc->time_base->den);

437 return 0;

438 }

439

440 static void set_disposition_bits(AVFormatContext *avf, char *value,

441 int stream_id)

442 {

443 int flag = 0, i;

444

445 for (i = 0; ff_nut_dispositions[i].flag; ++i)

446 if (!strcmp(ff_nut_dispositions[i].str, value))

447 flag = ff_nut_dispositions[i].flag;

448 if (!flag)

449 av_log(avf, AV_LOG_INFO, "unknown disposition type '%s'\n", value);

450 for (i = 0; i < avf->nb_streams; ++i)

451 if (stream_id == i || stream_id == -1)

452 avf->streams[i]->disposition |= flag;

453 }

454

455 static int decode_info_header(NUTContext *nut)

456 {

457 AVFormatContext *s = nut->avf;

458 AVIOContext *bc = s->pb;

459 uint64_t tmp, chapter_start, chapter_len;

460 unsigned int stream_id_plus1, count;

461 int chapter_id, i;

462 int64_t value, end;

463 char name[256], str_value[1024], type_str[256];

464 const char *type;

465 AVChapter *chapter = NULL;

466 AVStream *st = NULL;

467 AVDictionary **metadata = NULL;

468

469 end = get_packetheader(nut, bc, 1, INFO_STARTCODE);

470 end += avio_tell(bc);

471

472 GET_V(stream_id_plus1, tmp <= s->nb_streams);

473 chapter_id = get_s(bc);

474 chapter_start = ffio_read_varlen(bc);

475 chapter_len = ffio_read_varlen(bc);

476 count = ffio_read_varlen(bc);

477

478 if (chapter_id && !stream_id_plus1) {

479 int64_t start = chapter_start / nut->time_base_count;

480 chapter = avpriv_new_chapter(s, chapter_id,

481 nut->time_base[chapter_start %

482 nut->time_base_count],

483 start, start + chapter_len, NULL);

484 metadata = &chapter->metadata;

485 } else if (stream_id_plus1) {

486 st = s->streams[stream_id_plus1 - 1];

487 metadata = &st->metadata;

488 } else

489 metadata = &s->metadata;

490

491 for (i = 0; i < count; i++) {

492 get_str(bc, name, sizeof(name));

493 value = get_s(bc);

494 if (value == -1) {

495 type = "UTF-8";

496 get_str(bc, str_value, sizeof(str_value));

497 } else if (value == -2) {

498 get_str(bc, type_str, sizeof(type_str));

499 type = type_str;

500 get_str(bc, str_value, sizeof(str_value));

501 } else if (value == -3) {

502 type = "s";

503 value = get_s(bc);

504 } else if (value == -4) {

505 type = "t";

506 value = ffio_read_varlen(bc);

507 } else if (value < -4) {

508 type = "r";

509 get_s(bc);

510 } else {

511 type = "v";

512 }

513

514 if (stream_id_plus1 > s->nb_streams) {

515 av_log(s, AV_LOG_ERROR, "invalid stream id for info packet\n");

516 continue;

517 }

518

519 if (!strcmp(type, "UTF-8")) {

520 if (chapter_id == 0 && !strcmp(name, "Disposition")) {

521 set_disposition_bits(s, str_value, stream_id_plus1 - 1);

522 continue;

523 }

524

525 if (stream_id_plus1 && !strcmp(name, "r_frame_rate")) {

526 sscanf(str_value, "%d/%d", &st->r_frame_rate.num, &st->r_frame_rate.den);

527 if (st->r_frame_rate.num >= 1000LL*st->r_frame_rate.den)

528 st->r_frame_rate.num = st->r_frame_rate.den = 0;

529 continue;

530 }

531

532 if (metadata && av_strcasecmp(name, "Uses") &&

533 av_strcasecmp(name, "Depends") && av_strcasecmp(name, "Replaces"))

534 av_dict_set(metadata, name, str_value, 0);

535 }

536 }

537

538 if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

539 av_log(s, AV_LOG_ERROR, "info header checksum mismatch\n");

540 return -1;

541 }

542 return 0;

543 }

544

545 static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr)

546 {

547 AVFormatContext *s = nut->avf;

548 AVIOContext *bc = s->pb;

549 int64_t end;

550 uint64_t tmp;

551

552 nut->last_syncpoint_pos = avio_tell(bc) - 8;

553

554 end = get_packetheader(nut, bc, 1, SYNCPOINT_STARTCODE);

555 end += avio_tell(bc);

556

557 tmp = ffio_read_varlen(bc);

558 *back_ptr = nut->last_syncpoint_pos - 16 * ffio_read_varlen(bc);

559 if (*back_ptr < 0)

560 return AVERROR_INVALIDDATA;

561

562 ff_nut_reset_ts(nut, nut->time_base[tmp % nut->time_base_count],

563 tmp / nut->time_base_count);

564

565 if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

566 av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n");

567 return AVERROR_INVALIDDATA;

568 }

569

570 *ts = tmp / nut->time_base_count *

571 av_q2d(nut->time_base[tmp % nut->time_base_count]) * AV_TIME_BASE;

572 ff_nut_add_sp(nut, nut->last_syncpoint_pos, *back_ptr, *ts);

573

574 return 0;

575 }

576

577 //FIXME calculate exactly, this is just a good approximation.

578 static int64_t find_duration(NUTContext *nut, int64_t filesize)

579 {

580 AVFormatContext *s = nut->avf;

581 int64_t duration = 0;

582

583 int64_t pos = FFMAX(0, filesize - 2*nut->max_distance);

584 for(;;){

585 int64_t ts = nut_read_timestamp(s, -1, &pos, INT64_MAX);

586 if(ts < 0)

587 break;

588 duration = FFMAX(duration, ts);

589 pos++;

590 }

591 if(duration > 0)

592 s->duration_estimation_method = AVFMT_DURATION_FROM_PTS;

593 return duration;

594 }

595

596 static int find_and_decode_index(NUTContext *nut)

597 {

598 AVFormatContext *s = nut->avf;

599 AVIOContext *bc = s->pb;

600 uint64_t tmp, end;

601 int i, j, syncpoint_count;

602 int64_t filesize = avio_size(bc);

603 int64_t *syncpoints;

604 int8_t *has_keyframe;

605 int ret = -1;

606

607 if(filesize <= 0)

608 return -1;

609

610 avio_seek(bc, filesize - 12, SEEK_SET);

611 avio_seek(bc, filesize - avio_rb64(bc), SEEK_SET);

612 if (avio_rb64(bc) != INDEX_STARTCODE) {

613 av_log(s, AV_LOG_ERROR, "no index at the end\n");

614

615 if(s->duration<=0)

616 s->duration = find_duration(nut, filesize);

617 return -1;

618 }

619

620 end = get_packetheader(nut, bc, 1, INDEX_STARTCODE);

621 end += avio_tell(bc);

622

623 ffio_read_varlen(bc); // max_pts

624 GET_V(syncpoint_count, tmp < INT_MAX / 8 && tmp > 0);

625 syncpoints = av_malloc(sizeof(int64_t) * syncpoint_count);

626 has_keyframe = av_malloc(sizeof(int8_t) * (syncpoint_count + 1));

627 for (i = 0; i < syncpoint_count; i++) {

628 syncpoints[i] = ffio_read_varlen(bc);

629 if (syncpoints[i] <= 0)

630 goto fail;

631 if (i)

632 syncpoints[i] += syncpoints[i - 1];

633 }

634

635 for (i = 0; i < s->nb_streams; i++) {

636 int64_t last_pts = -1;

637 for (j = 0; j < syncpoint_count;) {

638 uint64_t x = ffio_read_varlen(bc);

639 int type = x & 1;

640 int n = j;

641 x >>= 1;

642 if (type) {

643 int flag = x & 1;

644 x >>= 1;

645 if (n + x >= syncpoint_count + 1) {

646 av_log(s, AV_LOG_ERROR, "index overflow A %d + %"PRIu64" >= %d\n", n, x, syncpoint_count + 1);

647 goto fail;

648 }

649 while (x--)

650 has_keyframe[n++] = flag;

651 has_keyframe[n++] = !flag;

652 } else {

653 while (x != 1) {

654 if (n >= syncpoint_count + 1) {

655 av_log(s, AV_LOG_ERROR, "index overflow B\n");

656 goto fail;

657 }

658 has_keyframe[n++] = x & 1;

659 x >>= 1;

660 }

661 }

662 if (has_keyframe[0]) {

663 av_log(s, AV_LOG_ERROR, "keyframe before first syncpoint in index\n");

664 goto fail;

665 }

666 av_assert0(n <= syncpoint_count + 1);

667 for (; j < n && j < syncpoint_count; j++) {

668 if (has_keyframe[j]) {

669 uint64_t B, A = ffio_read_varlen(bc);

670 if (!A) {

671 A = ffio_read_varlen(bc);

672 B = ffio_read_varlen(bc);

673 // eor_pts[j][i] = last_pts + A + B

674 } else

675 B = 0;

676 av_add_index_entry(s->streams[i], 16 * syncpoints[j - 1],

677 last_pts + A, 0, 0, AVINDEX_KEYFRAME);

678 last_pts += A + B;

679 }

680 }

681 }

682 }

683

684 if (skip_reserved(bc, end) || ffio_get_checksum(bc)) {

685 av_log(s, AV_LOG_ERROR, "index checksum mismatch\n");

686 goto fail;

687 }

688 ret = 0;

689

690 fail:

691 av_free(syncpoints);

692 av_free(has_keyframe);

693 return ret;

694 }

695

696 static int nut_read_header(AVFormatContext *s)

697 {

698 NUTContext *nut = s->priv_data;

699 AVIOContext *bc = s->pb;

700 int64_t pos;

701 int initialized_stream_count;

702

703 nut->avf = s;

704

705 /* main header */

706 pos = 0;

707 do {

708 pos = find_startcode(bc, MAIN_STARTCODE, pos) + 1;

709 if (pos < 0 + 1) {

710 av_log(s, AV_LOG_ERROR, "No main startcode found.\n");

711 return AVERROR_INVALIDDATA;

712 }

713 } while (decode_main_header(nut) < 0);

714

715 /* stream headers */

716 pos = 0;

717 for (initialized_stream_count = 0; initialized_stream_count < s->nb_streams;) {

718 pos = find_startcode(bc, STREAM_STARTCODE, pos) + 1;

719 if (pos < 0 + 1) {

720 av_log(s, AV_LOG_ERROR, "Not all stream headers found.\n");

721 return AVERROR_INVALIDDATA;

722 }

723 if (decode_stream_header(nut) >= 0)

724 initialized_stream_count++;

725 }

726

727 /* info headers */

728 pos = 0;

729 for (;;) {

730 uint64_t startcode = find_any_startcode(bc, pos);

731 pos = avio_tell(bc);

732

733 if (startcode == 0) {

734 av_log(s, AV_LOG_ERROR, "EOF before video frames\n");

735 return AVERROR_INVALIDDATA;

736 } else if (startcode == SYNCPOINT_STARTCODE) {

737 nut->next_startcode = startcode;

738 break;

739 } else if (startcode != INFO_STARTCODE) {

740 continue;

741 }

742

743 decode_info_header(nut);

744 }

745

746 s->data_offset = pos - 8;

747

748 if (bc->seekable) {

749 int64_t orig_pos = avio_tell(bc);

750 find_and_decode_index(nut);

751 avio_seek(bc, orig_pos, SEEK_SET);

752 }

753 av_assert0(nut->next_startcode == SYNCPOINT_STARTCODE);

754

755 ff_metadata_conv_ctx(s, NULL, ff_nut_metadata_conv);

756

757 return 0;

758 }

759

760 static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id,

761 uint8_t *header_idx, int frame_code)

762 {

763 AVFormatContext *s = nut->avf;

764 AVIOContext *bc = s->pb;

765 StreamContext *stc;

766 int size, flags, size_mul, pts_delta, i, reserved_count;

767 uint64_t tmp;

768

769 if (avio_tell(bc) > nut->last_syncpoint_pos + nut->max_distance) {

770 av_log(s, AV_LOG_ERROR,

771 "Last frame must have been damaged %"PRId64" > %"PRId64" + %d\n",

772 avio_tell(bc), nut->last_syncpoint_pos, nut->max_distance);

773 return AVERROR_INVALIDDATA;

774 }

775

776 flags = nut->frame_code[frame_code].flags;

777 size_mul = nut->frame_code[frame_code].size_mul;

778 size = nut->frame_code[frame_code].size_lsb;

779 *stream_id = nut->frame_code[frame_code].stream_id;

780 pts_delta = nut->frame_code[frame_code].pts_delta;

781 reserved_count = nut->frame_code[frame_code].reserved_count;

782 *header_idx = nut->frame_code[frame_code].header_idx;

783

784 if (flags & FLAG_INVALID)

785 return AVERROR_INVALIDDATA;

786 if (flags & FLAG_CODED)

787 flags ^= ffio_read_varlen(bc);

788 if (flags & FLAG_STREAM_ID) {

789 GET_V(*stream_id, tmp < s->nb_streams);

790 }

791 stc = &nut->stream[*stream_id];

792 if (flags & FLAG_CODED_PTS) {

793 int coded_pts = ffio_read_varlen(bc);

794 // FIXME check last_pts validity?

795 if (coded_pts < (1 << stc->msb_pts_shift)) {

796 *pts = ff_lsb2full(stc, coded_pts);

797 } else

798 *pts = coded_pts - (1LL << stc->msb_pts_shift);

799 } else

800 *pts = stc->last_pts + pts_delta;

801 if (flags & FLAG_SIZE_MSB)

802 size += size_mul * ffio_read_varlen(bc);

803 if (flags & FLAG_MATCH_TIME)

804 get_s(bc);

805 if (flags & FLAG_HEADER_IDX)

806 *header_idx = ffio_read_varlen(bc);

807 if (flags & FLAG_RESERVED)

808 reserved_count = ffio_read_varlen(bc);

809 for (i = 0; i < reserved_count; i++)

810 ffio_read_varlen(bc);

811

812 if (*header_idx >= (unsigned)nut->header_count) {

813 av_log(s, AV_LOG_ERROR, "header_idx invalid\n");

814 return AVERROR_INVALIDDATA;

815 }

816 if (size > 4096)

817 *header_idx = 0;

818 size -= nut->header_len[*header_idx];

819

820 if (flags & FLAG_CHECKSUM) {

821 avio_rb32(bc); // FIXME check this

822 } else if (size > 2 * nut->max_distance || FFABS(stc->last_pts - *pts) >

823 stc->max_pts_distance) {

824 av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");

825 return AVERROR_INVALIDDATA;

826 }

827

828 stc->last_pts = *pts;

829 stc->last_flags = flags;

830

831 return size;

832 }

833

834 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)

835 {

836 AVFormatContext *s = nut->avf;

837 AVIOContext *bc = s->pb;

838 int size, stream_id, discard;

839 int64_t pts, last_IP_pts;

840 StreamContext *stc;

841 uint8_t header_idx;

842

843 size = decode_frame_header(nut, &pts, &stream_id, &header_idx, frame_code);

844 if (size < 0)

845 return size;

846

847 stc = &nut->stream[stream_id];

848

849 if (stc->last_flags & FLAG_KEY)

850 stc->skip_until_key_frame = 0;

851

852 discard = s->streams[stream_id]->discard;

853 last_IP_pts = s->streams[stream_id]->last_IP_pts;

854 if ((discard >= AVDISCARD_NONKEY && !(stc->last_flags & FLAG_KEY)) ||

855 (discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE &&

856 last_IP_pts > pts) ||

857 discard >= AVDISCARD_ALL ||

858 stc->skip_until_key_frame) {

859 avio_skip(bc, size);

860 return 1;

861 }

862

863 if (av_new_packet(pkt, size + nut->header_len[header_idx]) < 0)

864 return AVERROR(ENOMEM);

865 memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);

866 pkt->pos = avio_tell(bc); // FIXME

867 avio_read(bc, pkt->data + nut->header_len[header_idx], size);

868

869 pkt->stream_index = stream_id;

870 if (stc->last_flags & FLAG_KEY)

871 pkt->flags |= AV_PKT_FLAG_KEY;

872 pkt->pts = pts;

873

874 return 0;

875 }

876

877 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)

878 {

879 NUTContext *nut = s->priv_data;

880 AVIOContext *bc = s->pb;

881 int i, frame_code = 0, ret, skip;

882 int64_t ts, back_ptr;

883

884 for (;;) {

885 int64_t pos = avio_tell(bc);

886 uint64_t tmp = nut->next_startcode;

887 nut->next_startcode = 0;

888

889 if (tmp) {

890 pos -= 8;

891 } else {

892 frame_code = avio_r8(bc);

893 if (url_feof(bc))

894 return -1;

895 if (frame_code == 'N') {

896 tmp = frame_code;

897 for (i = 1; i < 8; i++)

898 tmp = (tmp << 8) + avio_r8(bc);

899 }

900 }

901 switch (tmp) {

902 case MAIN_STARTCODE:

903 case STREAM_STARTCODE:

904 case INDEX_STARTCODE:

905 skip = get_packetheader(nut, bc, 0, tmp);

906 avio_skip(bc, skip);

907 break;

908 case INFO_STARTCODE:

909 if (decode_info_header(nut) < 0)

910 goto resync;

911 break;

912 case SYNCPOINT_STARTCODE:

913 if (decode_syncpoint(nut, &ts, &back_ptr) < 0)

914 goto resync;

915 frame_code = avio_r8(bc);

916 case 0:

917 ret = decode_frame(nut, pkt, frame_code);

918 if (ret == 0)

919 return 0;

920 else if (ret == 1) // OK but discard packet

921 break;

922 default:

923 resync:

924 av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos);

925 tmp = find_any_startcode(bc, nut->last_syncpoint_pos + 1);

926 if (tmp == 0)

927 return AVERROR_INVALIDDATA;

928 av_log(s, AV_LOG_DEBUG, "sync\n");

929 nut->next_startcode = tmp;

930 }

931 }

932 }

933

934 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index,

935 int64_t *pos_arg, int64_t pos_limit)

936 {

937 NUTContext *nut = s->priv_data;

938 AVIOContext *bc = s->pb;

939 int64_t pos, pts, back_ptr;

940 av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%"PRId64",%"PRId64")\n",

941 stream_index, *pos_arg, pos_limit);

942

943 pos = *pos_arg;

944 do {

945 pos = find_startcode(bc, SYNCPOINT_STARTCODE, pos) + 1;

946 if (pos < 1) {

947 av_log(s, AV_LOG_ERROR, "read_timestamp failed.\n");

948 return AV_NOPTS_VALUE;

949 }

950 } while (decode_syncpoint(nut, &pts, &back_ptr) < 0);

951 *pos_arg = pos - 1;

952 av_assert0(nut->last_syncpoint_pos == *pos_arg);

953

954 av_log(s, AV_LOG_DEBUG, "return %"PRId64" %"PRId64"\n", pts, back_ptr);

955 if (stream_index == -2)

956 return back_ptr;

957 av_assert0(stream_index == -1);

958 return pts;

959 }

960

961 static int read_seek(AVFormatContext *s, int stream_index,

962 int64_t pts, int flags)

963 {

964 NUTContext *nut = s->priv_data;

965 AVStream *st = s->streams[stream_index];

966 Syncpoint dummy = { .ts = pts * av_q2d(st->time_base) * AV_TIME_BASE };

967 Syncpoint nopts_sp = { .ts = AV_NOPTS_VALUE, .back_ptr = AV_NOPTS_VALUE };

968 Syncpoint *sp, *next_node[2] = { &nopts_sp, &nopts_sp };

969 int64_t pos, pos2, ts;

970 int i;

971

972 if (st->index_entries) {

973 int index = av_index_search_timestamp(st, pts, flags);

974 if (index < 0)

975 index = av_index_search_timestamp(st, pts, flags ^ AVSEEK_FLAG_BACKWARD);

976 if (index < 0)

977 return -1;

978

979 pos2 = st->index_entries[index].pos;

980 ts = st->index_entries[index].timestamp;

981 } else {

982 av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pts_cmp,

983 (void **) next_node);

984 av_log(s, AV_LOG_DEBUG, "%"PRIu64"-%"PRIu64" %"PRId64"-%"PRId64"\n",

985 next_node[0]->pos, next_node[1]->pos, next_node[0]->ts,

986 next_node[1]->ts);

987 pos = ff_gen_search(s, -1, dummy.ts, next_node[0]->pos,

988 next_node[1]->pos, next_node[1]->pos,

989 next_node[0]->ts, next_node[1]->ts,

990 AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);

991

992 if (!(flags & AVSEEK_FLAG_BACKWARD)) {

993 dummy.pos = pos + 16;

994 next_node[1] = &nopts_sp;

995 av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,

996 (void **) next_node);

997 pos2 = ff_gen_search(s, -2, dummy.pos, next_node[0]->pos,

998 next_node[1]->pos, next_node[1]->pos,

999 next_node[0]->back_ptr, next_node[1]->back_ptr,

1000 flags, &ts, nut_read_timestamp);

1001 if (pos2 >= 0)

1002 pos = pos2;

1003 // FIXME dir but I think it does not matter

1004 }

1005 dummy.pos = pos;

1006 sp = av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,

1007 NULL);

1008

1009 av_assert0(sp);

1010 pos2 = sp->back_ptr - 15;

1011 }

1012 av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos2);

1013 pos = find_startcode(s->pb, SYNCPOINT_STARTCODE, pos2);

1014 avio_seek(s->pb, pos, SEEK_SET);

1015 av_log(NULL, AV_LOG_DEBUG, "SP: %"PRId64"\n", pos);

1016 if (pos2 > pos || pos2 + 15 < pos)

1017 av_log(NULL, AV_LOG_ERROR, "no syncpoint at backptr pos\n");

1018 for (i = 0; i < s->nb_streams; i++)

1019 nut->stream[i].skip_until_key_frame = 1;

1020

1021 return 0;

1022 }

1023

1024 static int nut_read_close(AVFormatContext *s)

1025 {

1026 NUTContext *nut = s->priv_data;

1027 int i;

1028

1029 av_freep(&nut->time_base);

1030 av_freep(&nut->stream);

1031 ff_nut_free_sp(nut);

1032 for (i = 1; i < nut->header_count; i++)

1033 av_freep(&nut->header[i]);

1034

1035 return 0;

1036 }

1037

1038 AVInputFormat ff_nut_demuxer = {

1039 .name = "nut",

1040 .long_name = NULL_IF_CONFIG_SMALL("NUT"),

1041 .flags = AVFMT_SEEK_TO_PTS,

1042 .priv_data_size = sizeof(NUTContext),

1043 .read_probe = nut_probe,

1044 .read_header = nut_read_header,

1045 .read_packet = nut_read_packet,

1046 .read_close = nut_read_close,

1047 .read_seek = read_seek,

1048 .extensions = "nut",

1049 .codec_tag = ff_nut_codec_tags,

1050 };

Generated on Sat May 25 2013 04:01:18 for FFmpeg by doxygen 1.8.2