FFmpeg: libavformat/electronicarts.c Source File

FFmpeg

[フレーム]

libavformat

electronicarts.c

Go to the documentation of this file.

1 /* Electronic Arts Multimedia File Demuxer

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

23 * @file

24 * Electronic Arts Multimedia file demuxer (WVE/UV2/etc.)

25 * by Robin Kay (komadori at gekkou.co.uk)

26 */

28 #include "libavutil/intreadwrite.h"

29 #include "avformat.h"

30 #include "internal.h"

32 #define SCHl_TAG MKTAG('S', 'C', 'H', 'l')

33 #define SEAD_TAG MKTAG('S', 'E', 'A', 'D') /* Sxxx header */

34 #define SNDC_TAG MKTAG('S', 'N', 'D', 'C') /* Sxxx data */

35 #define SEND_TAG MKTAG('S', 'E', 'N', 'D') /* Sxxx end */

36 #define SHEN_TAG MKTAG('S', 'H', 'E', 'N') /* SxEN header */

37 #define SDEN_TAG MKTAG('S', 'D', 'E', 'N') /* SxEN data */

38 #define SEEN_TAG MKTAG('S', 'E', 'E', 'N') /* SxEN end */

39 #define ISNh_TAG MKTAG('1', 'S', 'N', 'h') /* 1SNx header */

40 #define EACS_TAG MKTAG('E', 'A', 'C', 'S')

41 #define ISNd_TAG MKTAG('1', 'S', 'N', 'd') /* 1SNx data */

42 #define ISNe_TAG MKTAG('1', 'S', 'N', 'e') /* 1SNx end */

43 #define PT00_TAG MKTAG('P', 'T', 0x0, 0x0)

44 #define GSTR_TAG MKTAG('G', 'S', 'T', 'R')

45 #define SCDl_TAG MKTAG('S', 'C', 'D', 'l')

46 #define SCEl_TAG MKTAG('S', 'C', 'E', 'l')

47 #define kVGT_TAG MKTAG('k', 'V', 'G', 'T') /* TGV i-frame */

48 #define fVGT_TAG MKTAG('f', 'V', 'G', 'T') /* TGV p-frame */

49 #define mTCD_TAG MKTAG('m', 'T', 'C', 'D') /* MDEC */

50 #define MADk_TAG MKTAG('M', 'A', 'D', 'k') /* MAD i-frame */

51 #define MADm_TAG MKTAG('M', 'A', 'D', 'm') /* MAD p-frame */

52 #define MADe_TAG MKTAG('M', 'A', 'D', 'e') /* MAD lqp-frame */

53 #define MPCh_TAG MKTAG('M', 'P', 'C', 'h') /* MPEG2 */

54 #define TGQs_TAG MKTAG('T', 'G', 'Q', 's') /* TGQ i-frame (appears in .TGQ files) */

55 #define pQGT_TAG MKTAG('p', 'Q', 'G', 'T') /* TGQ i-frame (appears in .UV files) */

56 #define pIQT_TAG MKTAG('p', 'I', 'Q', 'T') /* TQI/UV2 i-frame (.UV2/.WVE) */

57 #define MVhd_TAG MKTAG('M', 'V', 'h', 'd')

58 #define MV0K_TAG MKTAG('M', 'V', '0', 'K')

59 #define MV0F_TAG MKTAG('M', 'V', '0', 'F')

60 #define MVIh_TAG MKTAG('M', 'V', 'I', 'h') /* CMV header */

61 #define MVIf_TAG MKTAG('M', 'V', 'I', 'f') /* CMV i-frame */

63 typedef struct EaDemuxContext {

64 int big_endian;

66 enum AVCodecID video_codec;

67 AVRational time_base;

68 int width, height;

69 int nb_frames;

70 int video_stream_index;

72 enum AVCodecID audio_codec;

73 int audio_stream_index;

75 int bytes;

76 int sample_rate;

77 int num_channels;

78 int num_samples;

79 } EaDemuxContext;

