FFmpeg
iff.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008 Jaikrishnan Menon <realityman@gmx.net>
3  * Copyright (c) 2010 Peter Ross <pross@xvid.org>
4  * Copyright (c) 2010 Sebastian Vater <cdgs.basty@googlemail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * IFF file demuxer
26  * by Jaikrishnan Menon
27  * for more information on the .iff file format, visit:
28  * http://wiki.multimedia.cx/index.php?title=IFF
29  */
30 
31 #include <inttypes.h>
32 
33 #include "libavutil/avassert.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/dict.h"
37 #include "libavcodec/bytestream.h"
38 #include "avformat.h"
39 #include "id3v2.h"
40 #include "internal.h"
41 
42 #define ID_8SVX MKTAG('8','S','V','X')
43 #define ID_16SV MKTAG('1','6','S','V')
44 #define ID_MAUD MKTAG('M','A','U','D')
45 #define ID_MHDR MKTAG('M','H','D','R')
46 #define ID_MDAT MKTAG('M','D','A','T')
47 #define ID_VHDR MKTAG('V','H','D','R')
48 #define ID_ATAK MKTAG('A','T','A','K')
49 #define ID_RLSE MKTAG('R','L','S','E')
50 #define ID_CHAN MKTAG('C','H','A','N')
51 #define ID_PBM MKTAG('P','B','M',' ')
52 #define ID_ILBM MKTAG('I','L','B','M')
53 #define ID_BMHD MKTAG('B','M','H','D')
54 #define ID_DGBL MKTAG('D','G','B','L')
55 #define ID_CAMG MKTAG('C','A','M','G')
56 #define ID_CMAP MKTAG('C','M','A','P')
57 #define ID_ACBM MKTAG('A','C','B','M')
58 #define ID_DEEP MKTAG('D','E','E','P')
59 #define ID_RGB8 MKTAG('R','G','B','8')
60 #define ID_RGBN MKTAG('R','G','B','N')
61 #define ID_DSD MKTAG('D','S','D',' ')
62 #define ID_DST MKTAG('D','S','T',' ')
63 #define ID_DSTC MKTAG('D','S','T','C')
64 #define ID_DSTF MKTAG('D','S','T','F')
65 #define ID_FRTE MKTAG('F','R','T','E')
66 #define ID_ANIM MKTAG('A','N','I','M')
67 #define ID_ANHD MKTAG('A','N','H','D')
68 #define ID_DLTA MKTAG('D','L','T','A')
69 #define ID_DPAN MKTAG('D','P','A','N')
70 
71 #define ID_FORM MKTAG('F','O','R','M')
72 #define ID_FRM8 MKTAG('F','R','M','8')
73 #define ID_ANNO MKTAG('A','N','N','O')
74 #define ID_AUTH MKTAG('A','U','T','H')
75 #define ID_CHRS MKTAG('C','H','R','S')
76 #define ID_COPYRIGHT MKTAG('(','c',')',' ')
77 #define ID_CSET MKTAG('C','S','E','T')
78 #define ID_FVER MKTAG('F','V','E','R')
79 #define ID_NAME MKTAG('N','A','M','E')
80 #define ID_TEXT MKTAG('T','E','X','T')
81 #define ID_ABIT MKTAG('A','B','I','T')
82 #define ID_BODY MKTAG('B','O','D','Y')
83 #define ID_DBOD MKTAG('D','B','O','D')
84 #define ID_DPEL MKTAG('D','P','E','L')
85 #define ID_DLOC MKTAG('D','L','O','C')
86 #define ID_TVDC MKTAG('T','V','D','C')
87 
88 #define LEFT 2
89 #define RIGHT 4
90 #define STEREO 6
91 
92 /**
93  * This number of bytes if added at the beginning of each AVPacket
94  * which contain additional information about video properties
95  * which has to be shared between demuxer and decoder.
96  * This number may change between frames, e.g. the demuxer might
97  * set it to smallest possible size of 2 to indicate that there's
98  * no extradata changing in this frame.
99  */
100 #define IFF_EXTRA_VIDEO_SIZE 41
101 
102 typedef enum {
107 
108 typedef struct IffDemuxContext {
109  int is_64bit; ///< chunk size is 64-bit
110  int64_t body_pos;
111  int64_t body_end;
112  uint32_t body_size;
114  unsigned maud_bits;
116  unsigned bitmap_compression; ///< delta compression method used
117  unsigned bpp; ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
118  unsigned ham; ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
119  unsigned flags; ///< 1 for EHB, 0 is no extra half darkening
120  unsigned transparency; ///< transparency color index in palette
121  unsigned masking; ///< masking method used
122  uint8_t tvdc[32]; ///< TVDC lookup table
123  int64_t pts;
125 
126 /* Metadata string read */
128  const char *const tag,
129  const unsigned data_size)
130 {
131  uint8_t *buf = ((data_size + 1) == 0) ? NULL : av_malloc(data_size + 1);
132 
133  if (!buf)
134  return AVERROR(ENOMEM);
135 
136  if (avio_read(s->pb, buf, data_size) != data_size) {
137  av_free(buf);
138  return AVERROR(EIO);
139  }
140  buf[data_size] = 0;
142  return 0;
143 }
144 
145 static int iff_probe(const AVProbeData *p)
146 {
147  const uint8_t *d = p->buf;
148 
149  if ( (AV_RL32(d) == ID_FORM &&
150  (AV_RL32(d+8) == ID_8SVX ||
151  AV_RL32(d+8) == ID_16SV ||
152  AV_RL32(d+8) == ID_MAUD ||
153  AV_RL32(d+8) == ID_PBM ||
154  AV_RL32(d+8) == ID_ACBM ||
155  AV_RL32(d+8) == ID_DEEP ||
156  AV_RL32(d+8) == ID_ILBM ||
157  AV_RL32(d+8) == ID_RGB8 ||
158  AV_RL32(d+8) == ID_ANIM ||
159  AV_RL32(d+8) == ID_RGBN)) ||
160  (AV_RL32(d) == ID_FRM8 && AV_RL32(d+12) == ID_DSD))
161  return AVPROBE_SCORE_MAX;
162  return 0;
163 }
164 
165 static const AVCodecTag dsd_codec_tags[] = {
167  { AV_CODEC_ID_DST, ID_DST },
168  { AV_CODEC_ID_NONE, 0 },
169 };
170 
171 
172 #define DSD_SLFT MKTAG('S','L','F','T')
173 #define DSD_SRGT MKTAG('S','R','G','T')
174 #define DSD_MLFT MKTAG('M','L','F','T')
175 #define DSD_MRGT MKTAG('M','R','G','T')
176 #define DSD_C MKTAG('C',' ',' ',' ')
177 #define DSD_LS MKTAG('L','S',' ',' ')
178 #define DSD_RS MKTAG('R','S',' ',' ')
179 #define DSD_LFE MKTAG('L','F','E',' ')
180 
181 static const uint32_t dsd_stereo[] = { DSD_SLFT, DSD_SRGT };
182 static const uint32_t dsd_5point0[] = { DSD_MLFT, DSD_MRGT, DSD_C, DSD_LS, DSD_RS };
183 static const uint32_t dsd_5point1[] = { DSD_MLFT, DSD_MRGT, DSD_C, DSD_LFE, DSD_LS, DSD_RS };
184 
185 typedef struct {
186  uint64_t layout;
187  const uint32_t * dsd_layout;
188 } DSDLayoutDesc;
189 
194 };
195 
196 static const uint64_t dsd_loudspeaker_config[] = {
198  0, 0,
200 };
201 
202 static const char * dsd_source_comment[] = {
203  "dsd_source_comment",
204  "analogue_source_comment",
205  "pcm_source_comment",
206 };
207 
208 static const char * dsd_history_comment[] = {
209  "general_remark",
210  "operator_name",
211  "creating_machine",
212  "timezone",
213  "file_revision"
214 };
215 
216 static int parse_dsd_diin(AVFormatContext *s, AVStream *st, uint64_t eof)
217 {
218  AVIOContext *pb = s->pb;
219 
220  while (avio_tell(pb) + 12 <= eof && !avio_feof(pb)) {
221  uint32_t tag = avio_rl32(pb);
222  uint64_t size = avio_rb64(pb);
223  uint64_t orig_pos = avio_tell(pb);
224  const char * metadata_tag = NULL;
225 
226  switch(tag) {
227  case MKTAG('D','I','A','R'): metadata_tag = "artist"; break;
228  case MKTAG('D','I','T','I'): metadata_tag = "title"; break;
229  }
230 
231  if (metadata_tag && size > 4) {
232  unsigned int tag_size = avio_rb32(pb);
233  int ret = get_metadata(s, metadata_tag, FFMIN(tag_size, size - 4));
234  if (ret < 0) {
235  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag);
236  return ret;
237  }
238  }
239 
240  avio_skip(pb, size - (avio_tell(pb) - orig_pos) + (size & 1));
241  }
242 
243  return 0;
244 }
245 
246 static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
247 {
248  AVIOContext *pb = s->pb;
249  char abss[24];
250  int hour, min, sec, i, ret, config;
251  int dsd_layout[6];
252  ID3v2ExtraMeta *id3v2_extra_meta;
253 
254  while (avio_tell(pb) + 12 <= eof && !avio_feof(pb)) {
255  uint32_t tag = avio_rl32(pb);
256  uint64_t size = avio_rb64(pb);
257  uint64_t orig_pos = avio_tell(pb);
258 
259  switch(tag) {
260  case MKTAG('A','B','S','S'):
261  if (size < 8)
262  return AVERROR_INVALIDDATA;
263  hour = avio_rb16(pb);
264  min = avio_r8(pb);
265  sec = avio_r8(pb);
266  snprintf(abss, sizeof(abss), "%02dh:%02dm:%02ds:%d", hour, min, sec, avio_rb32(pb));
267  av_dict_set(&st->metadata, "absolute_start_time", abss, 0);
268  break;
269 
270  case MKTAG('C','H','N','L'):
271  if (size < 2)
272  return AVERROR_INVALIDDATA;
273  st->codecpar->channels = avio_rb16(pb);
274  if (size < 2 + st->codecpar->channels * 4)
275  return AVERROR_INVALIDDATA;
276  st->codecpar->channel_layout = 0;
277  if (st->codecpar->channels > FF_ARRAY_ELEMS(dsd_layout)) {
278  avpriv_request_sample(s, "channel layout");
279  break;
280  }
281  for (i = 0; i < st->codecpar->channels; i++)
282  dsd_layout[i] = avio_rl32(pb);
283  for (i = 0; i < FF_ARRAY_ELEMS(dsd_channel_layout); i++) {
284  const DSDLayoutDesc * d = &dsd_channel_layout[i];
286  !memcmp(d->dsd_layout, dsd_layout, st->codecpar->channels * sizeof(uint32_t))) {
287  st->codecpar->channel_layout = d->layout;
288  break;
289  }
290  }
291  break;
292 
293  case MKTAG('C','M','P','R'):
294  if (size < 4)
295  return AVERROR_INVALIDDATA;
296  st->codecpar->codec_tag = tag = avio_rl32(pb);
297  st->codecpar->codec_id = ff_codec_get_id(dsd_codec_tags, tag);
298  if (!st->codecpar->codec_id) {
299  av_log(s, AV_LOG_ERROR, "'%s' compression is not supported\n",
300  av_fourcc2str(tag));
301  return AVERROR_PATCHWELCOME;
302  }
303  break;
304 
305  case MKTAG('F','S',' ',' '):
306  if (size < 4)
307  return AVERROR_INVALIDDATA;
308  st->codecpar->sample_rate = avio_rb32(pb) / 8;
309  break;
310 
311  case MKTAG('I','D','3',' '):
312  id3v2_extra_meta = NULL;
313  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, size);
314  if (id3v2_extra_meta) {
315  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0 ||
316  (ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0) {
317  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
318  return ret;
319  }
320  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
321  }
322 
323  if (size < avio_tell(pb) - orig_pos) {
324  av_log(s, AV_LOG_ERROR, "id3 exceeds chunk size\n");
325  return AVERROR_INVALIDDATA;
326  }
327  break;
328 
329  case MKTAG('L','S','C','O'):
330  if (size < 2)
331  return AVERROR_INVALIDDATA;
332  config = avio_rb16(pb);
333  if (config != 0xFFFF) {
336  if (!st->codecpar->channel_layout)
337  avpriv_request_sample(s, "loudspeaker configuration %d", config);
338  }
339  break;
340  }
341 
342  avio_skip(pb, size - (avio_tell(pb) - orig_pos) + (size & 1));
343  }
344 
345  return 0;
346 }
347 
349 {
350  IffDemuxContext *iff = s->priv_data;
351  AVIOContext *pb = s->pb;
352  uint32_t chunk_id;
353  uint64_t chunk_pos, data_pos, data_size;
354  int ret = AVERROR_EOF;
355 
356  while (!avio_feof(pb)) {
357  chunk_pos = avio_tell(pb);
358  if (chunk_pos >= iff->body_end)
359  return AVERROR_EOF;
360 
361  chunk_id = avio_rl32(pb);
362  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
363  data_pos = avio_tell(pb);
364 
365  if (data_size < 1)
366  return AVERROR_INVALIDDATA;
367 
368  switch (chunk_id) {
369  case ID_DSTF:
370  if (!pkt) {
371  iff->body_pos = avio_tell(pb) - (iff->is_64bit ? 12 : 8);
372  iff->body_size = iff->body_end - iff->body_pos;
373  return 0;
374  }
375  ret = av_get_packet(pb, pkt, data_size);
376  if (ret < 0)
377  return ret;
378  if (data_size & 1)
379  avio_skip(pb, 1);
380  pkt->flags |= AV_PKT_FLAG_KEY;
381  pkt->stream_index = 0;
382  pkt->duration = 588 * s->streams[0]->codecpar->sample_rate / 44100;
383  pkt->pos = chunk_pos;
384 
385  chunk_pos = avio_tell(pb);
386  if (chunk_pos >= iff->body_end)
387  return 0;
388 
389  avio_seek(pb, chunk_pos, SEEK_SET);
390  return 0;
391 
392  case ID_FRTE:
393  if (data_size < 4)
394  return AVERROR_INVALIDDATA;
395  s->streams[0]->duration = avio_rb32(pb) * 588LL * s->streams[0]->codecpar->sample_rate / 44100;
396  break;
397  }
398 
399  avio_skip(pb, data_size - (avio_tell(pb) - data_pos) + (data_size & 1));
400  }
401 
402  return ret;
403 }
404 
405 static const uint8_t deep_rgb24[] = {0, 0, 0, 3, 0, 1, 0, 8, 0, 2, 0, 8, 0, 3, 0, 8};
406 static const uint8_t deep_rgba[] = {0, 0, 0, 4, 0, 1, 0, 8, 0, 2, 0, 8, 0, 3, 0, 8};
407 static const uint8_t deep_bgra[] = {0, 0, 0, 4, 0, 3, 0, 8, 0, 2, 0, 8, 0, 1, 0, 8};
408 static const uint8_t deep_argb[] = {0, 0, 0, 4, 0,17, 0, 8, 0, 1, 0, 8, 0, 2, 0, 8};
409 static const uint8_t deep_abgr[] = {0, 0, 0, 4, 0,17, 0, 8, 0, 3, 0, 8, 0, 2, 0, 8};
410 
412 {
413  IffDemuxContext *iff = s->priv_data;
414  AVIOContext *pb = s->pb;
415  AVStream *st;
416  uint8_t *buf;
417  uint32_t chunk_id;
418  uint64_t data_size;
419  uint32_t screenmode = 0, num, den;
420  unsigned transparency = 0;
421  unsigned masking = 0; // no mask
422  uint8_t fmt[16];
423  int fmt_size;
424 
425  st = avformat_new_stream(s, NULL);
426  if (!st)
427  return AVERROR(ENOMEM);
428 
429  st->codecpar->channels = 1;
431  iff->is_64bit = avio_rl32(pb) == ID_FRM8;
432  avio_skip(pb, iff->is_64bit ? 8 : 4);
433  // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content
434  st->codecpar->codec_tag = avio_rl32(pb);
435  if (st->codecpar->codec_tag == ID_ANIM) {
436  avio_skip(pb, 12);
437  }
438  iff->bitmap_compression = -1;
439  iff->svx8_compression = -1;
440  iff->maud_bits = -1;
441  iff->maud_compression = -1;
442 
443  while(!avio_feof(pb)) {
444  uint64_t orig_pos;
445  int res;
446  const char *metadata_tag = NULL;
447  int version, nb_comments, i;
448  chunk_id = avio_rl32(pb);
449  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
450  orig_pos = avio_tell(pb);
451 
452  if (data_size >= INT64_MAX)
453  return AVERROR_INVALIDDATA;
454 
455  switch(chunk_id) {
456  case ID_VHDR:
458 
459  if (data_size < 14)
460  return AVERROR_INVALIDDATA;
461  avio_skip(pb, 12);
462  st->codecpar->sample_rate = avio_rb16(pb);
463  if (data_size >= 16) {
464  avio_skip(pb, 1);
465  iff->svx8_compression = avio_r8(pb);
466  }
467  break;
468 
469  case ID_MHDR:
471 
472  if (data_size < 32)
473  return AVERROR_INVALIDDATA;
474  avio_skip(pb, 4);
475  iff->maud_bits = avio_rb16(pb);
476  avio_skip(pb, 2);
477  num = avio_rb32(pb);
478  den = avio_rb16(pb);
479  if (!den)
480  return AVERROR_INVALIDDATA;
481  avio_skip(pb, 2);
482  st->codecpar->sample_rate = num / den;
483  st->codecpar->channels = avio_rb16(pb);
484  iff->maud_compression = avio_rb16(pb);
485  if (st->codecpar->channels == 1)
487  else if (st->codecpar->channels == 2)
489  break;
490 
491  case ID_ABIT:
492  case ID_BODY:
493  case ID_DBOD:
494  case ID_DSD:
495  case ID_DST:
496  case ID_MDAT:
497  iff->body_pos = avio_tell(pb);
498  iff->body_end = iff->body_pos + data_size;
499  iff->body_size = data_size;
500  if (chunk_id == ID_DST) {
501  int ret = read_dst_frame(s, NULL);
502  if (ret < 0)
503  return ret;
504  }
505  break;
506 
507  case ID_CHAN:
508  if (data_size < 4)
509  return AVERROR_INVALIDDATA;
510  if (avio_rb32(pb) < 6) {
511  st->codecpar->channels = 1;
513  } else {
514  st->codecpar->channels = 2;
516  }
517  break;
518 
519  case ID_CAMG:
520  if (data_size < 4)
521  return AVERROR_INVALIDDATA;
522  screenmode = avio_rb32(pb);
523  break;
524 
525  case ID_CMAP:
526  if (data_size < 3 || data_size > 768 || data_size % 3) {
527  av_log(s, AV_LOG_ERROR, "Invalid CMAP chunk size %"PRIu64"\n",
528  data_size);
529  return AVERROR_INVALIDDATA;
530  }
531  res = ff_alloc_extradata(st->codecpar,
532  data_size + IFF_EXTRA_VIDEO_SIZE);
533  if (res < 0)
534  return res;
535  if (avio_read(pb, st->codecpar->extradata + IFF_EXTRA_VIDEO_SIZE, data_size) < 0) {
536  av_freep(&st->codecpar->extradata);
537  st->codecpar->extradata_size = 0;
538  return AVERROR(EIO);
539  }
540  break;
541 
542  case ID_BMHD:
544  if (data_size <= 8)
545  return AVERROR_INVALIDDATA;
546  st->codecpar->width = avio_rb16(pb);
547  st->codecpar->height = avio_rb16(pb);
548  avio_skip(pb, 4); // x, y offset
550  if (data_size >= 10)
551  masking = avio_r8(pb);
552  if (data_size >= 11)
553  iff->bitmap_compression = avio_r8(pb);
554  if (data_size >= 14) {
555  avio_skip(pb, 1); // padding
556  transparency = avio_rb16(pb);
557  }
558  if (data_size >= 16) {
559  st->sample_aspect_ratio.num = avio_r8(pb);
560  st->sample_aspect_ratio.den = avio_r8(pb);
561  }
562  break;
563 
564  case ID_ANHD:
565  break;
566 
567  case ID_DPAN:
568  avio_skip(pb, 2);
569  st->duration = avio_rb16(pb);
570  break;
571 
572  case ID_DPEL:
573  if (data_size < 4 || (data_size & 3))
574  return AVERROR_INVALIDDATA;
575  if ((fmt_size = avio_read(pb, fmt, sizeof(fmt))) < 0)
576  return fmt_size;
577  if (fmt_size == sizeof(deep_rgb24) && !memcmp(fmt, deep_rgb24, sizeof(deep_rgb24)))
579  else if (fmt_size == sizeof(deep_rgba) && !memcmp(fmt, deep_rgba, sizeof(deep_rgba)))
581  else if (fmt_size == sizeof(deep_bgra) && !memcmp(fmt, deep_bgra, sizeof(deep_bgra)))
583  else if (fmt_size == sizeof(deep_argb) && !memcmp(fmt, deep_argb, sizeof(deep_argb)))
585  else if (fmt_size == sizeof(deep_abgr) && !memcmp(fmt, deep_abgr, sizeof(deep_abgr)))
587  else {
588  avpriv_request_sample(s, "color format %.16s", fmt);
589  return AVERROR_PATCHWELCOME;
590  }
591  break;
592 
593  case ID_DGBL:
595  if (data_size < 8)
596  return AVERROR_INVALIDDATA;
597  st->codecpar->width = avio_rb16(pb);
598  st->codecpar->height = avio_rb16(pb);
599  iff->bitmap_compression = avio_rb16(pb);
600  st->sample_aspect_ratio.num = avio_r8(pb);
601  st->sample_aspect_ratio.den = avio_r8(pb);
603  break;
604 
605  case ID_DLOC:
606  if (data_size < 4)
607  return AVERROR_INVALIDDATA;
608  st->codecpar->width = avio_rb16(pb);
609  st->codecpar->height = avio_rb16(pb);
610  break;
611 
612  case ID_TVDC:
613  if (data_size < sizeof(iff->tvdc))
614  return AVERROR_INVALIDDATA;
615  res = avio_read(pb, iff->tvdc, sizeof(iff->tvdc));
616  if (res < 0)
617  return res;
618  break;
619 
620  case ID_ANNO:
621  case ID_TEXT: metadata_tag = "comment"; break;
622  case ID_AUTH: metadata_tag = "artist"; break;
623  case ID_COPYRIGHT: metadata_tag = "copyright"; break;
624  case ID_NAME: metadata_tag = "title"; break;
625 
626  /* DSD tags */
627 
628  case MKTAG('F','V','E','R'):
629  if (data_size < 4)
630  return AVERROR_INVALIDDATA;
631  version = avio_rb32(pb);
632  av_log(s, AV_LOG_DEBUG, "DSIFF v%d.%d.%d.%d\n",version >> 24, (version >> 16) & 0xFF, (version >> 8) & 0xFF, version & 0xFF);
634  break;
635 
636  case MKTAG('D','I','I','N'):
637  res = parse_dsd_diin(s, st, orig_pos + data_size);
638  if (res < 0)
639  return res;
640  break;
641 
642  case MKTAG('P','R','O','P'):
643  if (data_size < 4)
644  return AVERROR_INVALIDDATA;
645  if (avio_rl32(pb) != MKTAG('S','N','D',' ')) {
646  avpriv_request_sample(s, "unknown property type");
647  break;
648  }
649  res = parse_dsd_prop(s, st, orig_pos + data_size);
650  if (res < 0)
651  return res;
652  break;
653 
654  case MKTAG('C','O','M','T'):
655  if (data_size < 2)
656  return AVERROR_INVALIDDATA;
657  nb_comments = avio_rb16(pb);
658  for (i = 0; i < nb_comments; i++) {
659  int year, mon, day, hour, min, type, ref;
660  char tmp[24];
661  const char *tag;
662  int metadata_size;
663 
664  year = avio_rb16(pb);
665  mon = avio_r8(pb);
666  day = avio_r8(pb);
667  hour = avio_r8(pb);
668  min = avio_r8(pb);
669  snprintf(tmp, sizeof(tmp), "%04d-%02d-%02d %02d:%02d", year, mon, day, hour, min);
670  av_dict_set(&st->metadata, "comment_time", tmp, 0);
671 
672  type = avio_rb16(pb);
673  ref = avio_rb16(pb);
674  switch (type) {
675  case 1:
676  if (!i)
677  tag = "channel_comment";
678  else {
679  snprintf(tmp, sizeof(tmp), "channel%d_comment", ref);
680  tag = tmp;
681  }
682  break;
683  case 2:
684  tag = ref < FF_ARRAY_ELEMS(dsd_source_comment) ? dsd_source_comment[ref] : "source_comment";
685  break;
686  case 3:
687  tag = ref < FF_ARRAY_ELEMS(dsd_history_comment) ? dsd_history_comment[ref] : "file_history";
688  break;
689  default:
690  tag = "comment";
691  }
692 
693  metadata_size = avio_rb32(pb);
694  if ((res = get_metadata(s, tag, metadata_size)) < 0) {
695  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", tag);
696  return res;
697  }
698 
699  if (metadata_size & 1)
700  avio_skip(pb, 1);
701  }
702  break;
703  }
704 
705  if (metadata_tag) {
706  if ((res = get_metadata(s, metadata_tag, data_size)) < 0) {
707  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag);
708  return res;
709  }
710  }
711  avio_skip(pb, data_size - (avio_tell(pb) - orig_pos) + (data_size & 1));
712  }
713 
714  if (st->codecpar->codec_tag == ID_ANIM)
715  avio_seek(pb, 12, SEEK_SET);
716  else
717  avio_seek(pb, iff->body_pos, SEEK_SET);
718 
719  switch(st->codecpar->codec_type) {
720  case AVMEDIA_TYPE_AUDIO:
721  avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
722 
723  if (st->codecpar->codec_tag == ID_16SV)
725  else if (st->codecpar->codec_tag == ID_MAUD) {
726  if (iff->maud_bits == 8 && !iff->maud_compression) {
728  } else if (iff->maud_bits == 16 && !iff->maud_compression) {
730  } else if (iff->maud_bits == 8 && iff->maud_compression == 2) {
732  } else if (iff->maud_bits == 8 && iff->maud_compression == 3) {
734  } else {
735  avpriv_request_sample(s, "compression %d and bit depth %d", iff->maud_compression, iff->maud_bits);
736  return AVERROR_PATCHWELCOME;
737  }
738  } else if (st->codecpar->codec_tag != ID_DSD &&
739  st->codecpar->codec_tag != ID_DST) {
740  switch (iff->svx8_compression) {
741  case COMP_NONE:
743  break;
744  case COMP_FIB:
746  break;
747  case COMP_EXP:
749  break;
750  default:
751  av_log(s, AV_LOG_ERROR,
752  "Unknown SVX8 compression method '%d'\n", iff->svx8_compression);
753  return -1;
754  }
755  }
756 
760  if (st->codecpar->codec_tag == ID_DSD && st->codecpar->block_align <= 0)
761  return AVERROR_INVALIDDATA;
762  break;
763 
764  case AVMEDIA_TYPE_VIDEO:
765  iff->bpp = st->codecpar->bits_per_coded_sample;
766  if (st->codecpar->codec_tag == ID_ANIM)
767  avpriv_set_pts_info(st, 32, 1, 60);
768  if ((screenmode & 0x800 /* Hold And Modify */) && iff->bpp <= 8) {
769  iff->ham = iff->bpp > 6 ? 6 : 4;
771  }
772  iff->flags = (screenmode & 0x80 /* Extra HalfBrite */) && iff->bpp <= 8;
773  iff->masking = masking;
774  iff->transparency = transparency;
775 
776  if (!st->codecpar->extradata) {
778  if (ret < 0)
779  return ret;
780  }
782  buf = st->codecpar->extradata;
783  bytestream_put_be16(&buf, IFF_EXTRA_VIDEO_SIZE);
784  bytestream_put_byte(&buf, iff->bitmap_compression);
785  bytestream_put_byte(&buf, iff->bpp);
786  bytestream_put_byte(&buf, iff->ham);
787  bytestream_put_byte(&buf, iff->flags);
788  bytestream_put_be16(&buf, iff->transparency);
789  bytestream_put_byte(&buf, iff->masking);
790  bytestream_put_buffer(&buf, iff->tvdc, sizeof(iff->tvdc));
792  break;
793  default:
794  return -1;
795  }
796 
797  return 0;
798 }
799 
800 static unsigned get_anim_duration(uint8_t *buf, int size)
801 {
802  GetByteContext gb;
803 
804  bytestream2_init(&gb, buf, size);
805  bytestream2_skip(&gb, 4);
806  while (bytestream2_get_bytes_left(&gb) > 8) {
807  unsigned chunk = bytestream2_get_le32(&gb);
808  unsigned size = bytestream2_get_be32(&gb);
809 
810  if (chunk == ID_ANHD) {
811  if (size < 40)
812  break;
813  bytestream2_skip(&gb, 14);
814  return bytestream2_get_be32(&gb);
815  } else {
816  bytestream2_skip(&gb, size + size & 1);
817  }
818  }
819  return 10;
820 }
821 
823  AVPacket *pkt)
824 {
825  IffDemuxContext *iff = s->priv_data;
826  AVIOContext *pb = s->pb;
827  AVStream *st = s->streams[0];
828  int ret;
829  int64_t pos = avio_tell(pb);
830 
831  if (avio_feof(pb))
832  return AVERROR_EOF;
833  if (st->codecpar->codec_tag != ID_ANIM && pos >= iff->body_end)
834  return AVERROR_EOF;
835 
836  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
837  if (st->codecpar->codec_tag == ID_DSD || st->codecpar->codec_tag == ID_MAUD) {
838  ret = av_get_packet(pb, pkt, FFMIN(iff->body_end - pos, 1024 * st->codecpar->block_align));
839  } else if (st->codecpar->codec_tag == ID_DST) {
840  return read_dst_frame(s, pkt);
841  } else {
842  if (iff->body_size > INT_MAX)
843  return AVERROR_INVALIDDATA;
844  ret = av_get_packet(pb, pkt, iff->body_size);
845  }
846  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
847  st->codecpar->codec_tag == ID_ANIM) {
848  uint64_t data_size, orig_pos;
849  uint32_t chunk_id, chunk_id2;
850 
851  while (!avio_feof(pb)) {
852  if (avio_feof(pb))
853  return AVERROR_EOF;
854 
855  orig_pos = avio_tell(pb);
856  chunk_id = avio_rl32(pb);
857  data_size = avio_rb32(pb);
858  chunk_id2 = avio_rl32(pb);
859 
860  if (chunk_id == ID_FORM &&
861  chunk_id2 == ID_ILBM) {
862  avio_skip(pb, -4);
863  break;
864  } else if (chunk_id == ID_FORM &&
865  chunk_id2 == ID_ANIM) {
866  continue;
867  } else {
868  avio_skip(pb, data_size);
869  }
870  }
871  ret = av_get_packet(pb, pkt, data_size);
872  pkt->pos = orig_pos;
873  pkt->duration = get_anim_duration(pkt->data, pkt->size);
874  if (pos == 12)
875  pkt->flags |= AV_PKT_FLAG_KEY;
876  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
877  st->codecpar->codec_tag != ID_ANIM) {
878  ret = av_get_packet(pb, pkt, iff->body_size);
879  pkt->pos = pos;
880  if (pos == iff->body_pos)
881  pkt->flags |= AV_PKT_FLAG_KEY;
882  } else {
883  av_assert0(0);
884  }
885 
886  if (ret < 0)
887  return ret;
888  pkt->stream_index = 0;
889  return ret;
890 }
891 
893  .name = "iff",
894  .long_name = NULL_IF_CONFIG_SMALL("IFF (Interchange File Format)"),
895  .priv_data_size = sizeof(IffDemuxContext),
900 };
static const uint8_t deep_abgr[]
Definition: iff.c:409
#define DSD_SRGT
Definition: iff.c:173
#define NULL
Definition: coverity.c:32
#define DSD_SLFT
Definition: iff.c:172
unsigned transparency
transparency color index in palette
Definition: iff.c:120
#define ID_CAMG
Definition: iff.c:55
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define ID_ANHD
Definition: iff.c:67
static const uint32_t dsd_5point0[]
Definition: iff.c:182
version
Definition: libkvazaar.c:317
unsigned ham
0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
Definition: iff.c:118
#define ID_RGB8
Definition: iff.c:59
#define ID_ACBM
Definition: iff.c:57
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3095
#define ID_PBM
Definition: iff.c:51
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
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:4868
static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
Definition: iff.c:246
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:942
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
unsigned maud_compression
Definition: iff.c:115
int64_t body_end
Definition: iff.c:111
static const uint32_t dsd_5point1[]
Definition: iff.c:183
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
GLint GLenum type
Definition: opengl_enc.c:104
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
static AVPacket pkt
#define ID_8SVX
Definition: iff.c:42
#define AV_CH_LAYOUT_STEREO
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:768
svx8_compression_type svx8_compression
Definition: iff.c:113
#define AV_CH_LAYOUT_5POINT0
#define IFF_EXTRA_VIDEO_SIZE
This number of bytes if added at the beginning of each AVPacket which contain additional information ...
Definition: iff.c:100
#define ID_16SV
Definition: iff.c:43
static const DSDLayoutDesc dsd_channel_layout[]
Definition: iff.c:190
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Format I/O context.
Definition: avformat.h:1355
#define ID_MHDR
Definition: iff.c:45
uint8_t tvdc[32]
TVDC lookup table.
Definition: iff.c:122
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
#define ID_ANNO
Definition: iff.c:73
#define ID_FRTE
Definition: iff.c:65
uint8_t
#define av_malloc(s)
int width
Video only.
Definition: codec_par.h:126
#define ID_MAUD
Definition: iff.c:44
#define DSD_LS
Definition: iff.c:177
#define ID_NAME
Definition: iff.c:79
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:783
uint32_t body_size
Definition: iff.c:112
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
static int parse_dsd_diin(AVFormatContext *s, AVStream *st, uint64_t eof)
Definition: iff.c:216
#define ID_DSD
Definition: iff.c:61
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4449
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1423
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
#define ID_DBOD
Definition: iff.c:83
Definition: iff.c:104
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1170
uint8_t * data
Definition: packet.h:363
uint64_t layout
Definition: iff.c:186
uint32_t tag
Definition: movenc.c:1597
#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:305
ptrdiff_t size
Definition: opengl_enc.c:100
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:904
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define ID_DPAN
Definition: iff.c:69
#define ID_CHAN
Definition: iff.c:50
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
#define AV_CH_LAYOUT_5POINT1
#define ID_ANIM
Definition: iff.c:66
static int iff_read_header(AVFormatContext *s)
Definition: iff.c:411
#define ID_TEXT
Definition: iff.c:80
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1572
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1595
#define ID_DST
Definition: iff.c:62
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:752
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
static const char * dsd_history_comment[]
Definition: iff.c:208
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define ID_FRM8
Definition: iff.c:72
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1114
simple assert() macros that are a bit more flexible than ISO C assert().
#define ID_FORM
Definition: iff.c:71
#define ID_ILBM
Definition: iff.c:52
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
#define DSD_C
Definition: iff.c:176
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
unsigned flags
1 for EHB, 0 is no extra half darkening
Definition: iff.c:119
int block_align
Audio only.
Definition: codec_par.h:177
#define ID_VHDR
Definition: iff.c:47
#define ID_TVDC
Definition: iff.c:86
audio channel layout utility functions
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3258
Definition: iff.c:105
#define ID_ABIT
Definition: iff.c:81
#define ID_BODY
Definition: iff.c:82
#define FFMIN(a, b)
Definition: common.h:96
AVInputFormat ff_iff_demuxer
Definition: iff.c:892
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
#define ID_AUTH
Definition: iff.c:74
#define DSD_MLFT
Definition: iff.c:174
static const uint32_t dsd_stereo[]
Definition: iff.c:181
#define s(width, name)
Definition: cbs_vp9.c:257
AVDictionary * metadata
Definition: avformat.h:944
int64_t pts
Definition: iff.c:123
#define FF_ARRAY_ELEMS(a)
static int iff_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: iff.c:822
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
if(ret)
Stream structure.
Definition: avformat.h:880
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
svx8_compression_type
Definition: iff.c:102
unsigned bpp
bits per plane to decode (differs from bits_per_coded_sample if HAM)
Definition: iff.c:117
AVIOContext * pb
I/O context.
Definition: avformat.h:1397
static const uint64_t dsd_loudspeaker_config[]
Definition: iff.c:196
#define ID_RGBN
Definition: iff.c:60
int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta *extra_meta)
Create a stream for each APIC (attached picture) extracted from the ID3v2 header. ...
Definition: id3v2.c:1130
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
#define ID_MDAT
Definition: iff.c:46
#define ID_DEEP
Definition: iff.c:58
static const AVCodecTag dsd_codec_tags[]
Definition: iff.c:165
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
unsigned maud_bits
Definition: iff.c:114
#define snprintf
Definition: snprintf.h:34
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
#define ID_DGBL
Definition: iff.c:54
static int iff_probe(const AVProbeData *p)
Definition: iff.c:145
#define ID_DLOC
Definition: iff.c:85
const uint32_t * dsd_layout
Definition: iff.c:187
static const uint8_t deep_rgba[]
Definition: iff.c:406
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:929
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
Main libavformat public API header.
unsigned bitmap_compression
delta compression method used
Definition: iff.c:116
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int is_64bit
chunk size is 64-bit
Definition: iff.c:109
static const uint8_t deep_bgra[]
Definition: iff.c:407
#define ID_CMAP
Definition: iff.c:56
#define DSD_LFE
Definition: iff.c:179
void ff_id3v2_read(AVFormatContext *s, const char *magic, ID3v2ExtraMeta **extra_meta, unsigned int max_search_size)
Read an ID3v2 tag, including supported extra metadata.
Definition: id3v2.c:1108
int den
Denominator.
Definition: rational.h:60
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
Definition: iff.c:103
static const uint8_t deep_rgb24[]
Definition: iff.c:405
#define av_free(p)
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:470
static const char * dsd_source_comment[]
Definition: iff.c:202
void * priv_data
Format private data.
Definition: avformat.h:1383
int64_t body_pos
Definition: iff.c:110
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int channels
Audio only.
Definition: codec_par.h:166
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
#define ID_DPEL
Definition: iff.c:84
static int get_metadata(AVFormatContext *s, const char *const tag, const unsigned data_size)
Definition: iff.c:127
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1027
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
#define DSD_MRGT
Definition: iff.c:175
#define DSD_RS
Definition: iff.c:178
static const uint8_t deep_argb[]
Definition: iff.c:408
int stream_index
Definition: packet.h:365
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
#define ID_COPYRIGHT
Definition: iff.c:76
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
Definition: common.h:406
#define ID_BMHD
Definition: iff.c:53
float min
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
#define ID_DSTF
Definition: iff.c:64
int i
Definition: input.c:407
static int read_dst_frame(AVFormatContext *s, AVPacket *pkt)
Definition: iff.c:348
unsigned masking
masking method used
Definition: iff.c:121
static unsigned get_anim_duration(uint8_t *buf, int size)
Definition: iff.c:800
static uint8_t tmp[11]
Definition: aes_ctr.c:26