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)
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  while (!avio_feof(pb)) {
368  chunk_pos = avio_tell(pb);
369  if (chunk_pos >= iff->body_end)
370  return AVERROR_EOF;
371 
372  chunk_id = avio_rl32(pb);
373  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
374  data_pos = avio_tell(pb);
375 
376  if (data_size < 1 || data_size >= INT64_MAX)
377  return AVERROR_INVALIDDATA;
378 
379  switch (chunk_id) {
380  case ID_DSTF:
381  if (!pkt) {
382  iff->body_pos = avio_tell(pb) - (iff->is_64bit ? 12 : 8);
383  iff->body_size = iff->body_end - iff->body_pos;
384  return 0;
385  }
386  ret = av_get_packet(pb, pkt, data_size);
387  if (ret < 0)
388  return ret;
389  if (data_size & 1)
390  avio_skip(pb, 1);
391  pkt->flags |= AV_PKT_FLAG_KEY;
392  pkt->stream_index = iff->audio_stream_index;
393  pkt->duration = s->streams[0]->codecpar->sample_rate / 75;
394  pkt->pos = chunk_pos;
395 
396  chunk_pos = avio_tell(pb);
397  if (chunk_pos >= iff->body_end)
398  return 0;
399 
400  avio_seek(pb, chunk_pos, SEEK_SET);
401  return 0;
402 
403  case ID_FRTE:
404  if (data_size < 4)
405  return AVERROR_INVALIDDATA;
406  s->streams[0]->duration = avio_rb32(pb) * (uint64_t)s->streams[0]->codecpar->sample_rate / 75;
407 
408  break;
409  }
410 
411  avio_skip(pb, data_size - (avio_tell(pb) - data_pos) + (data_size & 1));
412  }
413 
414  return ret;
415 }
416 
417 static const uint8_t deep_rgb24[] = {0, 0, 0, 3, 0, 1, 0, 8, 0, 2, 0, 8, 0, 3, 0, 8};
418 static const uint8_t deep_rgba[] = {0, 0, 0, 4, 0, 1, 0, 8, 0, 2, 0, 8, 0, 3, 0, 8};
419 static const uint8_t deep_bgra[] = {0, 0, 0, 4, 0, 3, 0, 8, 0, 2, 0, 8, 0, 1, 0, 8};
420 static const uint8_t deep_argb[] = {0, 0, 0, 4, 0,17, 0, 8, 0, 1, 0, 8, 0, 2, 0, 8};
421 static const uint8_t deep_abgr[] = {0, 0, 0, 4, 0,17, 0, 8, 0, 3, 0, 8, 0, 2, 0, 8};
422 
423 static AVStream * new_stream(AVFormatContext *s, AVStream **st_ptr, int *index_ptr, enum AVMediaType codec_type)
424 {
425  if (!*st_ptr) {
426  *st_ptr = avformat_new_stream(s, NULL);
427  if (!*st_ptr)
428  return NULL;
429  (*st_ptr)->codecpar->codec_type = codec_type;
430  (*index_ptr) = (*st_ptr)->index;
431  }
432  return *st_ptr;
433 }
434 
435 static int iff_read_header(AVFormatContext *s)
436 {
437  IffDemuxContext *iff = s->priv_data;
438  AVIOContext *pb = s->pb;
439  AVStream *sta = NULL, *stv = NULL;
440  uint8_t *buf;
441  uint32_t chunk_id;
442  uint64_t data_size;
443  uint32_t screenmode = 0, num, den;
444  unsigned transparency = 0;
445  unsigned masking = 0; // no mask
446  uint8_t fmt[16];
447  int fmt_size;
448 
449  iff->audio_stream_index = -1;
450  iff->video_stream_index = -1;
451  iff->is_64bit = avio_rl32(pb) == ID_FRM8;
452  avio_skip(pb, iff->is_64bit ? 8 : 4);
453  iff->form_tag = avio_rl32(pb);
454  if (iff->form_tag == ID_ANIM) {
455  avio_skip(pb, 12);
456  }
457  iff->bitmap_compression = -1;
458  iff->svx8_compression = -1;
459  iff->maud_bits = -1;
460  iff->maud_compression = -1;
461 
462  while(!avio_feof(pb)) {
463  uint64_t orig_pos;
464  int res;
465  const char *metadata_tag = NULL;
466  int version, nb_comments, i;
467  chunk_id = avio_rl32(pb);
468  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
469  orig_pos = avio_tell(pb);
470 
471  if (data_size >= INT64_MAX)
472  return AVERROR_INVALIDDATA;
473 
474  switch(chunk_id) {
475  case ID_VHDR:
476  if (data_size < 14)
477  return AVERROR_INVALIDDATA;
478  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
479  return AVERROR(ENOMEM);
480  avio_skip(pb, 12);
481  sta->codecpar->sample_rate = avio_rb16(pb);
482  if (data_size >= 16) {
483  avio_skip(pb, 1);
484  iff->svx8_compression = avio_r8(pb);
485  }
486  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
487  break;
488 
489  case ID_MHDR:
490  if (data_size < 32)
491  return AVERROR_INVALIDDATA;
492  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
493  return AVERROR(ENOMEM);
494  avio_skip(pb, 4);
495  iff->maud_bits = avio_rb16(pb);
496  avio_skip(pb, 2);
497  num = avio_rb32(pb);
498  den = avio_rb16(pb);
499  if (!den)
500  return AVERROR_INVALIDDATA;
501  avio_skip(pb, 2);
502  sta->codecpar->sample_rate = num / den;
503  sta->codecpar->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
504  sta->codecpar->ch_layout.nb_channels = avio_rb16(pb);
505  iff->maud_compression = avio_rb16(pb);
506  if (sta->codecpar->ch_layout.nb_channels == 1)
507  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
508  else if (sta->codecpar->ch_layout.nb_channels == 2)
509  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
510  break;
511 
512  case ID_ABIT:
513  case ID_BODY:
514  case ID_DBOD:
515  case ID_DSD:
516  case ID_DST:
517  case ID_MDAT:
518  iff->body_pos = avio_tell(pb);
519  if (iff->body_pos < 0 || iff->body_pos + data_size > INT64_MAX)
520  return AVERROR_INVALIDDATA;
521 
522  iff->body_end = iff->body_pos + data_size;
523  iff->body_size = data_size;
524  if (chunk_id == ID_DST) {
525  int ret = read_dst_frame(s, NULL);
526  if (ret < 0)
527  return ret;
528  }
529  break;
530 
531  case ID_CHAN:
532  if (data_size < 4)
533  return AVERROR_INVALIDDATA;
534  if (!sta)
535  return AVERROR_INVALIDDATA;
536  if (avio_rb32(pb) < 6) {
537  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
538  } else {
539  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
540  }
541  break;
542 
543  case ID_CAMG:
544  if (data_size < 4)
545  return AVERROR_INVALIDDATA;
546  screenmode = avio_rb32(pb);
547  break;
548 
549  case ID_CMAP:
550  if (data_size < 3 || data_size > 768 || data_size % 3) {
551  av_log(s, AV_LOG_ERROR, "Invalid CMAP chunk size %"PRIu64"\n",
552  data_size);
553  return AVERROR_INVALIDDATA;
554  }
555  if (!stv)
556  return AVERROR_INVALIDDATA;
557  res = ff_alloc_extradata(stv->codecpar,
558  data_size + IFF_EXTRA_VIDEO_SIZE);
559  if (res < 0)
560  return res;
561  if (avio_read(pb, stv->codecpar->extradata + IFF_EXTRA_VIDEO_SIZE, data_size) < 0) {
562  av_freep(&stv->codecpar->extradata);
563  stv->codecpar->extradata_size = 0;
564  return AVERROR(EIO);
565  }
566  break;
567 
568  case ID_BMHD:
569  if (data_size <= 8)
570  return AVERROR_INVALIDDATA;
571  if (!new_stream(s, &stv, &iff->video_stream_index, AVMEDIA_TYPE_VIDEO))
572  return AVERROR(ENOMEM);
573  stv->codecpar->width = avio_rb16(pb);
574  stv->codecpar->height = avio_rb16(pb);
575  avio_skip(pb, 4); // x, y offset
576  stv->codecpar->bits_per_coded_sample = avio_r8(pb);
577  if (data_size >= 10)
578  masking = avio_r8(pb);
579  if (data_size >= 11)
580  iff->bitmap_compression = avio_r8(pb);
581  if (data_size >= 14) {
582  avio_skip(pb, 1); // padding
583  transparency = avio_rb16(pb);
584  }
585  if (data_size >= 16) {
586  stv->sample_aspect_ratio.num = avio_r8(pb);
587  stv->sample_aspect_ratio.den = avio_r8(pb);
588  }
589  break;
590 
591  case ID_ANHD:
592  break;
593 
594  case ID_DPAN:
595  if (!stv)
596  return AVERROR_INVALIDDATA;
597  avio_skip(pb, 2);
598  stv->duration = avio_rb16(pb);
599  break;
600 
601  case ID_DPEL:
602  if (data_size < 4 || (data_size & 3))
603  return AVERROR_INVALIDDATA;
604  if (!stv)
605  return AVERROR_INVALIDDATA;
606  if ((fmt_size = avio_read(pb, fmt, sizeof(fmt))) < 0)
607  return fmt_size;
608  if (fmt_size == sizeof(deep_rgb24) && !memcmp(fmt, deep_rgb24, sizeof(deep_rgb24)))
609  stv->codecpar->format = AV_PIX_FMT_RGB24;
610  else if (fmt_size == sizeof(deep_rgba) && !memcmp(fmt, deep_rgba, sizeof(deep_rgba)))
611  stv->codecpar->format = AV_PIX_FMT_RGBA;
612  else if (fmt_size == sizeof(deep_bgra) && !memcmp(fmt, deep_bgra, sizeof(deep_bgra)))
613  stv->codecpar->format = AV_PIX_FMT_BGRA;
614  else if (fmt_size == sizeof(deep_argb) && !memcmp(fmt, deep_argb, sizeof(deep_argb)))
615  stv->codecpar->format = AV_PIX_FMT_ARGB;
616  else if (fmt_size == sizeof(deep_abgr) && !memcmp(fmt, deep_abgr, sizeof(deep_abgr)))
617  stv->codecpar->format = AV_PIX_FMT_ABGR;
618  else {
619  avpriv_request_sample(s, "color format %.16s", fmt);
620  return AVERROR_PATCHWELCOME;
621  }
622  break;
623 
624  case ID_DGBL:
625  if (data_size < 8)
626  return AVERROR_INVALIDDATA;
627  if (!new_stream(s, &stv, &iff->video_stream_index, AVMEDIA_TYPE_VIDEO))
628  return AVERROR(ENOMEM);
629  stv->codecpar->width = avio_rb16(pb);
630  stv->codecpar->height = avio_rb16(pb);
631  iff->bitmap_compression = avio_rb16(pb);
632  stv->sample_aspect_ratio.num = avio_r8(pb);
633  stv->sample_aspect_ratio.den = avio_r8(pb);
634  stv->codecpar->bits_per_coded_sample = 24;
635  break;
636 
637  case ID_DLOC:
638  if (data_size < 4)
639  return AVERROR_INVALIDDATA;
640  if (!new_stream(s, &stv, &iff->video_stream_index, AVMEDIA_TYPE_VIDEO))
641  return AVERROR(ENOMEM);
642  stv->codecpar->width = avio_rb16(pb);
643  stv->codecpar->height = avio_rb16(pb);
644  break;
645 
646  case ID_TVDC:
647  if (data_size < sizeof(iff->tvdc))
648  return AVERROR_INVALIDDATA;
649  res = avio_read(pb, iff->tvdc, sizeof(iff->tvdc));
650  if (res < 0)
651  return res;
652  break;
653 
654  case MKTAG('S','X','H','D'):
655  if (data_size < 22)
656  return AVERROR_INVALIDDATA;
657  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
658  return AVERROR(ENOMEM);
659  sta->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
660  switch(avio_r8(pb)) {
661  case 8:
662  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S8_PLANAR;
663  break;
664  default:
665  avpriv_request_sample(s, "sound bitdepth");
666  return AVERROR_INVALIDDATA;
667  }
668  avio_skip(pb, 9);
669  if (avio_rb32(pb)) {
670  avpriv_request_sample(s, "sound compression");
671  return AVERROR_INVALIDDATA;
672  }
673  avio_skip(pb, 1);
674  sta->codecpar->ch_layout.nb_channels = avio_r8(pb);
675  if (!sta->codecpar->ch_layout.nb_channels)
676  return AVERROR_INVALIDDATA;
677  if (sta->codecpar->ch_layout.nb_channels == 1)
678  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
679  else if (sta->codecpar->ch_layout.nb_channels == 2)
680  sta->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
681  sta->codecpar->sample_rate = avio_rb32(pb);
682  avpriv_set_pts_info(sta, 64, 1, sta->codecpar->sample_rate);
683  avio_skip(pb, 2);
684  break;
685 
686  case ID_ANNO:
687  case ID_TEXT: metadata_tag = "comment"; break;
688  case ID_AUTH: metadata_tag = "artist"; break;
689  case ID_COPYRIGHT: metadata_tag = "copyright"; break;
690  case ID_NAME: metadata_tag = "title"; break;
691 
692  /* DSD tags */
693 
694  case MKTAG('F','V','E','R'):
695  if (data_size < 4)
696  return AVERROR_INVALIDDATA;
697  version = avio_rb32(pb);
698  av_log(s, AV_LOG_DEBUG, "DSIFF v%d.%d.%d.%d\n",version >> 24, (version >> 16) & 0xFF, (version >> 8) & 0xFF, version & 0xFF);
699  if (!new_stream(s, &sta, &iff->audio_stream_index, AVMEDIA_TYPE_AUDIO))
700  return AVERROR(ENOMEM);
701  sta->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
702  break;
703 
704  case MKTAG('D','I','I','N'):
705  if (!sta)
706  return AVERROR_INVALIDDATA;
707  res = parse_dsd_diin(s, sta, orig_pos + data_size);
708  if (res < 0)
709  return res;
710  break;
711 
712  case MKTAG('P','R','O','P'):
713  if (data_size < 4)
714  return AVERROR_INVALIDDATA;
715  if (avio_rl32(pb) != MKTAG('S','N','D',' ')) {
716  avpriv_request_sample(s, "unknown property type");
717  break;
718  }
719  if (!sta)
720  return AVERROR_INVALIDDATA;
721  res = parse_dsd_prop(s, sta, orig_pos + data_size);
722  if (res < 0)
723  return res;
724  break;
725 
726  case MKTAG('C','O','M','T'):
727  if (data_size < 2)
728  return AVERROR_INVALIDDATA;
729  if (!sta)
730  return AVERROR_INVALIDDATA;
731  nb_comments = avio_rb16(pb);
732  for (i = 0; i < nb_comments; i++) {
733  int year, mon, day, hour, min, type, ref;
734  char tmp[24];
735  const char *tag;
736  int metadata_size;
737 
738  year = avio_rb16(pb);
739  mon = avio_r8(pb);
740  day = avio_r8(pb);
741  hour = avio_r8(pb);
742  min = avio_r8(pb);
743  snprintf(tmp, sizeof(tmp), "%04d-%02d-%02d %02d:%02d", year, mon, day, hour, min);
744  av_dict_set(&sta->metadata, "comment_time", tmp, 0);
745 
746  type = avio_rb16(pb);
747  ref = avio_rb16(pb);
748  switch (type) {
749  case 1:
750  if (!i)
751  tag = "channel_comment";
752  else {
753  snprintf(tmp, sizeof(tmp), "channel%d_comment", ref);
754  tag = tmp;
755  }
756  break;
757  case 2:
758  tag = ref < FF_ARRAY_ELEMS(dsd_source_comment) ? dsd_source_comment[ref] : "source_comment";
759  break;
760  case 3:
761  tag = ref < FF_ARRAY_ELEMS(dsd_history_comment) ? dsd_history_comment[ref] : "file_history";
762  break;
763  default:
764  tag = "comment";
765  }
766 
767  metadata_size = avio_rb32(pb);
768  if ((res = get_metadata(s, tag, metadata_size)) < 0) {
769  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", tag);
770  return res;
771  }
772 
773  if (metadata_size & 1)
774  avio_skip(pb, 1);
775  }
776  break;
777  }
778 
779  if (metadata_tag) {
780  if ((res = get_metadata(s, metadata_tag, data_size)) < 0) {
781  av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag);
782  return res;
783  }
784  }
785  avio_skip(pb, data_size - (avio_tell(pb) - orig_pos) + (data_size & 1));
786  }
787 
788  if ((!sta && !stv) ||
789  (iff->form_tag == ID_ANIM && !stv) ||
790  (iff->form_tag != ID_ANIM && sta && stv))
791  return AVERROR_INVALIDDATA;
792 
793  if (iff->form_tag == ID_ANIM)
794  avio_seek(pb, 12, SEEK_SET);
795  else
796  avio_seek(pb, iff->body_pos, SEEK_SET);
797 
798  if (sta) {
799  avpriv_set_pts_info(sta, 32, 1, sta->codecpar->sample_rate);
800 
801  if (sta->codecpar->codec_id != AV_CODEC_ID_NONE) {
802  /* codec_id already set by PROP or SXHD chunk */
803  } else if (iff->form_tag == ID_16SV)
804  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR;
805  else if (iff->form_tag == ID_MAUD) {
806  if (iff->maud_bits == 8 && !iff->maud_compression) {
807  sta->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
808  } else if (iff->maud_bits == 16 && !iff->maud_compression) {
809  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE;
810  } else if (iff->maud_bits == 8 && iff->maud_compression == 2) {
811  sta->codecpar->codec_id = AV_CODEC_ID_PCM_ALAW;
812  } else if (iff->maud_bits == 8 && iff->maud_compression == 3) {
813  sta->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW;
814  } else {
815  avpriv_request_sample(s, "compression %d and bit depth %d", iff->maud_compression, iff->maud_bits);
816  return AVERROR_PATCHWELCOME;
817  }
818  } else {
819  switch (iff->svx8_compression) {
820  case COMP_NONE:
821  sta->codecpar->codec_id = AV_CODEC_ID_PCM_S8_PLANAR;
822  break;
823  case COMP_FIB:
824  sta->codecpar->codec_id = AV_CODEC_ID_8SVX_FIB;
825  break;
826  case COMP_EXP:
827  sta->codecpar->codec_id = AV_CODEC_ID_8SVX_EXP;
828  break;
829  default:
830  av_log(s, AV_LOG_ERROR,
831  "Unknown SVX8 compression method '%d'\n", iff->svx8_compression);
832  return -1;
833  }
834  }
835 
836  sta->codecpar->bits_per_coded_sample = av_get_bits_per_sample(sta->codecpar->codec_id);
837  sta->codecpar->bit_rate = (int64_t)sta->codecpar->ch_layout.nb_channels *
838  sta->codecpar->sample_rate *
839  sta->codecpar->bits_per_coded_sample;
840  sta->codecpar->block_align = sta->codecpar->ch_layout.nb_channels *
841  sta->codecpar->bits_per_coded_sample;
842  if ((sta->codecpar->codec_tag == ID_DSD || iff->form_tag == ID_MAUD) && sta->codecpar->block_align <= 0)
843  return AVERROR_INVALIDDATA;
844  }
845 
846  if (stv) {
847  iff->bpp = stv->codecpar->bits_per_coded_sample;
848  if (iff->form_tag == ID_ANIM)
849  avpriv_set_pts_info(stv, 32, 1, 60);
850  if ((screenmode & 0x800 /* Hold And Modify */) && iff->bpp <= 8) {
851  iff->ham = iff->bpp > 6 ? 6 : 4;
852  stv->codecpar->bits_per_coded_sample = 24;
853  }
854  iff->flags = (screenmode & 0x80 /* Extra HalfBrite */) && iff->bpp <= 8;
855  iff->masking = masking;
856  iff->transparency = transparency;
857 
858  if (!stv->codecpar->extradata) {
859  int ret = ff_alloc_extradata(stv->codecpar, IFF_EXTRA_VIDEO_SIZE);
860  if (ret < 0)
861  return ret;
862  }
863  av_assert0(stv->codecpar->extradata_size >= IFF_EXTRA_VIDEO_SIZE);
864  buf = stv->codecpar->extradata;
865  bytestream_put_be16(&buf, IFF_EXTRA_VIDEO_SIZE);
866  bytestream_put_byte(&buf, iff->bitmap_compression);
867  bytestream_put_byte(&buf, iff->bpp);
868  bytestream_put_byte(&buf, iff->ham);
869  bytestream_put_byte(&buf, iff->flags);
870  bytestream_put_be16(&buf, iff->transparency);
871  bytestream_put_byte(&buf, iff->masking);
872  bytestream_put_buffer(&buf, iff->tvdc, sizeof(iff->tvdc));
873  stv->codecpar->codec_id = AV_CODEC_ID_IFF_ILBM;
874  stv->codecpar->codec_tag = iff->form_tag; // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content
875  }
876 
877  return 0;
878 }
879 
880 static unsigned get_anim_duration(uint8_t *buf, int size)
881 {
882  GetByteContext gb;
883 
884  bytestream2_init(&gb, buf, size);
885  bytestream2_skip(&gb, 4);
886  while (bytestream2_get_bytes_left(&gb) > 8) {
887  unsigned chunk = bytestream2_get_le32(&gb);
888  unsigned size = bytestream2_get_be32(&gb);
889 
890  if (chunk == ID_ANHD) {
891  if (size < 40)
892  break;
893  bytestream2_skip(&gb, 14);
894  return bytestream2_get_be32(&gb);
895  } else {
896  bytestream2_skip(&gb, size + size & 1);
897  }
898  }
899  return 10;
900 }
901 
902 static int64_t get_sbdy_offset(uint8_t *buf, int size)
903 {
904  GetByteContext gb;
905 
906  bytestream2_init(&gb, buf, size);
907  bytestream2_skip(&gb, 4);
908  while (bytestream2_get_bytes_left(&gb) > 8) {
909  unsigned chunk = bytestream2_get_le32(&gb);
910  unsigned size = bytestream2_get_be32(&gb);
911 
912  if (chunk == MKTAG('S','B','D','Y'))
913  return bytestream2_tell(&gb);
914 
915  bytestream2_skip(&gb, size + size & 1);
916  }
917 
918  return 0;
919 }
920 
921 static int iff_read_packet(AVFormatContext *s,
922  AVPacket *pkt)
923 {
924  IffDemuxContext *iff = s->priv_data;
925  AVIOContext *pb = s->pb;
926  int ret;
927  int64_t pos = avio_tell(pb);
928 
929  if (avio_feof(pb))
930  return AVERROR_EOF;
931  if (iff->form_tag != ID_ANIM && pos >= iff->body_end)
932  return AVERROR_EOF;
933 
934  if (iff->sbdy_pos) {
935  int64_t data_size;
936  avio_seek(pb, iff->sbdy_pos, SEEK_SET);
937  data_size = iff->is_64bit ? avio_rb64(pb) : avio_rb32(pb);
938  ret = av_get_packet(pb, pkt, data_size);
939  pkt->stream_index = iff->audio_stream_index;
940  pkt->duration = data_size / s->streams[iff->audio_stream_index]->codecpar->ch_layout.nb_channels;
941  pkt->pos = INT_MAX; /* not seekable */
942 
943  iff->sbdy_pos = 0;
944  avio_seek(pb, iff->resume_pos, SEEK_SET);
945  return ret;
946  }
947 
948  if (iff->audio_stream_index >= 0 && iff->video_stream_index < 0) { /* audio only */
949  AVStream *sta = s->streams[iff->audio_stream_index];
950  if (sta->codecpar->codec_tag == ID_DSD || iff->form_tag == ID_MAUD) {
951  ret = av_get_packet(pb, pkt, FFMIN(iff->body_end - pos, 1024 * sta->codecpar->block_align));
952  } else if (sta->codecpar->codec_tag == ID_DST) {
953  return read_dst_frame(s, pkt);
954  } else {
955  if (iff->body_size > INT_MAX || !iff->body_size)
956  return AVERROR_INVALIDDATA;
957  ret = av_get_packet(pb, pkt, iff->body_size);
958  }
959  pkt->stream_index = iff->audio_stream_index;
960  } else if (iff->form_tag == ID_ANIM) {
961  uint64_t data_size, orig_pos;
962  uint32_t chunk_id, chunk_id2;
963 
964  while (!avio_feof(pb)) {
965  if (avio_feof(pb))
966  return AVERROR_EOF;
967 
968  orig_pos = avio_tell(pb);
969  chunk_id = avio_rl32(pb);
970  data_size = avio_rb32(pb);
971  chunk_id2 = avio_rl32(pb);
972 
973  if (chunk_id == ID_FORM &&
974  chunk_id2 == ID_ILBM) {
975  avio_skip(pb, -4);
976  break;
977  } else if (chunk_id == ID_FORM &&
978  chunk_id2 == ID_ANIM) {
979  continue;
980  } else {
981  avio_skip(pb, data_size);
982  }
983  }
984  ret = av_get_packet(pb, pkt, data_size);
985  pkt->stream_index = iff->video_stream_index;
986  pkt->pos = orig_pos;
987  pkt->duration = get_anim_duration(pkt->data, pkt->size);
988  if (pos == 12)
989  pkt->flags |= AV_PKT_FLAG_KEY;
990 
991  if (iff->audio_stream_index >= 0) {
992  iff->sbdy_pos = get_sbdy_offset(pkt->data, pkt->size);
993  if (iff->sbdy_pos) {
994  iff->sbdy_pos += orig_pos + 4;
995  iff->resume_pos = avio_tell(pb);
996  }
997  }
998  } else if (iff->video_stream_index >= 0 && iff->audio_stream_index < 0) { /* video only */
999  if (iff->body_size > INT_MAX || !iff->body_size)
1000  return AVERROR_INVALIDDATA;
1001  ret = av_get_packet(pb, pkt, iff->body_size);
1002  pkt->stream_index = iff->video_stream_index;
1003  pkt->pos = pos;
1004  if (pos == iff->body_pos)
1005  pkt->flags |= AV_PKT_FLAG_KEY;
1006  } else {
1007  av_assert0(0);
1008  }
1009 
1010  return ret;
1011 }
1012 
1013 const FFInputFormat ff_iff_demuxer = {
1014  .p.name = "iff",
1015  .p.long_name = NULL_IF_CONFIG_SMALL("IFF (Interchange File Format)"),
1016  .p.flags = AVFMT_GENERIC_INDEX | AVFMT_NO_BYTE_SEEK,
1017  .priv_data_size = sizeof(IffDemuxContext),
1018  .read_probe = iff_probe,
1019  .read_header = iff_read_header,
1020  .read_packet = iff_read_packet,
1021 };
get_sbdy_offset
static int64_t get_sbdy_offset(uint8_t *buf, int size)
Definition: iff.c:902
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:487
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:420
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:502
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
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
DSD_MRGT
#define DSD_MRGT
Definition: iff.c:181
AVPacket::data
uint8_t * data
Definition: packet.h:539
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:365
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:1140
deep_bgra
static const uint8_t deep_bgra[]
Definition: iff.c:419
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:557
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:880
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:594
COMP_NONE
@ COMP_NONE
Definition: iff.c:105
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:867
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:336
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:480
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:503
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:1193
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:423
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
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:209
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:553
iff_read_header
static int iff_read_header(AVFormatContext *s)
Definition: iff.c:435
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:921
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
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:40
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:230
ID_8SVX
#define ID_8SVX
Definition: iff.c:44
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:341
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:1300
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:342
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:540
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:529
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:1162
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:828
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:199
AVPacket::size
int size
Definition: packet.h:540
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:133
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:522
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:545
version
version
Definition: libkvazaar.c:321
ID_FRM8
#define ID_FRM8
Definition: iff.c:74
deep_rgb24
static const uint8_t deep_rgb24[]
Definition: iff.c:417
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:91
ID_ANHD
#define ID_ANHD
Definition: iff.c:69
tag
uint32_t tag
Definition: movenc.c:1879
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
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:421
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:541
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:201
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:340
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
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:33
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:516
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:34
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:88
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:1146
deep_rgba
static const uint8_t deep_rgba[]
Definition: iff.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
FFInputFormat
Definition: demux.h:42
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:362
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:1013
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:348
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:227
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 Wed Jan 8 2025 19:21:28 for FFmpeg by   doxygen 1.8.17