FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flac.c
Go to the documentation of this file.
1 /*
2  * FLAC common code
3  * Copyright (c) 2009 Justin Ruggles
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 
23 #include "libavutil/crc.h"
24 #include "libavutil/log.h"
25 #include "bytestream.h"
26 #include "get_bits.h"
27 #include "flac.h"
28 #include "flacdata.h"
29 
30 static const int8_t sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 0 };
31 
32 static const uint64_t flac_channel_layouts[8] = {
41 };
42 
43 static int64_t get_utf8(GetBitContext *gb)
44 {
45  int64_t val;
46  GET_UTF8(val, get_bits(gb, 8), return -1;)
47  return val;
48 }
49 
51  FLACFrameInfo *fi, int log_level_offset)
52 {
53  int bs_code, sr_code, bps_code;
54 
55  /* frame sync code */
56  if ((get_bits(gb, 15) & 0x7FFF) != 0x7FFC) {
57  av_log(avctx, AV_LOG_ERROR + log_level_offset, "invalid sync code\n");
58  return AVERROR_INVALIDDATA;
59  }
60 
61  /* variable block size stream code */
62  fi->is_var_size = get_bits1(gb);
63 
64  /* block size and sample rate codes */
65  bs_code = get_bits(gb, 4);
66  sr_code = get_bits(gb, 4);
67 
68  /* channels and decorrelation */
69  fi->ch_mode = get_bits(gb, 4);
70  if (fi->ch_mode < FLAC_MAX_CHANNELS) {
71  fi->channels = fi->ch_mode + 1;
73  } else if (fi->ch_mode < FLAC_MAX_CHANNELS + FLAC_CHMODE_MID_SIDE) {
74  fi->channels = 2;
75  fi->ch_mode -= FLAC_MAX_CHANNELS - 1;
76  } else {
77  av_log(avctx, AV_LOG_ERROR + log_level_offset,
78  "invalid channel mode: %d\n", fi->ch_mode);
79  return AVERROR_INVALIDDATA;
80  }
81 
82  /* bits per sample */
83  bps_code = get_bits(gb, 3);
84  if (bps_code == 3 || bps_code == 7) {
85  av_log(avctx, AV_LOG_ERROR + log_level_offset,
86  "invalid sample size code (%d)\n",
87  bps_code);
88  return AVERROR_INVALIDDATA;
89  }
90  fi->bps = sample_size_table[bps_code];
91 
92  /* reserved bit */
93  if (get_bits1(gb)) {
94  av_log(avctx, AV_LOG_ERROR + log_level_offset,
95  "broken stream, invalid padding\n");
96  return AVERROR_INVALIDDATA;
97  }
98 
99  /* sample or frame count */
100  fi->frame_or_sample_num = get_utf8(gb);
101  if (fi->frame_or_sample_num < 0) {
102  av_log(avctx, AV_LOG_ERROR + log_level_offset,
103  "sample/frame number invalid; utf8 fscked\n");
104  return AVERROR_INVALIDDATA;
105  }
106 
107  /* blocksize */
108  if (bs_code == 0) {
109  av_log(avctx, AV_LOG_ERROR + log_level_offset,
110  "reserved blocksize code: 0\n");
111  return AVERROR_INVALIDDATA;
112  } else if (bs_code == 6) {
113  fi->blocksize = get_bits(gb, 8) + 1;
114  } else if (bs_code == 7) {
115  fi->blocksize = get_bits(gb, 16) + 1;
116  } else {
117  fi->blocksize = ff_flac_blocksize_table[bs_code];
118  }
119 
120  /* sample rate */
121  if (sr_code < 12) {
122  fi->samplerate = ff_flac_sample_rate_table[sr_code];
123  } else if (sr_code == 12) {
124  fi->samplerate = get_bits(gb, 8) * 1000;
125  } else if (sr_code == 13) {
126  fi->samplerate = get_bits(gb, 16);
127  } else if (sr_code == 14) {
128  fi->samplerate = get_bits(gb, 16) * 10;
129  } else {
130  av_log(avctx, AV_LOG_ERROR + log_level_offset,
131  "illegal sample rate code %d\n",
132  sr_code);
133  return AVERROR_INVALIDDATA;
134  }
135 
136  /* header CRC-8 check */
137  skip_bits(gb, 8);
139  get_bits_count(gb)/8)) {
140  av_log(avctx, AV_LOG_ERROR + log_level_offset,
141  "header crc mismatch\n");
142  return AVERROR_INVALIDDATA;
143  }
144 
145  return 0;
146 }
147 
148 int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
149 {
150  /* Technically, there is no limit to FLAC frame size, but an encoder
151  should not write a frame that is larger than if verbatim encoding mode
152  were to be used. */
153 
154  int count;
155 
156  count = 16; /* frame header */
157  count += ch * ((7+bps+7)/8); /* subframe headers */
158  if (ch == 2) {
159  /* for stereo, need to account for using decorrelation */
160  count += (( 2*bps+1) * blocksize + 7) / 8;
161  } else {
162  count += ( ch*bps * blocksize + 7) / 8;
163  }
164  count += 2; /* frame footer */
165 
166  return count;
167 }
168 
170  enum FLACExtradataFormat *format,
171  uint8_t **streaminfo_start)
172 {
173  if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
174  av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
175  return 0;
176  }
177  if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
178  /* extradata contains STREAMINFO only */
179  if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
180  av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
182  }
184  *streaminfo_start = avctx->extradata;
185  } else {
186  if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
187  av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
188  return 0;
189  }
191  *streaminfo_start = &avctx->extradata[8];
192  }
193  return 1;
194 }
195 
197 {
199  avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
200  else
201  avctx->channel_layout = 0;
202 }
203 
205  const uint8_t *buffer)
206 {
207  GetBitContext gb;
208  init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
209 
210  skip_bits(&gb, 16); /* skip min blocksize */
211  s->max_blocksize = get_bits(&gb, 16);
212  if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
213  av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
214  s->max_blocksize);
215  s->max_blocksize = 16;
216  }
217 
218  skip_bits(&gb, 24); /* skip min frame size */
219  s->max_framesize = get_bits_long(&gb, 24);
220 
221  s->samplerate = get_bits_long(&gb, 20);
222  s->channels = get_bits(&gb, 3) + 1;
223  s->bps = get_bits(&gb, 5) + 1;
224 
225  avctx->channels = s->channels;
226  avctx->sample_rate = s->samplerate;
227  avctx->bits_per_raw_sample = s->bps;
228 
229  if (!avctx->channel_layout ||
232 
233  s->samples = get_bits64(&gb, 36);
234 
235  skip_bits_long(&gb, 64); /* md5 sum */
236  skip_bits_long(&gb, 64); /* md5 sum */
237 }
238 
239 #if LIBAVCODEC_VERSION_MAJOR < 57
241  const uint8_t *buffer)
242 {
243  ff_flac_parse_streaminfo(avctx, s, buffer);
244 }
245 
247  enum FLACExtradataFormat *format,
248  uint8_t **streaminfo_start)
249 {
250  return ff_flac_is_extradata_valid(avctx, format, streaminfo_start);
251 }
252 #endif
const char const char void * val
Definition: avisynth_c.h:634
#define AV_CH_LAYOUT_7POINT1
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:334
#define AV_CH_LAYOUT_6POINT1
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define AV_CH_LAYOUT_SURROUND
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:217
int64_t frame_or_sample_num
frame number or sample number
Definition: flac.h:88
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
Calculate an estimate for the maximum frame size based on verbatim mode.
Definition: flac.c:148
const uint8_t * buffer
Definition: get_bits.h:55
int avpriv_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Definition: flac.c:246
#define FF_ARRAY_ELEMS(a)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2753
#define AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_5POINT0
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
int ff_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
uint8_t
static const int8_t sample_size_table[]
Definition: flac.c:30
static int64_t get_utf8(GetBitContext *gb)
Definition: flac.c:43
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1366
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
bitstream reader API header.
#define FLAC_MIN_BLOCKSIZE
Definition: flac.h:36
#define av_log(a,...)
#define AV_CH_LAYOUT_5POINT1
FLACExtradataFormat
Definition: flac.h:58
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:357
AVS_FilterInfo ** fi
Definition: avisynth_c.h:594
int ch_mode
channel decorrelation mode
Definition: flac.h:87
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
#define AV_CH_LAYOUT_QUAD
void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Definition: flac.c:240
GLsizei count
Definition: opengl_enc.c:109
int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, FLACFrameInfo *fi, int log_level_offset)
Validate and decode a frame header.
Definition: flac.c:50
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2071
audio channel layout utility functions
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:356
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
const int ff_flac_sample_rate_table[16]
Definition: flacdata.c:24
int sample_rate
samples per second
Definition: avcodec.h:2010
main external API structure.
Definition: avcodec.h:1252
void ff_flac_set_channel_layout(AVCodecContext *avctx)
Definition: flac.c:196
int extradata_size
Definition: avcodec.h:1367
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:204
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
static const uint64_t flac_channel_layouts[8]
Definition: flac.c:32
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:410
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:337
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:342
const int32_t ff_flac_blocksize_table[16]
Definition: flacdata.c:30
unsigned bps
Definition: movenc.c:1334
int channels
number of audio channels
Definition: avcodec.h:2011
int is_var_size
specifies if the stream uses variable block sizes or a fixed block size; also determines the meaning ...
Definition: flac.h:89
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
Definition: common.h:315
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:85
GLuint buffer
Definition: opengl_enc.c:102
#define FLAC_MAX_CHANNELS
Definition: flac.h:35