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 <inttypes.h>

30 #include "libavutil/intreadwrite.h"

31 #include "libavutil/opt.h"

32 #include "avformat.h"

33 #include "demux.h"

34 #include "internal.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

57 #define MPCh_TAG MKTAG('M', 'P', 'C', 'h') /* MPEG-2 */

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

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

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

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

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

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

64 #define AVhd_TAG MKTAG('A', 'V', 'h', 'd')

65 #define AV0K_TAG MKTAG('A', 'V', '0', 'K')

66 #define AV0F_TAG MKTAG('A', 'V', '0', 'F')

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

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

69 #define AVP6_TAG MKTAG('A', 'V', 'P', '6')

71 typedef struct VideoProperties {

72 enum AVCodecID codec;

73 AVRational time_base;

74 int width, height;

75 int nb_frames;

76 int stream_index;

77 } VideoProperties;

79 typedef struct EaDemuxContext {

80 const AVClass *class;

82 int big_endian;

84 VideoProperties video, alpha;

86 enum AVCodecID audio_codec;

87 int audio_stream_index;

89 int bytes;

90 int sample_rate;

91 int num_channels;

92 int num_samples;

94 int platform;

95 int merge_alpha;

96 } EaDemuxContext;

98 static uint32_t read_arbitrary(AVIOContext *pb)

99 {

100 uint8_t size, byte;

101 int i;

102 uint32_t word;

103

104 size = avio_r8(pb);

105

106 word = 0;

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

108 byte = avio_r8(pb);

109 word <<= 8;

110 word |= byte;

111 }

112

113 return word;

114 }

115

116 static int process_audio_header_elements(AVFormatContext *s)

117 {

118 EaDemuxContext *ea = s->priv_data;

119 AVIOContext *pb = s->pb;

120 int in_header = 1;

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

122

123 ea->bytes = 2;

124 ea->sample_rate = -1;

125 ea->num_channels = 1;

126

127 while (!avio_feof(pb) && in_header) {

128 int in_subheader;

129 uint8_t byte;

130 byte = avio_r8(pb);

131

132 switch (byte) {

133 case 0xFD:

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

135 in_subheader = 1;

136 while (!avio_feof(pb) && in_subheader) {

137 uint8_t subbyte;

138 subbyte = avio_r8(pb);

139

140 switch (subbyte) {

141 case 0x80:

142 revision = read_arbitrary(pb);

143 av_log(s, AV_LOG_DEBUG,

144 "revision (element 0x80) set to 0x%08x\n", revision);

145 break;

146 case 0x82:

147 ea->num_channels = read_arbitrary(pb);

148 av_log(s, AV_LOG_DEBUG,

149 "num_channels (element 0x82) set to 0x%08x\n",

150 ea->num_channels);

151 break;

152 case 0x83:

153 compression_type = read_arbitrary(pb);

154 av_log(s, AV_LOG_DEBUG,

155 "compression_type (element 0x83) set to 0x%08x\n",

156 compression_type);

157 break;

158 case 0x84:

159 ea->sample_rate = read_arbitrary(pb);

160 av_log(s, AV_LOG_DEBUG,

161 "sample_rate (element 0x84) set to %i\n",

162 ea->sample_rate);

163 break;

164 case 0x85:

165 ea->num_samples = read_arbitrary(pb);

166 av_log(s, AV_LOG_DEBUG,

167 "num_samples (element 0x85) set to 0x%08x\n",

168 ea->num_samples);

169 break;

170 case 0x8A:

171 av_log(s, AV_LOG_DEBUG,

172 "element 0x%02x set to 0x%08"PRIx32"\n",

173 subbyte, read_arbitrary(pb));

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

175 in_subheader = 0;

176 break;

177 case 0xA0:

178 revision2 = read_arbitrary(pb);

179 av_log(s, AV_LOG_DEBUG,

180 "revision2 (element 0xA0) set to 0x%08x\n",

181 revision2);

182 break;

183 case 0xFF:

184 av_log(s, AV_LOG_DEBUG,

185 "end of header block reached (within audio subheader)\n");

186 in_subheader = 0;

187 in_header = 0;

188 break;

189 default:

190 av_log(s, AV_LOG_DEBUG,

191 "element 0x%02x set to 0x%08"PRIx32"\n",

192 subbyte, read_arbitrary(pb));

193 break;

194 }

195 }

196 break;

197 case 0xFF:

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

199 in_header = 0;

200 break;

201 case 0x1B:

202 ea->video.time_base = (AVRational) {1, read_arbitrary(pb)};

203 av_log(s, AV_LOG_DEBUG, "Setting framerate to %u\n", ea->video.time_base.den);

204 break;

205 default:

206 av_log(s, AV_LOG_DEBUG,

207 "header element 0x%02x set to 0x%08"PRIx32"\n",

208 byte, read_arbitrary(pb));

209 break;

210 }

211 }

212

213 switch (compression_type) {

214 case 0:

215 ea->audio_codec = AV_CODEC_ID_PCM_S16LE;

216 break;

217 case 7:

218 ea->audio_codec = AV_CODEC_ID_ADPCM_EA;

219 break;

220 case -1:

221 switch (revision) {

222 case 1:

223 ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1;

224 break;

225 case 2:

226 ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2;

227 break;

228 case 3:

229 ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3;

230 break;

231 case -1:

232 break;

233 default:

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

235 return 0;

236 }

237 switch (revision2) {

238 case 8:

239 ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR;

240 break;

241 case 10:

242 switch (revision) {

243 case -1:

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

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

246 default:

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

248 return 0;

249 }

250 break;

251 case 15:

252 case 16:

253 ea->audio_codec = AV_CODEC_ID_MP3;

254 break;

255 case -1:

256 break;

257 default:

258 ea->audio_codec = AV_CODEC_ID_NONE;

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

260 return 0;

261 }

262 break;

263 default:

264 avpriv_request_sample(s,

265 "stream type; compression_type=%i",

266 compression_type);

267 return 0;

268 }

269

270 if (ea->audio_codec == AV_CODEC_ID_NONE && ea->platform == 0x01)

271 ea->audio_codec = AV_CODEC_ID_ADPCM_PSX;

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

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

274

275 return 1;

276 }

