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"
34 #include "libavutil/channel_layout.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/dict.h"
37 #include "libavutil/mem.h"
38 #include "libavcodec/bytestream.h"
39 #include "avformat.h"
40 #include "demux.h"
41 #include "id3v2.h"
42 #include "internal.h"
43 
44 #define ID_8SVX MKTAG('8','S','V','X')
45 #define ID_16SV MKTAG('1','6','S','V')
46 #define ID_MAUD MKTAG('M','A','U','D')
47 #define ID_MHDR MKTAG('M','H','D','R')
48 #define ID_MDAT MKTAG('M','D','A','T')
49 #define ID_VHDR MKTAG('V','H','D','R')
50 #define ID_ATAK MKTAG('A','T','A','K')
51 #define ID_RLSE MKTAG('R','L','S','E')
52 #define ID_CHAN MKTAG('C','H','A','N')
53 #define ID_PBM MKTAG('P','B','M',' ')
54 #define ID_ILBM MKTAG('I','L','B','M')
55 #define ID_BMHD MKTAG('B','M','H','D')
56 #define ID_DGBL MKTAG('D','G','B','L')
57 #define ID_CAMG MKTAG('C','A','M','G')
58 #define ID_CMAP MKTAG('C','M','A','P')
59 #define ID_ACBM MKTAG('A','C','B','M')
60 #define ID_DEEP MKTAG('D','E','E','P')
61 #define ID_RGB8 MKTAG('R','G','B','8')
62 #define ID_RGBN MKTAG('R','G','B','N')
63 #define ID_DSD MKTAG('D','S','D',' ')
64 #define ID_DST MKTAG('D','S','T',' ')
65 #define ID_DSTC MKTAG('D','S','T','C')
66 #define ID_DSTF MKTAG('D','S','T','F')
67 #define ID_FRTE MKTAG('F','R','T','E')
68 #define ID_ANIM MKTAG('A','N','I','M')
69 #define ID_ANHD MKTAG('A','N','H','D')
70 #define ID_DLTA MKTAG('D','L','T','A')
71 #define ID_DPAN MKTAG('D','P','A','N')
72 
73 #define ID_FORM MKTAG('F','O','R','M')
74 #define ID_FRM8 MKTAG('F','R','M','8')
75 #define ID_ANNO MKTAG('A','N','N','O')
76 #define ID_AUTH MKTAG('A','U','T','H')
77 #define ID_CHRS MKTAG('C','H','R','S')
78 #define ID_COPYRIGHT MKTAG('(','c',')',' ')
79 #define ID_CSET MKTAG('C','S','E','T')
80 #define ID_FVER MKTAG('F','V','E','R')
81 #define ID_NAME MKTAG('N','A','M','E')
82 #define ID_TEXT MKTAG('T','E','X','T')
83 #define ID_ABIT MKTAG('A','B','I','T')
84 #define ID_BODY MKTAG('B','O','D','Y')
85 #define ID_DBOD MKTAG('D','B','O','D')
86 #define ID_DPEL MKTAG('D','P','E','L')
87 #define ID_DLOC MKTAG('D','L','O','C')
88 #define ID_TVDC MKTAG('T','V','D','C')
89 
90 #define LEFT 2
91 #define RIGHT 4
92 #define STEREO 6
93 
94 /**
95  * This number of bytes if added at the beginning of each AVPacket
96  * which contain additional information about video properties
97  * which has to be shared between demuxer and decoder.
98  * This number may change between frames, e.g. the demuxer might
99  * set it to smallest possible size of 2 to indicate that there's
100  * no extradata changing in this frame.
101  */
102 #define IFF_EXTRA_VIDEO_SIZE 41
103 
104 typedef enum {
105  COMP_NONE,
106  COMP_FIB,
107  COMP_EXP
108 } svx8_compression_type;
109 
110 typedef struct IffDemuxContext {
111  int is_64bit; ///< chunk size is 64-bit
112  int64_t body_pos;
113  int64_t body_end;
114  int64_t sbdy_pos;
115  int64_t resume_pos;
116  uint32_t body_size;
117  svx8_compression_type svx8_compression;
118  unsigned maud_bits;
119  unsigned maud_compression;
120  unsigned bitmap_compression; ///< delta compression method used
121  unsigned bpp; ///< bits per plane to decode (differs from bits_per_coded_sample if HAM)
122  unsigned ham; ///< 0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
123  unsigned flags; ///< 1 for EHB, 0 is no extra half darkening
124  unsigned transparency; ///< transparency color index in palette
125  unsigned masking; ///< masking method used
126  uint8_t tvdc[32]; ///< TVDC lookup table
127  uint32_t form_tag;
128  int audio_stream_index;
129  int video_stream_index;
130 } IffDemuxContext;
131 
132 /* Metadata string read */
133 static int get_metadata(AVFormatContext *s,
134  const char *const tag,
135  const unsigned data_size)
136 {
137  uint8_t *buf = ((data_size + 1) == 0) ? NULL : av_malloc(data_size + 1);
138 
139  if (!buf)
140  return AVERROR(ENOMEM);
141 
142  if (avio_read(s->pb, buf, data_size) != data_size) {
143  av_free(buf);
144  return AVERROR(EIO);
145  }
146  buf[data_size] = 0;
147  av_dict_set(&s->metadata, tag, buf, AV_DICT_DONT_STRDUP_VAL);
148  return 0;
149 }
150 
151 static int iff_probe(const AVProbeData *p)
152 {
153  const uint8_t *d = p->buf;
154 
155  if ( (AV_RL32(d) == ID_FORM &&
156  (AV_RL32(d+8) == ID_8SVX ||
157  AV_RL32(d+8) == ID_16SV ||
158  AV_RL32(d+8) == ID_MAUD ||
159  AV_RL32(d+8) == ID_PBM ||
160  AV_RL32(d+8) == ID_ACBM ||
161  AV_RL32(d+8) == ID_DEEP ||
162  AV_RL32(d+8) == ID_ILBM ||
163  AV_RL32(d+8) == ID_RGB8 ||
164  AV_RL32(d+8) == ID_ANIM ||
165  AV_RL32(d+8) == ID_RGBN)) ||
166  (AV_RL32(d) == ID_FRM8 && AV_RL32(d+12) == ID_DSD))
167  return AVPROBE_SCORE_MAX;
168  return 0;
169 }
170 
171 static const AVCodecTag dsd_codec_tags[] = {
172  { AV_CODEC_ID_DSD_MSBF, ID_DSD },
173  { AV_CODEC_ID_DST, ID_DST },
174  { AV_CODEC_ID_NONE, 0 },
175 };
176 
177 
178 #define DSD_SLFT MKTAG('S','L','F','T')
179 #define DSD_SRGT MKTAG('S','R','G','T')
180 #define DSD_MLFT MKTAG('M','L','F','T')
181 #define DSD_MRGT MKTAG('M','R','G','T')
182 #define DSD_C MKTAG('C',' ',' ',' ')
183 #define DSD_LS MKTAG('L','S',' ',' ')
184 #define DSD_RS MKTAG('R','S',' ',' ')
185 #define DSD_LFE MKTAG('L','F','E',' ')
186 
187 static const uint32_t dsd_stereo[] = { DSD_SLFT, DSD_SRGT };
188 static const uint32_t dsd_5point0[] = { DSD_MLFT, DSD_MRGT, DSD_C, DSD_LS, DSD_RS };
189 static const uint32_t dsd_5point1[] = { DSD_MLFT, DSD_MRGT, DSD_C, DSD_LFE, DSD_LS, DSD_RS };
190 
191 typedef struct {
192  AVChannelLayout layout;
193  const uint32_t * dsd_layout;
194 } DSDLayoutDesc;
195 
196 static const DSDLayoutDesc dsd_channel_layout[] = {
197  { AV_CHANNEL_LAYOUT_STEREO, dsd_stereo },
198  { AV_CHANNEL_LAYOUT_5POINT0, dsd_5point0 },
199  { AV_CHANNEL_LAYOUT_5POINT1, dsd_5point1 },
200 };
201 
202 static const AVChannelLayout dsd_loudspeaker_config[] = {
203  AV_CHANNEL_LAYOUT_STEREO,
204  { 0 }, { 0 },
205  AV_CHANNEL_LAYOUT_5POINT0, AV_CHANNEL_LAYOUT_5POINT1,
206 };
207 
208 static const char * dsd_source_comment[] = {
209  "dsd_source_comment",
210  "analogue_source_comment",
211  "pcm_source_comment",
212 };
213 
214 static const char * dsd_history_comment[] = {
215  "general_remark",
216  "operator_name",
217  "creating_machine",
218  "timezone",
219  "file_revision"
220 };
221 
222 static int parse_dsd_diin(AVFormatContext *s, AVStream *st, uint64_t eof)
223 {
224  AVIOContext *pb = s->pb;
225 
226  while (av_sat_add64(avio_tell(pb), 12) <= eof && !avio_feof(pb)) {
227  uint32_t tag = avio_rl32(pb);
228  uint64_t size = avio_rb64(pb);
229  uint64_t orig_pos = avio_tell(pb);
230  const char * metadata_tag = NULL;
231 
232  if (size >= INT64_MAX)
233  return AVERROR_INVALIDDATA;
234 
235  switch(tag) {
236  case MKTAG('D','I','A','R'): metadata_tag = "artist"; break;
237  case MKTAG('D','I','T','I'): metadata_tag = "title"; break;
238  }
239 
240  if (metadata_tag && size > 4) {
241  unsigned int tag_size = avio_rb32(pb);
242  int ret = get_metadata(s, metadata_tag, FFMIN(tag_size, size - 4));
243  if (ret < 0) {
244  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag);
245  return ret;
246  }
247  }
248 
249  avio_skip(pb, size - (avio_tell(pb) - orig_pos) + (size & 1));
250  }
251 
252  return 0;
253 }
254 
255 static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
256 {
257  AVIOContext *pb = s->pb;
258  char abss[24];
259  int hour, min, sec, i, ret, config;
260  int dsd_layout[6];
261  ID3v2ExtraMeta *id3v2_extra_meta;
262 
263  while (av_sat_add64(avio_tell(pb), 12) <= eof && !avio_feof(pb)) {
264  uint32_t tag = avio_rl32(pb);
265  uint64_t size = avio_rb64(pb);
266  uint64_t orig_pos = avio_tell(pb);
267 
268  if (size >= INT64_MAX)
269  return AVERROR_INVALIDDATA;
270 
271  switch(tag) {
272  case MKTAG('A','B','S','S'):
273  if (size < 8)
274  return AVERROR_INVALIDDATA;
275  hour = avio_rb16(pb);
276  min = avio_r8(pb);
277  sec = avio_r8(pb);
278  snprintf(abss, sizeof(abss), "%02dh:%02dm:%02ds:%d", hour, min, sec, avio_rb32(pb));
279  av_dict_set(&st->metadata, "absolute_start_time", abss, 0);
280  break;
281 
282  case MKTAG('C','H','N','L'):
283  if (size < 2)
284  return AVERROR_INVALIDDATA;
285  st->codecpar->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
286  st->codecpar->ch_layout.nb_channels = avio_rb16(pb);
287  if (size < 2 + st->codecpar->ch_layout.nb_channels * 4 || !st->codecpar->ch_layout.nb_channels)
288  return AVERROR_INVALIDDATA;
289  if (st->codecpar->ch_layout.nb_channels > FF_ARRAY_ELEMS(dsd_layout)) {
290  avpriv_request_sample(s, "channel layout");
291  break;
292  }
293  for (i = 0; i < st->codecpar->ch_layout.nb_channels; i++)
294  dsd_layout[i] = avio_rl32(pb);
295  for (i = 0; i < FF_ARRAY_ELEMS(dsd_channel_layout); i++) {
296  const DSDLayoutDesc * d = &dsd_channel_layout[i];
297  if (d->layout.nb_channels == st->codecpar->ch_layout.nb_channels &&
298  !memcmp(d->dsd_layout, dsd_layout, d->layout.nb_channels * sizeof(uint32_t))) {
299  st->codecpar->ch_layout = d->layout;
300  break;
301  }
302  }
303  break;
304 
305  case MKTAG('C','M','P','R'):
306  if (size < 4)
307  return AVERROR_INVALIDDATA;
308  st->codecpar->codec_tag = tag = avio_rl32(pb);
309  st->codecpar->codec_id = ff_codec_get_id(dsd_codec_tags, tag);
310  if (!st->codecpar->codec_id) {
311  av_log(s, AV_LOG_ERROR, "'%s' compression is not supported\n",
312  av_fourcc2str(tag));
313  return AVERROR_PATCHWELCOME;
314  }
315  break;
316 
317  case MKTAG('F','S',' ',' '):
318  if (size < 4)
319  return AVERROR_INVALIDDATA;
320  st->codecpar->sample_rate = avio_rb32(pb) / 8;
321  break;
322 
323  case MKTAG('I','D','3',' '):
324  ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, size);
325  if (id3v2_extra_meta) {
326  if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0 ||
327  (ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0) {
328  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
329  return ret;
330  }
331  ff_id3v2_free_extra_meta(&id3v2_extra_meta);
332  }
333 
334  if (size < avio_tell(pb) - orig_pos) {
335  av_log(s, AV_LOG_ERROR, "id3 exceeds chunk size\n");
336  return AVERROR_INVALIDDATA;
337  }
338  break;
339 
340  case MKTAG('L','S','C','O'):
341  if (size < 2)
342  return AVERROR_INVALIDDATA;
343  config = avio_rb16(pb);
344  if (config != 0xFFFF) {
345  if (config < FF_ARRAY_ELEMS(dsd_loudspeaker_config))
346  st->codecpar->ch_layout = dsd_loudspeaker_config[config];
347  if (!st->codecpar->ch_layout.nb_channels)
348  avpriv_request_sample(s, "loudspeaker configuration %d", config);
349  }
350  break;
351  }
352 
353  avio_skip(pb, size - (avio_tell(pb) - orig_pos) + (size & 1));
354  }
355 
356  return 0;
357 }
358 
359 static int read_dst_frame(AVFormatContext *s, AVPacket *pkt)
360 {
361  IffDemuxContext *iff = s->priv_data;
362  AVIOContext *pb = s->pb;
363  uint32_t chunk_id;
364  uint64_t chunk_pos, data_pos, data_size;
365  int ret = AVERROR_EOF;
366 
367  if (s->nb_streams < 1)
368  return AVERROR_INVALIDDATA;
369 
370  while (!avio_feof(pb)) {
371  chunk_pos = avio_tell(pb);
372  if (chunk_pos >= iff->body_end)
373  return AVERROR_EOF;
374 
375  chunk_id = avio_rl32(pb);
376  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
377  data_pos = avio_tell(pb);
378 
379  if (data_size < 1 || data_size >= INT64_MAX)
380  return AVERROR_INVALIDDATA;
381 
382  switch (chunk_id) {
383  case ID_DSTF:
384  if (!pkt) {
385  iff->body_pos = avio_tell(pb) - (iff->is_64bit ? 12 : 8);
386  iff->body_size = iff->body_end - iff->body_pos;
387  return 0;
388  }
389  ret = av_get_packet(pb, pkt, data_size);
390  if (ret < 0)
391  return ret;
392  if (data_size & 1)
393  avio_skip(pb, 1);
394  pkt->flags |= AV_PKT_FLAG_KEY;
395  pkt->stream_index = iff->audio_stream_index;
396  pkt->duration = s->streams[0]->codecpar->sample_rate / 75;
397  pkt->pos = chunk_pos;
398 
399  chunk_pos = avio_tell(pb);
400  if (chunk_pos >= iff->body_end)
401  return 0;
402 
403  avio_seek(pb, chunk_pos, SEEK_SET);
404  return 0;
405 
406  case ID_FRTE:
407  if (data_size < 4)
408  return AVERROR_INVALIDDATA;
409  s->streams[0]->duration = avio_rb32(pb) * (uint64_t)s->streams[0]->codecpar->sample_rate / 75;
410 
411  break;
412  }
413 
414  avio_skip(pb, data_size - (avio_tell(pb) - data_pos) + (data_size & 1));
415  }
416 
417  return ret;
418 }
419 
420 static const uint8_t deep_rgb24[] = {0, 0, 0, 3, 0, 1, 0, 8, 0, 2, 0, 8, 0, 3, 0, 8};
421 static const uint8_t deep_rgba[] = {0, 0, 0, 4, 0, 1, 0, 8, 0, 2, 0, 8, 0, 3, 0, 8};
422 static const uint8_t deep_bgra[] = {0, 0, 0, 4, 0, 3, 0, 8, 0, 2, 0, 8, 0, 1, 0, 8};
423 static const uint8_t deep_argb[] = {0, 0, 0, 4, 0,17, 0, 8, 0, 1, 0, 8, 0, 2, 0, 8};
424 static const uint8_t deep_abgr[] = {0, 0, 0, 4, 0,17, 0, 8, 0, 3, 0, 8, 0, 2, 0, 8};
425 
426 static AVStream * new_stream(AVFormatContext *s, AVStream **st_ptr, int *index_ptr, enum AVMediaType codec_type)
427 {
428  if (!*st_ptr) {
429  *st_ptr = avformat_new_stream(s, NULL);
430  if (!*st_ptr)
431  return NULL;
432  (*st_ptr)->codecpar->codec_type = codec_type;
433  (*index_ptr) = (*st_ptr)->index;
434  }
435  return *st_ptr;
436 }
437 
438 static int iff_read_header(AVFormatContext *s)
439 {
440  IffDemuxContext *iff = s->priv_data;
441  AVIOContext *pb = s->pb;
442  AVStream *sta = NULL, *stv = NULL;
443  uint8_t *buf;
444  uint32_t chunk_id;
445  uint64_t data_size;
446  uint32_t screenmode = 0, num, den;
447  unsigned transparency = 0;
448  unsigned masking = 0; // no mask
449  uint8_t fmt[16];
450  int fmt_size;
451 
452  iff->audio_stream_index = -1;
453  iff->video_stream_index = -1;
454  iff->is_64bit = avio_rl32(pb) == ID_FRM8;
455  avio_skip(pb, iff->is_64bit ? 8 : 4);
456  iff->form_tag = avio_rl32(pb);
457  if (iff->form_tag == ID_ANIM) {
458  avio_skip(pb, 12);
459  }
460  iff->bitmap_compression = -1;
461  iff->svx8_compression = -1;
462  iff->maud_bits = -1;
463  iff->maud_compression = -1;
464 
465  while(!avio_feof(pb)) {
466  uint64_t orig_pos;
467  int res;
468  const char *metadata_tag = NULL;
469  int version, nb_comments, i;
470  chunk_id = avio_rl32(pb);
471  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
472  orig_pos = avio_tell(pb);
473 
474  if (data_size >= INT64_MAX)
475  return AVERROR_INVALIDDATA;
476 
477  switch(chunk_id) {
478  case ID_VHDR:
479  if (data_size < 14)
480  return AVERROR_INVALIDDATA;
481  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
482  return AVERROR(ENOMEM);
483  avio_skip(pb, 12);
484  sta->codecpar->sample_rate = avio_rb16(pb);
485  if (data_size >= 16) {
486  avio_skip(pb, 1);
487  iff->svx8_compression = avio_r8(pb);
488  }
489  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
490  break;
491 
492  case ID_MHDR:
493  if (data_size < 32)
494  return AVERROR_INVALIDDATA;
495  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
496  return AVERROR(ENOMEM);
497  avio_skip(pb, 4);
498  iff->maud_bits = avio_rb16(pb);
499  avio_skip(pb, 2);
500  num = avio_rb32(pb);
501  den = avio_rb16(pb);
502  if (!den)
503  return AVERROR_INVALIDDATA;
504  avio_skip(pb, 2);
505  sta->codecpar->sample_rate = num / den;
506  sta->codecpar->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
507  sta->codecpar->ch_layout.nb_channels = avio_rb16(pb);
508  iff->maud_compression = avio_rb16(pb);
509  if (sta->codecpar->ch_layout.nb_channels == 1)
510  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
511  else if (sta->codecpar->ch_layout.nb_channels == 2)
512  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
513  else if (sta->codecpar->ch_layout.nb_channels == 0)
514  return AVERROR_INVALIDDATA;
515  break;
516 
517  case ID_ABIT:
518  case ID_BODY:
519  case ID_DBOD:
520  case ID_DSD:
521  case ID_DST:
522  case ID_MDAT:
523  iff->body_pos = avio_tell(pb);
524  if (iff->body_pos < 0 || iff->body_pos + data_size > INT64_MAX)
525  return AVERROR_INVALIDDATA;
526 
527  iff->body_end = iff->body_pos + data_size;
528  iff->body_size = data_size;
529  if (chunk_id == ID_DST) {
530  int ret = read_dst_frame(s, NULL);
531  if (ret < 0)
532  return ret;
533  }
534  break;
535 
536  case ID_CHAN:
537  if (data_size < 4)
538  return AVERROR_INVALIDDATA;
539  if (!sta)
540  return AVERROR_INVALIDDATA;
541  if (avio_rb32(pb) < 6) {
542  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
543  } else {
544  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
545  }
546  break;
547 
548  case ID_CAMG:
549  if (data_size < 4)
550  return AVERROR_INVALIDDATA;
551  screenmode = avio_rb32(pb);
552  break;
553 
554  case ID_CMAP:
555  if (data_size < 3 || data_size > 768 || data_size % 3) {
556  av_log(s, AV_LOG_ERROR, "Invalid CMAP chunk size %"PRIu64"\n",
557  data_size);
558  return AVERROR_INVALIDDATA;
559  }
560  if (!stv)
561  return AVERROR_INVALIDDATA;
562  res = ff_alloc_extradata(stv->codecpar,
563  data_size + IFF_EXTRA_VIDEO_SIZE);
564  if (res < 0)
565  return res;
566  if (avio_read(pb, stv->codecpar->extradata + IFF_EXTRA_VIDEO_SIZE, data_size) < 0) {
567  av_freep(&stv->codecpar->extradata);
568  stv->codecpar->extradata_size = 0;
569  return AVERROR(EIO);
570  }
571  break;
572 
573  case ID_BMHD:
574  if (data_size <= 8)
575  return AVERROR_INVALIDDATA;
576  if (!new_stream(s, &stv, &iff->video_stream_index, AVMEDIA_TYPE_VIDEO))
577  return AVERROR(ENOMEM);
578  stv->codecpar->width = avio_rb16(pb);
579  stv->codecpar->height = avio_rb16(pb);
580  avio_skip(pb, 4); // x, y offset
581  stv->codecpar->bits_per_coded_sample = avio_r8(pb);
582  if (data_size >= 10)
583  masking = avio_r8(pb);
584  if (data_size >= 11)
585  iff->bitmap_compression = avio_r8(pb);
586  if (data_size >= 14) {
587  avio_skip(pb, 1); // padding
588  transparency = avio_rb16(pb);
589  }
590  if (data_size >= 16) {
591  stv->sample_aspect_ratio.num = avio_r8(pb);
592  stv->sample_aspect_ratio.den = avio_r8(pb);
593  }
594  break;
595 
596  case ID_ANHD:
597  break;
598 
599  case ID_DPAN:
600  if (!stv)
601  return AVERROR_INVALIDDATA;
602  avio_skip(pb, 2);
603  stv->duration = avio_rb16(pb);
604  break;
605 
606  case ID_DPEL:
607  if (data_size < 4 || (data_size & 3))
608  return AVERROR_INVALIDDATA;
609  if (!stv)
610  return AVERROR_INVALIDDATA;
611  if ((fmt_size = avio_read(pb, fmt, sizeof(fmt))) < 0)
612  return fmt_size;
613  if (fmt_size == sizeof(deep_rgb24) && !memcmp(fmt, deep_rgb24, sizeof(deep_rgb24)))
614  stv->codecpar->format = AV_PIX_FMT_RGB24;
615  else if (fmt_size == sizeof(deep_rgba) && !memcmp(fmt, deep_rgba, sizeof(deep_rgba)))
616  stv->codecpar->format = AV_PIX_FMT_RGBA;
617  else if (fmt_size == sizeof(deep_bgra) && !memcmp(fmt, deep_bgra, sizeof(deep_bgra)))
618  stv->codecpar->format = AV_PIX_FMT_BGRA;
619  else if (fmt_size == sizeof(deep_argb) && !memcmp(fmt, deep_argb, sizeof(deep_argb)))
620  stv->codecpar->format = AV_PIX_FMT_ARGB;
621  else if (fmt_size == sizeof(deep_abgr) && !memcmp(fmt, deep_abgr, sizeof(deep_abgr)))
622  stv->codecpar->format = AV_PIX_FMT_ABGR;
623  else {
624  avpriv_request_sample(s, "color format %.16s", fmt);
625  return AVERROR_PATCHWELCOME;
626  }
627  break;
628 
629  case ID_DGBL:
630  if (data_size < 8)
631  return AVERROR_INVALIDDATA;
632  if (!new_stream(s, &stv, &iff->video_stream_index, AVMEDIA_TYPE_VIDEO))
633  return AVERROR(ENOMEM);
634  stv->codecpar->width = avio_rb16(pb);
635  stv->codecpar->height = avio_rb16(pb);
636  iff->bitmap_compression = avio_rb16(pb);
637  stv->sample_aspect_ratio.num = avio_r8(pb);
638  stv->sample_aspect_ratio.den = avio_r8(pb);
639  stv->codecpar->bits_per_coded_sample = 24;
640  break;
641 
642  case ID_DLOC:
643  if (data_size < 4)
644  return AVERROR_INVALIDDATA;
645  if (!new_stream(s, &stv, &iff->video_stream_index, AVMEDIA_TYPE_VIDEO))
646  return AVERROR(ENOMEM);
647  stv->codecpar->width = avio_rb16(pb);
648  stv->codecpar->height = avio_rb16(pb);
649  break;
650 
651  case ID_TVDC:
652  if (data_size < sizeof(iff->tvdc))
653  return AVERROR_INVALIDDATA;
654  res = avio_read(pb, iff->tvdc, sizeof(iff->tvdc));
655  if (res < 0)
656  return res;
657  break;
658 
659  case MKTAG('S','X','H','D'):
660  if (data_size < 22)
661  return AVERROR_INVALIDDATA;
662  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
663  return AVERROR(ENOMEM);
664  sta->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
665  switch(avio_r8(pb)) {
666  case 8:
667  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S8_PLANAR;
668  break;
669  default:
670  avpriv_request_sample(s, "sound bitdepth");
671  return AVERROR_INVALIDDATA;
672  }
673  avio_skip(pb, 9);
674  if (avio_rb32(pb)) {
675  avpriv_request_sample(s, "sound compression");
676  return AVERROR_INVALIDDATA;
677  }
678  avio_skip(pb, 1);
679  sta->codecpar->ch_layout.nb_channels = avio_r8(pb);
680  if (!sta->codecpar->ch_layout.nb_channels)
681  return AVERROR_INVALIDDATA;
682  if (sta->codecpar->ch_layout.nb_channels == 1)
683  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
684  else if (sta->codecpar->ch_layout.nb_channels == 2)
685  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
686  sta->codecpar->sample_rate = avio_rb32(pb);
687  avpriv_set_pts_info(sta, 64, 1, sta->codecpar->sample_rate);
688  avio_skip(pb, 2);
689  break;
690 
691  case ID_ANNO:
692  case ID_TEXT: metadata_tag = "comment"; break;
693  case ID_AUTH: metadata_tag = "artist"; break;
694  case ID_COPYRIGHT: metadata_tag = "copyright"; break;
695  case ID_NAME: metadata_tag = "title"; break;
696 
697  /* DSD tags */
698 
699  case MKTAG('F','V','E','R'):
700  if (iff->form_tag == ID_DSD || iff->form_tag == ID_DST) {
701  if (data_size < 4)
702  return AVERROR_INVALIDDATA;
703  version = avio_rb32(pb);
704  av_log(s, AV_LOG_DEBUG, "DSIFF v%d.%d.%d.%d\n",version >> 24, (version >> 16) & 0xFF, (version >> 8) & 0xFF, version & 0xFF);
705  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
706  return AVERROR(ENOMEM);
707  sta->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
708  }
709  break;
710 
711  case MKTAG('D','I','I','N'):
712  if (!sta)
713  return AVERROR_INVALIDDATA;
714  res = parse_dsd_diin(s, sta, orig_pos + data_size);
715  if (res < 0)
716  return res;
717  break;
718 
719  case MKTAG('P','R','O','P'):
720  if (data_size < 4)
721  return AVERROR_INVALIDDATA;
722  if (avio_rl32(pb) != MKTAG('S','N','D',' ')) {
723  avpriv_request_sample(s, "unknown property type");
724  break;
725  }
726  if (!sta)
727  return AVERROR_INVALIDDATA;
728  res = parse_dsd_prop(s, sta, orig_pos + data_size);
729  if (res < 0)
730  return res;
731  break;
732 
733  case MKTAG('C','O','M','T'):
734  if (data_size < 2)
735  return AVERROR_INVALIDDATA;
736  if (!sta)
737  return AVERROR_INVALIDDATA;
738  nb_comments = avio_rb16(pb);
739  for (i = 0; i < nb_comments; i++) {
740  int year, mon, day, hour, min, type, ref;
741  char tmp[24];
742  const char *tag;
743  int metadata_size;
744 
745  year = avio_rb16(pb);
746  mon = avio_r8(pb);
747  day = avio_r8(pb);
748  hour = avio_r8(pb);
749  min = avio_r8(pb);
750  snprintf(tmp, sizeof(tmp), "%04d-%02d-%02d %02d:%02d", year, mon, day, hour, min);
751  av_dict_set(&sta->metadata, "comment_time", tmp, 0);
752 
753  type = avio_rb16(pb);
754  ref = avio_rb16(pb);
755  switch (type) {
756  case 1:
757  if (!i)
758  tag = "channel_comment";
759  else {
760  snprintf(tmp, sizeof(tmp), "channel%d_comment", ref);
761  tag = tmp;
762  }
763  break;
764  case 2:
765  tag = ref < FF_ARRAY_ELEMS(dsd_source_comment) ? dsd_source_comment[ref] : "source_comment";
766  break;
767  case 3:
768  tag = ref < FF_ARRAY_ELEMS(dsd_history_comment) ? dsd_history_comment[ref] : "file_history";
769  break;
770  default:
771  tag = "comment";
772  }
773 
774  metadata_size = avio_rb32(pb);
775  if ((res = get_metadata(s, tag, metadata_size)) < 0) {
776  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", tag);
777  return res;
778  }
779 
780  if (metadata_size & 1)
781  avio_skip(pb, 1);
782  }
783  break;
784  }
785 
786  if (metadata_tag) {
787  if ((res = get_metadata(s, metadata_tag, data_size)) < 0) {
788  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag);
789  return res;
790  }
791  }
792  avio_skip(pb, data_size - (avio_tell(pb) - orig_pos) + (data_size & 1));
793  }
794 
795  if ((!sta && !stv) ||
796  (iff->form_tag == ID_ANIM && !stv) ||
797  (iff->form_tag != ID_ANIM && sta && stv))
798  return AVERROR_INVALIDDATA;
799 
800  if (iff->form_tag == ID_ANIM)
801  avio_seek(pb, 12, SEEK_SET);
802  else
803  avio_seek(pb, iff->body_pos, SEEK_SET);
804 
805  if (sta) {
806  avpriv_set_pts_info(sta, 32, 1, sta->codecpar->sample_rate);
807 
808  if (sta->codecpar->codec_id != AV_CODEC_ID_NONE) {
809  /* codec_id already set by PROP or SXHD chunk */
810  } else if (iff->form_tag == ID_16SV)
811  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR;
812  else if (iff->form_tag == ID_MAUD) {
813  if (iff->maud_bits == 8 && !iff->maud_compression) {
814  sta->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
815  } else if (iff->maud_bits == 16 && !iff->maud_compression) {
816  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE;
817  } else if (iff->maud_bits == 8 && iff->maud_compression == 2) {
818  sta->codecpar->codec_id = AV_CODEC_ID_PCM_ALAW;
819  } else if (iff->maud_bits == 8 && iff->maud_compression == 3) {
820  sta->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW;
821  } else {
822  avpriv_request_sample(s, "compression %d and bit depth %d", iff->maud_compression, iff->maud_bits);
823  return AVERROR_PATCHWELCOME;
824  }
825  } else {
826  switch (iff->svx8_compression) {
827  case COMP_NONE:
828  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S8_PLANAR;
829  break;
830  case COMP_FIB:
831  sta->codecpar->codec_id = AV_CODEC_ID_8SVX_FIB;
832  break;
833  case COMP_EXP:
834  sta->codecpar->codec_id = AV_CODEC_ID_8SVX_EXP;
835  break;
836  default:
837  av_log(s, AV_LOG_ERROR,
838  "Unknown SVX8 compression method '%d'\n", iff->svx8_compression);
839  return -1;
840  }
841  }
842 
843  sta->codecpar->bits_per_coded_sample = av_get_bits_per_sample(sta->codecpar->codec_id);
844  sta->codecpar->bit_rate = (int64_t)sta->codecpar->ch_layout.nb_channels *
845  sta->codecpar->sample_rate *
846  sta->codecpar->bits_per_coded_sample;
847  sta->codecpar->block_align = sta->codecpar->ch_layout.nb_channels *
848  sta->codecpar->bits_per_coded_sample;
849  if ((sta->codecpar->codec_tag == ID_DSD || iff->form_tag == ID_MAUD) && sta->codecpar->block_align <= 0)
850  return AVERROR_INVALIDDATA;
851  }
852 
853  if (stv) {
854  iff->bpp = stv->codecpar->bits_per_coded_sample;
855  if (iff->form_tag == ID_ANIM)
856  avpriv_set_pts_info(stv, 32, 1, 60);
857  if ((screenmode & 0x800 /* Hold And Modify */) && iff->bpp <= 8) {
858  iff->ham = iff->bpp > 6 ? 6 : 4;
859  stv->codecpar->bits_per_coded_sample = 24;
860  }
861  iff->flags = (screenmode & 0x80 /* Extra HalfBrite */) && iff->bpp <= 8;
862  iff->masking = masking;
863  iff->transparency = transparency;
864 
865  if (!stv->codecpar->extradata) {
866  int ret = ff_alloc_extradata(stv->codecpar, IFF_EXTRA_VIDEO_SIZE);
867  if (ret < 0)
868  return ret;
869  }
870  av_assert0(stv->codecpar->extradata_size >= IFF_EXTRA_VIDEO_SIZE);
871  buf = stv->codecpar->extradata;
872  bytestream_put_be16(&buf, IFF_EXTRA_VIDEO_SIZE);
873  bytestream_put_byte(&buf, iff->bitmap_compression);
874  bytestream_put_byte(&buf, iff->bpp);
875  bytestream_put_byte(&buf, iff->ham);
876  bytestream_put_byte(&buf, iff->flags);
877  bytestream_put_be16(&buf, iff->transparency);
878  bytestream_put_byte(&buf, iff->masking);
879  bytestream_put_buffer(&buf, iff->tvdc, sizeof(iff->tvdc));
880  stv->codecpar->codec_id = AV_CODEC_ID_IFF_ILBM;
881  stv->codecpar->codec_tag = iff->form_tag; // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content
882  }
883 
884  return 0;
885 }
886 
887 static unsigned get_anim_duration(uint8_t *buf, int size)
888 {
889  GetByteContext gb;
890 
891  bytestream2_init(&gb, buf, size);
892  bytestream2_skip(&gb, 4);
893  while (bytestream2_get_bytes_left(&gb) > 8) {
894  unsigned chunk = bytestream2_get_le32(&gb);
895  unsigned size = bytestream2_get_be32(&gb);
896 
897  if (chunk == ID_ANHD) {
898  if (size < 40)
899  break;
900  bytestream2_skip(&gb, 14);
901  return bytestream2_get_be32(&gb);
902  } else {
903  bytestream2_skip(&gb, size + size & 1);
904  }
905  }
906  return 10;
907 }
908 
909 static int64_t get_sbdy_offset(uint8_t *buf, int size)
910 {
911  GetByteContext gb;
912 
913  bytestream2_init(&gb, buf, size);
914  bytestream2_skip(&gb, 4);
915  while (bytestream2_get_bytes_left(&gb) > 8) {
916  unsigned chunk = bytestream2_get_le32(&gb);
917  unsigned size = bytestream2_get_be32(&gb);
918 
919  if (chunk == MKTAG('S','B','D','Y'))
920  return bytestream2_tell(&gb);
921 
922  bytestream2_skip(&gb, size + size & 1);
923  }
924 
925  return 0;
926 }
927 
928 static int iff_read_packet(AVFormatContext *s,
929  AVPacket *pkt)
930 {
931  IffDemuxContext *iff = s->priv_data;
932  AVIOContext *pb = s->pb;
933  int ret;
934  int64_t pos = avio_tell(pb);
935 
936  if (avio_feof(pb))
937  return AVERROR_EOF;
938  if (iff->form_tag != ID_ANIM && pos >= iff->body_end)
939  return AVERROR_EOF;
940 
941  if (iff->sbdy_pos) {
942  int64_t data_size;
943  avio_seek(pb, iff->sbdy_pos, SEEK_SET);
944  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
945  ret = av_get_packet(pb, pkt, data_size);
946  pkt->stream_index = iff->audio_stream_index;
947  pkt->duration = data_size / s->streams[iff->audio_stream_index]->codecpar->ch_layout.nb_channels;
948  pkt->pos = INT_MAX; /* not seekable */
949 
950  iff->sbdy_pos = 0;
951  avio_seek(pb, iff->resume_pos, SEEK_SET);
952  return ret;
953  }
954 
955  if (iff->audio_stream_index >= 0 && iff->video_stream_index < 0) { /* audio only */
956  AVStream *sta = s->streams[iff->audio_stream_index];
957  if (sta->codecpar->codec_tag == ID_DSD || iff->form_tag == ID_MAUD) {
958  ret = av_get_packet(pb, pkt, FFMIN(iff->body_end - pos, 1024 * sta->codecpar->block_align));
959  } else if (sta->codecpar->codec_tag == ID_DST) {
960  return read_dst_frame(s, pkt);
961  } else {
962  if (iff->body_size > INT_MAX || !iff->body_size)
963  return AVERROR_INVALIDDATA;
964  ret = av_get_packet(pb, pkt, iff->body_size);
965  }
966  pkt->stream_index = iff->audio_stream_index;
967  } else if (iff->form_tag == ID_ANIM) {
968  uint64_t data_size, orig_pos;
969  uint32_t chunk_id, chunk_id2;
970 
971  while (!avio_feof(pb)) {
972  if (avio_feof(pb))
973  return AVERROR_EOF;
974 
975  orig_pos = avio_tell(pb);
976  chunk_id = avio_rl32(pb);
977  data_size = avio_rb32(pb);
978  chunk_id2 = avio_rl32(pb);
979 
980  if (chunk_id == ID_FORM &&
981  chunk_id2 == ID_ILBM) {
982  avio_skip(pb, -4);
983  break;
984  } else if (chunk_id == ID_FORM &&
985  chunk_id2 == ID_ANIM) {
986  continue;
987  } else {
988  avio_skip(pb, data_size);
989  }
990  }
991  ret = av_get_packet(pb, pkt, data_size);
992  pkt->stream_index = iff->video_stream_index;
993  pkt->pos = orig_pos;
994  pkt->duration = get_anim_duration(pkt->data, pkt->size);
995  if (pos == 12)
996  pkt->flags |= AV_PKT_FLAG_KEY;
997 
998  if (iff->audio_stream_index >= 0) {
999  iff->sbdy_pos = get_sbdy_offset(pkt->data, pkt->size);
1000  if (iff->sbdy_pos) {
1001  iff->sbdy_pos += orig_pos + 4;
1002  iff->resume_pos = avio_tell(pb);
1003  }
1004  }
1005  } else if (iff->video_stream_index >= 0 && iff->audio_stream_index < 0) { /* video only */
1006  if (iff->body_size > INT_MAX || !iff->body_size)
1007  return AVERROR_INVALIDDATA;
1008  ret = av_get_packet(pb, pkt, iff->body_size);
1009  pkt->stream_index = iff->video_stream_index;
1010  pkt->pos = pos;
1011  if (pos == iff->body_pos)
1012  pkt->flags |= AV_PKT_FLAG_KEY;
1013  } else {
1014  av_assert0(0);
1015  }
1016 
1017  return ret;
1018 }
1019 
1020 const FFInputFormat ff_iff_demuxer = {
1021  .p.name = "iff",
1022  .p.long_name = NULL_IF_CONFIG_SMALL("IFF (Interchange File Format)"),
1023  .p.flags = AVFMT_GENERIC_INDEX | AVFMT_NO_BYTE_SEEK,
1024  .priv_data_size = sizeof(IffDemuxContext),
1025  .read_probe = iff_probe,
1026  .read_header = iff_read_header,
1027  .read_packet = iff_read_packet,
1028 };
get_sbdy_offset
static int64_t get_sbdy_offset(uint8_t *buf, int size)
Definition: iff.c:909
IffDemuxContext::svx8_compression
svx8_compression_type svx8_compression
Definition: iff.c:117
AVFMT_NO_BYTE_SEEK
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:486
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
deep_argb
static const uint8_t deep_argb[]
Definition: iff.c:423
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
ID_BODY
#define ID_BODY
Definition: iff.c:84
ID_CMAP
#define ID_CMAP
Definition: iff.c:58
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:395
GetByteContext
Definition: bytestream.h:33
ID_PBM
#define ID_PBM
Definition: iff.c:53
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
ID_RGBN
#define ID_RGBN
Definition: iff.c:62
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_CODEC_ID_8SVX_EXP
@ AV_CODEC_ID_8SVX_EXP
Definition: codec_id.h:504
int64_t
long long int64_t
Definition: coverity.c:34
ID_CHAN
#define ID_CHAN
Definition: iff.c:52
ID_DEEP
#define ID_DEEP
Definition: iff.c:60
ID_DSTF
#define ID_DSTF
Definition: iff.c:66
id3v2.h
DSD_MRGT
#define DSD_MRGT
Definition: iff.c:181
AVPacket::data
uint8_t * data
Definition: packet.h:546
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:366
ff_id3v2_read
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:1141
deep_bgra
static const uint8_t deep_bgra[]
Definition: iff.c:422
IffDemuxContext::masking
unsigned masking
masking method used
Definition: iff.c:125
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:564
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
get_anim_duration
static unsigned get_anim_duration(uint8_t *buf, int size)
Definition: iff.c:887
IffDemuxContext::body_size
uint32_t body_size
Definition: iff.c:116
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
ID_ILBM
#define ID_ILBM
Definition: iff.c:54
tf_sess_config.config
config
Definition: tf_sess_config.py:33
IffDemuxContext::sbdy_pos
int64_t sbdy_pos
Definition: iff.c:114
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:601
COMP_NONE
@ COMP_NONE
Definition: iff.c:105
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:777
ID_DGBL
#define ID_DGBL
Definition: iff.c:56
ID_TEXT
#define ID_TEXT
Definition: iff.c:82
AV_CODEC_ID_IFF_ILBM
@ AV_CODEC_ID_IFF_ILBM
Definition: codec_id.h:188
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:337
ID_DBOD
#define ID_DBOD
Definition: iff.c:85
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:479
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
dsd_source_comment
static const char * dsd_source_comment[]
Definition: iff.c:208
AV_CODEC_ID_8SVX_FIB
@ AV_CODEC_ID_8SVX_FIB
Definition: codec_id.h:505
ID_FORM
#define ID_FORM
Definition: iff.c:73
parse_dsd_prop
static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
Definition: iff.c:255
ff_id3v2_parse_chapters
int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta *cur)
Create chapters for all CHAP tags found in the ID3v2 header.
Definition: id3v2.c:1194
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
new_stream
static AVStream * new_stream(AVFormatContext *s, AVStream **st_ptr, int *index_ptr, enum AVMediaType codec_type)
Definition: iff.c:426
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVCodecTag
Definition: internal.h:42
ID3v2ExtraMeta
Definition: id3v2.h:84
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
DSD_RS
#define DSD_RS
Definition: iff.c:184
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:549
iff_read_header
static int iff_read_header(AVFormatContext *s)
Definition: iff.c:438
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
iff_read_packet
static int iff_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: iff.c:928
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:119
IffDemuxContext::tvdc
uint8_t tvdc[32]
TVDC lookup table.
Definition: iff.c:126
DSD_C
#define DSD_C
Definition: iff.c:182
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
ID_DPEL
#define ID_DPEL
Definition: iff.c:86
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ID_8SVX
#define ID_8SVX
Definition: iff.c:44
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:342
ID_AUTH
#define ID_AUTH
Definition: iff.c:76
ID_BMHD
#define ID_BMHD
Definition: iff.c:55
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
if
if(ret)
Definition: filter_design.txt:179
DSD_SRGT
#define DSD_SRGT
Definition: iff.c:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:343
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
DSD_LFE
#define DSD_LFE
Definition: iff.c:185
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_CODEC_ID_DST
@ AV_CODEC_ID_DST
Definition: codec_id.h:531
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
ID_FRTE
#define ID_FRTE
Definition: iff.c:67
ff_id3v2_parse_apic
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:1163
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:908
dsd_codec_tags
static const AVCodecTag dsd_codec_tags[]
Definition: iff.c:171
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:824
IffDemuxContext
Definition: iff.c:110
ID_ACBM
#define ID_ACBM
Definition: iff.c:59
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
ID_DPAN
#define ID_DPAN
Definition: iff.c:71
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
IffDemuxContext::form_tag
uint32_t form_tag
Definition: iff.c:127
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
IffDemuxContext::resume_pos
int64_t resume_pos
Definition: iff.c:115
ID_ABIT
#define ID_ABIT
Definition: iff.c:83
dsd_history_comment
static const char * dsd_history_comment[]
Definition: iff.c:214
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
AVMediaType
AVMediaType
Definition: avutil.h:198
AVPacket::size
int size
Definition: packet.h:547
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
IffDemuxContext::flags
unsigned flags
1 for EHB, 0 is no extra half darkening
Definition: iff.c:123
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:136
iff_probe
static int iff_probe(const AVProbeData *p)
Definition: iff.c:151
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
AV_CODEC_ID_DSD_MSBF
@ AV_CODEC_ID_DSD_MSBF
Definition: codec_id.h:524
ID_ANIM
#define ID_ANIM
Definition: iff.c:68
size
int size
Definition: twinvq_data.h:10344
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
ID_CAMG
#define ID_CAMG
Definition: iff.c:57
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:46
read_dst_frame
static int read_dst_frame(AVFormatContext *s, AVPacket *pkt)
Definition: iff.c:359
ID_MHDR
#define ID_MHDR
Definition: iff.c:47
DSD_MLFT
#define DSD_MLFT
Definition: iff.c:180
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
IffDemuxContext::audio_stream_index
int audio_stream_index
Definition: iff.c:128
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:552
read_header
static int read_header(FFV1Context *f, RangeCoder *c)
Definition: ffv1dec.c:489
version
version
Definition: libkvazaar.c:315
ID_FRM8
#define ID_FRM8
Definition: iff.c:74
deep_rgb24
static const uint8_t deep_rgb24[]
Definition: iff.c:420
DSDLayoutDesc::layout
AVChannelLayout layout
Definition: iff.c:192
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
COMP_FIB
@ COMP_FIB
Definition: iff.c:106
IffDemuxContext::maud_bits
unsigned maud_bits
Definition: iff.c:118
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
get_metadata
static int get_metadata(AVFormatContext *s, const char *const tag, const unsigned data_size)
Definition: iff.c:133
ID_RGB8
#define ID_RGB8
Definition: iff.c:61
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
ID_DST
#define ID_DST
Definition: iff.c:64
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
IffDemuxContext::bitmap_compression
unsigned bitmap_compression
delta compression method used
Definition: iff.c:120
IffDemuxContext::body_pos
int64_t body_pos
Definition: iff.c:112
ID_VHDR
#define ID_VHDR
Definition: iff.c:49
ID_DLOC
#define ID_DLOC
Definition: iff.c:87
demux.h
ID_DSD
#define ID_DSD
Definition: iff.c:63
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:94
ID_ANHD
#define ID_ANHD
Definition: iff.c:69
tag
uint32_t tag
Definition: movenc.c:1907
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
DSDLayoutDesc::dsd_layout
const uint32_t * dsd_layout
Definition: iff.c:193
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
dict.h
DSD_SLFT
#define DSD_SLFT
Definition: iff.c:178
av_sat_add64
#define av_sat_add64
Definition: common.h:139
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
IffDemuxContext::bpp
unsigned bpp
bits per plane to decode (differs from bits_per_coded_sample if HAM)
Definition: iff.c:121
dsd_5point1
static const uint32_t dsd_5point1[]
Definition: iff.c:189
DSD_LS
#define DSD_LS
Definition: iff.c:183
ID_TVDC
#define ID_TVDC
Definition: iff.c:88
channel_layout.h
deep_abgr
static const uint8_t deep_abgr[]
Definition: iff.c:424
IffDemuxContext::video_stream_index
int video_stream_index
Definition: iff.c:129
parse_dsd_diin
static int parse_dsd_diin(AVFormatContext *s, AVStream *st, uint64_t eof)
Definition: iff.c:222
ID_MDAT
#define ID_MDAT
Definition: iff.c:48
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
ID_MAUD
#define ID_MAUD
Definition: iff.c:46
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
AVPacket::stream_index
int stream_index
Definition: packet.h:548
COMP_EXP
@ COMP_EXP
Definition: iff.c:107
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
ID_16SV
#define ID_16SV
Definition: iff.c:45
mem.h
ID_COPYRIGHT
#define ID_COPYRIGHT
Definition: iff.c:78
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:341
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
IffDemuxContext::ham
unsigned ham
0 if non-HAM or number of hold bits (6 for bpp > 6, 4 otherwise)
Definition: iff.c:122
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
dsd_5point0
static const uint32_t dsd_5point0[]
Definition: iff.c:188
AVPacket
This structure stores compressed data.
Definition: packet.h:523
svx8_compression_type
svx8_compression_type
Definition: iff.c:104
IFF_EXTRA_VIDEO_SIZE
#define IFF_EXTRA_VIDEO_SIZE
This number of bytes if added at the beginning of each AVPacket which contain additional information ...
Definition: iff.c:102
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
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:86
ff_id3v2_free_extra_meta
void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta)
Free memory allocated parsing special (non-text) metadata.
Definition: id3v2.c:1147
deep_rgba
static const uint8_t deep_rgba[]
Definition: iff.c:421
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:566
FFInputFormat
Definition: demux.h:42
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:363
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
IffDemuxContext::transparency
unsigned transparency
transparency color index in palette
Definition: iff.c:124
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:404
dsd_loudspeaker_config
static const AVChannelLayout dsd_loudspeaker_config[]
Definition: iff.c:202
dsd_channel_layout
static const DSDLayoutDesc dsd_channel_layout[]
Definition: iff.c:196
IffDemuxContext::body_end
int64_t body_end
Definition: iff.c:113
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:405
ff_iff_demuxer
const FFInputFormat ff_iff_demuxer
Definition: iff.c:1020
dsd_stereo
static const uint32_t dsd_stereo[]
Definition: iff.c:187
snprintf
#define snprintf
Definition: snprintf.h:34
IffDemuxContext::is_64bit
int is_64bit
chunk size is 64-bit
Definition: iff.c:111
IffDemuxContext::maud_compression
unsigned maud_compression
Definition: iff.c:119
DSDLayoutDesc
Definition: iff.c:191
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:347
ff_alloc_extradata
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:230
min
float min
Definition: vorbis_enc_data.h:429
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346
ID_ANNO
#define ID_ANNO
Definition: iff.c:75
ID_NAME
#define ID_NAME
Definition: iff.c:81
Generated on Sun Jul 6 2025 19:22:01 for FFmpeg by   doxygen 1.8.17