bitstream.c 11 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * Common bit i/o utils
3
 * Copyright (c) 2000, 2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
Loren Merritt's avatar
Loren Merritt committed
5
 * Copyright (c) 2010 Loren Merritt
Fabrice Bellard's avatar
Fabrice Bellard committed
6
 *
7 8
 * alternative bitstream reader & writer by Michael Niedermayer <michaelni@gmx.at>
 *
9 10 11
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
12 13
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
14
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
15
 *
16
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 *
21
 * You should have received a copy of the GNU Lesser General Public
22
 * License along with FFmpeg; if not, write to the Free Software
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
24
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
25 26

/**
27
 * @file
28
 * bitstream api.
Michael Niedermayer's avatar
Michael Niedermayer committed
29
 */
30

31
#include "libavutil/avassert.h"
Zdenek Kabelac's avatar
Zdenek Kabelac committed
32
#include "avcodec.h"
33
#include "mathops.h"
34
#include "get_bits.h"
35
#include "put_bits.h"
Michael Niedermayer's avatar
Michael Niedermayer committed
36

37
const uint8_t ff_log2_run[41]={
38 39 40
 0, 0, 0, 0, 1, 1, 1, 1,
 2, 2, 2, 2, 3, 3, 3, 3,
 4, 4, 5, 5, 6, 6, 7, 7,
41 42 43
 8, 9,10,11,12,13,14,15,
16,17,18,19,20,21,22,23,
24,
44 45
};

46
void avpriv_align_put_bits(PutBitContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
47
{
48
    put_bits(s,s->bit_left & 7,0);
Fabrice Bellard's avatar
Fabrice Bellard committed
49 50
}

51
void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string)
52
{
53 54 55
    while(*string){
        put_bits(pb, 8, *string);
        string++;
56
    }
57
    if(terminate_string)
58
        put_bits(pb, 8, 0);
59 60
}

61
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
62 63 64 65 66 67 68
{
    int words= length>>4;
    int bits= length&15;
    int i;

    if(length==0) return;

69
    if(CONFIG_SMALL || words < 16 || put_bits_count(pb)&7){
70
        for(i=0; i<words; i++) put_bits(pb, 16, AV_RB16(src + 2*i));
71 72 73 74
    }else{
        for(i=0; put_bits_count(pb)&31; i++)
            put_bits(pb, 8, src[i]);
        flush_put_bits(pb);
75
        memcpy(put_bits_ptr(pb), src+i, 2*words-i);
76 77 78
        skip_put_bytes(pb, 2*words-i);
    }

79
    put_bits(pb, bits, AV_RB16(src + 2*words)>>(16-bits));
80 81
}

Fabrice Bellard's avatar
Fabrice Bellard committed
82 83 84 85
/* VLC decoding */

#define GET_DATA(v, table, i, wrap, size) \
{\
86
    const uint8_t *ptr = (const uint8_t *)table + i * wrap;\
Fabrice Bellard's avatar
Fabrice Bellard committed
87 88
    switch(size) {\
    case 1:\
89
        v = *(const uint8_t *)ptr;\
Fabrice Bellard's avatar
Fabrice Bellard committed
90 91
        break;\
    case 2:\
92
        v = *(const uint16_t *)ptr;\
Fabrice Bellard's avatar
Fabrice Bellard committed
93 94
        break;\
    default:\
95
        v = *(const uint32_t *)ptr;\
Fabrice Bellard's avatar
Fabrice Bellard committed
96 97 98 99 100
        break;\
    }\
}


101
static int alloc_table(VLC *vlc, int size, int use_static)
Fabrice Bellard's avatar
Fabrice Bellard committed
102 103 104 105 106
{
    int index;
    index = vlc->table_size;
    vlc->table_size += size;
    if (vlc->table_size > vlc->table_allocated) {
107
        if(use_static)
108
            abort(); // cannot do anything, init_vlc() is used with too little memory
Fabrice Bellard's avatar
Fabrice Bellard committed
109
        vlc->table_allocated += (1 << vlc->bits);
110 111
        vlc->table = av_realloc_f(vlc->table,
                                  vlc->table_allocated, sizeof(VLC_TYPE) * 2);
112
        if (!vlc->table)
Fabrice Bellard's avatar
Fabrice Bellard committed
113 114 115 116 117
            return -1;
    }
    return index;
}

Loren Merritt's avatar
Loren Merritt committed
118
static av_always_inline uint32_t bitswap_32(uint32_t x) {
119 120 121 122
    return (uint32_t)ff_reverse[x&0xFF]<<24
         | (uint32_t)ff_reverse[(x>>8)&0xFF]<<16
         | (uint32_t)ff_reverse[(x>>16)&0xFF]<<8
         | (uint32_t)ff_reverse[x>>24];
Loren Merritt's avatar
Loren Merritt committed
123 124 125 126 127 128 129 130 131 132 133
}

typedef struct {
    uint8_t bits;
    uint16_t symbol;
    /** codeword, with the first bit-to-be-read in the msb
     * (even if intended for a little-endian bitstream reader) */
    uint32_t code;
} VLCcode;

