FFmpeg: libavformat/flvdec.c Source File

FFmpeg

[フレーム]

libavformat

flvdec.c

Go to the documentation of this file.

1 /*

2 * FLV demuxer

4 *

5 * This demuxer will generate a 1 byte extradata for VP6F content.

6 * It is composed of:

7 * - upper 4bits: difference between encoded width and visible width

8 * - lower 4bits: difference between encoded height and visible height

9 *

10 * This file is part of FFmpeg.

11 *

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

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

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

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

16 *

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

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

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

20 * Lesser General Public License for more details.

21 *

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

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

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

25 */

27 #include "libavutil/avstring.h"

28 #include "libavutil/channel_layout.h"

29 #include "libavutil/dict.h"

30 #include "libavutil/opt.h"

31 #include "libavutil/intfloat.h"

32 #include "libavutil/mathematics.h"

33 #include "libavcodec/bytestream.h"

34 #include "libavcodec/mpeg4audio.h"

35 #include "avformat.h"

36 #include "internal.h"

37 #include "avio_internal.h"

38 #include "flv.h"

40 #define VALIDATE_INDEX_TS_THRESH 2500

42 typedef struct FLVContext {

43 const AVClass *class; ///< Class for private options.

44 int trust_metadata; ///< configure streams according onMetaData

45 int wrong_dts; ///< wrong dts due to negative cts

46 uint8_t *new_extradata[FLV_STREAM_TYPE_NB];

47 int new_extradata_size[FLV_STREAM_TYPE_NB];

48 int last_sample_rate;

49 int last_channels;

50 struct {

51 int64_t dts;

52 int64_t pos;

53 } validate_index[2];

54 int validate_next;

55 int validate_count;

56 int searched_for_end;

57 } FLVContext;

59 static int probe(AVProbeData *p, int live)

60 {

61 const uint8_t *d = p->buf;

62 unsigned offset = AV_RB32(d + 5);

64 if (d[0] == 'F' &&

65 d[1] == 'L' &&

66 d[2] == 'V' &&

67 d[3] < 5 && d[5] == 0 &&

68 offset + 100 < p->buf_size &&

69 offset > 8) {

70 int is_live = !memcmp(d + offset + 40, "NGINX RTMP", 10);

72 if (live == is_live)

73 return AVPROBE_SCORE_MAX;

74 }

75 return 0;

76 }

78 static int flv_probe(AVProbeData *p)

79 {

80 return probe(p, 0);

81 }

83 static int live_flv_probe(AVProbeData *p)

84 {

85 return probe(p, 1);

86 }

88 static AVStream *create_stream(AVFormatContext *s, int codec_type)

89 {

90 AVStream *st = avformat_new_stream(s, NULL);

91 if (!st)

92 return NULL;

93 st->codec->codec_type = codec_type;

94 if (s->nb_streams>=3 ||( s->nb_streams==2

95 && s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA

96 && s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))

97 s->ctx_flags &= ~AVFMTCTX_NOHEADER;

99 avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */

100 return st;

101 }

102

103 static int flv_same_audio_codec(AVCodecContext *acodec, int flags)

104 {

105 int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;

106 int flv_codecid = flags & FLV_AUDIO_CODECID_MASK;

107 int codec_id;

108

109 if (!acodec->codec_id && !acodec->codec_tag)

110 return 1;

111

112 if (acodec->bits_per_coded_sample != bits_per_coded_sample)

113 return 0;

114

115 switch (flv_codecid) {

116 // no distinction between S16 and S8 PCM codec flags

117 case FLV_CODECID_PCM:

118 codec_id = bits_per_coded_sample == 8

119 ? AV_CODEC_ID_PCM_U8

120 #if HAVE_BIGENDIAN

121 : AV_CODEC_ID_PCM_S16BE;

122 #else

123 : AV_CODEC_ID_PCM_S16LE;

124 #endif

125 return codec_id == acodec->codec_id;

126 case FLV_CODECID_PCM_LE:

127 codec_id = bits_per_coded_sample == 8

128 ? AV_CODEC_ID_PCM_U8

129 : AV_CODEC_ID_PCM_S16LE;

130 return codec_id == acodec->codec_id;

131 case FLV_CODECID_AAC:

132 return acodec->codec_id == AV_CODEC_ID_AAC;

133 case FLV_CODECID_ADPCM:

134 return acodec->codec_id == AV_CODEC_ID_ADPCM_SWF;

135 case FLV_CODECID_SPEEX:

136 return acodec->codec_id == AV_CODEC_ID_SPEEX;

137 case FLV_CODECID_MP3:

138 return acodec->codec_id == AV_CODEC_ID_MP3;

139 case FLV_CODECID_NELLYMOSER_8KHZ_MONO:

140 case FLV_CODECID_NELLYMOSER_16KHZ_MONO:

141 case FLV_CODECID_NELLYMOSER:

142 return acodec->codec_id == AV_CODEC_ID_NELLYMOSER;

143 case FLV_CODECID_PCM_MULAW:

144 return acodec->sample_rate == 8000 &&

145 acodec->codec_id == AV_CODEC_ID_PCM_MULAW;

146 case FLV_CODECID_PCM_ALAW:

147 return acodec->sample_rate == 8000 &&

148 acodec->codec_id == AV_CODEC_ID_PCM_ALAW;

149 default:

150 return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);

151 }

