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