FFmpeg: libavcodec/vorbis_parser.c Source File

FFmpeg

[フレーム]

libavcodec

vorbis_parser.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 /**

22 * @file

23 * Vorbis audio parser

24 *

25 * Determines the duration for each packet.

26 */

28 #include "get_bits.h"

29 #include "parser.h"

30 #include "xiph.h"

31 #include "vorbis_parser.h"

33 static int parse_id_header(AVCodecContext *avctx, VorbisParseContext *s,

34 const uint8_t *buf, int buf_size)

35 {

36 /* Id header should be 30 bytes */

37 if (buf_size < 30) {

38 av_log(avctx, AV_LOG_ERROR, "Id header is too short\n");

39 return AVERROR_INVALIDDATA;

40 }

42 /* make sure this is the Id header */

43 if (buf[0] != 1) {

44 av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Id header\n");

45 return AVERROR_INVALIDDATA;

46 }

48 /* check for header signature */

49 if (memcmp(&buf[1], "vorbis", 6)) {

50 av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Id header\n");

51 return AVERROR_INVALIDDATA;

52 }

54 if (!(buf[29] & 0x1)) {

55 av_log(avctx, AV_LOG_ERROR, "Invalid framing bit in Id header\n");

56 return AVERROR_INVALIDDATA;

57 }

59 s->blocksize[0] = 1 << (buf[28] & 0xF);

60 s->blocksize[1] = 1 << (buf[28] >> 4);

62 return 0;

63 }

65 static int parse_setup_header(AVCodecContext *avctx, VorbisParseContext *s,

66 const uint8_t *buf, int buf_size)

67 {

68 GetBitContext gb, gb0;

69 uint8_t *rev_buf;

70 int i, ret = 0;

71 int got_framing_bit, mode_count, got_mode_header, last_mode_count = 0;

73 /* avoid overread */

74 if (buf_size < 7) {

75 av_log(avctx, AV_LOG_ERROR, "Setup header is too short\n");

76 return AVERROR_INVALIDDATA;

77 }

79 /* make sure this is the Setup header */

80 if (buf[0] != 5) {

81 av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Setup header\n");

82 return AVERROR_INVALIDDATA;

83 }

85 /* check for header signature */

86 if (memcmp(&buf[1], "vorbis", 6)) {

87 av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Setup header\n");

88 return AVERROR_INVALIDDATA;

89 }

91 /* reverse bytes so we can easily read backwards with get_bits() */

92 if (!(rev_buf = av_malloc(buf_size))) {

93 av_log(avctx, AV_LOG_ERROR, "Out of memory\n");

94 return AVERROR(ENOMEM);

95 }

96 for (i = 0; i < buf_size; i++)

97 rev_buf[i] = buf[buf_size - 1 - i];

98 init_get_bits(&gb, rev_buf, buf_size * 8);

100 got_framing_bit = 0;

101 while (get_bits_left(&gb) > 97) {

102 if (get_bits1(&gb)) {

103 got_framing_bit = get_bits_count(&gb);

104 break;

105 }

106 }

107 if (!got_framing_bit) {

108 av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n");

109 ret = AVERROR_INVALIDDATA;

110 goto bad_header;

111 }

112

113 /* Now we search backwards to find possible valid mode counts. This is not

114 * fool-proof because we could have false positive matches and read too

115 * far, but there isn't really any way to be sure without parsing through

116 * all the many variable-sized fields before the modes. This approach seems

117 * to work well in testing, and it is similar to how it is handled in

118 * liboggz. */

119 mode_count = 0;

120 got_mode_header = 0;

121 while (get_bits_left(&gb) >= 97) {

122 if (get_bits(&gb, 8) > 63 || get_bits(&gb, 16) || get_bits(&gb, 16))

123 break;

124 skip_bits(&gb, 1);

125 mode_count++;

126 if (mode_count > 64)

127 break;

128 gb0 = gb;

129 if (get_bits(&gb0, 6) + 1 == mode_count) {

130 got_mode_header = 1;

131 last_mode_count = mode_count;

132 }

133 }

134 if (!got_mode_header) {

135 av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n");

136 ret = AVERROR_INVALIDDATA;

137 goto bad_header;

138 }

139 /* All samples I've seen use <= 2 modes, so ask for a sample if we find

140 * more than that, as it is most likely a false positive. If we get any

141 * we may need to approach this the long way and parse the whole Setup

142 * header, but I hope very much that it never comes to that. */

143 if (last_mode_count > 2) {

144 avpriv_request_sample(avctx,

145 "%d modes (either a false positive or a "

146 "sample from an unknown encoder)",

147 last_mode_count);

148 }

149 /* We're limiting the mode count to 63 so that we know that the previous

150 * block flag will be in the first packet byte. */

151 if (last_mode_count > 63) {

152 av_log(avctx, AV_LOG_ERROR, "Unsupported mode count: %d\n",

153 last_mode_count);

154 ret = AVERROR_INVALIDDATA;

155 goto bad_header;

156 }

157 s->mode_count = mode_count = last_mode_count;

158 /* Determine the number of bits required to code the mode and turn that

159 * into a bitmask to directly access the mode from the first frame byte. */

160 s->mode_mask = ((1 << (av_log2(mode_count - 1) + 1)) - 1) << 1;

161 /* The previous window flag is the next bit after the mode */

162 s->prev_mask = (s->mode_mask | 0x1) + 1;

163

164 init_get_bits(&gb, rev_buf, buf_size * 8);

165 skip_bits_long(&gb, got_framing_bit);

166 for (i = mode_count - 1; i >= 0; i--) {

167 skip_bits_long(&gb, 40);

168 s->mode_blocksize[i] = get_bits1(&gb);

169 }

170

171 bad_header:

172 av_free(rev_buf);

173 return ret;

174 }