152 }

153

154 static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream,

155 AVCodecContext *acodec, int flv_codecid)

156 {

157 switch (flv_codecid) {

158 // no distinction between S16 and S8 PCM codec flags

159 case FLV_CODECID_PCM:

160 acodec->codec_id = acodec->bits_per_coded_sample == 8

161 ? AV_CODEC_ID_PCM_U8

162 #if HAVE_BIGENDIAN

163 : AV_CODEC_ID_PCM_S16BE;

164 #else

165 : AV_CODEC_ID_PCM_S16LE;

166 #endif

167 break;

168 case FLV_CODECID_PCM_LE:

169 acodec->codec_id = acodec->bits_per_coded_sample == 8

170 ? AV_CODEC_ID_PCM_U8

171 : AV_CODEC_ID_PCM_S16LE;

172 break;

173 case FLV_CODECID_AAC:

174 acodec->codec_id = AV_CODEC_ID_AAC;

175 break;

176 case FLV_CODECID_ADPCM:

177 acodec->codec_id = AV_CODEC_ID_ADPCM_SWF;

178 break;

179 case FLV_CODECID_SPEEX:

180 acodec->codec_id = AV_CODEC_ID_SPEEX;

181 acodec->sample_rate = 16000;

182 break;

183 case FLV_CODECID_MP3:

184 acodec->codec_id = AV_CODEC_ID_MP3;

185 astream->need_parsing = AVSTREAM_PARSE_FULL;

186 break;

187 case FLV_CODECID_NELLYMOSER_8KHZ_MONO:

188 // in case metadata does not otherwise declare samplerate

189 acodec->sample_rate = 8000;

190 acodec->codec_id = AV_CODEC_ID_NELLYMOSER;

191 break;

192 case FLV_CODECID_NELLYMOSER_16KHZ_MONO:

193 acodec->sample_rate = 16000;

194 acodec->codec_id = AV_CODEC_ID_NELLYMOSER;

195 break;

196 case FLV_CODECID_NELLYMOSER:

197 acodec->codec_id = AV_CODEC_ID_NELLYMOSER;

198 break;

199 case FLV_CODECID_PCM_MULAW:

200 acodec->sample_rate = 8000;

201 acodec->codec_id = AV_CODEC_ID_PCM_MULAW;

202 break;

203 case FLV_CODECID_PCM_ALAW:

204 acodec->sample_rate = 8000;

205 acodec->codec_id = AV_CODEC_ID_PCM_ALAW;

206 break;

207 default:

208 avpriv_request_sample(s, "Audio codec (%x)",

209 flv_codecid >> FLV_AUDIO_CODECID_OFFSET);

210 acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;

211 }

212 }

213

214 static int flv_same_video_codec(AVCodecContext *vcodec, int flags)

215 {

216 int flv_codecid = flags & FLV_VIDEO_CODECID_MASK;

217

218 if (!vcodec->codec_id && !vcodec->codec_tag)

219 return 1;

220

221 switch (flv_codecid) {

222 case FLV_CODECID_H263:

223 return vcodec->codec_id == AV_CODEC_ID_FLV1;

224 case FLV_CODECID_SCREEN:

225 return vcodec->codec_id == AV_CODEC_ID_FLASHSV;

226 case FLV_CODECID_SCREEN2:

227 return vcodec->codec_id == AV_CODEC_ID_FLASHSV2;

228 case FLV_CODECID_VP6:

229 return vcodec->codec_id == AV_CODEC_ID_VP6F;

230 case FLV_CODECID_VP6A:

231 return vcodec->codec_id == AV_CODEC_ID_VP6A;

232 case FLV_CODECID_H264:

233 return vcodec->codec_id == AV_CODEC_ID_H264;

234 default:

235 return vcodec->codec_tag == flv_codecid;

236 }

237 }

238

239 static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,

240 int flv_codecid, int read)

241 {

242 AVCodecContext *vcodec = vstream->codec;

243 switch (flv_codecid) {

244 case FLV_CODECID_H263:

245 vcodec->codec_id = AV_CODEC_ID_FLV1;

246 break;

247 case FLV_CODECID_REALH263:

248 vcodec->codec_id = AV_CODEC_ID_H263;

249 break; // Really mean it this time

250 case FLV_CODECID_SCREEN:

251 vcodec->codec_id = AV_CODEC_ID_FLASHSV;

252 break;

253 case FLV_CODECID_SCREEN2:

254 vcodec->codec_id = AV_CODEC_ID_FLASHSV2;

255 break;

256 case FLV_CODECID_VP6:

257 vcodec->codec_id = AV_CODEC_ID_VP6F;

258 case FLV_CODECID_VP6A:

259 if (flv_codecid == FLV_CODECID_VP6A)

260 vcodec->codec_id = AV_CODEC_ID_VP6A;

261 if (read) {

262 if (vcodec->extradata_size != 1) {

263 ff_alloc_extradata(vcodec, 1);

264 }

265 if (vcodec->extradata)

266 vcodec->extradata[0] = avio_r8(s->pb);

267 else

268 avio_skip(s->pb, 1);

269 }

270 return 1; // 1 byte body size adjustment for flv_read_packet()

271 case FLV_CODECID_H264:

272 vcodec->codec_id = AV_CODEC_ID_H264;

273 vstream->need_parsing = AVSTREAM_PARSE_HEADERS;

274 return 3; // not 4, reading packet type will consume one byte

275 case FLV_CODECID_MPEG4:

276 vcodec->codec_id = AV_CODEC_ID_MPEG4;

277 return 3;

278 default:

279 avpriv_request_sample(s, "Video codec (%x)", flv_codecid);

280 vcodec->codec_tag = flv_codecid;

281 }

282

283 return 0;

284 }

