FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flacdec.c
Go to the documentation of this file.
1 /*
2  * Raw FLAC demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavcodec/flac.h"
23 #include "avformat.h"
24 #include "flac_picture.h"
25 #include "internal.h"
26 #include "rawdec.h"
27 #include "oggdec.h"
28 #include "vorbiscomment.h"
29 #include "replaygain.h"
30 
31 #define SEEKPOINT_SIZE 18
32 
33 typedef struct FLACDecContext {
36 
37 static void reset_index_position(int64_t metadata_head_size, AVStream *st)
38 {
39  /* the real seek index offset should be the size of metadata blocks with the offset in the frame blocks */
40  int i;
41  for(i=0; i<st->nb_index_entries; i++) {
42  st->index_entries[i].pos += metadata_head_size;
43  }
44 }
45 
47 {
48  int ret, metadata_last=0, metadata_type, metadata_size, found_streaminfo=0;
49  uint8_t header[4];
51  FLACDecContext *flac = s->priv_data;
53  if (!st)
54  return AVERROR(ENOMEM);
58  /* the parameters will be extracted from the compressed bitstream */
59 
60  /* if fLaC marker is not found, assume there is no header */
61  if (avio_rl32(s->pb) != MKTAG('f','L','a','C')) {
62  avio_seek(s->pb, -4, SEEK_CUR);
63  return 0;
64  }
65 
66  /* process metadata blocks */
67  while (!avio_feof(s->pb) && !metadata_last) {
68  if (avio_read(s->pb, header, 4) != 4)
70  flac_parse_block_header(header, &metadata_last, &metadata_type,
71  &metadata_size);
72  switch (metadata_type) {
73  /* allocate and read metadata block for supported types */
79  buffer = av_mallocz(metadata_size + AV_INPUT_BUFFER_PADDING_SIZE);
80  if (!buffer) {
81  return AVERROR(ENOMEM);
82  }
83  if (avio_read(s->pb, buffer, metadata_size) != metadata_size) {
84  RETURN_ERROR(AVERROR(EIO));
85  }
86  break;
87  /* skip metadata block for unsupported types */
88  default:
89  ret = avio_skip(s->pb, metadata_size);
90  if (ret < 0)
91  return ret;
92  }
93 
94  if (metadata_type == FLAC_METADATA_TYPE_STREAMINFO) {
95  uint32_t samplerate;
96  uint64_t samples;
97 
98  /* STREAMINFO can only occur once */
99  if (found_streaminfo) {
101  }
102  if (metadata_size != FLAC_STREAMINFO_SIZE) {
104  }
105  found_streaminfo = 1;
106  st->codecpar->extradata = buffer;
107  st->codecpar->extradata_size = metadata_size;
108  buffer = NULL;
109 
110  /* get sample rate and sample count from STREAMINFO header;
111  * other parameters will be extracted by the parser */
112  samplerate = AV_RB24(st->codecpar->extradata + 10) >> 4;
113  samples = (AV_RB64(st->codecpar->extradata + 13) >> 24) & ((1ULL << 36) - 1);
114 
115  /* set time base and duration */
116  if (samplerate > 0) {
117  avpriv_set_pts_info(st, 64, 1, samplerate);
118  if (samples > 0)
119  st->duration = samples;
120  }
121  } else if (metadata_type == FLAC_METADATA_TYPE_CUESHEET) {
122  uint8_t isrc[13];
123  uint64_t start;
124  const uint8_t *offset;
125  int i, chapters, track, ti;
126  if (metadata_size < 431)
128  offset = buffer + 395;
129  chapters = bytestream_get_byte(&offset) - 1;
130  if (chapters <= 0)
132  for (i = 0; i < chapters; i++) {
133  if (offset + 36 - buffer > metadata_size)
135  start = bytestream_get_be64(&offset);
136  track = bytestream_get_byte(&offset);
137  bytestream_get_buffer(&offset, isrc, 12);
138  isrc[12] = 0;
139  offset += 14;
140  ti = bytestream_get_byte(&offset);
141  if (ti <= 0) RETURN_ERROR(AVERROR_INVALIDDATA);
142  offset += ti * 12;
143  avpriv_new_chapter(s, track, st->time_base, start, AV_NOPTS_VALUE, isrc);
144  }
145  av_freep(&buffer);
146  } else if (metadata_type == FLAC_METADATA_TYPE_PICTURE) {
147  ret = ff_flac_parse_picture(s, buffer, metadata_size);
148  av_freep(&buffer);
149  if (ret < 0) {
150  av_log(s, AV_LOG_ERROR, "Error parsing attached picture.\n");
151  return ret;
152  }
153  } else if (metadata_type == FLAC_METADATA_TYPE_SEEKTABLE) {
154  const uint8_t *seekpoint = buffer;
155  int i, seek_point_count = metadata_size/SEEKPOINT_SIZE;
156  flac->found_seektable = 1;
157  if ((s->flags&AVFMT_FLAG_FAST_SEEK)) {
158  for(i=0; i<seek_point_count; i++) {
159  int64_t timestamp = bytestream_get_be64(&seekpoint);
160  int64_t pos = bytestream_get_be64(&seekpoint);
161  /* skip number of samples */
162  bytestream_get_be16(&seekpoint);
163  av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);
164  }
165  }
166  av_freep(&buffer);
167  }
168  else {
169 
170  /* STREAMINFO must be the first block */
171  if (!found_streaminfo) {
173  }
174  /* process supported blocks other than STREAMINFO */
175  if (metadata_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
176  AVDictionaryEntry *chmask;
177 
178  ret = ff_vorbis_comment(s, &s->metadata, buffer, metadata_size, 1);
179  if (ret < 0) {
180  av_log(s, AV_LOG_WARNING, "error parsing VorbisComment metadata\n");
181  } else if (ret > 0) {
183  }
184 
185  /* parse the channels mask if present */
186  chmask = av_dict_get(s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
187  if (chmask) {
188  uint64_t mask = strtol(chmask->value, NULL, 0);
189  if (!mask || mask & ~0x3ffffULL) {
191  "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
192  } else {
194  av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
195  }
196  }
197  }
198  av_freep(&buffer);
199  }
200  }
201 
202  ret = ff_replaygain_export(st, s->metadata);
203  if (ret < 0)
204  return ret;
205 
207  return 0;
208 
209 fail:
210  av_free(buffer);
211  return ret;
212 }
213 
215 {
216  if ((p->buf[2] & 0xF0) == 0) // blocksize code invalid
217  return 0;
218  if ((p->buf[2] & 0x0F) == 0x0F) // sample rate code invalid
219  return 0;
220  if ((p->buf[3] & 0xF0) >= FLAC_MAX_CHANNELS + FLAC_CHMODE_MID_SIDE << 4)
221  // channel mode invalid
222  return 0;
223  if ((p->buf[3] & 0x06) == 0x06) // bits per sample code invalid
224  return 0;
225  if ((p->buf[3] & 0x01) == 0x01) // reserved bit set
226  return 0;
227  return AVPROBE_SCORE_EXTENSION / 4 + 1;
228 }
229 
230 static int flac_probe(AVProbeData *p)
231 {
232  if ((AV_RB16(p->buf) & 0xFFFE) == 0xFFF8)
233  return raw_flac_probe(p);
234 
235  /* file header + metadata header + checked bytes of streaminfo */
236  if (p->buf_size >= 4 + 4 + 13) {
237  int type = p->buf[4] & 0x7f;
238  int size = AV_RB24(p->buf + 5);
239  int min_block_size = AV_RB16(p->buf + 8);
240  int max_block_size = AV_RB16(p->buf + 10);
241  int sample_rate = AV_RB24(p->buf + 18) >> 4;
242 
243  if (memcmp(p->buf, "fLaC", 4))
244  return 0;
245  if (type == FLAC_METADATA_TYPE_STREAMINFO &&
246  size == FLAC_STREAMINFO_SIZE &&
247  min_block_size >= 16 &&
248  max_block_size >= min_block_size &&
249  sample_rate && sample_rate <= 655350)
250  return AVPROBE_SCORE_MAX;
252  }
253 
254  return 0;
255 }
256 
257 static av_unused int64_t flac_read_timestamp(AVFormatContext *s, int stream_index,
258  int64_t *ppos, int64_t pos_limit)
259 {
260  AVPacket pkt, out_pkt;
261  AVStream *st = s->streams[stream_index];
262  AVCodecParserContext *parser;
263  int ret;
264  int64_t pts = AV_NOPTS_VALUE;
265 
266  if (avio_seek(s->pb, *ppos, SEEK_SET) < 0)
267  return AV_NOPTS_VALUE;
268 
269  av_init_packet(&pkt);
270  parser = av_parser_init(st->codecpar->codec_id);
271  if (!parser){
272  return AV_NOPTS_VALUE;
273  }
274  parser->flags |= PARSER_FLAG_USE_CODEC_TS;
275 
276  for (;;){
277  ret = ff_raw_read_partial_packet(s, &pkt);
278  if (ret < 0){
279  if (ret == AVERROR(EAGAIN))
280  continue;
281  else {
282  av_packet_unref(&pkt);
283  av_assert1(!pkt.size);
284  }
285  }
286  av_init_packet(&out_pkt);
287  av_parser_parse2(parser, st->internal->avctx,
288  &out_pkt.data, &out_pkt.size, pkt.data, pkt.size,
289  pkt.pts, pkt.dts, *ppos);
290 
291  av_packet_unref(&pkt);
292  if (out_pkt.size){
293  int size = out_pkt.size;
294  if (parser->pts != AV_NOPTS_VALUE){
295  // seeking may not have started from beginning of a frame
296  // calculate frame start position from next frame backwards
297  *ppos = parser->next_frame_offset - size;
298  pts = parser->pts;
299  break;
300  }
301  } else if (ret < 0)
302  break;
303  }
304  av_parser_close(parser);
305  return pts;
306 }
307 
308 static int flac_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) {
309  int index;
310  int64_t pos;
311  AVIndexEntry e;
312  FLACDecContext *flac = s->priv_data;
313 
314  if (!flac->found_seektable || !(s->flags&AVFMT_FLAG_FAST_SEEK)) {
315  return -1;
316  }
317 
318  index = av_index_search_timestamp(s->streams[0], timestamp, flags);
319  if(index<0 || index >= s->streams[0]->nb_index_entries)
320  return -1;
321 
322  e = s->streams[0]->index_entries[index];
323  pos = avio_seek(s->pb, e.pos, SEEK_SET);
324  if (pos >= 0) {
325  return 0;
326  }
327  return -1;
328 }
329 
331  .name = "flac",
332  .long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),
333  .read_probe = flac_probe,
334  .read_header = flac_read_header,
335  .read_packet = ff_raw_read_partial_packet,
336  .read_seek = flac_seek,
337  .read_timestamp = flac_read_timestamp,
338  .flags = AVFMT_GENERIC_INDEX,
339  .extensions = "flac",
340  .raw_codec_id = AV_CODEC_ID_FLAC,
341  .priv_data_size = sizeof(FLACDecContext),
342 };
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static av_unused int64_t flac_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: flacdec.c:257
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:1979
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4727
int64_t next_frame_offset
Definition: avcodec.h:5089
int64_t pos
Definition: avformat.h:820
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4074
int size
Definition: avcodec.h:1658
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:235
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1092
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1642
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
static AVPacket pkt
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4484
Format I/O context.
Definition: avformat.h:1349
uint8_t
enum AVStreamParseType need_parsing
Definition: avformat.h:1081
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4357
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1417
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1460
uint8_t * data
Definition: avcodec.h:1657
int ff_vorbis_comment(AVFormatContext *ms, AVDictionary **m, const uint8_t *buf, int size, int parse_picture)
static int flags
Definition: log.c:57
ptrdiff_t size
Definition: opengl_enc.c:101
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:527
static const uint8_t header[24]
Definition: sdr2.c:67
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
Definition: replaygain.c:91
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:814
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4176
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:621
#define AVINDEX_KEYFRAME
Definition: avformat.h:827
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1567
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2088
int found_seektable
Definition: flacdec.c:34
AVInputFormat ff_flac_demuxer
Definition: flacdec.c:330
static const uint16_t mask[17]
Definition: lzw.c:38
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:743
#define AVERROR(e)
Definition: error.h:43
int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rawdec.c:35
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4070
static int flac_probe(AVProbeData *p)
Definition: flacdec.c:230
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define fail()
Definition: checkasm.h:90
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4092
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:464
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:463
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:136
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:240
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:1643
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
int ff_flac_parse_picture(AVFormatContext *s, uint8_t *buf, int buf_size)
Definition: flac_picture.c:28
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
Definition: bytestream.h:359
Stream structure.
Definition: avformat.h:889
sample_rate
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:51
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1241
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
AVIOContext * pb
I/O context.
Definition: avformat.h:1391
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:576
GLint GLenum type
Definition: opengl_enc.c:105
static int flac_read_header(AVFormatContext *s)
Definition: flacdec.c:46
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int nb_index_entries
Definition: avformat.h:1094
int index
Definition: gxfenc.c:89
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:487
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.h:145
#define RETURN_ERROR(code)
Definition: flac_picture.h:27
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:471
This structure contains the data a format has to probe a file.
Definition: avformat.h:461
static int64_t pts
Global timestamp for the audio frames.
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:946
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:473
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:87
Main libavformat public API header.
static int raw_flac_probe(AVProbeData *p)
Definition: flacdec.c:214
static void reset_index_position(int64_t metadata_head_size, AVStream *st)
Definition: flacdec.c:37
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:772
#define av_free(p)
char * value
Definition: dict.h:87
#define AVFMT_FLAG_FAST_SEEK
Enable fast, but inaccurate seeks for some formats.
Definition: avformat.h:1484
void * priv_data
Format private data.
Definition: avformat.h:1377
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4088
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:173
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1656
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:690
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:664
AVCodecParameters * codecpar
Definition: avformat.h:1252
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:345
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:926
#define MKTAG(a, b, c, d)
Definition: common.h:342
#define SEEKPOINT_SIZE
Definition: flacdec.c:31
static int flac_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: flacdec.c:308
This structure stores compressed data.
Definition: avcodec.h:1634
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1650
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
GLuint buffer
Definition: opengl_enc.c:102
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
#define av_unused
Definition: attributes.h:125
#define PARSER_FLAG_USE_CODEC_TS
Definition: avcodec.h:5121