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 {
72  int width, height;
73  int nb_frames;
76 
77 typedef struct EaDemuxContext {
79 
81 
82  enum AVCodecID audio_codec;
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(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 
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 || ea->bytes > 2) {
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 = (int64_t)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  int hit_end = 0;
578  unsigned int chunk_type, chunk_size;
579  int ret = 0, packet_read = 0, key = 0;
580  int av_uninit(num_samples);
581 
582  while ((!packet_read && !hit_end) || partial_packet) {
583  chunk_type = avio_rl32(pb);
584  chunk_size = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
585  if (chunk_size < 8)
586  return AVERROR_INVALIDDATA;
587  chunk_size -= 8;
588 
589  switch (chunk_type) {
590  /* audio data */
591  case ISNh_TAG:
592  /* header chunk also contains data; skip over the header portion */
593  if (chunk_size < 32)
594  return AVERROR_INVALIDDATA;
595  avio_skip(pb, 32);
596  chunk_size -= 32;
597  case ISNd_TAG:
598  case SCDl_TAG:
599  case SNDC_TAG:
600  case SDEN_TAG:
601  if (!ea->audio_codec) {
602  avio_skip(pb, chunk_size);
603  break;
604  } else if (ea->audio_codec == AV_CODEC_ID_PCM_S16LE_PLANAR ||
605  ea->audio_codec == AV_CODEC_ID_MP3) {
606  num_samples = avio_rl32(pb);
607  avio_skip(pb, 8);
608  chunk_size -= 12;
609  } else if (ea->audio_codec == AV_CODEC_ID_ADPCM_PSX) {
610  avio_skip(pb, 8);
611  chunk_size -= 8;
612  }
613 
614  if (partial_packet) {
615  avpriv_request_sample(s, "video header followed by audio packet");
616  av_packet_unref(pkt);
617  partial_packet = 0;
618  }
619 
620  if (!chunk_size)
621  continue;
622 
623  ret = av_get_packet(pb, pkt, chunk_size);
624  if (ret < 0)
625  return ret;
626  pkt->stream_index = ea->audio_stream_index;
627 
628  switch (ea->audio_codec) {
634  if (pkt->size < 4) {
635  av_log(s, AV_LOG_ERROR, "Packet is too short\n");
636  av_packet_unref(pkt);
637  return AVERROR_INVALIDDATA;
638  }
640  pkt->duration = AV_RB32(pkt->data);
641  else
642  pkt->duration = AV_RL32(pkt->data);
643  break;
645  pkt->duration = ret * 2 / ea->num_channels;
646  break;
648  case AV_CODEC_ID_MP3:
649  pkt->duration = num_samples;
650  break;
652  pkt->duration = chunk_size / (16 * ea->num_channels) * 28;
653  break;
654  default:
655  pkt->duration = chunk_size / (ea->bytes * ea->num_channels);
656  }
657 
658  packet_read = 1;
659  break;
660 
661  /* ending tag */
662  case 0:
663  case ISNe_TAG:
664  case SCEl_TAG:
665  case SEND_TAG:
666  case SEEN_TAG:
667  while (!avio_feof(pb)) {
668  int tag = avio_rl32(pb);
669 
670  if (tag == ISNh_TAG ||
671  tag == SCHl_TAG ||
672  tag == SEAD_TAG ||
673  tag == SHEN_TAG) {
674  avio_skip(pb, -4);
675  break;
676  }
677  }
678  if (avio_feof(pb))
679  ret = AVERROR_EOF;
680  hit_end = 1;
681  break;
682 
683  case MVIh_TAG:
684  case kVGT_TAG:
685  case pQGT_TAG:
686  case TGQs_TAG:
687  case MADk_TAG:
689  case MVIf_TAG:
690  case fVGT_TAG:
691  case MADm_TAG:
692  case MADe_TAG:
693  avio_seek(pb, -8, SEEK_CUR); // include chunk preamble
694  chunk_size += 8;
695  goto get_video_packet;
696 
697  case mTCD_TAG:
698  if (chunk_size < 8)
699  return AVERROR_INVALIDDATA;
700 
701  avio_skip(pb, 8); // skip ea DCT header
702  chunk_size -= 8;
703  goto get_video_packet;
704 
705  case MV0K_TAG:
706  case AV0K_TAG:
707  case MPCh_TAG:
708  case pIQT_TAG:
710  case MV0F_TAG:
711  case AV0F_TAG:
712 get_video_packet:
713  if (!chunk_size)
714  continue;
715 
716  if (partial_packet) {
717  ret = av_append_packet(pb, pkt, chunk_size);
718  } else
719  ret = av_get_packet(pb, pkt, chunk_size);
720  if (ret < 0) {
721  packet_read = 1;
722  break;
723  }
724  partial_packet = chunk_type == MVIh_TAG;
725  if (chunk_type == AV0K_TAG || chunk_type == AV0F_TAG)
726  pkt->stream_index = ea->alpha.stream_index;
727  else
728  pkt->stream_index = ea->video.stream_index;
729  pkt->flags |= key;
730  packet_read = 1;
731  break;
732 
733  default:
734  avio_skip(pb, chunk_size);
735  break;
736  }
737  }
738 
739  if (ret < 0 && partial_packet)
740  av_packet_unref(pkt);
741  if (ret >= 0 && hit_end && !packet_read)
742  return AVERROR(EAGAIN);
743 
744  return ret;
745 }
746 
748  .name = "ea",
749  .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia"),
750  .priv_data_size = sizeof(EaDemuxContext),
751  .read_probe = ea_probe,
754 };
#define NULL
Definition: coverity.c:32
#define SEEN_TAG
static int process_ea_header(AVFormatContext *s)
Bytestream IO Context.
Definition: avio.h:161
#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:4929
#define mTCD_TAG
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1481
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
#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:334
const char * key
#define SCEl_TAG
static AVPacket pkt
#define pQGT_TAG
#define ISNe_TAG
#define TGQs_TAG
Format I/O context.
Definition: avformat.h:1358
#define MPCh_TAG
#define PT00_TAG
uint8_t
int width
Video only.
Definition: avcodec.h:4034
#define MADm_TAG
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:803
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1498
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4502
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:1480
static int init_video_stream(AVFormatContext *s, VideoProperties *video)
uint32_t tag
Definition: movenc.c:1531
#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:310
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#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:320
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3997
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#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:772
static int process_video_header_vp6(AVFormatContext *s, VideoProperties *video)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#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:566
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
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:1486
Only parse headers, do not repack.
Definition: avformat.h:801
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:641
#define SDEN_TAG
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
int block_align
Audio only.
Definition: avcodec.h:4085
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)
#define AVhd_TAG
static int ea_read_header(AVFormatContext *s)
#define s(width, name)
Definition: cbs_vp9.c:257
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
#define AV0K_TAG
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
Stream structure.
Definition: avformat.h:881
#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:1400
#define kVGT_TAG
#define AV0F_TAG
static const int16_t alpha[]
Definition: ilbcdata.h:55
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
#define GSTR_TAG
#define MVIh_TAG
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define MVhd_TAG
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
#define SHEN_TAG
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: avcodec.h:4078
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
#define MV0K_TAG
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:756
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:920
#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:60
#define ISNh_TAG
static int ea_probe(const AVProbeData *p)
A Quick Description Of Rate Distortion Theory We want to encode a video
#define MVIf_TAG
void * priv_data
Format private data.
Definition: avformat.h:1386
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4010
int channels
Audio only.
Definition: avcodec.h:4074
#define av_uninit(x)
Definition: attributes.h:148
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:361
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3972
int stream_index
Definition: avcodec.h:1482
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
AVInputFormat ff_ea_demuxer
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1005
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1457