FFmpeg
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 
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 
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 {
198  if (channels == avctx->ch_layout.nb_channels &&
200  return;
201 
205  else
207  .nb_channels = channels };
208 }
209 
211  const uint8_t *buffer)
212 {
213  GetBitContext gb;
215 
216  skip_bits(&gb, 16); /* skip min blocksize */
217  s->max_blocksize = get_bits(&gb, 16);
218  if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
219  av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
220  s->max_blocksize);
221  s->max_blocksize = 16;
222  return AVERROR_INVALIDDATA;
223  }
224 
225  skip_bits(&gb, 24); /* skip min frame size */
226  s->max_framesize = get_bits(&gb, 24);
227 
228  s->samplerate = get_bits(&gb, 20);
229  s->channels = get_bits(&gb, 3) + 1;
230  s->bps = get_bits(&gb, 5) + 1;
231 
232  if (s->bps < 4) {
233  av_log(avctx, AV_LOG_ERROR, "invalid bps: %d\n", s->bps);
234  s->bps = 16;
235  return AVERROR_INVALIDDATA;
236  }
237 
238  avctx->sample_rate = s->samplerate;
239  avctx->bits_per_raw_sample = s->bps;
240  ff_flac_set_channel_layout(avctx, s->channels);
241 
242  s->samples = get_bits64(&gb, 36);
243 
244  skip_bits_long(&gb, 64); /* md5 sum */
245  skip_bits_long(&gb, 64); /* md5 sum */
246 
247  return 0;
248 }
sample_size_table
static const int8_t sample_size_table[]
Definition: flac.c:30
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:364
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
AV_CHANNEL_LAYOUT_6POINT1
#define AV_CHANNEL_LAYOUT_6POINT1
Definition: channel_layout.h:370
FLACFrameInfo::frame_or_sample_num
int64_t frame_or_sample_num
frame number or sample number
Definition: flac.h:88
FLACFrameInfo::is_var_size
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
ff_flac_parse_streaminfo
int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, const uint8_t *buffer)
Parse the Streaminfo metadata block.
Definition: flac.c:210
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
ff_flac_decode_frame_header
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
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:354
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:295
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:363
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
ff_flac_set_channel_layout
void ff_flac_set_channel_layout(AVCodecContext *avctx, int channels)
Definition: flac.c:196
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
flac_channel_layouts
static const AVChannelLayout flac_channel_layouts[8]
Definition: flac.c:32
GetBitContext
Definition: get_bits.h:62
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:357
val
static double val(void *priv, double ch)
Definition: aeval.c:77
ff_flac_blocksize_table
const int32_t ff_flac_blocksize_table[16]
Definition: flacdata.c:30
GET_UTF8
#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:469
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
FLACStreaminfo
Definition: flac.h:80
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
s
#define s(width, name)
Definition: cbs_vp9.c:256
ff_flac_get_max_frame_size
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
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
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:106
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1448
channels
channels
Definition: aptx.h:32
get_bits.h
FLACExtradataFormat
FLACExtradataFormat
Definition: flac.h:58
ff_flac_sample_rate_table
const int ff_flac_sample_rate_table[16]
Definition: flacdata.c:24
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:63
FLACFrameInfo::blocksize
FLACCOMMONINFO int blocksize
block size of the frame
Definition: flac.h:86
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:375
FLACFrameInfo
Definition: flac.h:84
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
ff_flac_is_extradata_valid
int ff_flac_is_extradata_valid(AVCodecContext *avctx, enum FLACExtradataFormat *format, uint8_t **streaminfo_start)
Validate the FLAC extradata.
Definition: flac.c:169
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
bps
unsigned bps
Definition: movenc.c:1631
flacdata.h
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
FLAC_EXTRADATA_FORMAT_FULL_HEADER
@ FLAC_EXTRADATA_FORMAT_FULL_HEADER
Definition: flac.h:60
get_utf8
static int64_t get_utf8(GetBitContext *gb)
Definition: flac.c:43
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:573
log.h
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
FLACFrameInfo::ch_mode
int ch_mode
channel decorrelation mode
Definition: flac.h:87
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
AVCodecContext
main external API structure.
Definition: avcodec.h:389
channel_layout.h
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
av_crc
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:392
FLAC_EXTRADATA_FORMAT_STREAMINFO
@ FLAC_EXTRADATA_FORMAT_STREAMINFO
Definition: flac.h:59
FLAC_CHMODE_MID_SIDE
@ FLAC_CHMODE_MID_SIDE
Definition: flac.h:44
FLAC_CHMODE_INDEPENDENT
@ FLAC_CHMODE_INDEPENDENT
Definition: flac.h:41
AV_CRC_8_ATM
@ AV_CRC_8_ATM
Definition: crc.h:49
bytestream.h
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
FLAC_MIN_BLOCKSIZE
#define FLAC_MIN_BLOCKSIZE
Definition: flac.h:36
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:362
flac.h