277

278 static void process_audio_header_eacs(AVFormatContext *s)

279 {

280 EaDemuxContext *ea = s->priv_data;

281 AVIOContext *pb = s->pb;

282 int compression_type;

283

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

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

286 ea->num_channels = avio_r8(pb);

287 compression_type = avio_r8(pb);

288 avio_skip(pb, 13);

289

290 switch (compression_type) {

291 case 0:

292 switch (ea->bytes) {

293 case 1:

294 ea->audio_codec = AV_CODEC_ID_PCM_S8;

295 break;

296 case 2:

297 ea->audio_codec = AV_CODEC_ID_PCM_S16LE;

298 break;

299 }

300 break;

301 case 1:

302 ea->audio_codec = AV_CODEC_ID_PCM_MULAW;

303 ea->bytes = 1;

304 break;

305 case 2:

306 ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS;

307 break;

308 default:

309 avpriv_request_sample(s,

310 "stream type; audio compression_type=%i",

311 compression_type);

312 }

313 }

314

315 static void process_audio_header_sead(AVFormatContext *s)

316 {

317 EaDemuxContext *ea = s->priv_data;

318 AVIOContext *pb = s->pb;

319

320 ea->sample_rate = avio_rl32(pb);

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

322 ea->num_channels = avio_rl32(pb);

323 ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;

324 }

325

326 static void process_video_header_mdec(AVFormatContext *s, VideoProperties *video)

327 {

328 AVIOContext *pb = s->pb;

329 avio_skip(pb, 4);

330 video->width = avio_rl16(pb);

331 video->height = avio_rl16(pb);

332 if (!video->time_base.num)

333 video->time_base = (AVRational) { 1, 15 };

334 video->codec = AV_CODEC_ID_MDEC;

335 }

336

337 static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)

338 {

339 AVIOContext *pb = s->pb;

340

341 avio_skip(pb, 8);

342 video->nb_frames = avio_rl32(pb);

343 avio_skip(pb, 4);

344 video->time_base.den = avio_rl32(pb);

345 video->time_base.num = avio_rl32(pb);

346 if (video->time_base.den <= 0 || video->time_base.num <= 0) {

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

348 return AVERROR_INVALIDDATA;

349 }

350 video->codec = AV_CODEC_ID_VP6;

351

352 return 1;

353 }

354

355 static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)

356 {

357 int fps;

358

359 avio_skip(s->pb, 10);

360 fps = avio_rl16(s->pb);

361 if (fps)

362 video->time_base = (AVRational) { 1, fps };

363 video->codec = AV_CODEC_ID_CMV;

364 }

365

366 /* Process EA file header.

367 * Return 1 if the EA file is valid and successfully opened, 0 otherwise. */

368 static int process_ea_header(AVFormatContext *s)