81 static uint32_t read_arbitary(AVIOContext *pb) {

82 uint8_t size, byte;

83 int i;

84 uint32_t word;

86 size = avio_r8(pb);

88 word = 0;

89 for (i = 0; i < size; i++) {

90 byte = avio_r8(pb);

91 word <<= 8;

92 word |= byte;

93 }

95 return word;

96 }

98 /*

99 * Process PT/GSTR sound header

100 * return 1 if success, 0 if invalid format, otherwise AVERROR_xxx

101 */

102 static int process_audio_header_elements(AVFormatContext *s)

103 {

104 int inHeader = 1;

105 EaDemuxContext *ea = s->priv_data;

106 AVIOContext *pb = s->pb;

107 int compression_type = -1, revision = -1, revision2 = -1;

108

109 ea->bytes = 2;

110 ea->sample_rate = -1;

111 ea->num_channels = 1;

112

113 while (!url_feof(pb) && inHeader) {

114 int inSubheader;

115 uint8_t byte;

116 byte = avio_r8(pb);

117

118 switch (byte) {

119 case 0xFD:

120 av_log (s, AV_LOG_DEBUG, "entered audio subheader\n");

121 inSubheader = 1;

122 while (!url_feof(pb) && inSubheader) {

123 uint8_t subbyte;

124 subbyte = avio_r8(pb);

125

126 switch (subbyte) {

127 case 0x80:

128 revision = read_arbitary(pb);

129 av_log (s, AV_LOG_DEBUG, "revision (element 0x80) set to 0x%08x\n", revision);

130 break;

131 case 0x82:

132 ea->num_channels = read_arbitary(pb);

133 av_log (s, AV_LOG_DEBUG, "num_channels (element 0x82) set to 0x%08x\n", ea->num_channels);

134 break;

135 case 0x83:

136 compression_type = read_arbitary(pb);

137 av_log (s, AV_LOG_DEBUG, "compression_type (element 0x83) set to 0x%08x\n", compression_type);

138 break;

139 case 0x84:

140 ea->sample_rate = read_arbitary(pb);

141 av_log (s, AV_LOG_DEBUG, "sample_rate (element 0x84) set to %i\n", ea->sample_rate);

142 break;

143 case 0x85:

144 ea->num_samples = read_arbitary(pb);

145 av_log (s, AV_LOG_DEBUG, "num_samples (element 0x85) set to 0x%08x\n", ea->num_samples);

146 break;

147 case 0x8A:

148 av_log (s, AV_LOG_DEBUG, "element 0x%02x set to 0x%08x\n", subbyte, read_arbitary(pb));

149 av_log (s, AV_LOG_DEBUG, "exited audio subheader\n");

150 inSubheader = 0;

151 break;

152 case 0xA0:

153 revision2 = read_arbitary(pb);

154 av_log (s, AV_LOG_DEBUG, "revision2 (element 0xA0) set to 0x%08x\n", revision2);

155 break;

156 case 0xFF:

157 av_log (s, AV_LOG_DEBUG, "end of header block reached (within audio subheader)\n");

158 inSubheader = 0;

159 inHeader = 0;

160 break;

161 default:

162 av_log (s, AV_LOG_DEBUG, "element 0x%02x set to 0x%08x\n", subbyte, read_arbitary(pb));

163 break;

164 }

165 }

166 break;

167 case 0xFF:

168 av_log (s, AV_LOG_DEBUG, "end of header block reached\n");

169 inHeader = 0;

170 break;

171 default:

172 av_log (s, AV_LOG_DEBUG, "header element 0x%02x set to 0x%08x\n", byte, read_arbitary(pb));

173 break;

174 }

175 }

176

177 switch (compression_type) {

178 case 0: ea->audio_codec = AV_CODEC_ID_PCM_S16LE; break;

179 case 7: ea->audio_codec = AV_CODEC_ID_ADPCM_EA; break;

180 case -1:

181 switch (revision) {

182 case 1: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;

183 case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;

184 case 3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3; break;

185 case -1: break;

186 default:

187 avpriv_request_sample(s, "stream type; revision=%i", revision);

188 return 0;

189 }

190 switch (revision2) {

191 case 8: ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR; break;

192 case 10:

193 switch (revision) {

194 case -1:

195 case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;

196 case 3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;

197 default:

198 avpriv_request_sample(s, "stream type; revision=%i, revision2=%i", revision, revision2);

199 return 0;

200 }

201 break;

202 case 16: ea->audio_codec = AV_CODEC_ID_MP3; break;

203 case -1: break;

204 default:

205 ea->audio_codec = AV_CODEC_ID_NONE;

206 avpriv_request_sample(s, "stream type; revision2=%i", revision2);

207 return 0;

208 }

209 break;

210 default:

211 avpriv_request_sample(s, "stream type; compression_type=%i", compression_type);

212 return 0;

213 }

214

215 if (ea->sample_rate == -1)

216 ea->sample_rate = revision==3 ? 48000 : 22050;

217

218 return 1;

219 }

