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 "avformat.h"
32 #include "internal.h"
33 
34 #define SCHl_TAG MKTAG('S', 'C', 'H', 'l')
35 #define SEAD_TAG MKTAG('S', 'E', 'A', 'D') /* Sxxx header */
36 #define SNDC_TAG MKTAG('S', 'N', 'D', 'C') /* Sxxx data */
37 #define SEND_TAG MKTAG('S', 'E', 'N', 'D') /* Sxxx end */
38 #define SHEN_TAG MKTAG('S', 'H', 'E', 'N') /* SxEN header */
39 #define SDEN_TAG MKTAG('S', 'D', 'E', 'N') /* SxEN data */
40 #define SEEN_TAG MKTAG('S', 'E', 'E', 'N') /* SxEN end */
41 #define ISNh_TAG MKTAG('1', 'S', 'N', 'h') /* 1SNx header */
42 #define EACS_TAG MKTAG('E', 'A', 'C', 'S')
43 #define ISNd_TAG MKTAG('1', 'S', 'N', 'd') /* 1SNx data */
44 #define ISNe_TAG MKTAG('1', 'S', 'N', 'e') /* 1SNx end */
45 #define PT00_TAG MKTAG('P', 'T', 0x0, 0x0)
46 #define GSTR_TAG MKTAG('G', 'S', 'T', 'R')
47 #define SCDl_TAG MKTAG('S', 'C', 'D', 'l')
48 #define SCEl_TAG MKTAG('S', 'C', 'E', 'l')
49 #define kVGT_TAG MKTAG('k', 'V', 'G', 'T') /* TGV I-frame */
50 #define fVGT_TAG MKTAG('f', 'V', 'G', 'T') /* TGV P-frame */
51 #define mTCD_TAG MKTAG('m', 'T', 'C', 'D') /* MDEC */
52 #define MADk_TAG MKTAG('M', 'A', 'D', 'k') /* MAD I-frame */
53 #define MADm_TAG MKTAG('M', 'A', 'D', 'm') /* MAD P-frame */
54 #define MADe_TAG MKTAG('M', 'A', 'D', 'e') /* MAD lqp-frame */
55 #define MPCh_TAG MKTAG('M', 'P', 'C', 'h') /* MPEG-2 */
56 #define TGQs_TAG MKTAG('T', 'G', 'Q', 's') /* TGQ I-frame (appears in .TGQ files) */
57 #define pQGT_TAG MKTAG('p', 'Q', 'G', 'T') /* TGQ I-frame (appears in .UV files) */
58 #define pIQT_TAG MKTAG('p', 'I', 'Q', 'T') /* TQI/UV2 I-frame (.UV2/.WVE) */
59 #define MVhd_TAG MKTAG('M', 'V', 'h', 'd')
60 #define MV0K_TAG MKTAG('M', 'V', '0', 'K')
61 #define MV0F_TAG MKTAG('M', 'V', '0', 'F')
62 #define AVhd_TAG MKTAG('A', 'V', 'h', 'd')
63 #define AV0K_TAG MKTAG('A', 'V', '0', 'K')
64 #define AV0F_TAG MKTAG('A', 'V', '0', 'F')
65 #define MVIh_TAG MKTAG('M', 'V', 'I', 'h') /* CMV header */
66 #define MVIf_TAG MKTAG('M', 'V', 'I', 'f') /* CMV I-frame */
67 #define AVP6_TAG MKTAG('A', 'V', 'P', '6')
68 
69 typedef struct VideoProperties {
70  enum AVCodecID codec;
71  AVRational time_base;
72  int width, height;
73  int nb_frames;
74  int stream_index;
75 } VideoProperties;
76 
77 typedef struct EaDemuxContext {
78  int big_endian;
79 
80  VideoProperties video, alpha;
81 
82  enum AVCodecID audio_codec;
83  int audio_stream_index;
84 
85  int bytes;
86  int sample_rate;
87  int num_channels;
88  int num_samples;
89 
90  int platform;
91 } EaDemuxContext;
92 
93 static uint32_t read_arbitrary(AVIOContext *pb)
94 {
95  uint8_t size, byte;
96  int i;
97  uint32_t word;
98 
99  size = avio_r8(pb);
100 
101  word = 0;
102  for (i = 0; i < size; i++) {
103  byte = avio_r8(pb);
104  word <<= 8;
105  word |= byte;
106  }
107 
108  return word;
109 }
110 
111 static int process_audio_header_elements(AVFormatContext *s)
112 {
113  EaDemuxContext *ea = s->priv_data;
114  AVIOContext *pb = s->pb;
115  int in_header = 1;
116  int compression_type = -1, revision = -1, revision2 = -1;
117 
118  ea->bytes = 2;
119  ea->sample_rate = -1;
120  ea->num_channels = 1;
121 
122  while (!avio_feof(pb) && in_header) {
123  int in_subheader;
124  uint8_t byte;
125  byte = avio_r8(pb);
126 
127  switch (byte) {
128  case 0xFD:
129  av_log(s, AV_LOG_DEBUG, "entered audio subheader\n");
130  in_subheader = 1;
131  while (!avio_feof(pb) && in_subheader) {
132  uint8_t subbyte;
133  subbyte = avio_r8(pb);
134 
135  switch (subbyte) {
136  case 0x80:
137  revision = read_arbitrary(pb);
138  av_log(s, AV_LOG_DEBUG,
139  "revision (element 0x80) set to 0x%08x\n", revision);
140  break;
141  case 0x82:
142  ea->num_channels = read_arbitrary(pb);
143  av_log(s, AV_LOG_DEBUG,
144  "num_channels (element 0x82) set to 0x%08x\n",
145  ea->num_channels);
146  break;
147  case 0x83:
148  compression_type = read_arbitrary(pb);
149  av_log(s, AV_LOG_DEBUG,
150  "compression_type (element 0x83) set to 0x%08x\n",
151  compression_type);
152  break;
153  case 0x84:
154  ea->sample_rate = read_arbitrary(pb);
155  av_log(s, AV_LOG_DEBUG,
156  "sample_rate (element 0x84) set to %i\n",
157  ea->sample_rate);
158  break;
159  case 0x85:
160  ea->num_samples = read_arbitrary(pb);
161  av_log(s, AV_LOG_DEBUG,
162  "num_samples (element 0x85) set to 0x%08x\n",
163  ea->num_samples);
164  break;
165  case 0x8A:
166  av_log(s, AV_LOG_DEBUG,
167  "element 0x%02x set to 0x%08"PRIx32"\n",
168  subbyte, read_arbitrary(pb));
169  av_log(s, AV_LOG_DEBUG, "exited audio subheader\n");
170  in_subheader = 0;
171  break;
172  case 0xA0:
173  revision2 = read_arbitrary(pb);
174  av_log(s, AV_LOG_DEBUG,
175  "revision2 (element 0xA0) set to 0x%08x\n",
176  revision2);
177  break;
178  case 0xFF:
179  av_log(s, AV_LOG_DEBUG,
180  "end of header block reached (within audio subheader)\n");
181  in_subheader = 0;
182  in_header = 0;
183  break;
184  default:
185  av_log(s, AV_LOG_DEBUG,
186  "element 0x%02x set to 0x%08"PRIx32"\n",
187  subbyte, read_arbitrary(pb));
188  break;
189  }
190  }
191  break;
192  case 0xFF:
193  av_log(s, AV_LOG_DEBUG, "end of header block reached\n");
194  in_header = 0;
195  break;
196  default:
197  av_log(s, AV_LOG_DEBUG,
198  "header element 0x%02x set to 0x%08"PRIx32"\n",
199  byte, read_arbitrary(pb));
200  break;
201  }
202  }
203 
204  switch (compression_type) {
205  case 0:
206  ea->audio_codec = AV_CODEC_ID_PCM_S16LE;
207  break;
208  case 7:
209  ea->audio_codec = AV_CODEC_ID_ADPCM_EA;
210  break;
211  case -1:
212  switch (revision) {
213  case 1:
214  ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1;
215  break;
216  case 2:
217  ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2;
218  break;
219  case 3:
220  ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3;
221  break;
222  case -1:
223  break;
224  default:
225  avpriv_request_sample(s, "stream type; revision=%i", revision);
226  return 0;
227  }
228  switch (revision2) {
229  case 8:
230  ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR;
231  break;
232  case 10:
233  switch (revision) {
234  case -1:
235  case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;
236  case 3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
237  default:
238  avpriv_request_sample(s, "stream type; revision=%i, revision2=%i", revision, revision2);
239  return 0;
240  }
241  break;
242  case 15:
243  case 16:
244  ea->audio_codec = AV_CODEC_ID_MP3;
245  break;
246  case -1:
247  break;
248  default:
249  ea->audio_codec = AV_CODEC_ID_NONE;
250  avpriv_request_sample(s, "stream type; revision2=%i", revision2);
251  return 0;
252  }
253  break;
254  default:
255  avpriv_request_sample(s,
256  "stream type; compression_type=%i",
257  compression_type);
258  return 0;
259  }
260 
261  if (ea->audio_codec == AV_CODEC_ID_NONE && ea->platform == 0x01)
262  ea->audio_codec = AV_CODEC_ID_ADPCM_PSX;
263  if (ea->sample_rate == -1)
264  ea->sample_rate = revision == 3 ? 48000 : 22050;
265 
266  return 1;
267 }
268 
269 static void process_audio_header_eacs(AVFormatContext *s)
270 {
271  EaDemuxContext *ea = s->priv_data;
272  AVIOContext *pb = s->pb;
273  int compression_type;
274 
275  ea->sample_rate = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
276  ea->bytes = avio_r8(pb); /* 1=8-bit, 2=16-bit */
277  ea->num_channels = avio_r8(pb);
278  compression_type = avio_r8(pb);
279  avio_skip(pb, 13);
280 
281  switch (compression_type) {
282  case 0:
283  switch (ea->bytes) {
284  case 1:
285  ea->audio_codec = AV_CODEC_ID_PCM_S8;
286  break;
287  case 2:
288  ea->audio_codec = AV_CODEC_ID_PCM_S16LE;
289  break;
290  }
291  break;
292  case 1:
293  ea->audio_codec = AV_CODEC_ID_PCM_MULAW;
294  ea->bytes = 1;
295  break;
296  case 2:
297  ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS;
298  break;
299  default:
300  avpriv_request_sample(s,
301  "stream type; audio compression_type=%i",
302  compression_type);
303  }
304 }
305 
306 static void process_audio_header_sead(AVFormatContext *s)
307 {
308  EaDemuxContext *ea = s->priv_data;
309  AVIOContext *pb = s->pb;
310 
311  ea->sample_rate = avio_rl32(pb);
312  ea->bytes = avio_rl32(pb); /* 1=8-bit, 2=16-bit */
313  ea->num_channels = avio_rl32(pb);
314  ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;
315 }
316 
317 static void process_video_header_mdec(AVFormatContext *s, VideoProperties *video)
318 {
319  AVIOContext *pb = s->pb;
320  avio_skip(pb, 4);
321  video->width = avio_rl16(pb);
322  video->height = avio_rl16(pb);
323  video->time_base = (AVRational) { 1, 15 };
324  video->codec = AV_CODEC_ID_MDEC;
325 }
326 
327 static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)
328 {
329  AVIOContext *pb = s->pb;
330 
331  avio_skip(pb, 8);
332  video->nb_frames = avio_rl32(pb);
333  avio_skip(pb, 4);
334  video->time_base.den = avio_rl32(pb);
335  video->time_base.num = avio_rl32(pb);
336  if (video->time_base.den <= 0 || video->time_base.num <= 0) {
337  av_log(s, AV_LOG_ERROR, "Timebase is invalid\n");
338  return AVERROR_INVALIDDATA;
339  }
340  video->codec = AV_CODEC_ID_VP6;
341 
342  return 1;
343 }
344 
345 static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)
346 {
347  int fps;
348 
349  avio_skip(s->pb, 10);
350  fps = avio_rl16(s->pb);
351  if (fps)
352  video->time_base = (AVRational) { 1, fps };
353  video->codec = AV_CODEC_ID_CMV;
354 }
355 
356 /* Process EA file header.
357  * Return 1 if the EA file is valid and successfully opened, 0 otherwise. */
358 static int process_ea_header(AVFormatContext *s)
359 {
360  uint32_t blockid, size = 0;
361  EaDemuxContext *ea = s->priv_data;
362  AVIOContext *pb = s->pb;
363  int i;
364 
365  for (i = 0; i < 5 && (!ea->audio_codec || !ea->video.codec); i++) {
366  uint64_t startpos = avio_tell(pb);
367  int err = 0;
368 
369  blockid = avio_rl32(pb);
370  size = avio_rl32(pb);
371  if (i == 0)
372  ea->big_endian = size > av_bswap32(size);
373  if (ea->big_endian)
374  size = av_bswap32(size);
375 
376  if (size < 8) {
377  av_log(s, AV_LOG_ERROR, "chunk size too small\n");
378  return AVERROR_INVALIDDATA;
379  }
380 
381  switch (blockid) {
382  case ISNh_TAG:
383  if (avio_rl32(pb) != EACS_TAG) {
384  avpriv_request_sample(s, "unknown 1SNh headerid");
385  return 0;
386  }
387  process_audio_header_eacs(s);
388  break;
389 
390  case SCHl_TAG:
391  case SHEN_TAG:
392  blockid = avio_rl32(pb);
393  if (blockid == GSTR_TAG) {
394  avio_skip(pb, 4);
395  } else if ((blockid & 0xFF) != (PT00_TAG & 0xFF)) {
396  blockid = avio_rl32(pb);
397  }
398  ea->platform = (blockid >> 16) & 0xFF;
399  err = process_audio_header_elements(s);
400  break;
401 
402  case SEAD_TAG:
403  process_audio_header_sead(s);
404  break;
405 
406  case MVIh_TAG:
407  process_video_header_cmv(s, &ea->video);
408  break;
409 
410  case kVGT_TAG:
411  ea->video.codec = AV_CODEC_ID_TGV;
412  break;
413 
414  case mTCD_TAG:
415  process_video_header_mdec(s, &ea->video);
416  break;
417 
418  case MPCh_TAG:
419  ea->video.codec = AV_CODEC_ID_MPEG2VIDEO;
420  break;
421 
422  case pQGT_TAG:
423  case TGQs_TAG:
424  ea->video.codec = AV_CODEC_ID_TGQ;
425  ea->video.time_base = (AVRational) { 1, 15 };
426  break;
427 
428  case pIQT_TAG:
429  ea->video.codec = AV_CODEC_ID_TQI;
430  ea->video.time_base = (AVRational) { 1, 15 };
431  break;
432 
433  case MADk_TAG:
434  ea->video.codec = AV_CODEC_ID_MAD;
435  avio_skip(pb, 6);
436  ea->video.time_base = (AVRational) { avio_rl16(pb), 1000 };
437  break;
438 
439  case MVhd_TAG:
440  err = process_video_header_vp6(s, &ea->video);
441  break;
442 
443  case AVhd_TAG:
444  err = process_video_header_vp6(s, &ea->alpha);
445  break;
446  }
447 
448  if (err < 0) {
449  av_log(s, AV_LOG_ERROR, "error parsing header: %i\n", err);
450  return err;
451  }
452 
453  avio_seek(pb, startpos + size, SEEK_SET);
454  }
455 
456  avio_seek(pb, 0, SEEK_SET);
457 
458  return 1;
459 }
460 
461 static int ea_probe(const AVProbeData *p)
462 {
463  unsigned big_endian, size;
464 
465  switch (AV_RL32(&p->buf[0])) {
466  case ISNh_TAG:
467  case SCHl_TAG:
468  case SEAD_TAG:
469  case SHEN_TAG:
470  case kVGT_TAG:
471  case MADk_TAG:
472  case MPCh_TAG:
473  case MVhd_TAG:
474  case MVIh_TAG:
475  case AVP6_TAG:
476  break;
477  default:
478  return 0;
479  }
480  size = AV_RL32(&p->buf[4]);
481  big_endian = size > 0x000FFFFF;
482  if (big_endian)
483  size = av_bswap32(size);
484  if (size > 0xfffff || size < 8)
485  return 0;
486 
487  return AVPROBE_SCORE_MAX;
488 }
489 
490 static int init_video_stream(AVFormatContext *s, VideoProperties *video)
491 {
492  AVStream *st;
493 
494  if (!video->codec)
495  return 0;
496 
497  /* initialize the video decoder stream */
498  st = avformat_new_stream(s, NULL);
499  if (!st)
500  return AVERROR(ENOMEM);
501  video->stream_index = st->index;
502  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
503  st->codecpar->codec_id = video->codec;
504  // parsing is necessary to make FFmpeg generate correct timestamps
505  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO)
506  ffstream(st)->need_parsing = AVSTREAM_PARSE_HEADERS;
507  st->codecpar->codec_tag = 0; /* no fourcc */
508  st->codecpar->width = video->width;
509  st->codecpar->height = video->height;
510  st->duration = st->nb_frames = video->nb_frames;
511  if (video->time_base.num)
512  avpriv_set_pts_info(st, 64, video->time_base.num, video->time_base.den);
513  st->r_frame_rate =
514  st->avg_frame_rate = av_inv_q(video->time_base);
515  return 0;
516 }
517 
518 static int ea_read_header(AVFormatContext *s)
519 {
520  EaDemuxContext *ea = s->priv_data;
521  AVStream *st;
522 
523  if (process_ea_header(s)<=0)
524  return AVERROR(EIO);
525 
526  if (init_video_stream(s, &ea->video) || init_video_stream(s, &ea->alpha))
527  return AVERROR(ENOMEM);
528 
529  if (ea->audio_codec) {
530  if (ea->num_channels <= 0 || ea->num_channels > 2) {
531  av_log(s, AV_LOG_WARNING,
532  "Unsupported number of channels: %d\n", ea->num_channels);
533  goto no_audio;
534  }
535  if (ea->sample_rate <= 0) {
536  av_log(s, AV_LOG_ERROR,
537  "Unsupported sample rate: %d\n", ea->sample_rate);
538  goto no_audio;
539  }
540  if (ea->bytes <= 0 || ea->bytes > 2) {
541  av_log(s, AV_LOG_ERROR,
542  "Invalid number of bytes per sample: %d\n", ea->bytes);
543  goto no_audio;
544  }
545 
546  /* initialize the audio decoder stream */
547  st = avformat_new_stream(s, NULL);
548  if (!st)
549  return AVERROR(ENOMEM);
550  avpriv_set_pts_info(st, 33, 1, ea->sample_rate);
551  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
552  st->codecpar->codec_id = ea->audio_codec;
553  st->codecpar->codec_tag = 0; /* no tag */
554  st->codecpar->channels = ea->num_channels;
555  st->codecpar->sample_rate = ea->sample_rate;
556  st->codecpar->bits_per_coded_sample = ea->bytes * 8;
557  st->codecpar->bit_rate = (int64_t)st->codecpar->channels *
558  st->codecpar->sample_rate *
559  st->codecpar->bits_per_coded_sample / 4;
560  st->codecpar->block_align = st->codecpar->channels *
561  st->codecpar->bits_per_coded_sample;
562  ea->audio_stream_index = st->index;
563  st->start_time = 0;
564  return 0;
565  }
566 no_audio:
567  ea->audio_codec = AV_CODEC_ID_NONE;
568 
569  if (!ea->video.codec)
570  return AVERROR_INVALIDDATA;
571  return 0;
572 }
573 
574 static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
575 {
576  EaDemuxContext *ea = s->priv_data;
577  AVIOContext *pb = s->pb;
578  int partial_packet = 0;
579  int hit_end = 0;
580  unsigned int chunk_type, chunk_size;
581  int ret = 0, packet_read = 0, key = 0;
582  int av_uninit(num_samples);
583 
584  while ((!packet_read && !hit_end) || partial_packet) {
585  if (avio_feof(pb))
586  return AVERROR_EOF;
587  chunk_type = avio_rl32(pb);
588  chunk_size = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
589  if (chunk_size < 8)
590  return AVERROR_INVALIDDATA;
591  chunk_size -= 8;
592 
593  switch (chunk_type) {
594  /* audio data */
595  case ISNh_TAG:
596  /* header chunk also contains data; skip over the header portion */
597  if (chunk_size < 32)
598  return AVERROR_INVALIDDATA;
599  avio_skip(pb, 32);
600  chunk_size -= 32;
601  case ISNd_TAG:
602  case SCDl_TAG:
603  case SNDC_TAG:
604  case SDEN_TAG:
605  if (!ea->audio_codec) {
606  avio_skip(pb, chunk_size);
607  break;
608  } else if (ea->audio_codec == AV_CODEC_ID_PCM_S16LE_PLANAR ||
609  ea->audio_codec == AV_CODEC_ID_MP3) {
610  if (chunk_size < 12)
611  return AVERROR_INVALIDDATA;
612  num_samples = avio_rl32(pb);
613  avio_skip(pb, 8);
614  chunk_size -= 12;
615  } else if (ea->audio_codec == AV_CODEC_ID_ADPCM_PSX) {
616  if (chunk_size < 8)
617  return AVERROR_INVALIDDATA;
618  avio_skip(pb, 8);
619  chunk_size -= 8;
620  }
621 
622  if (partial_packet) {
623  avpriv_request_sample(s, "video header followed by audio packet");
624  av_packet_unref(pkt);
625  partial_packet = 0;
626  }
627 
628  if (!chunk_size)
629  continue;
630 
631  ret = av_get_packet(pb, pkt, chunk_size);
632  if (ret < 0)
633  return ret;
634  pkt->stream_index = ea->audio_stream_index;
635 
636  switch (ea->audio_codec) {
637  case AV_CODEC_ID_ADPCM_EA:
638  case AV_CODEC_ID_ADPCM_EA_R1:
639  case AV_CODEC_ID_ADPCM_EA_R2:
640  case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
641  case AV_CODEC_ID_ADPCM_EA_R3:
642  if (pkt->size < 4) {
643  av_log(s, AV_LOG_ERROR, "Packet is too short\n");
644  return AVERROR_INVALIDDATA;
645  }
646  if (ea->audio_codec == AV_CODEC_ID_ADPCM_EA_R3)
647  pkt->duration = AV_RB32(pkt->data);
648  else
649  pkt->duration = AV_RL32(pkt->data);
650  break;
651  case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
652  pkt->duration = ret * 2 / ea->num_channels;
653  break;
654  case AV_CODEC_ID_PCM_S16LE_PLANAR:
655  case AV_CODEC_ID_MP3:
656  pkt->duration = num_samples;
657  break;
658  case AV_CODEC_ID_ADPCM_PSX:
659  pkt->duration = chunk_size / (16 * ea->num_channels) * 28;
660  break;
661  default:
662  pkt->duration = chunk_size / (ea->bytes * ea->num_channels);
663  }
664 
665  packet_read = 1;
666  break;
667 
668  /* ending tag */
669  case 0:
670  case ISNe_TAG:
671  case SCEl_TAG:
672  case SEND_TAG:
673  case SEEN_TAG:
674  while (!avio_feof(pb)) {
675  int tag = avio_rl32(pb);
676 
677  if (tag == ISNh_TAG ||
678  tag == SCHl_TAG ||
679  tag == SEAD_TAG ||
680  tag == SHEN_TAG) {
681  avio_skip(pb, -4);
682  break;
683  }
684  }
685  if (avio_feof(pb))
686  ret = AVERROR_EOF;
687  hit_end = 1;
688  break;
689 
690  case MVIh_TAG:
691  case kVGT_TAG:
692  case pQGT_TAG:
693  case TGQs_TAG:
694  case MADk_TAG:
695  key = AV_PKT_FLAG_KEY;
696  case MVIf_TAG:
697  case fVGT_TAG:
698  case MADm_TAG:
699  case MADe_TAG:
700  if (chunk_size > INT_MAX - 8)
701  return AVERROR_INVALIDDATA;
702  avio_seek(pb, -8, SEEK_CUR); // include chunk preamble
703  chunk_size += 8;
704  goto get_video_packet;
705 
706  case mTCD_TAG:
707  if (chunk_size < 8)
708  return AVERROR_INVALIDDATA;
709 
710  avio_skip(pb, 8); // skip ea DCT header
711  chunk_size -= 8;
712  goto get_video_packet;
713 
714  case MV0K_TAG:
715  case AV0K_TAG:
716  case MPCh_TAG:
717  case pIQT_TAG:
718  key = AV_PKT_FLAG_KEY;
719  case MV0F_TAG:
720  case AV0F_TAG:
721 get_video_packet:
722  if (!chunk_size)
723  continue;
724 
725  if (partial_packet) {
726  ret = av_append_packet(pb, pkt, chunk_size);
727  } else
728  ret = av_get_packet(pb, pkt, chunk_size);
729  if (ret < 0) {
730  packet_read = 1;
731  partial_packet = 0;
732  break;
733  }
734  partial_packet = chunk_type == MVIh_TAG;
735  if (chunk_type == AV0K_TAG || chunk_type == AV0F_TAG)
736  pkt->stream_index = ea->alpha.stream_index;
737  else
738  pkt->stream_index = ea->video.stream_index;
739  pkt->flags |= key;
740  packet_read = 1;
741  break;
742 
743  default:
744  avio_skip(pb, chunk_size);
745  break;
746  }
747  }
748 
749  if (ret >= 0 && hit_end && !packet_read)
750  return AVERROR(EAGAIN);
751 
752  return ret;
753 }
754 
755 const AVInputFormat ff_ea_demuxer = {
756  .name = "ea",
757  .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),
758  .priv_data_size = sizeof(EaDemuxContext),
759  .read_probe = ea_probe,
760  .read_header = ea_read_header,
761  .read_packet = ea_read_packet,
762 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
SCEl_TAG
#define SCEl_TAG
Definition: electronicarts.c:48
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:417
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ea_read_header
static int ea_read_header(AVFormatContext *s)
Definition: electronicarts.c:518
SCHl_TAG
#define SCHl_TAG
Definition: electronicarts.c:34
process_video_header_vp6
static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:327
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:724
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AV_CODEC_ID_TQI
@ AV_CODEC_ID_TQI
Definition: codec_id.h:172
SEEN_TAG
#define SEEN_TAG
Definition: electronicarts.c:40
init_video_stream
static int init_video_stream(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:490
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
VideoProperties::stream_index
int stream_index
Definition: electronicarts.c:74
AVP6_TAG
#define AVP6_TAG
Definition: electronicarts.c:67
MPCh_TAG
#define MPCh_TAG
Definition: electronicarts.c:55
MVIh_TAG
#define MVIh_TAG
Definition: electronicarts.c:65
AVPacket::data
uint8_t * data
Definition: packet.h:373
SEND_TAG
#define SEND_TAG
Definition: electronicarts.c:37
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:141
pQGT_TAG
#define pQGT_TAG
Definition: electronicarts.c:57
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:912
AV_CODEC_ID_ADPCM_EA_R3
@ AV_CODEC_ID_ADPCM_EA_R3
Definition: codec_id.h:373
ISNe_TAG
#define ISNe_TAG
Definition: electronicarts.c:44
process_audio_header_sead
static void process_audio_header_sead(AVFormatContext *s)
Definition: electronicarts.c:306
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
EaDemuxContext::num_channels
int num_channels
Definition: electronicarts.c:87
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:331
AV_CODEC_ID_TGQ
@ AV_CODEC_ID_TGQ
Definition: codec_id.h:171
AV_CODEC_ID_MAD
@ AV_CODEC_ID_MAD
Definition: codec_id.h:179
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
EaDemuxContext::alpha
VideoProperties alpha
Definition: electronicarts.c:80
EaDemuxContext::bytes
int bytes
Definition: electronicarts.c:85
read_arbitrary
static uint32_t read_arbitrary(AVIOContext *pb)
Definition: electronicarts.c:93
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
kVGT_TAG
#define kVGT_TAG
Definition: electronicarts.c:49
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:426
MADm_TAG
#define MADm_TAG
Definition: electronicarts.c:53
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:486
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:423
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:888
ISNh_TAG
#define ISNh_TAG
Definition: electronicarts.c:41
MADe_TAG
#define MADe_TAG
Definition: electronicarts.c:54
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:726
EaDemuxContext::audio_codec
enum AVCodecID audio_codec
Definition: electronicarts.c:82
av_bswap32
#define av_bswap32
Definition: bswap.h:33
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:317
VideoProperties::height
int height
Definition: electronicarts.c:72
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:773
AV_CODEC_ID_MDEC
@ AV_CODEC_ID_MDEC
Definition: codec_id.h:87
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:626
MV0K_TAG
#define MV0K_TAG
Definition: electronicarts.c:60
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition: codec_id.h:375
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:631
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
EaDemuxContext::sample_rate
int sample_rate
Definition: electronicarts.c:86
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:319
ISNd_TAG
#define ISNd_TAG
Definition: electronicarts.c:43
key
const char * key
Definition: hwcontext_opencl.c:168
process_audio_header_elements
static int process_audio_header_elements(AVFormatContext *s)
Definition: electronicarts.c:111
process_video_header_cmv
static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:345
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:399
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
SCDl_TAG
#define SCDl_TAG
Definition: electronicarts.c:47
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:992
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
AV0F_TAG
#define AV0F_TAG
Definition: electronicarts.c:64
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
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:376
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
TGQs_TAG
#define TGQs_TAG
Definition: electronicarts.c:56
EaDemuxContext
Definition: electronicarts.c:77
GSTR_TAG
#define GSTR_TAG
Definition: electronicarts.c:46
mTCD_TAG
#define mTCD_TAG
Definition: electronicarts.c:51
EaDemuxContext::num_samples
int num_samples
Definition: electronicarts.c:88
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:890
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
MADk_TAG
#define MADk_TAG
Definition: electronicarts.c:52
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:742
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVPacket::size
int size
Definition: packet.h:374
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:117
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
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
MVIf_TAG
#define MVIf_TAG
Definition: electronicarts.c:66
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
EaDemuxContext::video
VideoProperties video
Definition: electronicarts.c:80
ea_read_packet
static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: electronicarts.c:574
SEAD_TAG
#define SEAD_TAG
Definition: electronicarts.c:35
AV_CODEC_ID_TGV
@ AV_CODEC_ID_TGV
Definition: codec_id.h:170
EaDemuxContext::audio_stream_index
int audio_stream_index
Definition: electronicarts.c:83
pIQT_TAG
#define pIQT_TAG
Definition: electronicarts.c:58
i
int i
Definition: input.c:406
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
ff_ea_demuxer
const AVInputFormat ff_ea_demuxer
Definition: electronicarts.c:755
AVCodecParameters::height
int height
Definition: codec_par.h:127
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
AV_CODEC_ID_CMV
@ AV_CODEC_ID_CMV
Definition: codec_id.h:168
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
EaDemuxContext::platform
int platform
Definition: electronicarts.c:90
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:196
AV_CODEC_ID_ADPCM_EA
@ AV_CODEC_ID_ADPCM_EA
Definition: codec_id.h:362
VideoProperties::nb_frames
int nb_frames
Definition: electronicarts.c:73
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
tag
uint32_t tag
Definition: movenc.c:1597
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:845
ea_probe
static int ea_probe(const AVProbeData *p)
Definition: electronicarts.c:461
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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:212
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:769
avformat.h
fVGT_TAG
#define fVGT_TAG
Definition: electronicarts.c:50
VideoProperties::codec
enum AVCodecID codec
Definition: electronicarts.c:70
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:71
PT00_TAG
#define PT00_TAG
Definition: electronicarts.c:45
EACS_TAG
#define EACS_TAG
Definition: electronicarts.c:42
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:846
EaDemuxContext::big_endian
int big_endian
Definition: electronicarts.c:78
SNDC_TAG
#define SNDC_TAG
Definition: electronicarts.c:36
MVhd_TAG
#define MVhd_TAG
Definition: electronicarts.c:59
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:317
AV_CODEC_ID_ADPCM_EA_R1
@ AV_CODEC_ID_ADPCM_EA_R1
Definition: codec_id.h:372
SDEN_TAG
#define SDEN_TAG
Definition: electronicarts.c:39
AV_CODEC_ID_ADPCM_EA_R2
@ AV_CODEC_ID_ADPCM_EA_R2
Definition: codec_id.h:374
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:981
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: utils.c:1146
AVPacket::stream_index
int stream_index
Definition: packet.h:375
AVhd_TAG
#define AVhd_TAG
Definition: electronicarts.c:62
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:333
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
process_ea_header
static int process_ea_header(AVFormatContext *s)
Definition: electronicarts.c:358
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AV0K_TAG
#define AV0K_TAG
Definition: electronicarts.c:63
AVPacket
This structure stores compressed data.
Definition: packet.h:350
VideoProperties::width
int width
Definition: electronicarts.c:72
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:269
SHEN_TAG
#define SHEN_TAG
Definition: electronicarts.c:38
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:878
MV0F_TAG
#define MV0F_TAG
Definition: electronicarts.c:61
AV_CODEC_ID_ADPCM_PSX
@ AV_CODEC_ID_ADPCM_PSX
Definition: codec_id.h:389
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
VideoProperties
Definition: electronicarts.c:69
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:360
Generated on Tue Sep 21 2021 19:21:56 for FFmpeg by   doxygen 1.8.17