FFmpeg: libavformat/electronicarts.c Source File

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(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  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  ea->audio_codec = 0;
534  return 1;
535  }
536  if (ea->sample_rate <= 0) {
537  av_log(s, AV_LOG_ERROR,
538  "Unsupported sample rate: %d\n", ea->sample_rate);
539  ea->audio_codec = 0;
540  return 1;
541  }
542  if (ea->bytes <= 0 || ea->bytes > 2) {
543  av_log(s, AV_LOG_ERROR,
544  "Invalid number of bytes per sample: %d\n", ea->bytes);
545  ea->audio_codec = AV_CODEC_ID_NONE;
546  return 1;
547  }
548 
549  /* initialize the audio decoder stream */
550  st = avformat_new_stream(s, NULL);
551  if (!st)
552  return AVERROR(ENOMEM);
553  avpriv_set_pts_info(st, 33, 1, ea->sample_rate);
554  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
555  st->codecpar->codec_id = ea->audio_codec;
556  st->codecpar->codec_tag = 0; /* no tag */
557  st->codecpar->channels = ea->num_channels;
558  st->codecpar->sample_rate = ea->sample_rate;
559  st->codecpar->bits_per_coded_sample = ea->bytes * 8;
560  st->codecpar->bit_rate = (int64_t)st->codecpar->channels *
561  st->codecpar->sample_rate *
562  st->codecpar->bits_per_coded_sample / 4;
563  st->codecpar->block_align = st->codecpar->channels *
564  st->codecpar->bits_per_coded_sample;
565  ea->audio_stream_index = st->index;
566  st->start_time = 0;
567  }
568 
569  return 1;
570 }
571 
572  static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
573 {
574  EaDemuxContext *ea = s->priv_data;
575  AVIOContext *pb = s->pb;
576  int partial_packet = 0;
577  unsigned int chunk_type, chunk_size;
578  int ret = 0, packet_read = 0, key = 0;
579  int av_uninit(num_samples);
580 
581  while (!packet_read || partial_packet) {
582  chunk_type = avio_rl32(pb);
583  chunk_size = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
584  if (chunk_size < 8)
585  return AVERROR_INVALIDDATA;
586  chunk_size -= 8;
587 
588  switch (chunk_type) {
589  /* audio data */
590  case ISNh_TAG:
591  /* header chunk also contains data; skip over the header portion */
592  if (chunk_size < 32)
593  return AVERROR_INVALIDDATA;
594  avio_skip(pb, 32);
595  chunk_size -= 32;
596  case ISNd_TAG:
597  case SCDl_TAG:
598  case SNDC_TAG:
599  case SDEN_TAG:
600  if (!ea->audio_codec) {
601  avio_skip(pb, chunk_size);
602  break;
603  } else if (ea->audio_codec == AV_CODEC_ID_PCM_S16LE_PLANAR ||
604  ea->audio_codec == AV_CODEC_ID_MP3) {
605  num_samples = avio_rl32(pb);
606  avio_skip(pb, 8);
607  chunk_size -= 12;
608  } else if (ea->audio_codec == AV_CODEC_ID_ADPCM_PSX) {
609  avio_skip(pb, 8);
610  chunk_size -= 8;
611  }
612 
613  if (partial_packet) {
614  avpriv_request_sample(s, "video header followed by audio packet");
615  av_packet_unref(pkt);
616  partial_packet = 0;
617  }
618 
619  if (!chunk_size)
620  continue;
621 
622  ret = av_get_packet(pb, pkt, chunk_size);
623  if (ret < 0)
624  return ret;
625  pkt->stream_index = ea->audio_stream_index;
626 
627  switch (ea->audio_codec) {
628  case AV_CODEC_ID_ADPCM_EA:
629  case AV_CODEC_ID_ADPCM_EA_R1:
630  case AV_CODEC_ID_ADPCM_EA_R2:
631  case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
632  case AV_CODEC_ID_ADPCM_EA_R3:
633  if (pkt->size < 4) {
634  av_log(s, AV_LOG_ERROR, "Packet is too short\n");
635  av_packet_unref(pkt);
636  return AVERROR_INVALIDDATA;
637  }
638  if (ea->audio_codec == AV_CODEC_ID_ADPCM_EA_R3)
639  pkt->duration = AV_RB32(pkt->data);
640  else
641  pkt->duration = AV_RL32(pkt->data);
642  break;
643  case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
644  pkt->duration = ret * 2 / ea->num_channels;
645  break;
646  case AV_CODEC_ID_PCM_S16LE_PLANAR:
647  case AV_CODEC_ID_MP3:
648  pkt->duration = num_samples;
649  break;
650  case AV_CODEC_ID_ADPCM_PSX:
651  pkt->duration = chunk_size / (16 * ea->num_channels) * 28;
652  break;
653  default:
654  pkt->duration = chunk_size / (ea->bytes * ea->num_channels);
655  }
656 
657  packet_read = 1;
658  break;
659 
660  /* ending tag */
661  case 0:
662  case ISNe_TAG:
663  case SCEl_TAG:
664  case SEND_TAG:
665  case SEEN_TAG:
666  while (!avio_feof(pb)) {
667  int tag = avio_rl32(pb);
668 
669  if (tag == ISNh_TAG ||
670  tag == SCHl_TAG ||
671  tag == SEAD_TAG ||
672  tag == SHEN_TAG) {
673  avio_skip(pb, -4);
674  break;
675  }
676  }
677  if (avio_feof(pb))
678  ret = AVERROR_EOF;
679  packet_read = 1;
680  break;
681 
682  case MVIh_TAG:
683  case kVGT_TAG:
684  case pQGT_TAG:
685  case TGQs_TAG:
686  case MADk_TAG:
687  key = AV_PKT_FLAG_KEY;
688  case MVIf_TAG:
689  case fVGT_TAG:
690  case MADm_TAG:
691  case MADe_TAG:
692  avio_seek(pb, -8, SEEK_CUR); // include chunk preamble
693  chunk_size += 8;
694  goto get_video_packet;
695 
696  case mTCD_TAG:
697  if (chunk_size < 8)
698  return AVERROR_INVALIDDATA;
699 
700  avio_skip(pb, 8); // skip ea DCT header
701  chunk_size -= 8;
702  goto get_video_packet;
703 
704  case MV0K_TAG:
705  case AV0K_TAG:
706  case MPCh_TAG:
707  case pIQT_TAG:
708  key = AV_PKT_FLAG_KEY;
709  case MV0F_TAG:
710  case AV0F_TAG:
711 get_video_packet:
712  if (!chunk_size)
713  continue;
714 
715  if (partial_packet) {
716  ret = av_append_packet(pb, pkt, chunk_size);
717  } else
718  ret = av_get_packet(pb, pkt, chunk_size);
719  if (ret < 0) {
720  packet_read = 1;
721  break;
722  }
723  partial_packet = chunk_type == MVIh_TAG;
724  if (chunk_type == AV0K_TAG || chunk_type == AV0F_TAG)
725  pkt->stream_index = ea->alpha.stream_index;
726  else
727  pkt->stream_index = ea->video.stream_index;
728  pkt->flags |= key;
729  packet_read = 1;
730  break;
731 
732  default:
733  avio_skip(pb, chunk_size);
734  break;
735  }
736  }
737 
738  if (ret < 0 && partial_packet)
739  av_packet_unref(pkt);
740  return ret;
741 }
742 
743  AVInputFormat ff_ea_demuxer = {
744  .name = "ea",
745  .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),
746  .priv_data_size = sizeof(EaDemuxContext),
747  .read_probe = ea_probe,
748  .read_header = ea_read_header,
749  .read_packet = ea_read_packet,
750 };
NULL
#define NULL
Definition: coverity.c:32
SEEN_TAG
#define SEEN_TAG
Definition: electronicarts.c:40
process_ea_header
static int process_ea_header(AVFormatContext *s)
Definition: electronicarts.c:358
AV_CODEC_ID_ADPCM_EA
Definition: avcodec.h:500
s
const char * s
Definition: avisynth_c.h:768
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
read_arbitrary
static uint32_t read_arbitrary(AVIOContext *pb)
Definition: electronicarts.c:93
AV_CODEC_ID_NONE
Definition: avcodec.h:216
AV_CODEC_ID_PCM_S8
Definition: avcodec.h:456
VideoProperties::codec
enum AVCodecID codec
Definition: electronicarts.c:70
SCDl_TAG
#define SCDl_TAG
Definition: electronicarts.c:47
process_video_header_cmv
static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:345
pIQT_TAG
#define pIQT_TAG
Definition: electronicarts.c:58
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AV_CODEC_ID_MAD
Definition: avcodec.h:347
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, 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:4820
mTCD_TAG
#define mTCD_TAG
Definition: electronicarts.c:51
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3884
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition: avcodec.h:513
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:874
AVPacket::size
int size
Definition: avcodec.h:1431
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
MV0F_TAG
#define MV0F_TAG
Definition: electronicarts.c:61
EaDemuxContext::audio_codec
enum AVCodecID audio_codec
Definition: electronicarts.c:82
fVGT_TAG
#define fVGT_TAG
Definition: electronicarts.c:50
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
key
const char * key
Definition: hwcontext_opencl.c:165
SCEl_TAG
#define SCEl_TAG
Definition: electronicarts.c:48
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
pQGT_TAG
#define pQGT_TAG
Definition: electronicarts.c:57
ISNe_TAG
#define ISNe_TAG
Definition: electronicarts.c:44
AV_CODEC_ID_VP6
Definition: avcodec.h:309
TGQs_TAG
#define TGQs_TAG
Definition: electronicarts.c:56
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
MPCh_TAG
#define MPCh_TAG
Definition: electronicarts.c:55
avpriv_request_sample
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
PT00_TAG
#define PT00_TAG
Definition: electronicarts.c:45
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodecParameters::width
int width
Video only.
Definition: avcodec.h:3950
MADm_TAG
#define MADm_TAG
Definition: electronicarts.c:53
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:801
EaDemuxContext::audio_stream_index
int audio_stream_index
Definition: electronicarts.c:83
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1448
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1091
AV_CODEC_ID_TGQ
Definition: avcodec.h:339
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4450
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:87
AVPacket::data
uint8_t * data
Definition: avcodec.h:1430
AV_CODEC_ID_TGV
Definition: avcodec.h:338
init_video_stream
static int init_video_stream(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:490
AV_CODEC_ID_ADPCM_EA_R3
Definition: avcodec.h:511
tag
uint32_t tag
Definition: movenc.c:1455
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:310
size
ptrdiff_t size
Definition: opengl_enc.c:101
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
SEND_TAG
#define SEND_TAG
Definition: electronicarts.c:37
AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: avcodec.h:470
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:320
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3913
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1462
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
SCHl_TAG
#define SCHl_TAG
Definition: electronicarts.c:34
AVP6_TAG
#define AVP6_TAG
Definition: electronicarts.c:67
MADk_TAG
#define MADk_TAG
Definition: electronicarts.c:52
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:770
process_video_header_vp6
static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:327
AVERROR
#define AVERROR(e)
Definition: error.h:43
AV_CODEC_ID_TQI
Definition: avcodec.h:340
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:186
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:552
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3880
AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_ADPCM_IMA_EA_EACS
Definition: avcodec.h:514
VideoProperties::time_base
AVRational time_base
Definition: electronicarts.c:71
EaDemuxContext::video
VideoProperties video
Definition: electronicarts.c:80
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:946
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1436
AV_CODEC_ID_ADPCM_EA_R1
Definition: avcodec.h:510
AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:794
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:639
SDEN_TAG
#define SDEN_TAG
Definition: electronicarts.c:39
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:450
AVCodecParameters::block_align
int block_align
Audio only.
Definition: avcodec.h:4001
process_audio_header_eacs
static void process_audio_header_eacs(AVFormatContext *s)
Definition: electronicarts.c:269
process_video_header_mdec
static void process_video_header_mdec(AVFormatContext *s, VideoProperties *video)
Definition: electronicarts.c:317
SNDC_TAG
#define SNDC_TAG
Definition: electronicarts.c:36
process_audio_header_elements
static int process_audio_header_elements(AVFormatContext *s)
Definition: electronicarts.c:111
read_probe
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
AVhd_TAG
#define AVhd_TAG
Definition: electronicarts.c:62
ea_read_header
static int ea_read_header(AVFormatContext *s)
Definition: electronicarts.c:518
AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
AV0K_TAG
#define AV0K_TAG
Definition: electronicarts.c:63
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
AVStream
Stream structure.
Definition: avformat.h:873
ISNd_TAG
#define ISNd_TAG
Definition: electronicarts.c:43
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
av_bswap32
#define av_bswap32
Definition: bswap.h:33
SEAD_TAG
#define SEAD_TAG
Definition: electronicarts.c:35
EACS_TAG
#define EACS_TAG
Definition: electronicarts.c:42
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:87
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1384
kVGT_TAG
#define kVGT_TAG
Definition: electronicarts.c:49
AV0F_TAG
#define AV0F_TAG
Definition: electronicarts.c:64
AV_CODEC_ID_MDEC
Definition: avcodec.h:255
AV_CODEC_ID_CMV
Definition: avcodec.h:336
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:592
AV_CODEC_ID_PCM_MULAW
Definition: avcodec.h:458
GSTR_TAG
#define GSTR_TAG
Definition: electronicarts.c:46
MVIh_TAG
#define MVIh_TAG
Definition: electronicarts.c:65
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
MVhd_TAG
#define MVhd_TAG
Definition: electronicarts.c:59
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:448
ea_probe
static int ea_probe(AVProbeData *p)
Definition: electronicarts.c:461
SHEN_TAG
#define SHEN_TAG
Definition: electronicarts.c:38
AV_CODEC_ID_ADPCM_PSX
Definition: avcodec.h:528
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: avcodec.h:3994
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:460
MV0K_TAG
#define MV0K_TAG
Definition: electronicarts.c:60
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:754
avformat.h
Main libavformat public API header.
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:912
MADe_TAG
#define MADe_TAG
Definition: electronicarts.c:54
EaDemuxContext::alpha
VideoProperties alpha
Definition: electronicarts.c:80
process_audio_header_sead
static void process_audio_header_sead(AVFormatContext *s)
Definition: electronicarts.c:306
AV_CODEC_ID_PCM_S16LE
Definition: avcodec.h:452
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:924
AVRational::den
int den
Denominator.
Definition: rational.h:60
ISNh_TAG
#define ISNh_TAG
Definition: electronicarts.c:41
MVIf_TAG
#define MVIf_TAG
Definition: electronicarts.c:66
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1370
AV_CODEC_ID_ADPCM_EA_R2
Definition: avcodec.h:512
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3926
AVCodecParameters::channels
int channels
Audio only.
Definition: avcodec.h:3990
av_uninit
#define av_uninit(x)
Definition: attributes.h:148
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:647
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ea_read_packet
static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: electronicarts.c:572
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1020
avio_feof
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:358
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3888
AVPacket::stream_index
int stream_index
Definition: avcodec.h:1432
ff_ea_demuxer
AVInputFormat ff_ea_demuxer
Definition: electronicarts.c:743
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:997
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1407
Generated on Sun May 13 2018 02:04:04 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /