Mercurial > libavcodec.hg
annotate bitstream.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | 582e635cfa08 |
children | b33be8b00488 |
rev | line source |
---|---|
0 | 1 /* |
2 * Common bit i/o utils | |
429 | 3 * Copyright (c) 2000, 2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1660
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
429 | 6 * This library 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 of the License, or (at your option) any later version. | |
0 | 10 * |
429 | 11 * This library is distributed in the hope that it will be useful, |
0 | 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 * Lesser General Public License for more details. | |
0 | 15 * |
429 | 16 * You should have received a copy of the GNU Lesser General Public |
17 * License along with this library; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
144
diff
changeset
|
19 * |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
219
diff
changeset
|
20 * alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at> |
0 | 21 */ |
1106 | 22 |
23 /** | |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
24 * @file bitstream.c |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
25 * bitstream api. |
1106 | 26 */ |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
27 |
524 | 28 #include "avcodec.h" |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
29 #include "bitstream.h" |
1037 | 30 |
0 | 31 void align_put_bits(PutBitContext *s) |
32 { | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
219
diff
changeset
|
33 #ifdef ALT_BITSTREAM_WRITER |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
219
diff
changeset
|
34 put_bits(s,( - s->index) & 7,0); |
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
219
diff
changeset
|
35 #else |
238
99a9f903f0e3
optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents:
234
diff
changeset
|
36 put_bits(s,s->bit_left & 7,0); |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
219
diff
changeset
|
37 #endif |
0 | 38 } |
39 | |
1795 | 40 void put_string(PutBitContext * pbc, char *s, int put_zero) |
358 | 41 { |
42 while(*s){ | |
43 put_bits(pbc, 8, *s); | |
44 s++; | |
45 } | |
1795 | 46 if(put_zero) |
47 put_bits(pbc, 8, 0); | |
358 | 48 } |
49 | |
0 | 50 /* bit input functions */ |
51 | |
1257 | 52 /** |
53 * reads 0-32 bits. | |
54 */ | |
55 unsigned int get_bits_long(GetBitContext *s, int n){ | |
56 if(n<=17) return get_bits(s, n); | |
57 else{ | |
58 int ret= get_bits(s, 16) << (n-16); | |
59 return ret | get_bits(s, n-16); | |
60 } | |
61 } | |
62 | |
63 /** | |
64 * shows 0-32 bits. | |
65 */ | |
66 unsigned int show_bits_long(GetBitContext *s, int n){ | |
67 if(n<=17) return show_bits(s, n); | |
68 else{ | |
69 GetBitContext gb= *s; | |
70 int ret= get_bits_long(s, n); | |
71 *s= gb; | |
72 return ret; | |
73 } | |
74 } | |
75 | |
0 | 76 void align_get_bits(GetBitContext *s) |
77 { | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
78 int n= (-get_bits_count(s)) & 7; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
79 if(n) skip_bits(s, n); |
0 | 80 } |
192
1e5f64be86fc
another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents:
144
diff
changeset
|
81 |
862 | 82 int check_marker(GetBitContext *s, const char *msg) |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
238
diff
changeset
|
83 { |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
238
diff
changeset
|
84 int bit= get_bits1(s); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
85 if(!bit) |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
86 av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
238
diff
changeset
|
87 |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
238
diff
changeset
|
88 return bit; |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
238
diff
changeset
|
89 } |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
238
diff
changeset
|
90 |
0 | 91 /* VLC decoding */ |
92 | |
93 //#define DEBUG_VLC | |
94 | |
95 #define GET_DATA(v, table, i, wrap, size) \ | |
96 {\ | |
1064 | 97 const uint8_t *ptr = (const uint8_t *)table + i * wrap;\ |
0 | 98 switch(size) {\ |
99 case 1:\ | |
1064 | 100 v = *(const uint8_t *)ptr;\ |
0 | 101 break;\ |
102 case 2:\ | |
1064 | 103 v = *(const uint16_t *)ptr;\ |
0 | 104 break;\ |
105 default:\ | |
1064 | 106 v = *(const uint32_t *)ptr;\ |
0 | 107 break;\ |
108 }\ | |
109 } | |
110 | |
111 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
112 static int alloc_table(VLC *vlc, int size, int use_static) |
0 | 113 { |
114 int index; | |
115 index = vlc->table_size; | |
116 vlc->table_size += size; | |
117 if (vlc->table_size > vlc->table_allocated) { | |
118 vlc->table_allocated += (1 << vlc->bits); | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
119 if(use_static) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
120 vlc->table = av_realloc_static(vlc->table, |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
121 sizeof(VLC_TYPE) * 2 * vlc->table_allocated); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
122 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
123 vlc->table = av_realloc(vlc->table, |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
124 sizeof(VLC_TYPE) * 2 * vlc->table_allocated); |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
125 if (!vlc->table) |
0 | 126 return -1; |
127 } | |
128 return index; | |
129 } | |
130 | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
131 static int build_table(VLC *vlc, int table_nb_bits, |
0 | 132 int nb_codes, |
133 const void *bits, int bits_wrap, int bits_size, | |
134 const void *codes, int codes_wrap, int codes_size, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
135 uint32_t code_prefix, int n_prefix, int use_static) |
0 | 136 { |
137 int i, j, k, n, table_size, table_index, nb, n1, index; | |
1064 | 138 uint32_t code; |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
139 VLC_TYPE (*table)[2]; |
0 | 140 |
141 table_size = 1 << table_nb_bits; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
142 table_index = alloc_table(vlc, table_size, use_static); |
0 | 143 #ifdef DEBUG_VLC |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
144 printf("new table index=%d size=%d code_prefix=%x n=%d\n", |
0 | 145 table_index, table_size, code_prefix, n_prefix); |
146 #endif | |
147 if (table_index < 0) | |
148 return -1; | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
149 table = &vlc->table[table_index]; |
0 | 150 |
151 for(i=0;i<table_size;i++) { | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
152 table[i][1] = 0; //bits |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
153 table[i][0] = -1; //codes |
0 | 154 } |
155 | |
156 /* first pass: map codes and compute auxillary table sizes */ | |
157 for(i=0;i<nb_codes;i++) { | |
158 GET_DATA(n, bits, i, bits_wrap, bits_size); | |
159 GET_DATA(code, codes, i, codes_wrap, codes_size); | |
160 /* we accept tables with holes */ | |
161 if (n <= 0) | |
162 continue; | |
163 #if defined(DEBUG_VLC) && 0 | |
164 printf("i=%d n=%d code=0x%x\n", i, n, code); | |
165 #endif | |
166 /* if code matches the prefix, it is in the table */ | |
167 n -= n_prefix; | |
168 if (n > 0 && (code >> n) == code_prefix) { | |
169 if (n <= table_nb_bits) { | |
170 /* no need to add another table */ | |
171 j = (code << (table_nb_bits - n)) & (table_size - 1); | |
172 nb = 1 << (table_nb_bits - n); | |
173 for(k=0;k<nb;k++) { | |
174 #ifdef DEBUG_VLC | |
1602
fdb8244da1e5
av_log patch(2 of ?) by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1598
diff
changeset
|
175 av_log(NULL, AV_LOG_DEBUG, "%4x: code=%d n=%d\n", |
0 | 176 j, i, n); |
177 #endif | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
178 if (table[j][1] /*bits*/ != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
179 av_log(NULL, AV_LOG_ERROR, "incorrect codes\n"); |
2281 | 180 return -1; |
0 | 181 } |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
182 table[j][1] = n; //bits |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
183 table[j][0] = i; //code |
0 | 184 j++; |
185 } | |
186 } else { | |
187 n -= table_nb_bits; | |
188 j = (code >> n) & ((1 << table_nb_bits) - 1); | |
189 #ifdef DEBUG_VLC | |
190 printf("%4x: n=%d (subtable)\n", | |
191 j, n); | |
192 #endif | |
193 /* compute table size */ | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
194 n1 = -table[j][1]; //bits |
0 | 195 if (n > n1) |
196 n1 = n; | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
197 table[j][1] = -n1; //bits |
0 | 198 } |
199 } | |
200 } | |
201 | |
202 /* second pass : fill auxillary tables recursively */ | |
203 for(i=0;i<table_size;i++) { | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
204 n = table[i][1]; //bits |
0 | 205 if (n < 0) { |
206 n = -n; | |
207 if (n > table_nb_bits) { | |
208 n = table_nb_bits; | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
209 table[i][1] = -n; //bits |
0 | 210 } |
211 index = build_table(vlc, n, nb_codes, | |
212 bits, bits_wrap, bits_size, | |
213 codes, codes_wrap, codes_size, | |
214 (code_prefix << table_nb_bits) | i, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
215 n_prefix + table_nb_bits, use_static); |
0 | 216 if (index < 0) |
217 return -1; | |
218 /* note: realloc has been done, so reload tables */ | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
219 table = &vlc->table[table_index]; |
535 | 220 table[i][0] = index; //code |
0 | 221 } |
222 } | |
223 return table_index; | |
224 } | |
225 | |
226 | |
24 | 227 /* Build VLC decoding tables suitable for use with get_vlc(). |
228 | |
229 'nb_bits' set thee decoding table size (2^nb_bits) entries. The | |
230 bigger it is, the faster is the decoding. But it should not be too | |
231 big to save memory and L1 cache. '9' is a good compromise. | |
232 | |
233 'nb_codes' : number of vlcs codes | |
234 | |
235 'bits' : table which gives the size (in bits) of each vlc code. | |
236 | |
237 'codes' : table which gives the bit pattern of of each vlc code. | |
238 | |
239 'xxx_wrap' : give the number of bytes between each entry of the | |
240 'bits' or 'codes' tables. | |
241 | |
242 'xxx_size' : gives the number of bytes of each entry of the 'bits' | |
243 or 'codes' tables. | |
244 | |
245 'wrap' and 'size' allows to use any memory configuration and types | |
246 (byte/word/long) to store the 'bits' and 'codes' tables. | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
247 |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
248 'use_static' should be set to 1 for tables, which should be freed |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
249 with av_free_static(), 0 if free_vlc() will be used. |
24 | 250 */ |
0 | 251 int init_vlc(VLC *vlc, int nb_bits, int nb_codes, |
252 const void *bits, int bits_wrap, int bits_size, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
253 const void *codes, int codes_wrap, int codes_size, |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
254 int use_static) |
0 | 255 { |
256 vlc->bits = nb_bits; | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
257 if(!use_static) { |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
258 vlc->table = NULL; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
259 vlc->table_allocated = 0; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
260 vlc->table_size = 0; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
261 } else { |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
262 /* Static tables are initially always NULL, return |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
263 if vlc->table != NULL to avoid double allocation */ |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
264 if(vlc->table) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
265 return 0; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
266 } |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
267 |
0 | 268 #ifdef DEBUG_VLC |
269 printf("build table nb_codes=%d\n", nb_codes); | |
270 #endif | |
271 | |
272 if (build_table(vlc, nb_bits, nb_codes, | |
273 bits, bits_wrap, bits_size, | |
274 codes, codes_wrap, codes_size, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2281
diff
changeset
|
275 0, 0, use_static) < 0) { |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
276 av_free(vlc->table); |
0 | 277 return -1; |
278 } | |
279 return 0; | |
280 } | |
281 | |
282 | |
283 void free_vlc(VLC *vlc) | |
284 { | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
497
diff
changeset
|
285 av_free(vlc->table); |
0 | 286 } |
287 |