285

286 static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)

287 {

288 int length = avio_rb16(ioc);

289 if (length >= buffsize) {

290 avio_skip(ioc, length);

291 return -1;

292 }

293

294 avio_read(ioc, buffer, length);

295

296 buffer[length] = '0円';

297

298 return length;

299 }

300

301 static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc,

302 AVStream *vstream, int64_t max_pos)

303 {

304 FLVContext *flv = s->priv_data;

305 unsigned int timeslen = 0, fileposlen = 0, i;

306 char str_val[256];

307 int64_t *times = NULL;

308 int64_t *filepositions = NULL;

309 int ret = AVERROR(ENOSYS);

310 int64_t initial_pos = avio_tell(ioc);

311

312 if (vstream->nb_index_entries>0) {

313 av_log(s, AV_LOG_WARNING, "Skipping duplicate index\n");

314 return 0;

315 }

316

317 if (s->flags & AVFMT_FLAG_IGNIDX)

318 return 0;

319

320 while (avio_tell(ioc) < max_pos - 2 &&

321 amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {

322 int64_t **current_array;

323 unsigned int arraylen;

324

325 // Expect array object in context

326 if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)

327 break;

328

329 arraylen = avio_rb32(ioc);

330 if (arraylen>>28)

331 break;

332

333 if (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {

334 current_array = ×

335 timeslen = arraylen;

336 } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&

337 !filepositions) {

338 current_array = &filepositions;

339 fileposlen = arraylen;

340 } else

341 // unexpected metatag inside keyframes, will not use such

342 // metadata for indexing

343 break;

344

345 if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) {

346 ret = AVERROR(ENOMEM);

347 goto finish;

348 }

349

350 for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {

351 if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)

352 goto invalid;

353 current_array[0][i] = av_int2double(avio_rb64(ioc));

354 }

355 if (times && filepositions) {

356 // All done, exiting at a position allowing amf_parse_object

357 // to finish parsing the object

358 ret = 0;

359 break;

360 }

361 }

362

363 if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {

364 for (i = 0; i < fileposlen; i++) {

365 av_add_index_entry(vstream, filepositions[i], times[i] * 1000,

366 0, 0, AVINDEX_KEYFRAME);

367 if (i < 2) {

368 flv->validate_index[i].pos = filepositions[i];

369 flv->validate_index[i].dts = times[i] * 1000;

370 flv->validate_count = i + 1;

371 }

372 }

373 } else {

374 invalid:

375 av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");

376 }

377

378 finish:

379 av_freep(&times);

380 av_freep(&filepositions);

381 avio_seek(ioc, initial_pos, SEEK_SET);

382 return ret;

383 }

384

385 static int amf_parse_object(AVFormatContext *s, AVStream *astream,

386 AVStream *vstream, const char *key,

387 int64_t max_pos, int depth)

388 {

389 AVCodecContext *acodec, *vcodec;

390 FLVContext *flv = s->priv_data;

391 AVIOContext *ioc;

392 AMFDataType amf_type;

393 char str_val[1024];

394 double num_val;

395

396 num_val = 0;

397 ioc = s->pb;

398 amf_type = avio_r8(ioc);

399

400 switch (amf_type) {

401 case AMF_DATA_TYPE_NUMBER:

402 num_val = av_int2double(avio_rb64(ioc));

403 break;

404 case AMF_DATA_TYPE_BOOL:

405 num_val = avio_r8(ioc);

406 break;

407 case AMF_DATA_TYPE_STRING:

408 if (amf_get_string(ioc, str_val, sizeof(str_val)) < 0) {

409 av_log(s, AV_LOG_ERROR, "AMF_DATA_TYPE_STRING parsing failed\n");

410 return -1;

411 }

412 break;

413 case AMF_DATA_TYPE_OBJECT:

414 if ((vstream || astream) && key &&

415 ioc->seekable &&

416 !strcmp(KEYFRAMES_TAG, key) && depth == 1)

417 if (parse_keyframes_index(s, ioc, vstream ? vstream : astream,

418 max_pos) < 0)

419 av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");

420

421 while (avio_tell(ioc) < max_pos - 2 &&

422 amf_get_string(ioc, str_val, sizeof(str_val)) > 0)

423 if (amf_parse_object(s, astream, vstream, str_val, max_pos,

424 depth + 1) < 0)

425 return -1; // if we couldn't skip, bomb out.

426 if (avio_r8(ioc) != AMF_END_OF_OBJECT) {

427 av_log(s, AV_LOG_ERROR, "Missing AMF_END_OF_OBJECT in AMF_DATA_TYPE_OBJECT\n");

428 return -1;

429 }

430 break;

431 case AMF_DATA_TYPE_NULL:

432 case AMF_DATA_TYPE_UNDEFINED:

433 case AMF_DATA_TYPE_UNSUPPORTED:

434 break; // these take up no additional space

435 case AMF_DATA_TYPE_MIXEDARRAY:

436 avio_skip(ioc, 4); // skip 32-bit max array index

437 while (avio_tell(ioc) < max_pos - 2 &&

438 amf_get_string(ioc, str_val, sizeof(str_val)) > 0)

439 // this is the only case in which we would want a nested

440 // parse to not skip over the object

441 if (amf_parse_object(s, astream, vstream, str_val, max_pos,

442 depth + 1) < 0)

443 return -1;

444 if (avio_r8(ioc) != AMF_END_OF_OBJECT) {

445 av_log(s, AV_LOG_ERROR, "Missing AMF_END_OF_OBJECT in AMF_DATA_TYPE_MIXEDARRAY\n");

446 return -1;

447 }

448 break;

449 case AMF_DATA_TYPE_ARRAY:

450 {

451 unsigned int arraylen, i;

452

453 arraylen = avio_rb32(ioc);

454 for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++)

455 if (amf_parse_object(s, NULL, NULL, NULL, max_pos,

456 depth + 1) < 0)

457 return -1; // if we couldn't skip, bomb out.

458 }

459 break;

460 case AMF_DATA_TYPE_DATE:

461 avio_skip(ioc, 8 + 2); // timestamp (double) and UTC offset (int16)

462 break;

463 default: // unsupported type, we couldn't skip

464 av_log(s, AV_LOG_ERROR, "unsupported amf type %d\n", amf_type);

465 return -1;

466 }