static int compare_vlcspec(const void *a, const void *b)
Fabrice Bellard's avatar
Fabrice Bellard committed
134
{
Loren Merritt's avatar
Loren Merritt committed
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    const VLCcode *sa=a, *sb=b;
    return (sa->code >> 1) - (sb->code >> 1);
}

/**
 * Build VLC decoding tables suitable for use with get_vlc().
 *
 * @param vlc            the context to be initted
 *
 * @param table_nb_bits  max length of vlc codes to store directly in this table
 *                       (Longer codes are delegated to subtables.)
 *
 * @param nb_codes       number of elements in codes[]
 *
 * @param codes          descriptions of the vlc codes
 *                       These must be ordered such that codes going into the same subtable are contiguous.
 *                       Sorting by VLCcode.code is sufficient, though not necessary.
 */
static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
                       VLCcode *codes, int flags)
{
    int table_size, table_index, index, code_prefix, symbol, subtable_bits;
    int i, j, k, n, nb, inc;
158
    uint32_t code;
159
    VLC_TYPE (*table)[2];
Fabrice Bellard's avatar
Fabrice Bellard committed
160 161

    table_size = 1 << table_nb_bits;
162 163
    if (table_nb_bits > 30)
       return -1;
164
    table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
165
    av_dlog(NULL, "new table index=%d size=%d\n", table_index, table_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
166 167
    if (table_index < 0)
        return -1;
168
    table = &vlc->table[table_index];
Fabrice Bellard's avatar
Fabrice Bellard committed
169

Loren Merritt's avatar
Loren Merritt committed
170
    for (i = 0; i < table_size; i++) {
171 172
        table[i][1] = 0; //bits
        table[i][0] = -1; //codes
Fabrice Bellard's avatar
Fabrice Bellard committed
173 174
    }

Diego Biurrun's avatar
Diego Biurrun committed
175
    /* first pass: map codes and compute auxiliary table sizes */
Loren Merritt's avatar
Loren Merritt committed
176
    for (i = 0; i < nb_codes; i++) {
Loren Merritt's avatar
Loren Merritt committed
177 178 179
        n = codes[i].bits;
        code = codes[i].code;
        symbol = codes[i].symbol;
180
        av_dlog(NULL, "i=%d n=%d code=0x%x\n", i, n, code);
Loren Merritt's avatar
Loren Merritt committed
181 182 183 184 185 186 187 188 189 190
        if (n <= table_nb_bits) {
            /* no need to add another table */
            j = code >> (32 - table_nb_bits);
            nb = 1 << (table_nb_bits - n);
            inc = 1;
            if (flags & INIT_VLC_LE) {
                j = bitswap_32(code);
                inc = 1 << n;
            }
            for (k = 0; k < nb; k++) {
191
                av_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
Loren Merritt's avatar
Loren Merritt committed
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
                if (table[j][1] /*bits*/ != 0) {
                    av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
                    return -1;
                }
                table[j][1] = n; //bits
                table[j][0] = symbol;
                j += inc;
            }
        } else {
            /* fill auxiliary table recursively */
            n -= table_nb_bits;
            code_prefix = code >> (32 - table_nb_bits);
            subtable_bits = n;
            codes[i].bits = n;
            codes[i].code = code << table_nb_bits;
            for (k = i+1; k < nb_codes; k++) {
                n = codes[k].bits - table_nb_bits;
                if (n <= 0)
                    break;
                code = codes[k].code;
                if (code >> (32 - table_nb_bits) != code_prefix)
                    break;
                codes[k].bits = n;
                codes[k].code = code << table_nb_bits;
                subtable_bits = FFMAX(subtable_bits, n);
            }
            subtable_bits = FFMIN(subtable_bits, table_nb_bits);
            j = (flags & INIT_VLC_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) : code_prefix;
            table[j][1] = -subtable_bits;
221 222
            av_dlog(NULL, "%4x: n=%d (subtable)\n",
                    j, codes[i].bits + table_nb_bits);
Loren Merritt's avatar
Loren Merritt committed
223 224 225 226 227 228 229 230
            index = build_table(vlc, subtable_bits, k-i, codes+i, flags);
            if (index < 0)
                return -1;
            /* note: realloc has been done, so reload tables */
            table = &vlc->table[table_index];
            table[j][0] = index; //code
            i = k-1;
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
231 232 233 234 235
    }
    return table_index;
}


236 237 238 239 240
/* Build VLC decoding tables suitable for use with get_vlc().

   'nb_bits' set thee decoding table size (2^nb_bits) entries. The
   bigger it is, the faster is the decoding. But it should not be too
   big to save memory and L1 cache. '9' is a good compromise.
241

242 243 244 245 246 247
   'nb_codes' : number of vlcs codes

   'bits' : table which gives the size (in bits) of each vlc code.

   'codes' : table which gives the bit pattern of of each vlc code.

248 249
   'symbols' : table which gives the values to be returned from get_vlc().

250 251 252 253 254 255 256
   'xxx_wrap' : give the number of bytes between each entry of the
   'bits' or 'codes' tables.

   'xxx_size' : gives the number of bytes of each entry of the 'bits'
   or 'codes' tables.

   'wrap' and 'size' allows to use any memory configuration and types
257
   (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
258 259

   'use_static' should be set to 1 for tables, which should be freed
260
   with av_free_static(), 0 if ff_free_vlc() will be used.
261
*/
262
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
Fabrice Bellard's avatar
Fabrice Bellard committed
263
             const void *bits, int bits_wrap, int bits_size,
264
             const void *codes, int codes_wrap, int codes_size,
265
             const void *symbols, int symbols_wrap, int symbols_size,
266
             int flags)
Fabrice Bellard's avatar
Fabrice Bellard committed
267
{
268 269
    VLCcode *buf;
    int i, j, ret;
Loren Merritt's avatar
Loren Merritt committed
270

Fabrice Bellard's avatar
Fabrice Bellard committed
271
    vlc->bits = nb_bits;
272
    if(flags & INIT_VLC_USE_NEW_STATIC){
273 274 275
        VLC dyn_vlc = *vlc;

        if (vlc->table_size)
276
            return 0;
277 278 279 280 281 282 283 284 285 286 287 288 289 290

        ret = ff_init_vlc_sparse(&dyn_vlc, nb_bits, nb_codes,
                                 bits, bits_wrap, bits_size,
                                 codes, codes_wrap, codes_size,
                                 symbols, symbols_wrap, symbols_size,
                                 flags & ~INIT_VLC_USE_NEW_STATIC);
        av_assert0(ret >= 0);
        av_assert0(dyn_vlc.table_size <= vlc->table_allocated);
        if(dyn_vlc.table_size < vlc->table_allocated)
            av_log(NULL, AV_LOG_ERROR, "needed %d had %d\n", dyn_vlc.table_size, vlc->table_allocated);
        memcpy(vlc->table, dyn_vlc.table, dyn_vlc.table_size * sizeof(*vlc->table));
        vlc->table_size = dyn_vlc.table_size;
        ff_free_vlc(&dyn_vlc);
        return 0;
291
    }else {
292 293 294 295 296
        vlc->table = NULL;
        vlc->table_allocated = 0;
        vlc->table_size = 0;
    }

297
    av_dlog(NULL, "build table nb_codes=%d\n", nb_codes);
Fabrice Bellard's avatar
Fabrice Bellard committed
298

299 300
    buf = av_malloc((nb_codes+1)*sizeof(VLCcode));

301
    av_assert0(symbols_size <= 2 || !symbols);
Loren Merritt's avatar
Loren Merritt committed
302 303 304 305 306 307
    j = 0;
#define COPY(condition)\
    for (i = 0; i < nb_codes; i++) {\
        GET_DATA(buf[j].bits, bits, i, bits_wrap, bits_size);\
        if (!(condition))\
            continue;\
308
        if (buf[j].bits > 3*nb_bits || buf[j].bits>32) {\
309
            av_log(NULL, AV_LOG_ERROR, "Too long VLC (%d) in init_vlc\n", buf[j].bits);\
310
            av_free(buf);\
311 312
            return -1;\
        }\
Loren Merritt's avatar
Loren Merritt committed
313
        GET_DATA(buf[j].code, codes, i, codes_wrap, codes_size);\
314 315
        if (buf[j].code >= (1LL<<buf[j].bits)) {\
            av_log(NULL, AV_LOG_ERROR, "Invalid code in init_vlc\n");\
316
            av_free(buf);\
317 318
            return -1;\
        }\
Loren Merritt's avatar
Loren Merritt committed
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
        if (flags & INIT_VLC_LE)\
            buf[j].code = bitswap_32(buf[j].code);\
        else\
            buf[j].code <<= 32 - buf[j].bits;\
        if (symbols)\
            GET_DATA(buf[j].symbol, symbols, i, symbols_wrap, symbols_size)\
        else\
            buf[j].symbol = i;\
        j++;\
    }
    COPY(buf[j].bits > nb_bits);
    // qsort is the slowest part of init_vlc, and could probably be improved or avoided
    qsort(buf, j, sizeof(VLCcode), compare_vlcspec);
    COPY(buf[j].bits && buf[j].bits <= nb_bits);
    nb_codes = j;

335 336 337 338
    ret = build_table(vlc, nb_bits, nb_codes, buf, flags);

    av_free(buf);
    if (ret < 0) {
339
        av_freep(&vlc->table);
Fabrice Bellard's avatar
Fabrice Bellard committed
340 341 342 343 344 345
        return -1;
    }
    return 0;
}


346
void ff_free_vlc(VLC *vlc)
Fabrice Bellard's avatar
Fabrice Bellard committed
347
{
348
    av_freep(&vlc->table);
Fabrice Bellard's avatar
Fabrice Bellard committed
349
}