369 {

370 uint32_t blockid, size = 0;

371 EaDemuxContext *ea = s->priv_data;

372 AVIOContext *pb = s->pb;

373 int i;

374

375 for (i = 0; i < 5 && (!ea->audio_codec || !ea->video.codec); i++) {

376 uint64_t startpos = avio_tell(pb);

377 int err = 0;

378

379 blockid = avio_rl32(pb);

380 size = avio_rl32(pb);

381 if (i == 0)

382 ea->big_endian = size > av_bswap32(size);

383 if (ea->big_endian)

384 size = av_bswap32(size);

385

386 if (size < 8) {

387 av_log(s, AV_LOG_ERROR, "chunk size too small\n");

388 return AVERROR_INVALIDDATA;

389 }

390

391 switch (blockid) {

392 case ISNh_TAG:

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

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

395 return 0;

396 }

397 process_audio_header_eacs(s);

398 break;

399

400 case SCHl_TAG:

401 case SHEN_TAG:

402 blockid = avio_rl32(pb);

403 if (blockid == GSTR_TAG) {

404 avio_skip(pb, 4);

405 } else if ((blockid & 0xFF) != (PT00_TAG & 0xFF)) {

406 blockid = avio_rl32(pb);

407 }

408 ea->platform = (blockid >> 16) & 0xFF;

409 err = process_audio_header_elements(s);

410 break;

411

412 case SEAD_TAG:

413 process_audio_header_sead(s);

414 break;

415

416 case MVIh_TAG:

417 process_video_header_cmv(s, &ea->video);

418 break;

419

420 case kVGT_TAG:

421 ea->video.codec = AV_CODEC_ID_TGV;

422 break;

423

424 case mTCD_TAG:

425 process_video_header_mdec(s, &ea->video);

426 break;

427

428 case MPCh_TAG:

429 ea->video.codec = AV_CODEC_ID_MPEG2VIDEO;

430 break;

431

432 case pQGT_TAG:

433 case TGQs_TAG:

434 ea->video.codec = AV_CODEC_ID_TGQ;

435 if (!ea->video.time_base.num)

436 ea->video.time_base = (AVRational) { 1, 15 };

437 break;

438

439 case pIQT_TAG:

440 ea->video.codec = AV_CODEC_ID_TQI;

441 if (!ea->video.time_base.num)

442 ea->video.time_base = (AVRational) { 1, 15 };

443 break;

444

445 case MADk_TAG:

446 ea->video.codec = AV_CODEC_ID_MAD;

447 avio_skip(pb, 6);

448 ea->video.time_base = (AVRational) { avio_rl16(pb), 1000 };

449 break;

450

451 case MVhd_TAG:

452 err = process_video_header_vp6(s, &ea->video);

453 break;

454

455 case AVhd_TAG:

456 err = process_video_header_vp6(s, &ea->alpha);

457 if (err >= 0 && ea->video.codec == AV_CODEC_ID_VP6 && ea->merge_alpha) {

458 ea->alpha.codec = 0;

459 ea->video.codec = AV_CODEC_ID_VP6A;

460 }

461 break;

462 }

463

464 if (err < 0) {

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

466 return err;

467 }

468

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

470 }

471

472 avio_seek(pb, 0, SEEK_SET);

473

474 return 1;

475 }

476

477 static int ea_probe(const AVProbeData *p)

478 {

479 unsigned big_endian, size;

480

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

482 case ISNh_TAG:

483 case SCHl_TAG:

484 case SEAD_TAG:

485 case SHEN_TAG:

486 case kVGT_TAG:

487 case MADk_TAG:

488 case MPCh_TAG:

489 case MVhd_TAG:

490 case MVIh_TAG:

491 case AVP6_TAG:

492 break;

493 default:

494 return 0;

495 }

496 size = AV_RL32(&p->buf[4]);

497 big_endian = size > 0x000FFFFF;

498 if (big_endian)

499 size = av_bswap32(size);

500 if (size > 0xfffff || size < 8)

501 return 0;

502

503 return AVPROBE_SCORE_MAX;

504 }

505

506 static int init_video_stream(AVFormatContext *s, VideoProperties *video)

507 {

508 AVStream *st;

509

510 if (!video->codec)

511 return 0;

512

513 /* initialize the video decoder stream */

514 st = avformat_new_stream(s, NULL);

515 if (!st)

516 return AVERROR(ENOMEM);

517 video->stream_index = st->index;

518 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

519 st->codecpar->codec_id = video->codec;

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

521 if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO)

522 ffstream(st)->need_parsing = AVSTREAM_PARSE_HEADERS;

523 st->codecpar->codec_tag = 0; /* no fourcc */

524 st->codecpar->width = video->width;

525 st->codecpar->height = video->height;

526 st->duration = st->nb_frames = video->nb_frames;

527 if (video->time_base.num)

528 avpriv_set_pts_info(st, 64, video->time_base.num, video->time_base.den);

529 st->r_frame_rate =

530 st->avg_frame_rate = av_inv_q(video->time_base);

531 return 0;

532 }

533

534 static int ea_read_header(AVFormatContext *s)

535 {

536 EaDemuxContext *ea = s->priv_data;

537 AVStream *st;

538

539 if (process_ea_header(s)<=0)

540 return AVERROR(EIO);

541

542 if (init_video_stream(s, &ea->video) || init_video_stream(s, &ea->alpha))

543 return AVERROR(ENOMEM);

544

545 if (ea->audio_codec) {

546 if (ea->num_channels <= 0 || ea->num_channels > 2) {

547 av_log(s, AV_LOG_WARNING,

548 "Unsupported number of channels: %d\n", ea->num_channels);

549 goto no_audio;

550 }

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

552 av_log(s, AV_LOG_ERROR,

553 "Unsupported sample rate: %d\n", ea->sample_rate);

554 goto no_audio;

555 }

556 if (ea->bytes <= 0 || ea->bytes > 2) {

557 av_log(s, AV_LOG_ERROR,

558 "Invalid number of bytes per sample: %d\n", ea->bytes);

559 goto no_audio;

560 }

561

562 /* initialize the audio decoder stream */

563 st = avformat_new_stream(s, NULL);

564 if (!st)

565 return AVERROR(ENOMEM);

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

567 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

568 st->codecpar->codec_id = ea->audio_codec;

569 st->codecpar->codec_tag = 0; /* no tag */

570 st->codecpar->ch_layout.nb_channels = ea->num_channels;

571 st->codecpar->sample_rate = ea->sample_rate;

572 st->codecpar->bits_per_coded_sample = ea->bytes * 8;

573 st->codecpar->bit_rate = (int64_t)ea->num_channels *

574 st->codecpar->sample_rate *

575 st->codecpar->bits_per_coded_sample / 4;

576 st->codecpar->block_align = ea->num_channels *

577 st->codecpar->bits_per_coded_sample;

578 ea->audio_stream_index = st->index;

579 st->start_time = 0;

580 return 0;

581 }

582 no_audio:

583 ea->audio_codec = AV_CODEC_ID_NONE;

584

585 if (!ea->video.codec)

586 return AVERROR_INVALIDDATA;

587 return 0;

588 }

589

590 static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)