220

221 /*

222 * Process EACS sound header

223 * return 1 if success, 0 if invalid format, otherwise AVERROR_xxx

224 */

225 static int process_audio_header_eacs(AVFormatContext *s)

226 {

227 EaDemuxContext *ea = s->priv_data;

228 AVIOContext *pb = s->pb;

229 int compression_type;

230

231 ea->sample_rate = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);

232 ea->bytes = avio_r8(pb); /* 1=8-bit, 2=16-bit */

233 ea->num_channels = avio_r8(pb);

234 compression_type = avio_r8(pb);

235 avio_skip(pb, 13);

236

237 switch (compression_type) {

238 case 0:

239 switch (ea->bytes) {

240 case 1: ea->audio_codec = AV_CODEC_ID_PCM_S8; break;

241 case 2: ea->audio_codec = AV_CODEC_ID_PCM_S16LE; break;

242 }

243 break;

244 case 1: ea->audio_codec = AV_CODEC_ID_PCM_MULAW; ea->bytes = 1; break;

245 case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS; break;

246 default:

247 avpriv_request_sample(s, "stream type; audio compression_type=%i", compression_type);

248 }

249

250 return 1;

251 }

252

253 /*

254 * Process SEAD sound header

255 * return 1 if success, 0 if invalid format, otherwise AVERROR_xxx

256 */

257 static int process_audio_header_sead(AVFormatContext *s)

258 {

259 EaDemuxContext *ea = s->priv_data;

260 AVIOContext *pb = s->pb;

261

262 ea->sample_rate = avio_rl32(pb);

263 ea->bytes = avio_rl32(pb); /* 1=8-bit, 2=16-bit */

264 ea->num_channels = avio_rl32(pb);

265 ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;

266

267 return 1;

268 }

269

270 static int process_video_header_mdec(AVFormatContext *s)

271 {

272 EaDemuxContext *ea = s->priv_data;

273 AVIOContext *pb = s->pb;

274 avio_skip(pb, 4);

275 ea->width = avio_rl16(pb);

276 ea->height = avio_rl16(pb);

277 ea->time_base = (AVRational){1,15};

278 ea->video_codec = AV_CODEC_ID_MDEC;

279 return 1;

280 }

281

282 static int process_video_header_vp6(AVFormatContext *s)

283 {

284 EaDemuxContext *ea = s->priv_data;

285 AVIOContext *pb = s->pb;

286

287 avio_skip(pb, 8);

288 ea->nb_frames = avio_rl32(pb);

289 avio_skip(pb, 4);

290 ea->time_base.den = avio_rl32(pb);

291 ea->time_base.num = avio_rl32(pb);

292 if (ea->time_base.den <= 0 || ea->time_base.num <= 0) {

293 av_log(s, AV_LOG_ERROR, "Timebase is invalid\n");

294 return AVERROR_INVALIDDATA;

295 }

296 ea->video_codec = AV_CODEC_ID_VP6;

297

298 return 1;

299 }

