bitstream.c 10.3 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

Zdenek Kabelac's avatar
Zdenek Kabelac committed
31
#include "avcodec.h"
32
#include "get_bits.h"
33
#include "put_bits.h"
Michael Niedermayer's avatar
Michael Niedermayer committed
34

35 36 37 38 39 40 41
const uint8_t ff_log2_run[32]={
 0, 0, 0, 0, 1, 1, 1, 1,
 2, 2, 2, 2, 3, 3, 3, 3,
 4, 4, 5, 5, 6, 6, 7, 7,
 8, 9,10,11,12,13,14,15
};

Fabrice Bellard's avatar
Fabrice Bellard committed
42 43
void align_put_bits(PutBitContext *s)
{
44 45 46
#ifdef ALT_BITSTREAM_WRITER
    put_bits(s,(  - s->index) & 7,0);
#else
47
    put_bits(s,s->bit_left & 7,0);
48
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
49 50
}

51
void ff_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
}

Michael Niedermayer's avatar
Michael Niedermayer committed
61
void ff_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 86 87
/* VLC decoding */

//#define DEBUG_VLC

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


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

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

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
136
{
Loren Merritt's avatar
Loren Merritt committed
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
    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;
160
    uint32_t code;
161
    VLC_TYPE (*table)[2];
Fabrice Bellard's avatar
Fabrice Bellard committed
162 163

    table_size = 1 << table_nb_bits;
164
    table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
Fabrice Bellard's avatar
Fabrice Bellard committed
165
#ifdef DEBUG_VLC
Loren Merritt's avatar
Loren Merritt committed
166 167
    av_log(NULL,AV_LOG_DEBUG,"new table index=%d size=%d\n",
           table_index, table_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
168 169 170
#endif
    if (table_index < 0)
        return -1;
171
    table = &vlc->table[table_index];
Fabrice Bellard's avatar
Fabrice Bellard committed
172

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

    /* first pass: map codes and compute auxillary table sizes */
Loren Merritt's avatar
Loren Merritt committed
179
    for (i = 0; i < nb_codes; i++) {
Loren Merritt's avatar
Loren Merritt committed
180 181 182
        n = codes[i].bits;
        code = codes[i].code;
        symbol = codes[i].symbol;
Fabrice Bellard's avatar
Fabrice Bellard committed
183
#if defined(DEBUG_VLC) && 0
184
        av_log(NULL,AV_LOG_DEBUG,"i=%d n=%d code=0x%x\n", i, n, code);
Fabrice Bellard's avatar
Fabrice Bellard committed
185
#endif
Loren Merritt's avatar
Loren Merritt committed
186 187 188 189 190 191 192 193 194 195
        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++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
196
#ifdef DEBUG_VLC
Loren Merritt's avatar
Loren Merritt committed
197 198
                av_log(NULL, AV_LOG_DEBUG, "%4x: code=%d n=%d\n",
                       j, i, n);
Fabrice Bellard's avatar
Fabrice Bellard committed
199
#endif
Loren Merritt's avatar
Loren Merritt committed
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
                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;
Fabrice Bellard's avatar
Fabrice Bellard committed
229
#ifdef DEBUG_VLC
Loren Merritt's avatar
Loren Merritt committed
230 231
            av_log(NULL,AV_LOG_DEBUG,"%4x: n=%d (subtable)\n",
                   j, codes[i].bits + table_nb_bits);
Fabrice Bellard's avatar
Fabrice Bellard committed
232
#endif
Loren Merritt's avatar
Loren Merritt committed
233 234 235 236 237 238 239 240
            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
241 242 243 244 245
    }
    return table_index;
}


246 247 248 249 250
/* 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.
251

252 253 254 255 256 257
   '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.

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

260 261 262 263 264 265 266
   '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
267
   (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
268 269 270

   'use_static' should be set to 1 for tables, which should be freed
   with av_free_static(), 0 if free_vlc() will be used.
271
*/
272
int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
Fabrice Bellard's avatar
Fabrice Bellard committed
273
             const void *bits, int bits_wrap, int bits_size,
274
             const void *codes, int codes_wrap, int codes_size,
275
             const void *symbols, int symbols_wrap, int symbols_size,
276
             int flags)
Fabrice Bellard's avatar
Fabrice Bellard committed
277
{
278 279
    VLCcode *buf;
    int i, j, ret;
Loren Merritt's avatar
Loren Merritt committed
280

Fabrice Bellard's avatar
Fabrice Bellard committed
281
    vlc->bits = nb_bits;
282 283 284 285 286 287
    if(flags & INIT_VLC_USE_NEW_STATIC){
        if(vlc->table_size && vlc->table_size == vlc->table_allocated){
            return 0;
        }else if(vlc->table_size){
            abort(); // fatal error, we are called on a partially initialized table
        }
288
    }else {
289 290 291 292 293
        vlc->table = NULL;
        vlc->table_allocated = 0;
        vlc->table_size = 0;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
294
#ifdef DEBUG_VLC
295
    av_log(NULL,AV_LOG_DEBUG,"build table nb_codes=%d\n", nb_codes);
Fabrice Bellard's avatar
Fabrice Bellard committed
296 297
#endif

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

Loren Merritt's avatar
Loren Merritt committed
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
    assert(symbols_size <= 2 || !symbols);
    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;\
        GET_DATA(buf[j].code, codes, i, codes_wrap, codes_size);\
        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;

324 325 326 327
    ret = build_table(vlc, nb_bits, nb_codes, buf, flags);

    av_free(buf);
    if (ret < 0) {
328
        av_freep(&vlc->table);
Fabrice Bellard's avatar
Fabrice Bellard committed
329 330
        return -1;
    }
331 332
    if((flags & INIT_VLC_USE_NEW_STATIC) && vlc->table_size != vlc->table_allocated)
        av_log(NULL, AV_LOG_ERROR, "needed %d had %d\n", vlc->table_size, vlc->table_allocated);
Fabrice Bellard's avatar
Fabrice Bellard committed
333 334 335 336 337 338
    return 0;
}


void free_vlc(VLC *vlc)
{
339
    av_freep(&vlc->table);
Fabrice Bellard's avatar
Fabrice Bellard committed
340 341
}