467

468 if (key) {

469 acodec = astream ? astream->codec : NULL;

470 vcodec = vstream ? vstream->codec : NULL;

471

472 // stream info doesn't live any deeper than the first object

473 if (depth == 1) {

474 if (amf_type == AMF_DATA_TYPE_NUMBER ||

475 amf_type == AMF_DATA_TYPE_BOOL) {

476 if (!strcmp(key, "duration"))

477 s->duration = num_val * AV_TIME_BASE;

478 else if (!strcmp(key, "videodatarate") && vcodec &&

479 0 <= (int)(num_val * 1024.0))

480 vcodec->bit_rate = num_val * 1024.0;

481 else if (!strcmp(key, "audiodatarate") && acodec &&

482 0 <= (int)(num_val * 1024.0))

483 acodec->bit_rate = num_val * 1024.0;

484 else if (!strcmp(key, "datastream")) {

485 AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);

486 if (!st)

487 return AVERROR(ENOMEM);

488 st->codec->codec_id = AV_CODEC_ID_TEXT;

489 } else if (flv->trust_metadata) {

490 if (!strcmp(key, "videocodecid") && vcodec) {

491 flv_set_video_codec(s, vstream, num_val, 0);

492 } else if (!strcmp(key, "audiocodecid") && acodec) {

493 int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;

494 flv_set_audio_codec(s, astream, acodec, id);

495 } else if (!strcmp(key, "audiosamplerate") && acodec) {

496 acodec->sample_rate = num_val;

497 } else if (!strcmp(key, "audiosamplesize") && acodec) {

498 acodec->bits_per_coded_sample = num_val;

499 } else if (!strcmp(key, "stereo") && acodec) {

500 acodec->channels = num_val + 1;

501 acodec->channel_layout = acodec->channels == 2 ?

502 AV_CH_LAYOUT_STEREO :

503 AV_CH_LAYOUT_MONO;

504 } else if (!strcmp(key, "width") && vcodec) {

505 vcodec->width = num_val;

506 } else if (!strcmp(key, "height") && vcodec) {

507 vcodec->height = num_val;

508 }

509 }

510 }

511 }

512

513 if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 &&

514 ((!acodec && !strcmp(key, "audiocodecid")) ||

515 (!vcodec && !strcmp(key, "videocodecid"))))

516 s->ctx_flags &= ~AVFMTCTX_NOHEADER; //If there is either audio/video missing, codecid will be an empty object

517

518 if (!strcmp(key, "duration") ||

519 !strcmp(key, "filesize") ||

520 !strcmp(key, "width") ||

521 !strcmp(key, "height") ||

522 !strcmp(key, "videodatarate") ||

523 !strcmp(key, "framerate") ||

524 !strcmp(key, "videocodecid") ||

525 !strcmp(key, "audiodatarate") ||

526 !strcmp(key, "audiosamplerate") ||

527 !strcmp(key, "audiosamplesize") ||

528 !strcmp(key, "stereo") ||

529 !strcmp(key, "audiocodecid") ||

530 !strcmp(key, "datastream"))

531 return 0;

532

533 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;

534 if (amf_type == AMF_DATA_TYPE_BOOL) {

535 av_strlcpy(str_val, num_val > 0 ? "true" : "false",

536 sizeof(str_val));

537 av_dict_set(&s->metadata, key, str_val, 0);

538 } else if (amf_type == AMF_DATA_TYPE_NUMBER) {

539 snprintf(str_val, sizeof(str_val), "%.f", num_val);

540 av_dict_set(&s->metadata, key, str_val, 0);

541 } else if (amf_type == AMF_DATA_TYPE_STRING)