300

301 static int process_video_header_cmv(AVFormatContext *s)

302 {

303 EaDemuxContext *ea = s->priv_data;

304 int fps;

305

306 avio_skip(s->pb, 10);

307 fps = avio_rl16(s->pb);

308 if (fps)

309 ea->time_base = (AVRational){1, fps};

310 ea->video_codec = AV_CODEC_ID_CMV;

311

312 return 0;

313 }

314

315 /*

316 * Process EA file header

317 * Returns 1 if the EA file is valid and successfully opened, 0 otherwise

318 */

319 static int process_ea_header(AVFormatContext *s) {

320 uint32_t blockid, size = 0;

321 EaDemuxContext *ea = s->priv_data;

322 AVIOContext *pb = s->pb;

323 int i;

324

325 for (i=0; i<5 && (!ea->audio_codec || !ea->video_codec); i++) {

326 unsigned int startpos = avio_tell(pb);

327 int err = 0;

328

329 blockid = avio_rl32(pb);

330 size = avio_rl32(pb);

331 if (i == 0)

332 ea->big_endian = size > 0x000FFFFF;

333 if (ea->big_endian)

334 size = av_bswap32(size);

335

336 switch (blockid) {

337 case ISNh_TAG:

338 if (avio_rl32(pb) != EACS_TAG) {

339 avpriv_request_sample(s, "unknown 1SNh headerid");

340 return 0;

341 }

342 err = process_audio_header_eacs(s);

343 break;

344

345 case SCHl_TAG :

346 case SHEN_TAG :

347 blockid = avio_rl32(pb);

348 if (blockid == GSTR_TAG) {

349 avio_skip(pb, 4);

350 } else if ((blockid & 0xFFFF)!=PT00_TAG) {

351 avpriv_request_sample(s, "unknown SCHl headerid");

352 return 0;

353 }

354 err = process_audio_header_elements(s);

355 break;

356

357 case SEAD_TAG:

358 err = process_audio_header_sead(s);

359 break;

360

361 case MVIh_TAG :

362 err = process_video_header_cmv(s);

363 break;

364

365 case kVGT_TAG:

366 ea->video_codec = AV_CODEC_ID_TGV;

367 break;

368

369 case mTCD_TAG :

370 err = process_video_header_mdec(s);

371 break;

372

373 case MPCh_TAG:

374 ea->video_codec = AV_CODEC_ID_MPEG2VIDEO;

375 break;

376

377 case pQGT_TAG:

378 case TGQs_TAG:

379 ea->video_codec = AV_CODEC_ID_TGQ;

380 break;

381

382 case pIQT_TAG:

383 ea->video_codec = AV_CODEC_ID_TQI;

384 break;

385

386 case MADk_TAG :

387 ea->video_codec = AV_CODEC_ID_MAD;

388 break;

389

390 case MVhd_TAG :

391 err = process_video_header_vp6(s);

392 break;

393 }

394

395 if (err < 0) {

396 av_log(s, AV_LOG_ERROR, "error parsing header: %i\n", err);

397 return err;

398 }

399

400 avio_seek(pb, startpos + size, SEEK_SET);

401 }

402

403 avio_seek(pb, 0, SEEK_SET);

404

405 return 1;

406 }

407

408

409 static int ea_probe(AVProbeData *p)

410 {

411 switch (AV_RL32(&p->buf[0])) {

412 case ISNh_TAG:

413 case SCHl_TAG:

414 case SEAD_TAG:

415 case SHEN_TAG:

416 case kVGT_TAG:

417 case MADk_TAG:

418 case MPCh_TAG:

419 case MVhd_TAG:

420 case MVIh_TAG:

421 break;

422 default:

423 return 0;

424 }

425 if (AV_RL32(&p->buf[4]) > 0xfffff && AV_RB32(&p->buf[4]) > 0xfffff)

426 return 0;

427 return AVPROBE_SCORE_MAX;

428 }

