bitstream.c 10.1 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 "get_bits.h"
34
#include "put_bits.h"
Michael Niedermayer's avatar
Michael Niedermayer committed
35

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

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

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

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

    if(length==0) return;

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

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

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

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


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

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

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

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

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

    /* first pass: map codes and compute auxillary table sizes */
Loren Merritt's avatar
Loren Merritt committed
175
    for (i = 0; i < nb_codes; i++) {
Loren Merritt's avatar
Loren Merritt committed
176 177 178
        n = codes[i].bits;
        code = codes[i].code;
        symbol = codes[i].symbol;
179
        av_dlog(NULL, "i=%d n=%d code=0x%x\n", i, n, code);
Loren Merritt's avatar
Loren Merritt committed
180 181 182 183 184 185 186 187 188 189
        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++) {
190
                av_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
Loren Merritt's avatar
Loren Merritt committed
191 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
                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;
220 221
            av_dlog(NULL, "%4x: n=%d (subtable)\n",
                    j, codes[i].bits + table_nb_bits);
Loren Merritt's avatar
Loren Merritt committed
222 223 224 225 226 227 228 229
            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
230 231 232 233 234
    }
    return table_index;
}


235 236 237 238 239
/* 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.
240

241 242 243 244 245 246
   '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.

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

249 250 251 252 253 254 255
   '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
256
   (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
257 258

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

Fabrice Bellard's avatar
Fabrice Bellard committed
270
    vlc->bits = nb_bits;
271 272 273 274 275 276
    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
        }
277
    }else {
278 279 280 281 282
        vlc->table = NULL;
        vlc->table_allocated = 0;
        vlc->table_size = 0;
    }

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

285 286
    buf = av_malloc((nb_codes+1)*sizeof(VLCcode));

287
    av_assert0(symbols_size <= 2 || !symbols);
Loren Merritt's avatar
Loren Merritt committed
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
    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;

311 312 313 314
    ret = build_table(vlc, nb_bits, nb_codes, buf, flags);

    av_free(buf);
    if (ret < 0) {
315
        av_freep(&vlc->table);
Fabrice Bellard's avatar
Fabrice Bellard committed
316 317
        return -1;
    }
318 319
    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
320 321 322 323
    return 0;
}


324
void ff_free_vlc(VLC *vlc)
Fabrice Bellard's avatar
Fabrice Bellard committed
325
{
326
    av_freep(&vlc->table);
Fabrice Bellard's avatar
Fabrice Bellard committed
327
}