FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 {
72  int width, height;
73  int nb_frames;
76 
77 typedef struct EaDemuxContext {
79 
81 
84 
85  int bytes;
89 
90  int platform;
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 
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:
207  break;
208  case 7:
210  break;
211  case -1:
212  switch (revision) {
213  case 1:
215  break;
216  case 2:
218  break;
219  case 3:
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:
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:
245  break;
246  case -1:
247  break;
248  default:
250  avpriv_request_sample(s, "stream type; revision2=%i", revision2);
251  return 0;
252  }
253  break;
254  default:
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)
263  if (ea->sample_rate == -1)
264  ea->sample_rate = revision == 3 ? 48000 : 22050;
265 
266  return 1;
267 }
268 
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:
286  break;
287  case 2:
289  break;
290  }
291  break;
292  case 1:
294  ea->bytes = 1;
295  break;
296  case 2:
298  break;
299  default:
301  "stream type; audio compression_type=%i",
302  compression_type);
303  }
304 }
305 
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);
315 }
316 
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 
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 
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. */
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  }
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;
400  break;
401 
402  case SEAD_TAG:
404  break;
405 
406  case MVIh_TAG:
408  break;
409 
410  case kVGT_TAG:
412  break;
413 
414  case mTCD_TAG:
416  break;
417 
418  case MPCh_TAG:
420  break;
421 
422  case pQGT_TAG:
423  case TGQs_TAG:
425  ea->video.time_base = (AVRational) { 1, 15 };
426  break;
427 
428  case pIQT_TAG:
430  ea->video.time_base = (AVRational) { 1, 15 };
431  break;
432 
433  case MADk_TAG:
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 
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;
503  st->codecpar->codec_id = video->codec;
504  // parsing is necessary to make FFmpeg generate correct timestamps
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 
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) {
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) {
543  av_log(s, AV_LOG_ERROR,
544  "Invalid number of bytes per sample: %d\n", ea->bytes);
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);
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 = st->codecpar->channels *
561  st->codecpar->sample_rate *
563  st->codecpar->block_align = st->codecpar->channels *
565  ea->audio_stream_index = st->index;
566  st->start_time = 0;
567  }
568 
569  return 1;
570 }
571 
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) {
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  }
639  pkt->duration = AV_RB32(pkt->data);
640  else
641  pkt->duration = AV_RL32(pkt->data);
642  break;
644  pkt->duration = ret * 2 / ea->num_channels;
645  break;
647  case AV_CODEC_ID_MP3:
648  pkt->duration = num_samples;
649  break;
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 
744  .name = "ea",
745  .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),
746  .priv_data_size = sizeof(EaDemuxContext),
747  .read_probe = ea_probe,
750 };
#define NULL
Definition: coverity.c:32
#define SEEN_TAG
static int process_ea_header(AVFormatContext *s)
const char * s
Definition: avisynth_c.h:631
Bytestream IO Context.
Definition: avio.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static uint32_t read_arbitrary(AVIOContext *pb)
enum AVCodecID codec
#define SCDl_TAG
static void process_video_header_cmv(AVFormatContext *s, VideoProperties *video)
#define pIQT_TAG
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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:4436
#define mTCD_TAG
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3922
int num
numerator
Definition: rational.h:44
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: avcodec.h:1581
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:230
#define MV0F_TAG
enum AVCodecID audio_codec
#define fVGT_TAG
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:304
#define SCEl_TAG
static AVPacket pkt
#define pQGT_TAG
#define ISNe_TAG
#define TGQs_TAG
Format I/O context.
Definition: avformat.h:1325
#define MPCh_TAG
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define PT00_TAG
uint8_t
int width
Video only.
Definition: avcodec.h:3988
#define MADm_TAG
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:751
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1598
enum AVStreamParseType need_parsing
Definition: avformat.h:1063
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4074
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
uint8_t * data
Definition: avcodec.h:1580
static int init_video_stream(AVFormatContext *s, VideoProperties *video)
uint32_t tag
Definition: movenc.c:1367
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:260
ptrdiff_t size
Definition: opengl_enc.c:101
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:511
#define SEND_TAG
#define av_log(a,...)
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:270
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3951
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1612
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:189
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define SCHl_TAG
#define AVP6_TAG
#define MADk_TAG
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:720
static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:515
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3918
AVRational time_base
VideoProperties video
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1586
Only parse headers, do not repack.
Definition: avformat.h:807
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:589
#define SDEN_TAG
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:461
int block_align
Audio only.
Definition: avcodec.h:4039
static void process_audio_header_eacs(AVFormatContext *s)
static void process_video_header_mdec(AVFormatContext *s, VideoProperties *video)
#define SNDC_TAG
static int process_audio_header_elements(AVFormatContext *s)
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
#define AVhd_TAG
static int ea_read_header(AVFormatContext *s)
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:194
#define AV0K_TAG
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:638
Stream structure.
Definition: avformat.h:876
#define ISNd_TAG
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define av_bswap32
Definition: bswap.h:33
#define SEAD_TAG
#define EACS_TAG
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
AVIOContext * pb
I/O context.
Definition: avformat.h:1367
#define kVGT_TAG
#define AV0F_TAG
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:563
#define GSTR_TAG
#define MVIh_TAG
rational number numerator/denominator
Definition: rational.h:43
#define MVhd_TAG
This structure contains the data a format has to probe a file.
Definition: avformat.h:459
static int ea_probe(AVProbeData *p)
#define SHEN_TAG
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:133
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
int sample_rate
Audio only.
Definition: avcodec.h:4032
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:471
#define MV0K_TAG
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:704
Main libavformat public API header.
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:923
#define MADe_TAG
VideoProperties alpha
static void process_audio_header_sead(AVFormatContext *s)
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
int den
denominator
Definition: rational.h:45
#define ISNh_TAG
#define MVIf_TAG
void * priv_data
Format private data.
Definition: avformat.h:1353
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3964
int channels
Audio only.
Definition: avcodec.h:4028
#define av_uninit(x)
Definition: attributes.h:149
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:660
static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
AVCodecParameters * codecpar
Definition: avformat.h:1228
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:328
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3926
int stream_index
Definition: avcodec.h:1582
AVInputFormat ff_ea_demuxer
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1090
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1557