591 {

592 EaDemuxContext *ea = s->priv_data;

593 AVIOContext *pb = s->pb;

594 int partial_packet = 0;

595 int hit_end = 0;

596 unsigned int chunk_type, chunk_size;

597 int ret = 0, packet_read = 0, key = 0, vp6a;

598 int av_uninit(num_samples);

599

600 while ((!packet_read && !hit_end) || partial_packet) {

601 chunk_type = avio_rl32(pb);

602 if (avio_feof(pb))

603 return AVERROR_EOF;

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

605 if (chunk_size < 8)

606 return AVERROR_INVALIDDATA;

607 chunk_size -= 8;

608

609 switch (chunk_type) {

610 /* audio data */

611 case ISNh_TAG:

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

613 if (chunk_size < 32)

614 return AVERROR_INVALIDDATA;

615 avio_skip(pb, 32);

616 chunk_size -= 32;

617 case ISNd_TAG:

618 case SCDl_TAG:

619 case SNDC_TAG:

620 case SDEN_TAG:

621 if (!ea->audio_codec) {

622 avio_skip(pb, chunk_size);

623 break;

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

625 ea->audio_codec == AV_CODEC_ID_MP3) {

626 if (chunk_size < 12)

627 return AVERROR_INVALIDDATA;

628 num_samples = avio_rl32(pb);

629 avio_skip(pb, 8);

630 chunk_size -= 12;

631 } else if (ea->audio_codec == AV_CODEC_ID_ADPCM_PSX) {

632 if (chunk_size < 8)

633 return AVERROR_INVALIDDATA;

634 avio_skip(pb, 8);

635 chunk_size -= 8;

636 }

637

638 if (partial_packet) {

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

640 av_packet_unref(pkt);

641 partial_packet = 0;

642 }

643

644 if (!chunk_size)

645 continue;

646

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

648 if (ret < 0)

649 return ret;

650 pkt->stream_index = ea->audio_stream_index;

651

652 switch (ea->audio_codec) {

653 case AV_CODEC_ID_ADPCM_EA:

654 case AV_CODEC_ID_ADPCM_EA_R1:

655 case AV_CODEC_ID_ADPCM_EA_R2:

656 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:

657 case AV_CODEC_ID_ADPCM_EA_R3:

658 if (pkt->size < 4) {

659 av_log(s, AV_LOG_ERROR, "Packet is too short\n");

660 return AVERROR_INVALIDDATA;

661 }

662 if (ea->audio_codec == AV_CODEC_ID_ADPCM_EA_R3)

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

664 else

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

666 break;

667 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:

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

669 break;

670 case AV_CODEC_ID_PCM_S16LE_PLANAR:

671 case AV_CODEC_ID_MP3:

672 pkt->duration = num_samples;

673 break;

674 case AV_CODEC_ID_ADPCM_PSX:

675 pkt->duration = chunk_size / (16 * ea->num_channels) * 28;

676 break;

677 default:

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

679 }

680

681 packet_read = 1;

682 break;

683

684 /* ending tag */

685 case 0:

686 case ISNe_TAG:

687 case SCEl_TAG:

688 case SEND_TAG:

689 case SEEN_TAG:

690 while (!avio_feof(pb)) {

691 int tag = avio_rl32(pb);

692

693 if (tag == ISNh_TAG ||

694 tag == SCHl_TAG ||

695 tag == SEAD_TAG ||

696 tag == SHEN_TAG) {

697 avio_skip(pb, -4);

698 break;

699 }

700 }

701 if (avio_feof(pb))

702 ret = AVERROR_EOF;

703 hit_end = 1;

704 break;

705

706 case MVIh_TAG:

707 case kVGT_TAG:

708 case pQGT_TAG:

709 case TGQs_TAG:

710 case MADk_TAG:

711 key = AV_PKT_FLAG_KEY;

712 case MVIf_TAG:

713 case fVGT_TAG:

714 case MADm_TAG:

715 case MADe_TAG:

716 if (chunk_size > INT_MAX - 8)

717 return AVERROR_INVALIDDATA;

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

719 chunk_size += 8;

720 goto get_video_packet;

721

722 case mTCD_TAG:

723 if (chunk_size < 8)

724 return AVERROR_INVALIDDATA;

725

726 avio_skip(pb, 8); // skip ea DCT header

727 chunk_size -= 8;

728 goto get_video_packet;

729

730 case MV0K_TAG:

731 case AV0K_TAG:

732 case MPCh_TAG:

733 case pIQT_TAG:

734 key = AV_PKT_FLAG_KEY;

735 case MV0F_TAG:

736 case AV0F_TAG:

737 get_video_packet:

738 if (!chunk_size)

739 continue;

740 if (chunk_size > INT_MAX - 3)

741 return AVERROR_INVALIDDATA;

742

743 vp6a = (ea->video.codec == AV_CODEC_ID_VP6A && (chunk_type == MV0F_TAG || chunk_type == MV0K_TAG));

744

745 if (partial_packet) {

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

747 } else {

748 if (vp6a)

749 avio_seek(pb, -3, SEEK_CUR);

750 ret = av_get_packet(pb, pkt, chunk_size + (vp6a ? 3 : 0));

751 if (ret >= 0 && vp6a)

752 AV_WB24(pkt->data, chunk_size);

753 }

754 packet_read = 1;

755

756 if (ret < 0) {

757 partial_packet = 0;

758 break;

759 }

760 partial_packet = vp6a || chunk_type == MVIh_TAG;

761 if (ea->alpha.codec && (chunk_type == AV0K_TAG || chunk_type == AV0F_TAG))

762 pkt->stream_index = ea->alpha.stream_index;

763 else

764 pkt->stream_index = ea->video.stream_index;

765 pkt->flags |= key;

766 break;

767

768 default:

769 avio_skip(pb, chunk_size);

770 break;

771 }

772 }

773

774 if (ret >= 0 && hit_end && !packet_read)

775 return AVERROR(EAGAIN);

776

777 return ret;

778 }

779

780 #define OFFSET(x) offsetof(EaDemuxContext, x)

781 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

782 static const AVOption options[] = {

783 {"merge_alpha", "return VP6 alpha in the main video stream", OFFSET(merge_alpha), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },

784 {NULL}

785 };