542 av_dict_set(&s->metadata, key, str_val, 0);

543 }

544

545 return 0;

546 }

547

548 #define TYPE_ONTEXTDATA 1

549 #define TYPE_UNKNOWN 2

550

551 static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)

552 {

553 AMFDataType type;

554 AVStream *stream, *astream, *vstream;

555 AVStream av_unused *dstream;

556 AVIOContext *ioc;

557 int i;

558 // only needs to hold the string "onMetaData".

559 // Anything longer is something we don't want.

560 char buffer[11];

561

562 astream = NULL;

563 vstream = NULL;

564 dstream = NULL;

565 ioc = s->pb;

566

567 // first object needs to be "onMetaData" string

568 type = avio_r8(ioc);

569 if (type != AMF_DATA_TYPE_STRING ||

570 amf_get_string(ioc, buffer, sizeof(buffer)) < 0)

571 return TYPE_UNKNOWN;

572

573 if (!strcmp(buffer, "onTextData"))

574 return TYPE_ONTEXTDATA;

575

576 if (strcmp(buffer, "onMetaData") && strcmp(buffer, "onCuePoint"))

577 return TYPE_UNKNOWN;

578

579 // find the streams now so that amf_parse_object doesn't need to do

580 // the lookup every time it is called.

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

582 stream = s->streams[i];

583 if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO)

584 vstream = stream;

585 else if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO)

586 astream = stream;

587 else if (stream->codec->codec_type == AVMEDIA_TYPE_DATA)

588 dstream = stream;

589 }

590

591 // parse the second object (we want a mixed array)

592 if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)

593 return -1;

594

595 return 0;

596 }

597

598 static int flv_read_header(AVFormatContext *s)

599 {

600 int offset, flags;

601

602 avio_skip(s->pb, 4);

603 flags = avio_r8(s->pb);

604

605 s->ctx_flags |= AVFMTCTX_NOHEADER;

606

607 if (flags & FLV_HEADER_FLAG_HASVIDEO)

608 if (!create_stream(s, AVMEDIA_TYPE_VIDEO))

609 return AVERROR(ENOMEM);

610 if (flags & FLV_HEADER_FLAG_HASAUDIO)

611 if (!create_stream(s, AVMEDIA_TYPE_AUDIO))

612 return AVERROR(ENOMEM);

613 // Flag doesn't indicate whether or not there is script-data present. Must

614 // create that stream if it's encountered.

615

616 offset = avio_rb32(s->pb);

617 avio_seek(s->pb, offset, SEEK_SET);

618 avio_skip(s->pb, 4);

619

620 s->start_time = 0;

621

622 return 0;

623 }

624

625 static int flv_read_close(AVFormatContext *s)

626 {

627 int i;

628 FLVContext *flv = s->priv_data;

629 for (i=0; i<FLV_STREAM_TYPE_NB; i++)

630 av_freep(&flv->new_extradata[i]);

631 return 0;

632 }

633

634 static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)

635 {

636 av_freep(&st->codec->extradata);

637 if (ff_get_extradata(st->codec, s->pb, size) < 0)

638 return AVERROR(ENOMEM);

639 return 0;

640 }

641

642 static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,

643 int size)

644 {

645 av_free(flv->new_extradata[stream]);

646 flv->new_extradata[stream] = av_mallocz(size +

647 FF_INPUT_BUFFER_PADDING_SIZE);

648 if (!flv->new_extradata[stream])

649 return AVERROR(ENOMEM);

650 flv->new_extradata_size[stream] = size;

651 avio_read(pb, flv->new_extradata[stream], size);

652 return 0;

653 }

654

655 static void clear_index_entries(AVFormatContext *s, int64_t pos)

656 {

657 int i, j, out;

658 av_log(s, AV_LOG_WARNING,

659 "Found invalid index entries, clearing the index.\n");

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

661 AVStream *st = s->streams[i];

662 /* Remove all index entries that point to >= pos */

663 out = 0;

664 for (j = 0; j < st->nb_index_entries; j++)

665 if (st->index_entries[j].pos < pos)

666 st->index_entries[out++] = st->index_entries[j];

667 st->nb_index_entries = out;

668 }

669 }

670

671 static int amf_skip_tag(AVIOContext *pb, AMFDataType type)

672 {

673 int nb = -1, ret, parse_name = 1;

674

675 switch (type) {

676 case AMF_DATA_TYPE_NUMBER:

677 avio_skip(pb, 8);

678 break;

679 case AMF_DATA_TYPE_BOOL:

680 avio_skip(pb, 1);

681 break;

682 case AMF_DATA_TYPE_STRING:

683 avio_skip(pb, avio_rb16(pb));

684 break;

685 case AMF_DATA_TYPE_ARRAY:

686 parse_name = 0;

687 case AMF_DATA_TYPE_MIXEDARRAY:

688 nb = avio_rb32(pb);

689 case AMF_DATA_TYPE_OBJECT:

690 while(!pb->eof_reached && (nb-- > 0 || type != AMF_DATA_TYPE_ARRAY)) {

691 if (parse_name) {

692 int size = avio_rb16(pb);

693 if (!size) {

694 avio_skip(pb, 1);

695 break;

696 }

697 avio_skip(pb, size);

698 }

699 if ((ret = amf_skip_tag(pb, avio_r8(pb))) < 0)

700 return ret;

701 }

702 break;

703 case AMF_DATA_TYPE_NULL:

704 case AMF_DATA_TYPE_OBJECT_END:

705 break;

706 default:

707 return AVERROR_INVALIDDATA;

708 }

709 return 0;

710 }