429

430 static int ea_read_header(AVFormatContext *s)

431 {

432 EaDemuxContext *ea = s->priv_data;

433 AVStream *st;

434

435 if (process_ea_header(s)<=0)

436 return AVERROR(EIO);

437

438 if (ea->video_codec) {

439 /* initialize the video decoder stream */

440 st = avformat_new_stream(s, NULL);

441 if (!st)

442 return AVERROR(ENOMEM);

443 ea->video_stream_index = st->index;

444 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

445 st->codec->codec_id = ea->video_codec;

446 // parsing is necessary to make FFmpeg generate correct timestamps

447 if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO)

448 st->need_parsing = AVSTREAM_PARSE_HEADERS;

449 st->codec->codec_tag = 0; /* no fourcc */

450 st->codec->width = ea->width;

451 st->codec->height = ea->height;

452 st->duration = st->nb_frames = ea->nb_frames;

453 if (ea->time_base.num)

454 avpriv_set_pts_info(st, 64, ea->time_base.num, ea->time_base.den);

455 st->r_frame_rate =

456 st->avg_frame_rate = av_inv_q(ea->time_base);

457 }

458

459 if (ea->audio_codec) {

460 if (ea->num_channels <= 0) {

461 av_log(s, AV_LOG_WARNING, "Unsupported number of channels: %d\n", ea->num_channels);

462 ea->audio_codec = 0;

463 return 1;

464 }

465 if (ea->sample_rate <= 0) {

466 av_log(s, AV_LOG_ERROR, "Unsupported sample rate: %d\n", ea->sample_rate);

467 ea->audio_codec = 0;

468 return 1;

469 }

470 if (ea->bytes <= 0) {

471 av_log(s, AV_LOG_ERROR, "Invalid number of bytes per sample: %d\n", ea->bytes);

472 ea->audio_codec = AV_CODEC_ID_NONE;

473 return 1;

474 }

475

476 /* initialize the audio decoder stream */

477 st = avformat_new_stream(s, NULL);

478 if (!st)

479 return AVERROR(ENOMEM);

480 avpriv_set_pts_info(st, 33, 1, ea->sample_rate);

481 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

482 st->codec->codec_id = ea->audio_codec;

483 st->codec->codec_tag = 0; /* no tag */

484 st->codec->channels = ea->num_channels;

485 st->codec->sample_rate = ea->sample_rate;

486 st->codec->bits_per_coded_sample = ea->bytes * 8;

487 st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *

488 st->codec->bits_per_coded_sample / 4;

489 st->codec->block_align = st->codec->channels*st->codec->bits_per_coded_sample;

490 ea->audio_stream_index = st->index;

491 st->start_time = 0;

492 }

493

494 return 1;

495 }

496

497 static int ea_read_packet(AVFormatContext *s,

498 AVPacket *pkt)