786

787 static const AVClass ea_class = {

788 .class_name = "ea demuxer",

789 .item_name = av_default_item_name,

790 .option = options,

791 .version = LIBAVUTIL_VERSION_INT,

792 };

793

794 const FFInputFormat ff_ea_demuxer = {

795 .p.name = "ea",

796 .p.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),

797 .p.priv_class = &ea_class,

798 .priv_data_size = sizeof(EaDemuxContext),

799 .read_probe = ea_probe,

800 .read_header = ea_read_header,

801 .read_packet = ea_read_packet,

802 };

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:337

SCEl_TAG

#define SCEl_TAG

Definition: electronicarts.c:50

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: packet.c:433

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

ea_read_header

static int ea_read_header(AVFormatContext *s)

Definition: electronicarts.c:534

SCHl_TAG

#define SCHl_TAG

Definition: electronicarts.c:36

process_video_header_vp6

static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)

Definition: electronicarts.c:337

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

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

AV_CODEC_ID_TQI

@ AV_CODEC_ID_TQI

Definition: codec_id.h:174

ea_class

static const AVClass ea_class

Definition: electronicarts.c:787

SEEN_TAG

#define SEEN_TAG

Definition: electronicarts.c:42

avformat_new_stream

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

Add a new stream to a media file.

init_video_stream

static int init_video_stream(AVFormatContext *s, VideoProperties *video)

Definition: electronicarts.c:506

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

int64_t

long long int64_t

Definition: coverity.c:34

VideoProperties::stream_index

int stream_index

Definition: electronicarts.c:76

AVP6_TAG

#define AVP6_TAG

Definition: electronicarts.c:69

MPCh_TAG

#define MPCh_TAG

Definition: electronicarts.c:57

MVIh_TAG

#define MVIh_TAG

Definition: electronicarts.c:67

AVPacket::data

uint8_t * data

Definition: packet.h:558

SEND_TAG

#define SEND_TAG

Definition: electronicarts.c:39

AV_CODEC_ID_VP6

@ AV_CODEC_ID_VP6

Definition: codec_id.h:143

pQGT_TAG

#define pQGT_TAG

Definition: electronicarts.c:59

AVOption

AVOption.

Definition: opt.h:429

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:833

AV_CODEC_ID_ADPCM_EA_R3

@ AV_CODEC_ID_ADPCM_EA_R3

Definition: codec_id.h:397

ISNe_TAG

#define ISNe_TAG

Definition: electronicarts.c:46

process_audio_header_sead

static void process_audio_header_sead(AVFormatContext *s)

Definition: electronicarts.c:315

AVPacket::duration

int64_t duration

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

Definition: packet.h:576

AVCodecParameters::codec_tag

uint32_t codec_tag

Additional information about the codec (corresponds to the AVI FOURCC).

Definition: codec_par.h:59

EaDemuxContext::num_channels

int num_channels

Definition: electronicarts.c:91

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:613

AV_CODEC_ID_PCM_S16LE_PLANAR

@ AV_CODEC_ID_PCM_S16LE_PLANAR

Definition: codec_id.h:355

AV_CODEC_ID_TGQ

@ AV_CODEC_ID_TGQ

Definition: codec_id.h:173

AV_CODEC_ID_MAD

@ AV_CODEC_ID_MAD

Definition: codec_id.h:181

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:463

EaDemuxContext::alpha

VideoProperties alpha

Definition: electronicarts.c:84

EaDemuxContext::bytes

int bytes

Definition: electronicarts.c:89

read_arbitrary

static uint32_t read_arbitrary(AVIOContext *pb)

Definition: electronicarts.c:98

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

kVGT_TAG

#define kVGT_TAG

Definition: electronicarts.c:51

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:347

MADm_TAG

#define MADm_TAG

Definition: electronicarts.c:55

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:494

AV_CODEC_ID_MP3

@ AV_CODEC_ID_MP3

preferred ID for decoding MPEG audio layer 1, 2 or 3

Definition: codec_id.h:460

AVStream::duration

int64_t duration

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

Definition: avformat.h:803

ISNh_TAG

#define ISNh_TAG

Definition: electronicarts.c:43

MADe_TAG

#define MADe_TAG

Definition: electronicarts.c:56

avio_rl16

unsigned int avio_rl16(AVIOContext *s)

Definition: aviobuf.c:717

AVRational::num

int num

Numerator.

Definition: rational.h:59

EaDemuxContext::audio_codec