711

712 static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,

713 int64_t dts, int64_t next)

714 {

715 AVIOContext *pb = s->pb;

716 AVStream *st = NULL;

717 char buf[20];

718 int ret = AVERROR_INVALIDDATA;

719 int i, length = -1;

720

721 switch (avio_r8(pb)) {

722 case AMF_DATA_TYPE_MIXEDARRAY:

723 avio_seek(pb, 4, SEEK_CUR);

724 case AMF_DATA_TYPE_OBJECT:

725 break;

726 default:

727 goto skip;

728 }

729

730 while ((ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {

731 AMFDataType type = avio_r8(pb);

732 if (type == AMF_DATA_TYPE_STRING && !strcmp(buf, "text")) {

733 length = avio_rb16(pb);

734 ret = av_get_packet(pb, pkt, length);

735 if (ret < 0)

736 goto skip;

737 else

738 break;

739 } else {

740 if ((ret = amf_skip_tag(pb, type)) < 0)

741 goto skip;

742 }

743 }

744

745 if (length < 0) {

746 ret = AVERROR_INVALIDDATA;

747 goto skip;

748 }

749

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

751 st = s->streams[i];

752 if (st->codec->codec_type == AVMEDIA_TYPE_DATA)

753 break;

754 }

755

756 if (i == s->nb_streams) {

757 st = create_stream(s, AVMEDIA_TYPE_DATA);

758 if (!st)

759 return AVERROR(ENOMEM);

760 st->codec->codec_id = AV_CODEC_ID_TEXT;

761 }

762

763 pkt->dts = dts;

764 pkt->pts = dts;

765 pkt->size = ret;

766

767 pkt->stream_index = st->index;

768 pkt->flags |= AV_PKT_FLAG_KEY;

769

770 skip:

771 avio_seek(s->pb, next + 4, SEEK_SET);

772

773 return ret;

774 }

775

776 static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)

777 {

778 FLVContext *flv = s->priv_data;

779 int ret, i, type, size, flags;

780 int stream_type=-1;

781 int64_t next, pos, meta_pos;

782 int64_t dts, pts = AV_NOPTS_VALUE;

783 int av_uninit(channels);

784 int av_uninit(sample_rate);

785 AVStream *st = NULL;

786

787 /* pkt size is repeated at end. skip it */

788 for (;; avio_skip(s->pb, 4)) {

789 pos = avio_tell(s->pb);

790 type = (avio_r8(s->pb) & 0x1F);

791 size = avio_rb24(s->pb);

792 dts = avio_rb24(s->pb);

793 dts |= avio_r8(s->pb) << 24;

794 av_dlog(s, "type:%d, size:%d, dts:%"PRId64" pos:%"PRId64"\n", type, size, dts, avio_tell(s->pb));

795 if (avio_feof(s->pb))

796 return AVERROR_EOF;

797 avio_skip(s->pb, 3); /* stream id, always 0 */

798 flags = 0;

799

800 if (flv->validate_next < flv->validate_count) {

801 int64_t validate_pos = flv->validate_index[flv->validate_next].pos;

802 if (pos == validate_pos) {

803 if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <=

804 VALIDATE_INDEX_TS_THRESH) {

805 flv->validate_next++;

806 } else {

807 clear_index_entries(s, validate_pos);

808 flv->validate_count = 0;

809 }

810 } else if (pos > validate_pos) {

811 clear_index_entries(s, validate_pos);

812 flv->validate_count = 0;

813 }

814 }

815

816 if (size == 0)

817 continue;

818

819 next = size + avio_tell(s->pb);

820

821 if (type == FLV_TAG_TYPE_AUDIO) {

822 stream_type = FLV_STREAM_TYPE_AUDIO;

823 flags = avio_r8(s->pb);

824 size--;

825 } else if (type == FLV_TAG_TYPE_VIDEO) {

826 stream_type = FLV_STREAM_TYPE_VIDEO;

827 flags = avio_r8(s->pb);

828 size--;

829 if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD)

830 goto skip;

831 } else if (type == FLV_TAG_TYPE_META) {

832 stream_type=FLV_STREAM_TYPE_DATA;

833 if (size > 13 + 1 + 4 && dts == 0) { // Header-type metadata stuff

834 meta_pos = avio_tell(s->pb);

835 if (flv_read_metabody(s, next) <= 0) {

836 goto skip;

837 }

838 avio_seek(s->pb, meta_pos, SEEK_SET);

839 }

840 } else {

841 av_log(s, AV_LOG_DEBUG,

842 "Skipping flv packet: type %d, size %d, flags %d.\n",

843 type, size, flags);

844 skip:

845 avio_seek(s->pb, next, SEEK_SET);

846 continue;

847 }

848

849 /* skip empty data packets */

850 if (!size)

851 continue;

852

853 /* now find stream */

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

855 st = s->streams[i];

