FFmpeg
electronicarts.c
Go to the documentation of this file.
1 /* Electronic Arts Multimedia File Demuxer
2  * Copyright (c) 2004 The FFmpeg project
3  * Copyright (c) 2006-2008 Peter Ross
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  */
21 
22 /**
23  * @file
24  * Electronic Arts Multimedia file demuxer (WVE/UV2/etc.)
25  * by Robin Kay (komadori at gekkou.co.uk)
26  */
27 
28 #include <inttypes.h>
29 
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/opt.h"
32 #include "avformat.h"
33 #include "demux.h"
34 #include "internal.h"
35 
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')
70 
71 typedef struct VideoProperties {
74  int width, height;
75  int nb_frames;
78 
79 typedef struct EaDemuxContext {
80  const AVClass *class;
81 
83 
85 
88 
89  int bytes;
93 
94  int platform;
97 
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 
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);
144  "revision (element 0x80) set to 0x%08x\n", revision);
145  break;
146  case 0x82:
147  ea->num_channels = read_arbitrary(pb);
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);
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);
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);
167  "num_samples (element 0x85) set to 0x%08x\n",
168  ea->num_samples);
169  break;
170  case 0x8A:
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);
180  "revision2 (element 0xA0) set to 0x%08x\n",
181  revision2);
182  break;
183  case 0xFF:
185  "end of header block reached (within audio subheader)\n");
186  in_subheader = 0;
187  in_header = 0;
188  break;
189  default:
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:
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:
216  break;
217  case 7:
219  break;
220  case -1:
221  switch (revision) {
222  case 1:
224  break;
225  case 2:
227  break;
228  case 3:
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:
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:
254  break;
255  case -1:
256  break;
257  default:
259  avpriv_request_sample(s, "stream type; revision2=%i", revision2);
260  return 0;
261  }
262  break;
263  default:
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)
272  if (ea->sample_rate == -1)
273  ea->sample_rate = revision == 3 ? 48000 : 22050;
274 
275  return 1;
276 }
277 
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:
295  break;
296  case 2:
298  break;
299  }
300  break;
301  case 1:
303  ea->bytes = 1;
304  break;
305  case 2:
307  break;
308  default:
310  "stream type; audio compression_type=%i",
311  compression_type);
312  }
313 }
314 
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);
324 }
325 
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 
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 
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. */
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  }
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;
410  break;
411 
412  case SEAD_TAG:
414  break;
415 
416  case MVIh_TAG:
418  break;
419 
420  case kVGT_TAG:
422  break;
423 
424  case mTCD_TAG:
426  break;
427 
428  case MPCh_TAG:
430  break;
431 
432  case pQGT_TAG:
433  case TGQs_TAG:
435  if (!ea->video.time_base.num)
436  ea->video.time_base = (AVRational) { 1, 15 };
437  break;
438 
439  case pIQT_TAG:
441  if (!ea->video.time_base.num)
442  ea->video.time_base = (AVRational) { 1, 15 };
443  break;
444 
445  case MADk_TAG:
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;
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 
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;
519  st->codecpar->codec_id = video->codec;
520  // parsing is necessary to make FFmpeg generate correct timestamps
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 
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) {
548  "Unsupported number of channels: %d\n", ea->num_channels);
549  goto no_audio;
550  }
551  if (ea->sample_rate <= 0) {
553  "Unsupported sample rate: %d\n", ea->sample_rate);
554  goto no_audio;
555  }
556  if (ea->bytes <= 0 || ea->bytes > 2) {
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);
568  st->codecpar->codec_id = ea->audio_codec;
569  st->codecpar->codec_tag = 0; /* no tag */
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 *
576  st->codecpar->block_align = ea->num_channels *
578  ea->audio_stream_index = st->index;
579  st->start_time = 0;
580  return 0;
581  }
582 no_audio:
584 
585  if (!ea->video.codec)
586  return AVERROR_INVALIDDATA;
587  return 0;
588 }
589 
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");
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;
651 
652  switch (ea->audio_codec) {
658  if (pkt->size < 4) {
659  av_log(s, AV_LOG_ERROR, "Packet is too short\n");
660  return AVERROR_INVALIDDATA;
661  }
663  pkt->duration = AV_RB32(pkt->data);
664  else
665  pkt->duration = AV_RL32(pkt->data);
666  break;
668  pkt->duration = ret * 2 / ea->num_channels;
669  break;
671  case AV_CODEC_ID_MP3:
672  pkt->duration = num_samples;
673  break;
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:
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:
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))
763  else
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 
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,
802 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:329
SCEl_TAG
#define SCEl_TAG
Definition: electronicarts.c:50
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
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:539
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:837
AV_CODEC_ID_ADPCM_EA_R3
@ AV_CODEC_ID_ADPCM_EA_R3
Definition: codec_id.h:389
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:557
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:321
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:347
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:862
kVGT_TAG
#define kVGT_TAG
Definition: electronicarts.c:51
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:419
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:442
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:807
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:714
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:333
VideoProperties::height
int height
Definition: electronicarts.c:74
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
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:209
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
s
#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:391
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
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:230
EaDemuxContext::sample_rate
int sample_rate
Definition: electronicarts.c:90
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:335
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:386
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
SCDl_TAG
#define SCDl_TAG
Definition: electronicarts.c:49
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:538
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
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:392
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
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:809
AVCodecID
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:730
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVPacket::size
int size
Definition: packet.h:540
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:41
MVIf_TAG
#define MVIf_TAG
Definition: electronicarts.c:68
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
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
i
#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:91
AV_CODEC_ID_ADPCM_EA
@ AV_CODEC_ID_ADPCM_EA
Definition: codec_id.h:378
VideoProperties::nb_frames
int nb_frames
Definition: electronicarts.c:75
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
options
static const AVOption options[]
Definition: electronicarts.c:782
tag
uint32_t tag
Definition: movenc.c:1876
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
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:231
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:80
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:107
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
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:754
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:388
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:390
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:914
AVPacket::stream_index
int stream_index
Definition: packet.h:541
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:318
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:36
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:516
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
FFInputFormat
Definition: demux.h:37
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:797
MV0F_TAG
#define MV0F_TAG
Definition: electronicarts.c:63
AV_CODEC_ID_ADPCM_PSX
@ AV_CODEC_ID_ADPCM_PSX
Definition: codec_id.h:405
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:346