enum AVCodecID audio_codec

Definition: electronicarts.c:86

AV_CODEC_ID_PCM_S8

@ AV_CODEC_ID_PCM_S8

Definition: codec_id.h:341

VideoProperties::height

int height

Definition: electronicarts.c:74

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:764

AV_CODEC_ID_MDEC

@ AV_CODEC_ID_MDEC

Definition: codec_id.h:89

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

OFFSET

#define OFFSET(x)

Definition: electronicarts.c:780

MV0K_TAG

#define MV0K_TAG

Definition: electronicarts.c:62

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_read_callback.c:42

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:198

AV_CODEC_ID_ADPCM_IMA_EA_SEAD

@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD

Definition: codec_id.h:399

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:549

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:134

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

EaDemuxContext::sample_rate

int sample_rate

Definition: electronicarts.c:90

AV_CODEC_ID_PCM_MULAW

@ AV_CODEC_ID_PCM_MULAW

Definition: codec_id.h:343

ISNd_TAG

#define ISNd_TAG

Definition: electronicarts.c:45

key

const char * key

Definition: hwcontext_opencl.c:189

process_audio_header_elements

static int process_audio_header_elements(AVFormatContext *s)

Definition: electronicarts.c:116

process_video_header_cmv

static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)

Definition: electronicarts.c:355

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:314

AVFormatContext

Format I/O context.

Definition: avformat.h:1264

SCDl_TAG

#define SCDl_TAG

Definition: electronicarts.c:49

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:767

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

AV0F_TAG

#define AV0F_TAG

Definition: electronicarts.c:66

NULL

#define NULL

Definition: coverity.c:32

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AV_CODEC_ID_ADPCM_IMA_EA_EACS

@ AV_CODEC_ID_ADPCM_IMA_EA_EACS

Definition: codec_id.h:400

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

AVProbeData

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

Definition: avformat.h:451

options

Definition: swscale.c:43

TGQs_TAG

#define TGQs_TAG

Definition: electronicarts.c:58

EaDemuxContext

Definition: electronicarts.c:79

GSTR_TAG

#define GSTR_TAG

Definition: electronicarts.c:48

mTCD_TAG

#define mTCD_TAG

Definition: electronicarts.c:53

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

AV_CODEC_ID_VP6A

@ AV_CODEC_ID_VP6A

Definition: codec_id.h:158

EaDemuxContext::num_samples

int num_samples

Definition: electronicarts.c:92

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

AVStream::nb_frames

int64_t nb_frames

number of frames in this stream if known or 0

Definition: avformat.h:805

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

MADk_TAG

#define MADk_TAG

Definition: electronicarts.c:54

avio_rl32

unsigned int avio_rl32(AVIOContext *s)

Definition: aviobuf.c:733

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

AVPacket::size

int size

Definition: packet.h:559

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

byte

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte

Definition: bytestream.h:99

av_bswap32

#define av_bswap32

Definition: bswap.h:47

size

int size

Definition: twinvq_data.h:10344

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

AV_WB24

#define AV_WB24(p, d)

Definition: intreadwrite.h:446

FFInputFormat::p

AVInputFormat p

The public AVInputFormat.

Definition: demux.h:51

MVIf_TAG

#define MVIf_TAG

Definition: electronicarts.c:68

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:606

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:564

read_header

static int read_header(FFV1Context *f, RangeCoder *c)

Definition: ffv1dec.c:498

EaDemuxContext::video

VideoProperties video

Definition: electronicarts.c:84

ea_read_packet

static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: electronicarts.c:590

SEAD_TAG

#define SEAD_TAG

Definition: electronicarts.c:37

AV_CODEC_ID_TGV

@ AV_CODEC_ID_TGV

Definition: codec_id.h:172

EaDemuxContext::audio_stream_index

int audio_stream_index

Definition: electronicarts.c:87

pIQT_TAG

#define pIQT_TAG

Definition: electronicarts.c:60

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

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

Definition: cbs_h2645.c:256

AVCodecParameters::height

int height

Definition: codec_par.h:135

AVCodecParameters::block_align

int block_align

Audio only.

Definition: codec_par.h:191

AV_CODEC_ID_CMV

@ AV_CODEC_ID_CMV

Definition: codec_id.h:170

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

demux.h

EaDemuxContext::platform

int platform

Definition: electronicarts.c:94

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

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

Definition: utils.c:98

AV_CODEC_ID_ADPCM_EA

@ AV_CODEC_ID_ADPCM_EA

