Move *_static to bitstream.c which is the only file left which needs
[libav.git] / libavcodec / bitstream.c
CommitLineData
de6d9b64
FB
1/*
2 * Common bit i/o utils
ff4ec49e 3 * Copyright (c) 2000, 2001 Fabrice Bellard.
8f2ab833 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
de6d9b64 5 *
7b94177e
DB
6 * alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at>
7 *
b78e7197
DB
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
ff4ec49e
FB
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
b78e7197 13 * version 2.1 of the License, or (at your option) any later version.
de6d9b64 14 *
b78e7197 15 * FFmpeg is distributed in the hope that it will be useful,
de6d9b64 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
de6d9b64 19 *
ff4ec49e 20 * You should have received a copy of the GNU Lesser General Public
b78e7197 21 * License along with FFmpeg; if not, write to the Free Software
5509bffa 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
de6d9b64 23 */
983e3246
MN
24
25/**
caa336b4
MN
26 * @file bitstream.c
27 * bitstream api.
983e3246 28 */
115329f1 29
df595131 30#include "avcodec.h"
caa336b4 31#include "bitstream.h"
c81f0349 32
beebfdb1
PI
33/**
34 * Same as av_mallocz_static(), but does a realloc.
35 *
36 * @param[in] ptr The block of memory to reallocate.
37 * @param[in] size The requested size.
38 * @return Block of memory of requested size.
19032450 39 * @deprecated. Code which uses ff_realloc_static is broken/misdesigned
671adb17 40 * and should correctly use static arrays
beebfdb1 41 */
9f6152df 42attribute_deprecated av_alloc_size(2)
09dafaeb
MN
43static void *ff_realloc_static(void *ptr, unsigned int size);
44
45static unsigned int last_static = 0;
46static unsigned int allocated_static = 0;
47static void** array_static = NULL;
48
49static void *av_mallocz_static(unsigned int size)
50{
51 void *ptr = av_mallocz(size);
52
53 if(ptr){
54 array_static =av_fast_realloc(array_static, &allocated_static, sizeof(void*)*(last_static+1));
55 if(!array_static)
56 return NULL;
57 array_static[last_static++] = ptr;
58 }
59
60 return ptr;
61}
62
63static void *ff_realloc_static(void *ptr, unsigned int size)
64{
65 int i;
66 if(!ptr)
67 return av_mallocz_static(size);
68 /* Look for the old ptr */
69 for(i = 0; i < last_static; i++) {
70 if(array_static[i] == ptr) {
71 array_static[i] = av_realloc(array_static[i], size);
72 return array_static[i];
73 }
74 }
75 return NULL;
76
77}
78
79static void av_free_static(void)
80{
81 while(last_static){
82 av_freep(&array_static[--last_static]);
83 }
84 av_freep(&array_static);
85}
86
87/**
88 * Call av_free_static automatically before it's too late
89 */
90
91static void do_free(void) __attribute__ ((destructor));
92
93static void do_free(void)
94{
95 av_free_static();
96}
97
beebfdb1 98
de6d9b64
FB
99void align_put_bits(PutBitContext *s)
100{
17592475
MN
101#ifdef ALT_BITSTREAM_WRITER
102 put_bits(s,( - s->index) & 7,0);
103#else
d8cf5aea 104 put_bits(s,s->bit_left & 7,0);
17592475 105#endif
de6d9b64
FB
106}
107
1701cbfa 108void ff_put_string(PutBitContext * pbc, const char *s, int put_zero)
9717dad8
MN
109{
110 while(*s){
111 put_bits(pbc, 8, *s);
112 s++;
113 }
99683a30
MN
114 if(put_zero)
115 put_bits(pbc, 8, 0);
9717dad8
MN
116}
117
1701cbfa 118void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
98f7b56b 119{
1701cbfa 120 const uint16_t *srcw= (const uint16_t*)src;
98f7b56b
AJ
121 int words= length>>4;
122 int bits= length&15;
123 int i;
124
125 if(length==0) return;
126
58e28fd5 127 if(ENABLE_SMALL || words < 16 || put_bits_count(pb)&7){
98f7b56b
AJ
128 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
129 }else{
130 for(i=0; put_bits_count(pb)&31; i++)
131 put_bits(pb, 8, src[i]);
132 flush_put_bits(pb);
133 memcpy(pbBufPtr(pb), src+i, 2*words-i);
134 skip_put_bytes(pb, 2*words-i);
135 }
136
137 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
138}
139
de6d9b64
FB
140/* VLC decoding */
141
142//#define DEBUG_VLC
143
144#define GET_DATA(v, table, i, wrap, size) \
145{\
0c1a9eda 146 const uint8_t *ptr = (const uint8_t *)table + i * wrap;\
de6d9b64
FB
147 switch(size) {\
148 case 1:\
0c1a9eda 149 v = *(const uint8_t *)ptr;\
de6d9b64
FB
150 break;\
151 case 2:\
0c1a9eda 152 v = *(const uint16_t *)ptr;\
de6d9b64
FB
153 break;\
154 default:\
0c1a9eda 155 v = *(const uint32_t *)ptr;\
de6d9b64
FB
156 break;\
157 }\
158}
159
160
073c2593 161static int alloc_table(VLC *vlc, int size, int use_static)
de6d9b64
FB
162{
163 int index;
164 index = vlc->table_size;
165 vlc->table_size += size;
166 if (vlc->table_size > vlc->table_allocated) {
ccc54864
MN
167 if(use_static>1)
168 abort(); //cant do anything, init_vlc() is used with too little memory
de6d9b64 169 vlc->table_allocated += (1 << vlc->bits);
073c2593 170 if(use_static)
5dad0282 171 vlc->table = ff_realloc_static(vlc->table,
073c2593
BP
172 sizeof(VLC_TYPE) * 2 * vlc->table_allocated);
173 else
174 vlc->table = av_realloc(vlc->table,
175 sizeof(VLC_TYPE) * 2 * vlc->table_allocated);
8db1a1dd 176 if (!vlc->table)
de6d9b64
FB
177 return -1;
178 }
179 return index;
180}
181
8db1a1dd 182static int build_table(VLC *vlc, int table_nb_bits,
de6d9b64
FB
183 int nb_codes,
184 const void *bits, int bits_wrap, int bits_size,
185 const void *codes, int codes_wrap, int codes_size,
b613bacc 186 const void *symbols, int symbols_wrap, int symbols_size,
cea27ac7 187 uint32_t code_prefix, int n_prefix, int flags)
de6d9b64 188{
b613bacc 189 int i, j, k, n, table_size, table_index, nb, n1, index, code_prefix2, symbol;
0c1a9eda 190 uint32_t code;
8db1a1dd 191 VLC_TYPE (*table)[2];
de6d9b64
FB
192
193 table_size = 1 << table_nb_bits;
ccc54864 194 table_index = alloc_table(vlc, table_size, flags & (INIT_VLC_USE_STATIC|INIT_VLC_USE_NEW_STATIC));
de6d9b64 195#ifdef DEBUG_VLC
b8a99745 196 av_log(NULL,AV_LOG_DEBUG,"new table index=%d size=%d code_prefix=%x n=%d\n",
de6d9b64
FB
197 table_index, table_size, code_prefix, n_prefix);
198#endif
199 if (table_index < 0)
200 return -1;
8db1a1dd 201 table = &vlc->table[table_index];
de6d9b64
FB
202
203 for(i=0;i<table_size;i++) {
8db1a1dd
MN
204 table[i][1] = 0; //bits
205 table[i][0] = -1; //codes
de6d9b64
FB
206 }
207
208 /* first pass: map codes and compute auxillary table sizes */
209 for(i=0;i<nb_codes;i++) {
210 GET_DATA(n, bits, i, bits_wrap, bits_size);
211 GET_DATA(code, codes, i, codes_wrap, codes_size);
212 /* we accept tables with holes */
213 if (n <= 0)
214 continue;
b613bacc
LM
215 if (!symbols)
216 symbol = i;
217 else
218 GET_DATA(symbol, symbols, i, symbols_wrap, symbols_size);
de6d9b64 219#if defined(DEBUG_VLC) && 0
b8a99745 220 av_log(NULL,AV_LOG_DEBUG,"i=%d n=%d code=0x%x\n", i, n, code);
de6d9b64
FB
221#endif
222 /* if code matches the prefix, it is in the table */
223 n -= n_prefix;
cea27ac7
MN
224 if(flags & INIT_VLC_LE)
225 code_prefix2= code & (n_prefix>=32 ? 0xffffffff : (1 << n_prefix)-1);
226 else
227 code_prefix2= code >> n;
228 if (n > 0 && code_prefix2 == code_prefix) {
de6d9b64
FB
229 if (n <= table_nb_bits) {
230 /* no need to add another table */
231 j = (code << (table_nb_bits - n)) & (table_size - 1);
232 nb = 1 << (table_nb_bits - n);
233 for(k=0;k<nb;k++) {
cea27ac7
MN
234 if(flags & INIT_VLC_LE)
235 j = (code >> n_prefix) + (k<<n);
de6d9b64 236#ifdef DEBUG_VLC
3d0ef6dd 237 av_log(NULL, AV_LOG_DEBUG, "%4x: code=%d n=%d\n",
de6d9b64
FB
238 j, i, n);
239#endif
8db1a1dd 240 if (table[j][1] /*bits*/ != 0) {
9b879566 241 av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
9fe5a7b8 242 return -1;
de6d9b64 243 }
8db1a1dd 244 table[j][1] = n; //bits
b613bacc 245 table[j][0] = symbol;
de6d9b64
FB
246 j++;
247 }
248 } else {
249 n -= table_nb_bits;
cea27ac7 250 j = (code >> ((flags & INIT_VLC_LE) ? n_prefix : n)) & ((1 << table_nb_bits) - 1);
de6d9b64 251#ifdef DEBUG_VLC
b8a99745 252 av_log(NULL,AV_LOG_DEBUG,"%4x: n=%d (subtable)\n",
de6d9b64
FB
253 j, n);
254#endif
255 /* compute table size */
8db1a1dd 256 n1 = -table[j][1]; //bits
de6d9b64
FB
257 if (n > n1)
258 n1 = n;
8db1a1dd 259 table[j][1] = -n1; //bits
de6d9b64
FB
260 }
261 }
262 }
263
264 /* second pass : fill auxillary tables recursively */
265 for(i=0;i<table_size;i++) {
8db1a1dd 266 n = table[i][1]; //bits
de6d9b64
FB
267 if (n < 0) {
268 n = -n;
269 if (n > table_nb_bits) {
270 n = table_nb_bits;
8db1a1dd 271 table[i][1] = -n; //bits
de6d9b64
FB
272 }
273 index = build_table(vlc, n, nb_codes,
274 bits, bits_wrap, bits_size,
275 codes, codes_wrap, codes_size,
b613bacc 276 symbols, symbols_wrap, symbols_size,
cea27ac7
MN
277 (flags & INIT_VLC_LE) ? (code_prefix | (i << n_prefix)) : ((code_prefix << table_nb_bits) | i),
278 n_prefix + table_nb_bits, flags);
de6d9b64
FB
279 if (index < 0)
280 return -1;
281 /* note: realloc has been done, so reload tables */
8db1a1dd 282 table = &vlc->table[table_index];
6300c80a 283 table[i][0] = index; //code
de6d9b64
FB
284 }
285 }
286 return table_index;
287}
288
289
4e66ab3b
FB
290/* Build VLC decoding tables suitable for use with get_vlc().
291
292 'nb_bits' set thee decoding table size (2^nb_bits) entries. The
293 bigger it is, the faster is the decoding. But it should not be too
294 big to save memory and L1 cache. '9' is a good compromise.
115329f1 295
4e66ab3b
FB
296 'nb_codes' : number of vlcs codes
297
298 'bits' : table which gives the size (in bits) of each vlc code.
299
300 'codes' : table which gives the bit pattern of of each vlc code.
301
b613bacc
LM
302 'symbols' : table which gives the values to be returned from get_vlc().
303
4e66ab3b
FB
304 'xxx_wrap' : give the number of bytes between each entry of the
305 'bits' or 'codes' tables.
306
307 'xxx_size' : gives the number of bytes of each entry of the 'bits'
308 or 'codes' tables.
309
310 'wrap' and 'size' allows to use any memory configuration and types
b613bacc 311 (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
073c2593
BP
312
313 'use_static' should be set to 1 for tables, which should be freed
314 with av_free_static(), 0 if free_vlc() will be used.
4e66ab3b 315*/
b613bacc 316int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
de6d9b64 317 const void *bits, int bits_wrap, int bits_size,
073c2593 318 const void *codes, int codes_wrap, int codes_size,
b613bacc 319 const void *symbols, int symbols_wrap, int symbols_size,
d7645fb9 320 int flags)
de6d9b64
FB
321{
322 vlc->bits = nb_bits;
ccc54864
MN
323 if(flags & INIT_VLC_USE_NEW_STATIC){
324 if(vlc->table_size && vlc->table_size == vlc->table_allocated){
325 return 0;
326 }else if(vlc->table_size){
327 abort(); // fatal error, we are called on a partially initialized table
328 }
329 }else if(!(flags & INIT_VLC_USE_STATIC)) {
073c2593
BP
330 vlc->table = NULL;
331 vlc->table_allocated = 0;
332 vlc->table_size = 0;
333 } else {
334 /* Static tables are initially always NULL, return
335 if vlc->table != NULL to avoid double allocation */
336 if(vlc->table)
337 return 0;
338 }
339
de6d9b64 340#ifdef DEBUG_VLC
b8a99745 341 av_log(NULL,AV_LOG_DEBUG,"build table nb_codes=%d\n", nb_codes);
de6d9b64
FB
342#endif
343
344 if (build_table(vlc, nb_bits, nb_codes,
345 bits, bits_wrap, bits_size,
346 codes, codes_wrap, codes_size,
b613bacc 347 symbols, symbols_wrap, symbols_size,
d7645fb9 348 0, 0, flags) < 0) {
85d366fd 349 av_freep(&vlc->table);
de6d9b64
FB
350 return -1;
351 }
ccc54864
MN
352 if((flags & INIT_VLC_USE_NEW_STATIC) && vlc->table_size != vlc->table_allocated)
353 av_log(NULL, AV_LOG_ERROR, "needed %d had %d\n", vlc->table_size, vlc->table_allocated);
de6d9b64
FB
354 return 0;
355}
356
357
358void free_vlc(VLC *vlc)
359{
85d366fd 360 av_freep(&vlc->table);
de6d9b64
FB
361}
362