FFmpeg: libavcodec/flac.c Source File

FFmpeg

[フレーム]

libavcodec

flac.c

Go to the documentation of this file.

1 /*

2 * FLAC common code

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 */

22 #include "libavutil/channel_layout.h"

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"

30 static const int8_t sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 0 };

32 static const uint64_t flac_channel_layouts[8] = {

33 AV_CH_LAYOUT_MONO,

34 AV_CH_LAYOUT_STEREO,

35 AV_CH_LAYOUT_SURROUND,

36 AV_CH_LAYOUT_QUAD,

37 AV_CH_LAYOUT_5POINT0,

38 AV_CH_LAYOUT_5POINT1,

39 AV_CH_LAYOUT_6POINT1,

40 AV_CH_LAYOUT_7POINT1

41 };

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 }

50 int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,

51 FLACFrameInfo *fi, int log_level_offset)

52 {

53 int bs_code, sr_code, bps_code;

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 -1;

59 }

61 /* variable block size stream code */

62 fi->is_var_size = get_bits1(gb);

64 /* block size and sample rate codes */

65 bs_code = get_bits(gb, 4);

66 sr_code = get_bits(gb, 4);

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;

72 fi->ch_mode = FLAC_CHMODE_INDEPENDENT;

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 -1;

80 }

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 -1;

89 }

90 fi->bps = sample_size_table[bps_code];

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 -1;

97 }

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 -1;

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 -1;

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 -1;

134 }

135

136 /* header CRC-8 check */

137 skip_bits(gb, 8);

138 if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,

139 get_bits_count(gb)/8)) {

140 av_log(avctx, AV_LOG_ERROR + log_level_offset,

141 "header crc mismatch\n");

142 return -1;

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

169 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,

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",

181 FLAC_STREAMINFO_SIZE-avctx->extradata_size);

182 }

183 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;

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 }

190 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;

191 *streaminfo_start = &avctx->extradata[8];

192 }

193 return 1;

194 }

195

196 void ff_flac_set_channel_layout(AVCodecContext *avctx)

197 {

198 if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))

199 avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];

200 else

201 avctx->channel_layout = 0;

202 }

203

204 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

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 ff_flac_set_channel_layout(avctx);

229

230 s->samples = get_bits64(&gb, 36);

231

232 skip_bits_long(&gb, 64); /* md5 sum */

233 skip_bits_long(&gb, 64); /* md5 sum */

234 }

235

236 void avpriv_flac_parse_block_header(const uint8_t *block_header,

237 int *last, int *type, int *size)

238 {

239 int tmp = bytestream_get_byte(&block_header);

240 if (last)

241 *last = tmp & 0x80;

242 if (type)

243 *type = tmp & 0x7F;

244 if (size)

245 *size = bytestream_get_be24(&block_header);

246 }

Generated on Wed Jul 10 2013 23:47:58 for FFmpeg by doxygen 1.8.2