Definition: codec_id.h:386

VideoProperties::nb_frames

int nb_frames

Definition: electronicarts.c:75

av_uninit

#define av_uninit(x)

Definition: attributes.h:174

options

static const AVOption options[]

Definition: electronicarts.c:782

tag

uint32_t tag

Definition: movenc.c:1957

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:744

ea_probe

static int ea_probe(const AVProbeData *p)

Definition: electronicarts.c:477

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:236

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

av_append_packet

int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)

Read data and append it to the current content of the AVPacket.

Definition: utils.c:114

AVSTREAM_PARSE_HEADERS

@ AVSTREAM_PARSE_HEADERS

Only parse headers, do not repack.

Definition: avformat.h:590

FLAGS

#define FLAGS

Definition: electronicarts.c:781

avformat.h

fVGT_TAG

#define fVGT_TAG

Definition: electronicarts.c:52

VideoProperties::codec

enum AVCodecID codec

Definition: electronicarts.c:72

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

VideoProperties::time_base

AVRational time_base

Definition: electronicarts.c:73

PT00_TAG

#define PT00_TAG

Definition: electronicarts.c:47

EACS_TAG

#define EACS_TAG

Definition: electronicarts.c:44

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:750

EaDemuxContext::big_endian

int big_endian

Definition: electronicarts.c:82

SNDC_TAG

#define SNDC_TAG

Definition: electronicarts.c:38

AVRational::den

int den

Denominator.

Definition: rational.h:60

MVhd_TAG

#define MVhd_TAG

Definition: electronicarts.c:61

video

A Quick Description Of Rate Distortion Theory We want to encode a video

Definition: rate_distortion.txt:3

process_video_header_mdec

static void process_video_header_mdec(AVFormatContext *s, VideoProperties *video)

Definition: electronicarts.c:326

AV_CODEC_ID_ADPCM_EA_R1

@ AV_CODEC_ID_ADPCM_EA_R1

Definition: codec_id.h:396

SDEN_TAG

#define SDEN_TAG

Definition: electronicarts.c:41

AV_CODEC_ID_ADPCM_EA_R2

@ AV_CODEC_ID_ADPCM_EA_R2

Definition: codec_id.h:398

AVStream::r_frame_rate

AVRational r_frame_rate

Real base framerate of the stream.

Definition: avformat.h:878

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

AVPacket::stream_index

int stream_index

Definition: packet.h:560

AVhd_TAG

#define AVhd_TAG

Definition: electronicarts.c:64

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:321

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

read_probe

static int read_probe(const AVProbeData *p)

Definition: cdg.c:30

process_ea_header

static int process_ea_header(AVFormatContext *s)

Definition: electronicarts.c:368

AVCodecParameters::bits_per_coded_sample

int bits_per_coded_sample

The number of bits per sample in the codedwords.

Definition: codec_par.h:110

EaDemuxContext::merge_alpha

int merge_alpha

Definition: electronicarts.c:95

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:37

ff_ea_demuxer

const FFInputFormat ff_ea_demuxer

Definition: electronicarts.c:794

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: codec_par.h:55

AV0K_TAG

#define AV0K_TAG

Definition: electronicarts.c:65

AVPacket

This structure stores compressed data.

Definition: packet.h:535

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Underlying C type is int.

Definition: opt.h:327

FFInputFormat

Definition: demux.h:47

VideoProperties::width

int width

Definition: electronicarts.c:74

AVCodecParameters::bit_rate

int64_t bit_rate

The average bitrate of the encoded data (in bits per second).

Definition: codec_par.h:97

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

process_audio_header_eacs

static void process_audio_header_eacs(AVFormatContext *s)

Definition: electronicarts.c:278

SHEN_TAG

#define SHEN_TAG

Definition: electronicarts.c:40

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

MV0F_TAG

#define MV0F_TAG

Definition: electronicarts.c:63

AV_CODEC_ID_ADPCM_PSX

@ AV_CODEC_ID_ADPCM_PSX

Definition: codec_id.h:413

AV_CODEC_ID_MPEG2VIDEO

@ AV_CODEC_ID_MPEG2VIDEO

preferred ID for MPEG-1/2 video decoding

Definition: codec_id.h:54

VideoProperties

Definition: electronicarts.c:71

avio_feof

int avio_feof(AVIOContext *s)

Similar to feof() but also returns nonzero on read errors.

Definition: aviobuf.c:349

Generated on Fri Oct 17 2025 19:23:21 for FFmpeg by doxygen 1.8.17