499 {

500 EaDemuxContext *ea = s->priv_data;

501 AVIOContext *pb = s->pb;

502 int ret = 0;

503 int packet_read = 0;

504 int partial_packet = 0;

505 unsigned int chunk_type, chunk_size;

506 int key = 0;

507 int av_uninit(num_samples);

508

509 while (!packet_read || partial_packet) {

510 chunk_type = avio_rl32(pb);

511 chunk_size = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);

512 if (chunk_size <= 8)

513 return AVERROR_INVALIDDATA;

514 chunk_size -= 8;

515

516 switch (chunk_type) {

517 /* audio data */

518 case ISNh_TAG:

519 /* header chunk also contains data; skip over the header portion*/

520 if (chunk_size < 32)

521 return AVERROR_INVALIDDATA;

522 avio_skip(pb, 32);

523 chunk_size -= 32;

524 case ISNd_TAG:

525 case SCDl_TAG:

526 case SNDC_TAG:

527 case SDEN_TAG:

528 if (!ea->audio_codec) {

529 avio_skip(pb, chunk_size);

530 break;

531 } else if (ea->audio_codec == AV_CODEC_ID_PCM_S16LE_PLANAR ||

532 ea->audio_codec == AV_CODEC_ID_MP3) {

533 num_samples = avio_rl32(pb);

534 avio_skip(pb, 8);

535 chunk_size -= 12;

536 }

537 if (partial_packet) {

538 avpriv_request_sample(s, "video header followed by audio packet");

539 av_free_packet(pkt);

540 partial_packet = 0;

541 }

542 ret = av_get_packet(pb, pkt, chunk_size);

543 if (ret < 0)

544 return ret;

545 pkt->stream_index = ea->audio_stream_index;

546

547 switch (ea->audio_codec) {

548 case AV_CODEC_ID_ADPCM_EA:

549 case AV_CODEC_ID_ADPCM_EA_R1:

550 case AV_CODEC_ID_ADPCM_EA_R2:

551 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:

552 if (pkt->size >= 4)

553 pkt->duration = AV_RL32(pkt->data);

554 break;

555 case AV_CODEC_ID_ADPCM_EA_R3:

556 if (pkt->size >= 4)

557 pkt->duration = AV_RB32(pkt->data);

558 break;

559 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:

560 pkt->duration = ret * 2 / ea->num_channels;

561 break;

562 case AV_CODEC_ID_PCM_S16LE_PLANAR:

563 case AV_CODEC_ID_MP3:

564 pkt->duration = num_samples;

565 break;

566 default:

567 pkt->duration = chunk_size / (ea->bytes * ea->num_channels);

568 }

569

570 packet_read = 1;

571 break;

572

573 /* ending tag */

574 case 0:

575 case ISNe_TAG:

576 case SCEl_TAG:

577 case SEND_TAG:

578 case SEEN_TAG:

579 ret = AVERROR(EIO);

580 packet_read = 1;

581 break;

582

583 case MVIh_TAG:

584 case kVGT_TAG:

585 case pQGT_TAG:

586 case TGQs_TAG:

587 case MADk_TAG:

588 key = AV_PKT_FLAG_KEY;

589 case MVIf_TAG:

590 case fVGT_TAG:

591 case MADm_TAG:

592 case MADe_TAG:

593 avio_seek(pb, -8, SEEK_CUR); // include chunk preamble

594 chunk_size += 8;

595 goto get_video_packet;

596

597 case mTCD_TAG:

598 avio_skip(pb, 8); // skip ea dct header

599 chunk_size -= 8;

600 goto get_video_packet;

601

602 case MV0K_TAG:

603 case MPCh_TAG:

604 case pIQT_TAG:

605 key = AV_PKT_FLAG_KEY;

606 case MV0F_TAG:

607 get_video_packet:

608 if (partial_packet) {

609 ret = av_append_packet(pb, pkt, chunk_size);

610 } else

611 ret = av_get_packet(pb, pkt, chunk_size);

612 if (ret < 0) {

613 packet_read = 1;

614 break;

615 }

616 partial_packet = chunk_type == MVIh_TAG;

617 pkt->stream_index = ea->video_stream_index;

618 pkt->flags |= key;

619 packet_read = 1;

620 break;

621

622 default:

623 avio_skip(pb, chunk_size);

624 break;

625 }

626 }

627

628 if (ret < 0 && partial_packet)

629 av_free_packet(pkt);

630 return ret;

631 }

632

633 AVInputFormat ff_ea_demuxer = {

634 .name = "ea",

635 .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),

636 .priv_data_size = sizeof(EaDemuxContext),

637 .read_probe = ea_probe,

638 .read_header = ea_read_header,

639 .read_packet = ea_read_packet,

640 };

Generated on Wed Jul 10 2013 23:48:11 for FFmpeg by doxygen 1.8.2