856 if (stream_type == FLV_STREAM_TYPE_AUDIO) {

857 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&

858 (s->audio_codec_id || flv_same_audio_codec(st->codec, flags)))

859 break;

860 } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {

861 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&

862 (s->video_codec_id || flv_same_video_codec(st->codec, flags)))

863 break;

864 } else if (stream_type == FLV_STREAM_TYPE_DATA) {

865 if (st->codec->codec_type == AVMEDIA_TYPE_DATA)

866 break;

867 }

868 }

869 if (i == s->nb_streams) {

870 static const enum AVMediaType stream_types[] = {AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA};

871 av_log(s, AV_LOG_WARNING, "Stream discovered after head already parsed\n");

872 st = create_stream(s, stream_types[stream_type]);

873 if (!st)

874 return AVERROR(ENOMEM);

875

876 }

877 av_dlog(s, "%d %X %d \n", stream_type, flags, st->discard);

878

879 if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY ||

880 stream_type == FLV_STREAM_TYPE_AUDIO)

881 av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);

882

883 if ( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || (stream_type == FLV_STREAM_TYPE_AUDIO)))

884 ||(st->discard >= AVDISCARD_BIDIR && ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && (stream_type == FLV_STREAM_TYPE_VIDEO)))

885 || st->discard >= AVDISCARD_ALL

886 ) {

887 avio_seek(s->pb, next, SEEK_SET);

888 continue;

889 }

890 break;

891 }

892

893 // if not streamed and no duration from metadata then seek to end to find

894 // the duration from the timestamps

895 if (s->pb->seekable && (!s->duration || s->duration == AV_NOPTS_VALUE) && !flv->searched_for_end) {

896 int size;

897 const int64_t pos = avio_tell(s->pb);

898 // Read the last 4 bytes of the file, this should be the size of the

899 // previous FLV tag. Use the timestamp of its payload as duration.

900 int64_t fsize = avio_size(s->pb);

901 retry_duration:

902 avio_seek(s->pb, fsize - 4, SEEK_SET);

903 size = avio_rb32(s->pb);

904 // Seek to the start of the last FLV tag at position (fsize - 4 - size)

905 // but skip the byte indicating the type.

906 avio_seek(s->pb, fsize - 3 - size, SEEK_SET);

907 if (size == avio_rb24(s->pb) + 11) {

908 uint32_t ts = avio_rb24(s->pb);

909 ts |= avio_r8(s->pb) << 24;

910 if (ts)

911 s->duration = ts * (int64_t)AV_TIME_BASE / 1000;

912 else if (fsize >= 8 && fsize - 8 >= size) {

913 fsize -= size+4;

914 goto retry_duration;

915 }

916 }

917

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

919 flv->searched_for_end = 1;

920 }

921

922 if (stream_type == FLV_STREAM_TYPE_AUDIO) {

923 int bits_per_coded_sample;

924 channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;

925 sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>

926 FLV_AUDIO_SAMPLERATE_OFFSET) >> 3;

927 bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;

928 if (!st->codec->channels || !st->codec->sample_rate ||

929 !st->codec->bits_per_coded_sample) {

930 st->codec->channels = channels;

931 st->codec->channel_layout = channels == 1

932 ? AV_CH_LAYOUT_MONO

933 : AV_CH_LAYOUT_STEREO;

934 st->codec->sample_rate = sample_rate;

935 st->codec->bits_per_coded_sample = bits_per_coded_sample;

936 }

937 if (!st->codec->codec_id) {

938 flv_set_audio_codec(s, st, st->codec,

939 flags & FLV_AUDIO_CODECID_MASK);

940 flv->last_sample_rate =

941 sample_rate = st->codec->sample_rate;

942 flv->last_channels =

943 channels = st->codec->channels;

944 } else {

945 AVCodecContext ctx = {0};

946 ctx.sample_rate = sample_rate;

947 ctx.bits_per_coded_sample = bits_per_coded_sample;

948 flv_set_audio_codec(s, st, &ctx, flags & FLV_AUDIO_CODECID_MASK);

949 sample_rate = ctx.sample_rate;

950 }

951 } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {

952 size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);

953 }

954