175

176 int avpriv_vorbis_parse_extradata(AVCodecContext *avctx, VorbisParseContext *s)

177 {

178 uint8_t *header_start[3];

179 int header_len[3];

180 int ret;

181

182 s->avctx = avctx;

183 s->extradata_parsed = 1;

184

185 if ((ret = avpriv_split_xiph_headers(avctx->extradata,

186 avctx->extradata_size, 30,

187 header_start, header_len)) < 0) {

188 av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");

189 return ret;

190 }

191

192 if ((ret = parse_id_header(avctx, s, header_start[0], header_len[0])) < 0)

193 return ret;

194

195 if ((ret = parse_setup_header(avctx, s, header_start[2], header_len[2])) < 0)

196 return ret;

197

198 s->valid_extradata = 1;

199 s->previous_blocksize = s->blocksize[s->mode_blocksize[0]];

200

201 return 0;

202 }

203

204 int avpriv_vorbis_parse_frame(VorbisParseContext *s, const uint8_t *buf,

205 int buf_size)

206 {

207 int duration = 0;

208

209 if (s->valid_extradata && buf_size > 0) {

210 int mode, current_blocksize;

211 int previous_blocksize = s->previous_blocksize;

212

213 if (buf[0] & 1) {

214 av_log(s->avctx, AV_LOG_ERROR, "Invalid packet\n");

215 return AVERROR_INVALIDDATA;

216 }

217 if (s->mode_count == 1)

218 mode = 0;

219 else

220 mode = (buf[0] & s->mode_mask) >> 1;

221 if (mode >= s->mode_count) {

222 av_log(s->avctx, AV_LOG_ERROR, "Invalid mode in packet\n");

223 return AVERROR_INVALIDDATA;

224 }

225 if(s->mode_blocksize[mode]){

226 int flag = !!(buf[0] & s->prev_mask);

227 previous_blocksize = s->blocksize[flag];

228 }

229 current_blocksize = s->blocksize[s->mode_blocksize[mode]];

230 duration = (previous_blocksize + current_blocksize) >> 2;

231 s->previous_blocksize = current_blocksize;

232 }

233

234 return duration;

235 }

236

237 void avpriv_vorbis_parse_reset(VorbisParseContext *s)

238 {

239 if (s->valid_extradata)

240 s->previous_blocksize = s->blocksize[0];

241 }

242

243 #if CONFIG_VORBIS_PARSER

244 static int vorbis_parse(AVCodecParserContext *s1, AVCodecContext *avctx,

245 const uint8_t **poutbuf, int *poutbuf_size,

246 const uint8_t *buf, int buf_size)

247 {

248 VorbisParseContext *s = s1->priv_data;

249 int duration;

250

251 if (!s->extradata_parsed && avctx->extradata && avctx->extradata_size)

252 if (avpriv_vorbis_parse_extradata(avctx, s))

253 goto end;

254

255 if ((duration = avpriv_vorbis_parse_frame(s, buf, buf_size)) >= 0)

256 s1->duration = duration;

257

258 end:

259 /* always return the full packet. this parser isn't doing any splitting or

260 combining, only packet analysis */

261 *poutbuf = buf;

262 *poutbuf_size = buf_size;

263 return buf_size;

264 }

265

266 AVCodecParser ff_vorbis_parser = {

267 .codec_ids = { AV_CODEC_ID_VORBIS },

268 .priv_data_size = sizeof(VorbisParseContext),

269 .parser_parse = vorbis_parse,

270 };

271 #endif /* CONFIG_VORBIS_PARSER */

Generated on Sat Jan 25 2014 19:51:56 for FFmpeg by doxygen 1.8.2