Mercurial > libavcodec.hg
comparison flac.c @ 1812:6d762acfff5d libavcodec
flac fixes:
fix data types of residual&decoded
fix twos complement bitfields
fix utf8 (no, utf8 is not the same as the simple and compact uvlc used in nut)
add truncated bitstream support, both ogg and flac demuxers in mplayer cvs provide incomplete frames, and furthermore it isnt possible to find frameboundaries in flac without decoding it completly
add escape-less golomb rice decoder (=flac style golomb rice) (ultra efficient, the longest vlc code is just 2^32-1 bits)
printf->av_log
fix bps for non independant channels
fix a few +-1 bugs
fix sample order for independant channels
fix data_size
author | michael |
---|---|
date | Wed, 18 Feb 2004 01:49:30 +0000 |
parents | 98d4d32b90e8 |
children | ec0e71b1fc3a |
comparison
equal
deleted
inserted
replaced
1811:98d4d32b90e8 | 1812:6d762acfff5d |
---|---|
21 * @file flac.c | 21 * @file flac.c |
22 * FLAC (Free Lossless Audio Codec) decoder | 22 * FLAC (Free Lossless Audio Codec) decoder |
23 * @author Alex Beregszaszi | 23 * @author Alex Beregszaszi |
24 */ | 24 */ |
25 | 25 |
26 #include <limits.h> | |
27 | |
26 #include "avcodec.h" | 28 #include "avcodec.h" |
27 #include "golomb.h" | 29 #include "golomb.h" |
30 | |
31 #undef NDEBUG | |
32 #include <assert.h> | |
28 | 33 |
29 #define MAX_CHANNELS 8 | 34 #define MAX_CHANNELS 8 |
30 #define MAX_BLOCKSIZE 65535 | 35 #define MAX_BLOCKSIZE 65535 |
31 | 36 |
32 enum channel_order { | 37 enum channel_order { |
41 GetBitContext gb; | 46 GetBitContext gb; |
42 | 47 |
43 int min_blocksize, max_blocksize; | 48 int min_blocksize, max_blocksize; |
44 int min_framesize, max_framesize; | 49 int min_framesize, max_framesize; |
45 int samplerate, channels; | 50 int samplerate, channels; |
46 int blocksize, last_blocksize; | 51 int blocksize/*, last_blocksize*/; |
47 int bps, curr_bps; | 52 int bps, curr_bps; |
48 enum channel_order order; | 53 enum channel_order order; |
49 | 54 |
50 uint8_t *residual[MAX_CHANNELS]; | 55 int32_t *residual[MAX_CHANNELS]; |
51 uint32_t *decoded[MAX_CHANNELS]; | 56 int32_t *decoded[MAX_CHANNELS]; |
57 uint8_t *bitstream; | |
58 int bitstream_size; | |
59 int bitstream_index; | |
60 int allocated_bitstream_size; | |
52 } FLACContext; | 61 } FLACContext; |
53 | 62 |
54 #define METADATA_TYPE_STREAMINFO 0 | 63 #define METADATA_TYPE_STREAMINFO 0 |
55 | 64 |
56 static int sample_rate_table[] = | 65 static int sample_rate_table[] = |
59 0, 0, 0, 0 }; | 68 0, 0, 0, 0 }; |
60 | 69 |
61 static int sample_size_table[] = | 70 static int sample_size_table[] = |
62 { 0, 8, 12, 0, 16, 20, 24, 0 }; | 71 { 0, 8, 12, 0, 16, 20, 24, 0 }; |
63 | 72 |
64 static uint64_t get_uvlc(GetBitContext *gb, int is64) | 73 static int64_t get_utf8(GetBitContext *gb) |
65 { | 74 { |
66 uint64_t val = 0; | 75 uint64_t val; |
67 int i = 0; | 76 int ones=0, bytes; |
68 | 77 |
69 while(i++ < 5+is64) | 78 while(get_bits1(gb)) |
70 { | 79 ones++; |
80 | |
81 if (ones==0) bytes=0; | |
82 else if(ones==1) return -1; | |
83 else bytes= ones - 1; | |
84 | |
85 val= get_bits(gb, 7-ones); | |
86 while(bytes--){ | |
71 const int tmp = get_bits(gb, 8); | 87 const int tmp = get_bits(gb, 8); |
72 | 88 |
73 if (tmp & 0x80) | 89 if((tmp>>6) != 2) |
74 val = (val << 7) + tmp - 0x80; | 90 return -1; |
75 else | 91 val<<=6; |
76 return (val << 7) + tmp; | 92 val|= tmp&0x3F; |
77 } | 93 } |
78 return -1; | 94 return val; |
79 } | 95 } |
80 | 96 |
81 static int flac_decode_init(AVCodecContext * avctx) | 97 static int flac_decode_init(AVCodecContext * avctx) |
82 { | 98 { |
83 return 0; | 99 return 0; |
84 } | 100 } |
85 | 101 |
86 static void dump_headers(FLACContext *s) | 102 static void dump_headers(FLACContext *s) |
87 { | 103 { |
88 printf(" Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize); | 104 av_log(s->avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize); |
89 printf(" Framesize: %d .. %d\n", s->min_framesize, s->max_framesize); | 105 av_log(s->avctx, AV_LOG_DEBUG, " Framesize: %d .. %d\n", s->min_framesize, s->max_framesize); |
90 printf(" Samplerate: %d\n", s->samplerate); | 106 av_log(s->avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); |
91 printf(" Channels: %d\n", s->channels); | 107 av_log(s->avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); |
92 printf(" Bits: %d\n", s->bps); | 108 av_log(s->avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); |
109 } | |
110 | |
111 static void allocate_buffers(FLACContext *s){ | |
112 int i; | |
113 | |
114 assert(s->max_blocksize); | |
115 | |
116 if(s->max_framesize == 0 && s->max_blocksize){ | |
117 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead | |
118 } | |
119 | |
120 for (i = 0; i < s->channels; i++) | |
121 { | |
122 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize); | |
123 s->residual[i] = av_realloc(s->residual[i], sizeof(int32_t)*s->max_blocksize); | |
124 } | |
125 | |
126 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); | |
127 // s->bitstream= av_realloc(s->bitstream, s->max_framesize); | |
93 } | 128 } |
94 | 129 |
95 static void metadata_streaminfo(FLACContext *s) | 130 static void metadata_streaminfo(FLACContext *s) |
96 { | 131 { |
97 int i; | |
98 | |
99 /* mandatory streaminfo */ | 132 /* mandatory streaminfo */ |
100 s->min_blocksize = get_bits(&s->gb, 16); | 133 s->min_blocksize = get_bits(&s->gb, 16); |
101 s->max_blocksize = get_bits(&s->gb, 16); | 134 s->max_blocksize = get_bits(&s->gb, 16); |
102 | 135 |
103 s->min_framesize = get_bits_long(&s->gb, 24); | 136 s->min_framesize = get_bits_long(&s->gb, 24); |
112 | 145 |
113 skip_bits(&s->gb, 36); /* total num of samples */ | 146 skip_bits(&s->gb, 36); /* total num of samples */ |
114 | 147 |
115 skip_bits(&s->gb, 64); /* md5 sum */ | 148 skip_bits(&s->gb, 64); /* md5 sum */ |
116 skip_bits(&s->gb, 64); /* md5 sum */ | 149 skip_bits(&s->gb, 64); /* md5 sum */ |
117 | 150 |
118 for (i = 0; i < s->channels; i++) | 151 allocate_buffers(s); |
119 { | |
120 s->decoded[i] = av_realloc(s->decoded[i], sizeof(uint32_t)*s->max_blocksize); | |
121 s->residual[i] = av_realloc(s->residual[i], sizeof(uint8_t)*s->max_blocksize); | |
122 } | |
123 } | 152 } |
124 | 153 |
125 static int decode_residuals(FLACContext *s, int channel, int pred_order) | 154 static int decode_residuals(FLACContext *s, int channel, int pred_order) |
126 { | 155 { |
127 int i, tmp, partition, method_type, rice_order; | 156 int i, tmp, partition, method_type, rice_order; |
128 int sample = 0, samples; | 157 int sample = 0, samples; |
129 | 158 |
130 method_type = get_bits(&s->gb, 2); | 159 method_type = get_bits(&s->gb, 2); |
131 if (method_type != 0) | 160 if (method_type != 0){ |
132 return -1; | 161 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type); |
162 return -1; | |
163 } | |
133 | 164 |
134 rice_order = get_bits(&s->gb, 4); | 165 rice_order = get_bits(&s->gb, 4); |
135 | 166 |
136 samples = (rice_order > 0) ? | 167 samples= s->blocksize >> rice_order; |
137 (s->blocksize >> rice_order) : (s->blocksize - pred_order); | 168 |
138 | 169 sample= |
170 i= pred_order; | |
139 for (partition = 0; partition < (1 << rice_order); partition++) | 171 for (partition = 0; partition < (1 << rice_order); partition++) |
140 { | 172 { |
141 tmp = get_bits(&s->gb, 4); | 173 tmp = get_bits(&s->gb, 4); |
142 if (tmp == 0) | 174 if (tmp == 15) |
143 { | 175 { |
144 i = (!rice_order || partition) ? 0 : pred_order; | 176 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n"); |
177 tmp = get_bits(&s->gb, 5); | |
145 for (; i < samples; i++, sample++) | 178 for (; i < samples; i++, sample++) |
146 s->residual[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, 0, 0); | 179 s->residual[channel][sample] = get_sbits(&s->gb, tmp); |
147 printf("zero k\n"); | |
148 } | |
149 else if (tmp == 15) | |
150 { | |
151 printf("fixed len partition\n"); | |
152 tmp = get_bits(&s->gb, 5); | |
153 i = (!rice_order || partition) ? 0 : pred_order; | |
154 for (; i < samples; i++, sample++) | |
155 s->residual[channel][sample] = get_bits(&s->gb, tmp); | |
156 } | 180 } |
157 else | 181 else |
158 { | 182 { |
159 // printf("rice coded partition\n"); | 183 // av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp); |
160 #if 1 | 184 for (; i < samples; i++, sample++){ |
161 i = (!rice_order || partition) ? 0 : pred_order; | 185 s->residual[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); |
162 for (; i < samples; i++, sample++) | 186 if(get_bits_count(&s->gb) > s->gb.size_in_bits){ |
163 s->residual[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, 0, 0); | 187 av_log(s->avctx, AV_LOG_ERROR, "fucking FLAC\n"); |
164 #else | 188 return -1; |
165 i = ((!rice_order || partition) ? samples : samples - pred_order) + sample; | 189 } |
166 for (; sample < i; sample++) | 190 } |
167 s->residual[channel][sample] = get_ur_golomb(&s->gb, tmp, 0, 0); | |
168 // s->residual[channel][sample] = get_se_golomb(&s->gb); | |
169 #endif | |
170 } | 191 } |
171 } | 192 i= 0; |
172 | 193 } |
173 printf("partitions: %d, samples: %d\n", 1 << rice_order, sample); | 194 |
195 // av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample); | |
174 | 196 |
175 return 0; | 197 return 0; |
176 } | 198 } |
177 | 199 |
178 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) | 200 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) |
179 { | 201 { |
180 int i; | 202 int i; |
181 | 203 |
182 printf(" SUBFRAME FIXED\n"); | 204 av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n"); |
183 | 205 |
184 /* warm up samples */ | 206 /* warm up samples */ |
185 printf(" warm up samples: %d\n", pred_order); | 207 av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order); |
186 | 208 |
187 for (i = 0; i < pred_order; i++) | 209 for (i = 0; i < pred_order; i++) |
188 { | 210 { |
189 s->decoded[channel][i] = get_bits(&s->gb, s->curr_bps); | 211 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); |
190 printf(" %d: %d\n", i, s->decoded[channel][i]); | 212 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]); |
191 } | 213 } |
192 | 214 |
193 if (decode_residuals(s, channel, pred_order) < 0) | 215 if (decode_residuals(s, channel, pred_order) < 0) |
194 return -1; | 216 return -1; |
195 | 217 |
211 s->decoded[channel][i-2]; | 233 s->decoded[channel][i-2]; |
212 break; | 234 break; |
213 case 3: | 235 case 3: |
214 for (i = pred_order; i < s->blocksize; i++) | 236 for (i = pred_order; i < s->blocksize; i++) |
215 s->decoded[channel][i] = s->residual[channel][i] + | 237 s->decoded[channel][i] = s->residual[channel][i] + |
216 (((s->decoded[channel][i-1] - | 238 3*(s->decoded[channel][i-1] - s->decoded[channel][i-2]) |
217 s->decoded[channel][i-2]) << 1) + | 239 + s->decoded[channel][i-3]; |
218 (s->decoded[channel][i-1] - | |
219 s->decoded[channel][i-2])) + | |
220 s->decoded[channel][i-3]; | |
221 break; | 240 break; |
222 case 4: | 241 case 4: |
223 for (i = pred_order; i < s->blocksize; i++) | 242 for (i = pred_order; i < s->blocksize; i++) |
224 s->decoded[channel][i] = s->residual[channel][i] + | 243 s->decoded[channel][i] = s->residual[channel][i] + |
225 ((s->decoded[channel][i-1] + | 244 ((s->decoded[channel][i-1] + |
226 s->decoded[channel][i-3]) << 2) - | 245 s->decoded[channel][i-3]) << 2) - |
227 ((s->decoded[channel][i-2] << 2) + | 246 ((s->decoded[channel][i-2] << 2) + |
228 (s->decoded[channel][i-2] << 1)) - | 247 (s->decoded[channel][i-2] << 1)) - |
229 s->decoded[channel][i-4]; | 248 s->decoded[channel][i-4]; |
230 break; | 249 break; |
231 } | 250 default: |
232 | 251 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); |
252 return -1; | |
253 } | |
254 | |
233 return 0; | 255 return 0; |
234 } | 256 } |
235 | 257 |
236 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) | 258 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) |
237 { | 259 { |
238 int sum, i, j; | 260 int sum, i, j; |
239 int coeff_prec, qlevel; | 261 int coeff_prec, qlevel; |
240 int coeffs[pred_order]; | 262 int coeffs[pred_order]; |
241 | 263 |
242 printf(" SUBFRAME LPC\n"); | 264 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n"); |
243 | 265 |
244 /* warm up samples */ | 266 /* warm up samples */ |
245 printf(" warm up samples: %d\n", pred_order); | 267 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order); |
246 | 268 |
247 for (i = 0; i < pred_order; i++) | 269 for (i = 0; i < pred_order; i++) |
248 { | 270 { |
249 s->decoded[channel][i] = get_bits(&s->gb, s->curr_bps); | 271 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); |
250 printf(" %d: %d\n", i, s->decoded[channel][i]); | 272 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]); |
251 } | 273 } |
252 | 274 |
253 coeff_prec = get_bits(&s->gb, 4) + 1; | 275 coeff_prec = get_bits(&s->gb, 4) + 1; |
254 if (coeff_prec == 16) | 276 if (coeff_prec == 16) |
255 { | 277 { |
256 printf("invalid coeff precision\n"); | 278 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n"); |
257 return -1; | 279 return -1; |
258 } | 280 } |
259 printf(" qlp coeff prec: %d\n", coeff_prec); | 281 av_log(s->avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec); |
260 qlevel = get_bits(&s->gb, 5); | 282 qlevel = get_sbits(&s->gb, 5); |
261 printf(" quant level: %d\n", qlevel); | 283 av_log(s->avctx, AV_LOG_DEBUG, " quant level: %d\n", qlevel); |
262 | 284 assert(qlevel >= 0); //FIXME |
263 for (i = 0; i < pred_order; i++) | 285 for (i = 0; i < pred_order; i++) |
264 { | 286 { |
265 coeffs[i] = get_bits(&s->gb, coeff_prec); | 287 coeffs[i] = get_sbits(&s->gb, coeff_prec); |
266 printf(" %d: %d\n", i, coeffs[i]); | 288 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]); |
267 } | 289 } |
268 | 290 |
269 if (decode_residuals(s, channel, pred_order) < 0) | 291 if (decode_residuals(s, channel, pred_order) < 0) |
270 return -1; | 292 return -1; |
271 | 293 |
284 { | 306 { |
285 int type, wasted = 0; | 307 int type, wasted = 0; |
286 int i, tmp; | 308 int i, tmp; |
287 | 309 |
288 s->curr_bps = s->bps; | 310 s->curr_bps = s->bps; |
289 | 311 if(channel == 0){ |
312 if(s->order == RIGHT_SIDE) | |
313 s->curr_bps++; | |
314 }else{ | |
315 if(s->order == LEFT_SIDE || s->order == MID_SIDE) | |
316 s->curr_bps++; | |
317 } | |
318 | |
290 if (get_bits1(&s->gb)) | 319 if (get_bits1(&s->gb)) |
291 { | 320 { |
292 printf("invalid subframe padding\n"); | 321 av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n"); |
293 return -1; | 322 return -1; |
294 } | 323 } |
295 type = get_bits(&s->gb, 6); | 324 type = get_bits(&s->gb, 6); |
296 // wasted = get_bits1(&s->gb); | 325 // wasted = get_bits1(&s->gb); |
297 | 326 |
301 // wasted++; | 330 // wasted++; |
302 // if (wasted) | 331 // if (wasted) |
303 // wasted++; | 332 // wasted++; |
304 // s->curr_bps -= wasted; | 333 // s->curr_bps -= wasted; |
305 // } | 334 // } |
306 | 335 #if 0 |
336 wasted= 16 - av_log2(show_bits(&s->gb, 17)); | |
337 skip_bits(&s->gb, wasted+1); | |
338 s->curr_bps -= wasted; | |
339 #else | |
307 if (get_bits1(&s->gb)) | 340 if (get_bits1(&s->gb)) |
308 { | 341 { |
309 wasted = 1; | 342 wasted = 1; |
310 while (!get_bits1(&s->gb)) | 343 while (!get_bits1(&s->gb)) |
311 wasted++; | 344 wasted++; |
312 s->curr_bps -= wasted; | 345 s->curr_bps -= wasted; |
313 } | 346 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted); |
314 | 347 } |
348 #endif | |
349 //FIXME use av_log2 for types | |
315 if (type == 0) | 350 if (type == 0) |
316 { | 351 { |
317 printf("coding type: constant\n"); | 352 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n"); |
318 tmp = get_bits(&s->gb, s->curr_bps); | 353 tmp = get_sbits(&s->gb, s->curr_bps); |
319 for (i = 0; i < s->blocksize; i++) | 354 for (i = 0; i < s->blocksize; i++) |
320 s->decoded[channel][i] = tmp; | 355 s->decoded[channel][i] = tmp; |
321 } | 356 } |
322 else if (type == 1) | 357 else if (type == 1) |
323 { | 358 { |
324 printf("coding type: verbatim\n"); | 359 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n"); |
325 for (i = 0; i < s->blocksize; i++) | 360 for (i = 0; i < s->blocksize; i++) |
326 s->decoded[channel][i] = get_bits(&s->gb, s->curr_bps); | 361 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); |
327 } | 362 } |
328 else if ((type >= 8) && (type <= 12)) | 363 else if ((type >= 8) && (type <= 12)) |
329 { | 364 { |
330 printf("coding type: fixed\n"); | 365 av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n"); |
331 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) | 366 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) |
332 return -1; | 367 return -1; |
333 } | 368 } |
334 else if (type >= 32) | 369 else if (type >= 32) |
335 { | 370 { |
336 printf("coding type: lpc\n"); | 371 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n"); |
337 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) | 372 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) |
338 return -1; | 373 return -1; |
339 } | 374 } |
340 else | 375 else |
341 { | 376 { |
342 printf("invalid coding type\n"); | 377 av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n"); |
343 return -1; | 378 return -1; |
344 } | 379 } |
345 | 380 |
346 if (wasted) | 381 if (wasted) |
347 { | 382 { |
356 static int decode_frame(FLACContext *s) | 391 static int decode_frame(FLACContext *s) |
357 { | 392 { |
358 int blocksize_code, sample_rate_code, sample_size_code, assignment, i; | 393 int blocksize_code, sample_rate_code, sample_size_code, assignment, i; |
359 | 394 |
360 blocksize_code = get_bits(&s->gb, 4); | 395 blocksize_code = get_bits(&s->gb, 4); |
396 | |
397 sample_rate_code = get_bits(&s->gb, 4); | |
398 | |
399 assignment = get_bits(&s->gb, 4); /* channel assignment */ | |
400 if (assignment < 8) | |
401 { | |
402 s->order = INDEPENDENT; | |
403 if (s->channels != assignment+1) | |
404 av_log(s->avctx, AV_LOG_DEBUG, "channel number and number of assigned channels differ!\n"); | |
405 av_log(s->avctx, AV_LOG_DEBUG, "channels: %d\n", assignment+1); | |
406 } | |
407 else if (assignment == 8) | |
408 { | |
409 s->order = LEFT_SIDE; | |
410 av_log(s->avctx, AV_LOG_DEBUG, "left/side\n"); | |
411 } | |
412 else if (assignment == 9) | |
413 { | |
414 s->order = RIGHT_SIDE; | |
415 av_log(s->avctx, AV_LOG_DEBUG, "right/side\n"); | |
416 } | |
417 else if (assignment == 10) | |
418 { | |
419 s->order = MID_SIDE; | |
420 av_log(s->avctx, AV_LOG_DEBUG, "mid/side\n"); | |
421 } | |
422 else | |
423 { | |
424 av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment\n"); | |
425 return -1; | |
426 } | |
427 | |
428 if ((assignment >= 8) && (s->channels != 2)) | |
429 { | |
430 return -1; | |
431 } | |
432 | |
433 sample_size_code = get_bits(&s->gb, 3); | |
434 if (sample_size_code != 0) | |
435 s->bps = sample_size_table[sample_size_code]; | |
436 | |
437 if ((sample_size_code == 3) || (sample_size_code == 7)) | |
438 { | |
439 av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code); | |
440 return -1; | |
441 } | |
442 | |
443 if (get_bits1(&s->gb)) | |
444 { | |
445 av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n"); | |
446 // return -1; | |
447 } | |
448 | |
449 if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/ | |
450 (s->min_blocksize != s->max_blocksize)){ | |
451 if(get_utf8(&s->gb) < 0){ | |
452 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n"); | |
453 return -1; | |
454 } | |
455 }else{ | |
456 if(get_utf8(&s->gb) < 0){ | |
457 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n"); | |
458 return -1; | |
459 } | |
460 } | |
461 | |
361 if (blocksize_code == 0) | 462 if (blocksize_code == 0) |
362 s->blocksize = s->min_blocksize; | 463 s->blocksize = s->min_blocksize; |
363 else if (blocksize_code == 1) | 464 else if (blocksize_code == 1) |
364 s->blocksize = 192; | 465 s->blocksize = 192; |
365 else if (blocksize_code <= 5) | 466 else if (blocksize_code <= 5) |
366 s->blocksize = 576 << (blocksize_code - 2); | 467 s->blocksize = 576 << (blocksize_code - 2); |
468 else if (blocksize_code == 6) | |
469 s->blocksize = get_bits(&s->gb, 8)+1; | |
470 else if (blocksize_code == 7) | |
471 s->blocksize = get_bits(&s->gb, 16)+1; | |
367 else if (blocksize_code >= 8) | 472 else if (blocksize_code >= 8) |
368 s->blocksize = 256 << (blocksize_code - 8); | 473 s->blocksize = 256 << (blocksize_code - 8); |
369 | 474 |
370 sample_rate_code = get_bits(&s->gb, 4); | 475 if(s->blocksize > s->max_blocksize){ |
371 if ((sample_rate_code > 3) && (sample_rate_code < 12)) | 476 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", s->blocksize, s->max_blocksize); |
477 return -1; | |
478 } | |
479 | |
480 if (sample_rate_code == 0){ | |
481 //Streaminfo | |
482 }else if ((sample_rate_code > 3) && (sample_rate_code < 12)) | |
372 s->samplerate = sample_rate_table[sample_rate_code]; | 483 s->samplerate = sample_rate_table[sample_rate_code]; |
373 | 484 else if (sample_rate_code == 12) |
374 assignment = get_bits(&s->gb, 4); /* channel assignment */ | |
375 if (assignment < 8) | |
376 { | |
377 s->order = INDEPENDENT; | |
378 if (s->channels != assignment+1) | |
379 printf("channel number and number of assigned channels differ!\n"); | |
380 printf("channels: %d\n", assignment+1); | |
381 } | |
382 else if (assignment == 8) | |
383 { | |
384 s->order = LEFT_SIDE; | |
385 printf("left/side\n"); | |
386 } | |
387 else if (assignment == 9) | |
388 { | |
389 s->order = RIGHT_SIDE; | |
390 printf("right/side\n"); | |
391 } | |
392 else if (assignment == 10) | |
393 { | |
394 s->order = MID_SIDE; | |
395 printf("mid/side\n"); | |
396 } | |
397 else | |
398 { | |
399 printf("unsupported channel assignment\n"); | |
400 return -1; | |
401 } | |
402 | |
403 if ((assignment >= 8) && (s->channels != 2)) | |
404 { | |
405 return -1; | |
406 } | |
407 | |
408 sample_size_code = get_bits(&s->gb, 3); | |
409 if (s->bps != 0) | |
410 s->bps = sample_size_table[sample_size_code]; | |
411 | |
412 if ((sample_size_code == 3) || (sample_size_code == 7)) | |
413 { | |
414 printf("invalid sample size code (%d)\n", sample_size_code); | |
415 return -1; | |
416 } | |
417 | |
418 if (get_bits1(&s->gb)) | |
419 { | |
420 printf("broken stream, invalid padding\n"); | |
421 // return -1; | |
422 } | |
423 | |
424 if (((blocksize_code == 6) || (blocksize_code == 7)) && | |
425 (s->min_blocksize != s->max_blocksize)) | |
426 { | |
427 get_uvlc(&s->gb, 1); | |
428 } | |
429 else | |
430 get_uvlc(&s->gb, 0); | |
431 | |
432 if (blocksize_code == 6) | |
433 s->blocksize = get_bits(&s->gb, 8)+1; | |
434 if (blocksize_code == 7) | |
435 s->blocksize = get_bits(&s->gb, 16)+1; | |
436 | |
437 if ((sample_rate_code > 11) && (sample_rate_code < 15)) | |
438 { | |
439 switch(sample_rate_code) | |
440 { | |
441 case 12: | |
442 s->samplerate = get_bits(&s->gb, 8) * 1000; | 485 s->samplerate = get_bits(&s->gb, 8) * 1000; |
443 break; | 486 else if (sample_rate_code == 13) |
444 case 13: | |
445 s->samplerate = get_bits(&s->gb, 16); | 487 s->samplerate = get_bits(&s->gb, 16); |
446 break; | 488 else if (sample_rate_code == 14) |
447 case 14: | |
448 s->samplerate = get_bits(&s->gb, 16) * 10; | 489 s->samplerate = get_bits(&s->gb, 16) * 10; |
449 break; | 490 else{ |
450 } | 491 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code); |
492 return -1; | |
451 } | 493 } |
452 | 494 |
453 skip_bits(&s->gb, 8); /* header crc */ | 495 skip_bits(&s->gb, 8); /* header crc */ |
454 | 496 |
455 dump_headers(s); | 497 // dump_headers(s); |
456 | 498 |
457 /* subframes */ | 499 /* subframes */ |
458 for (i = 0; i < s->channels; i++) | 500 for (i = 0; i < s->channels; i++) |
459 { | 501 { |
460 if (s->blocksize != s->last_blocksize) | 502 /* if (s->blocksize != s->last_blocksize) |
461 { | 503 { |
462 s->decoded[i] = av_realloc(s->decoded[i], sizeof(uint32_t)*s->blocksize); | 504 s->decoded[i] = av_realloc(s->decoded[i], sizeof(uint32_t)*s->blocksize); |
463 s->residual[i] = av_realloc(s->residual[i], sizeof(uint8_t)*s->blocksize); | 505 s->residual[i] = av_realloc(s->residual[i], sizeof(uint8_t)*s->blocksize); |
464 } | 506 }*/ |
465 printf("decoded: %x residual: %x\n", s->decoded[i], s->residual[i]); | 507 // av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]); |
466 if (decode_subframe(s, i) < 0) | 508 if (decode_subframe(s, i) < 0) |
467 return -1; | 509 return -1; |
468 } | 510 } |
469 | 511 |
470 align_get_bits(&s->gb); | 512 align_get_bits(&s->gb); |
478 static int flac_decode_frame(AVCodecContext *avctx, | 520 static int flac_decode_frame(AVCodecContext *avctx, |
479 void *data, int *data_size, | 521 void *data, int *data_size, |
480 uint8_t *buf, int buf_size) | 522 uint8_t *buf, int buf_size) |
481 { | 523 { |
482 FLACContext *s = avctx->priv_data; | 524 FLACContext *s = avctx->priv_data; |
483 int metadata_flag, metadata_type, metadata_size; | 525 int metadata_last, metadata_type, metadata_size; |
484 int tmp = 0, i, j = 0; | 526 int tmp = 0, i, j = 0, input_buf_size; |
485 int16_t *samples = data, *left, *right; | 527 int16_t *samples = data, *left, *right; |
486 | 528 |
487 *data_size = 0; | 529 *data_size = 0; |
488 | 530 |
489 s->avctx = avctx; | 531 s->avctx = avctx; |
532 | |
533 if(s->max_framesize == 0){ | |
534 s->max_framesize= 8192; // should hopefully be enough for the first header | |
535 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); | |
536 } | |
537 | |
538 if(1 && s->max_framesize){//FIXME truncated | |
539 buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size); | |
540 input_buf_size= buf_size; | |
541 | |
542 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){ | |
543 // printf("memmove\n"); | |
544 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size); | |
545 s->bitstream_index=0; | |
546 } | |
547 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size); | |
548 buf= &s->bitstream[s->bitstream_index]; | |
549 buf_size += s->bitstream_size; | |
550 s->bitstream_size= buf_size; | |
551 | |
552 if(buf_size < s->max_framesize){ | |
553 // printf("wanna more data ...\n"); | |
554 return input_buf_size; | |
555 } | |
556 } | |
490 | 557 |
491 init_get_bits(&s->gb, buf, buf_size*8); | 558 init_get_bits(&s->gb, buf, buf_size*8); |
492 | 559 |
493 /* fLaC signature (be) */ | 560 /* fLaC signature (be) */ |
494 if (get_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC"))) | 561 if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC"))) |
495 { | 562 { |
496 printf("STREAM HEADER\n"); | 563 skip_bits(&s->gb, 32); |
564 | |
565 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n"); | |
497 do { | 566 do { |
498 metadata_flag = get_bits(&s->gb, 1); | 567 metadata_last = get_bits(&s->gb, 1); |
499 metadata_type = get_bits(&s->gb, 7); | 568 metadata_type = get_bits(&s->gb, 7); |
500 metadata_size = get_bits_long(&s->gb, 24); | 569 metadata_size = get_bits_long(&s->gb, 24); |
501 | 570 |
502 printf(" metadata block: flag = %d, type = %d, size = %d\n", | 571 av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n", |
503 metadata_flag, metadata_type, | 572 metadata_last, metadata_type, |
504 metadata_size); | 573 metadata_size); |
505 | 574 if(metadata_size){ |
506 switch(metadata_type) | 575 switch(metadata_type) |
507 { | 576 { |
508 case METADATA_TYPE_STREAMINFO: | 577 case METADATA_TYPE_STREAMINFO: |
578 if(metadata_size == 0) | |
579 av_log(s->avctx, AV_LOG_DEBUG, "size= 0 WTF!?\n"); | |
580 | |
509 metadata_streaminfo(s); | 581 metadata_streaminfo(s); |
510 dump_headers(s); | 582 dump_headers(s); |
511 break; | 583 break; |
512 default: | 584 default: |
513 while ((metadata_size -= 8) > 0) | 585 for(i=0; i<metadata_size; i++) |
514 skip_bits(&s->gb, 8); | 586 skip_bits(&s->gb, 8); |
587 } | |
515 } | 588 } |
516 } while(metadata_flag != 1); | 589 } while(!metadata_last); |
517 } | 590 } |
518 else | 591 else |
519 { | 592 { |
520 init_get_bits(&s->gb, buf, buf_size*8); | 593 |
521 tmp = get_bits(&s->gb, 16); | 594 tmp = show_bits(&s->gb, 16); |
522 if (tmp == 0xfff8) | 595 if(tmp != 0xFFF8){ |
523 printf("FRAME HEADER\n"); | 596 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n"); |
524 | 597 while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8) |
598 skip_bits(&s->gb, 8); | |
599 goto end; // we may not have enough bits left to decode a frame, so try next time | |
600 } | |
601 skip_bits(&s->gb, 16); | |
525 if (decode_frame(s) < 0) | 602 if (decode_frame(s) < 0) |
526 return -1; | 603 return -1; |
527 } | 604 } |
605 | |
528 | 606 |
529 #if 0 | 607 #if 0 |
530 /* fix the channel order here */ | 608 /* fix the channel order here */ |
531 if (s->order == MID_SIDE) | 609 if (s->order == MID_SIDE) |
532 { | 610 { |
560 else | 638 else |
561 for (j = 0; j < s->blocksize; j++) | 639 for (j = 0; j < s->blocksize; j++) |
562 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j]; | 640 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j]; |
563 break; | 641 break; |
564 // case MID_SIDE: | 642 // case MID_SIDE: |
565 // printf("mid-side unsupported\n"); | 643 // av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n"); |
566 } | 644 } |
567 *data_size += s->blocksize; | 645 *data_size += s->blocksize; |
568 } | 646 } |
569 } | 647 } |
570 #else | 648 #else |
571 switch(s->order) | 649 switch(s->order) |
572 { | 650 { |
573 case INDEPENDENT: | 651 case INDEPENDENT: |
574 for (i = 0; i < s->channels; i++) | 652 for (j = 0; j < s->blocksize; j++) |
575 { | 653 { |
576 for (j = 0; j < s->blocksize; j++) | 654 for (i = 0; i < s->channels; i++) |
577 *(samples++) = s->decoded[i][j]; | 655 *(samples++) = s->decoded[i][j]; |
578 *data_size += s->blocksize; | |
579 } | 656 } |
580 break; | 657 break; |
581 case LEFT_SIDE: | 658 case LEFT_SIDE: |
582 assert(s->channels == 2); | 659 assert(s->channels == 2); |
583 for (i = 0; i < s->blocksize; i++) | 660 for (i = 0; i < s->blocksize; i++) |
584 { | 661 { |
585 *(samples++) = s->decoded[0][i]; | 662 *(samples++) = s->decoded[0][i]; |
586 *(samples++) = s->decoded[0][i] - s->decoded[1][i]; | 663 *(samples++) = s->decoded[0][i] - s->decoded[1][i]; |
587 } | 664 } |
588 *data_size = 2*s->blocksize; | |
589 break; | 665 break; |
590 case RIGHT_SIDE: | 666 case RIGHT_SIDE: |
591 assert(s->channels == 2); | 667 assert(s->channels == 2); |
592 for (i = 0; i < s->blocksize; i++) | 668 for (i = 0; i < s->blocksize; i++) |
593 { | 669 { |
594 *(samples++) = s->decoded[0][i] + s->decoded[1][i]; | 670 *(samples++) = s->decoded[0][i] + s->decoded[1][i]; |
595 *(samples++) = s->decoded[1][i]; | 671 *(samples++) = s->decoded[1][i]; |
596 } | 672 } |
597 *data_size = 2*s->blocksize; | |
598 break; | 673 break; |
599 case MID_SIDE: | 674 case MID_SIDE: |
600 assert(s->channels == 2); | 675 assert(s->channels == 2); |
601 for (i = 0; i < s->blocksize; i++) | 676 for (i = 0; i < s->blocksize; i++) |
602 { | 677 { |
603 int16_t mid, side; | 678 int mid, side; |
604 mid = s->decoded[0][i]; | 679 mid = s->decoded[0][i]; |
605 side = s->decoded[1][i]; | 680 side = s->decoded[1][i]; |
606 | 681 |
607 mid <<= 1; | 682 mid <<= 1; |
608 if (side & 1) | 683 if (side & 1) |
609 mid++; | 684 mid++; |
610 *(samples++) = (mid + side) >> 1; | 685 *(samples++) = (mid + side) >> 1; |
611 *(samples++) = (mid - side) >> 1; | 686 *(samples++) = (mid - side) >> 1; |
612 } | 687 } |
613 *data_size = 2*s->blocksize; | |
614 break; | 688 break; |
615 } | 689 } |
616 #endif | 690 #endif |
617 | 691 |
618 // *data_size = (int8_t *)samples - (int8_t *)data; | 692 *data_size = (int8_t *)samples - (int8_t *)data; |
619 printf("data size: %d\n", *data_size); | 693 av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size); |
620 | 694 |
621 s->last_blocksize = s->blocksize; | 695 // s->last_blocksize = s->blocksize; |
622 | 696 end: |
623 return (get_bits_count(&s->gb)+7)/8; | 697 i= (get_bits_count(&s->gb)+7)/8;; |
698 if(i > buf_size){ | |
699 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size); | |
700 return -1; | |
701 } | |
702 | |
703 if(s->bitstream_size){ | |
704 s->bitstream_index += i; | |
705 s->bitstream_size -= i; | |
706 return input_buf_size; | |
707 }else | |
708 return i; | |
624 } | 709 } |
625 | 710 |
626 static int flac_decode_close(AVCodecContext *avctx) | 711 static int flac_decode_close(AVCodecContext *avctx) |
627 { | 712 { |
628 FLACContext *s = avctx->priv_data; | 713 FLACContext *s = avctx->priv_data; |
629 int i; | 714 int i; |
630 | 715 |
631 for (i = 0; i < s->channels; i++) | 716 for (i = 0; i < s->channels; i++) |
632 { | 717 { |
633 if (s->decoded[i]) | 718 av_freep(&s->decoded[i]); |
634 av_free(s->decoded[i]); | 719 av_freep(&s->residual[i]); |
635 if (s->residual[i]) | 720 } |
636 av_free(s->residual[i]); | 721 av_freep(&s->bitstream); |
637 } | |
638 | 722 |
639 return 0; | 723 return 0; |
640 } | 724 } |
641 | 725 |
642 AVCodec flac_decoder = { | 726 AVCodec flac_decoder = { |