955 if (st->codec->codec_id == AV_CODEC_ID_AAC ||

956 st->codec->codec_id == AV_CODEC_ID_H264 ||

957 st->codec->codec_id == AV_CODEC_ID_MPEG4) {

958 int type = avio_r8(s->pb);

959 size--;

960 if (st->codec->codec_id == AV_CODEC_ID_H264 || st->codec->codec_id == AV_CODEC_ID_MPEG4) {

961 // sign extension

962 int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;

963 pts = dts + cts;

964 if (cts < 0) { // dts might be wrong

965 if (!flv->wrong_dts)

966 av_log(s, AV_LOG_WARNING,

967 "Negative cts, previous timestamps might be wrong.\n");

968 flv->wrong_dts = 1;

969 } else if (FFABS(dts - pts) > 1000*60*15) {

970 av_log(s, AV_LOG_WARNING,

971 "invalid timestamps %"PRId64" %"PRId64"\n", dts, pts);

972 dts = pts = AV_NOPTS_VALUE;

973 }

974 }

975 if (type == 0 && (!st->codec->extradata || st->codec->codec_id == AV_CODEC_ID_AAC ||

976 st->codec->codec_id == AV_CODEC_ID_H264)) {

977 AVDictionaryEntry *t;

978

979 if (st->codec->extradata) {

980 if ((ret = flv_queue_extradata(flv, s->pb, stream_type, size)) < 0)

981 return ret;

982 ret = AVERROR(EAGAIN);

983 goto leave;

984 }

985 if ((ret = flv_get_extradata(s, st, size)) < 0)

986 return ret;

987

988 /* Workaround for buggy Omnia A/XE encoder */

989 t = av_dict_get(s->metadata, "Encoder", NULL, 0);

990 if (st->codec->codec_id == AV_CODEC_ID_AAC && t && !strcmp(t->value, "Omnia A/XE"))

991 st->codec->extradata_size = 2;

992

993 if (st->codec->codec_id == AV_CODEC_ID_AAC && 0) {

994 MPEG4AudioConfig cfg;

995

996 if (avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,

997 st->codec->extradata_size * 8, 1) >= 0) {

998 st->codec->channels = cfg.channels;

999 st->codec->channel_layout = 0;

1000 if (cfg.ext_sample_rate)

1001 st->codec->sample_rate = cfg.ext_sample_rate;

1002 else

1003 st->codec->sample_rate = cfg.sample_rate;

1004 av_dlog(s, "mp4a config channels %d sample rate %d\n",

1005 st->codec->channels, st->codec->sample_rate);

1006 }

1007 }

1008

1009 ret = AVERROR(EAGAIN);

1010 goto leave;

1011 }

1012 }

1013

1014 /* skip empty data packets */

1015 if (!size) {

1016 ret = AVERROR(EAGAIN);

1017 goto leave;

1018 }

1019

1020 ret = av_get_packet(s->pb, pkt, size);

1021 if (ret < 0)

1022 return ret;

1023 pkt->dts = dts;

1024 pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;

1025 pkt->stream_index = st->index;

1026 if (flv->new_extradata[stream_type]) {

1027 uint8_t *side = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

1028 flv->new_extradata_size[stream_type]);

1029 if (side) {

1030 memcpy(side, flv->new_extradata[stream_type],

1031 flv->new_extradata_size[stream_type]);

1032 av_freep(&flv->new_extradata[stream_type]);

1033 flv->new_extradata_size[stream_type] = 0;

1034 }

1035 }

1036 if (stream_type == FLV_STREAM_TYPE_AUDIO &&

1037 (sample_rate != flv->last_sample_rate ||

1038 channels != flv->last_channels)) {

1039 flv->last_sample_rate = sample_rate;

1040 flv->last_channels = channels;

1041 ff_add_param_change(pkt, channels, 0, sample_rate, 0, 0);

1042 }

1043

1044 if ( stream_type == FLV_STREAM_TYPE_AUDIO ||

1045 ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY) ||

1046 stream_type == FLV_STREAM_TYPE_DATA)

1047 pkt->flags |= AV_PKT_FLAG_KEY;

1048

1049 leave:

1050 avio_skip(s->pb, 4);

1051 return ret;

1052 }

1053

1054 static int flv_read_seek(AVFormatContext *s, int stream_index,

1055 int64_t ts, int flags)

1056 {

1057 FLVContext *flv = s->priv_data;

1058 flv->validate_count = 0;

1059 return avio_seek_time(s->pb, stream_index, ts, flags);

1060 }

1061

1062 #define OFFSET(x) offsetof(FLVContext, x)

1063 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

1064 static const AVOption options[] = {

1065 { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },

1066 { NULL }

1067 };

1068

1069 static const AVClass flv_class = {

1070 .class_name = "flvdec",

1071 .item_name = av_default_item_name,

1072 .option = options,

1073 .version = LIBAVUTIL_VERSION_INT,

1074 };

1075

1076 AVInputFormat ff_flv_demuxer = {

1077 .name = "flv",

1078 .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),

1079 .priv_data_size = sizeof(FLVContext),

1080 .read_probe = flv_probe,

1081 .read_header = flv_read_header,

1082 .read_packet = flv_read_packet,

1083 .read_seek = flv_read_seek,

1084 .read_close = flv_read_close,

1085 .extensions = "flv",

1086 .priv_class = &flv_class,

1087 };

1088

1089 static const AVClass live_flv_class = {

1090 .class_name = "live_flvdec",

1091 .item_name = av_default_item_name,

1092 .option = options,

1093 .version = LIBAVUTIL_VERSION_INT,

1094 };

1095

1096 AVInputFormat ff_live_flv_demuxer = {

1097 .name = "live_flv",

1098 .long_name = NULL_IF_CONFIG_SMALL("live RTMP FLV (Flash Video)"),

1099 .priv_data_size = sizeof(FLVContext),

1100 .read_probe = live_flv_probe,

1101 .read_header = flv_read_header,

1102 .read_packet = flv_read_packet,

1103 .read_seek = flv_read_seek,

1104 .read_close = flv_read_close,

1105 .extensions = "flv",

1106 .priv_class = &live_flv_class,

1107 .flags = AVFMT_TS_DISCONT

1108 };

Generated on Sun Mar 8 2015 02:34:51 for FFmpeg by doxygen 1.8.2