public static int alloc_table(VLC vlc, int size, int use_static) { int index; index = vlc.table_size; vlc.table_size += size; if (vlc.table_size > vlc.table_allocated) { if (use_static != 0) { //abort(); //cant do anything, init_vlc() is used with too little memory return(0); } vlc.table_allocated += 1 << vlc.bits; short[][] /*2*/ newTab = Arrays.Create <short>(2 * vlc.table_allocated, 2); for (int i = 0; i < vlc.table_base.Length; i++) { newTab[i][0] = vlc.table_base[i][0]; newTab[i][1] = vlc.table_base[i][1]; } // for i vlc.table_base = newTab; //vlc.table = av_realloc(vlc->table, // sizeof(VLC_TYPE) * 2 * vlc->table_allocated); if (null == vlc.table_base) { return(-1); } } return(index); }
public void ff_h264_decode_init_vlc() { if (0 == calvc_inited) { int i; int offset; calvc_inited = 1; //chroma_dc_coeff_token_vlc.table_base = chroma_dc_coeff_token_vlc_table; chroma_dc_coeff_token_vlc.table_base = CAVLCTables.expandTable(CAVLCTables.chroma_dc_coeff_token_vlc_table); chroma_dc_coeff_token_vlc.table_offset = 0; chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size; /* GetBitContext.init_vlc(chroma_dc_coeff_token_vlc, H264Context.CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, chroma_dc_coeff_token_len,0, 1, 1, chroma_dc_coeff_token_bits,0, 1, 1, GetBitContext.INIT_VLC_USE_NEW_STATIC); */ offset = 0; for (i = 0; i < 4; i++) { coeff_token_vlc[i] = new VLC(); // coeff_token_vlc[i].table_base = coeff_token_vlc_tables; // coeff_token_vlc[i].table_offset = offset; coeff_token_vlc[i].table_base = CAVLCTables.expandTable(CAVLCTables.coeff_token_vlc_table[i]); coeff_token_vlc[i].table_offset = 0; coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i]; /* GetBitContext.init_vlc(coeff_token_vlc[i], H264Context.COEFF_TOKEN_VLC_BITS, 4*17, coeff_token_len [i],0, 1, 1, coeff_token_bits[i],0, 1, 1, GetBitContext.INIT_VLC_USE_NEW_STATIC); */ offset += coeff_token_vlc_tables_size[i]; } /* * This is a one time safety check to make sure that * the packed static coeff_token_vlc table sizes * were initialized correctly. */ ////assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables)); for (i = 0; i < 3; i++) { chroma_dc_total_zeros_vlc[i] = new VLC(); // chroma_dc_total_zeros_vlc[i].table_base = chroma_dc_total_zeros_vlc_tables[i]; chroma_dc_total_zeros_vlc[i].table_base = CAVLCTables.expandTable(CAVLCTables.chroma_dc_total_zeros_vlc_table[i]); chroma_dc_total_zeros_vlc[i].table_offset = 0; chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size; /* GetBitContext.init_vlc(chroma_dc_total_zeros_vlc[i], H264Context.CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, chroma_dc_total_zeros_len [i],0, 1, 1, chroma_dc_total_zeros_bits[i],0, 1, 1, GetBitContext.INIT_VLC_USE_NEW_STATIC); */ } for (i = 0; i < 15; i++) { total_zeros_vlc[i] = new VLC(); // total_zeros_vlc[i].table_base = total_zeros_vlc_tables[i]; total_zeros_vlc[i].table_base = CAVLCTables.expandTable(CAVLCTables.total_zeros_vlc[i]); total_zeros_vlc[i].table_offset = 0; total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size; /* GetBitContext.init_vlc(total_zeros_vlc[i], H264Context.TOTAL_ZEROS_VLC_BITS, 16, total_zeros_len [i],0, 1, 1, total_zeros_bits[i],0, 1, 1, GetBitContext.INIT_VLC_USE_NEW_STATIC); */ } for (i = 0; i < 6; i++) { run_vlc[i] = new VLC(); // run_vlc[i].table_base = run_vlc_tables[i]; run_vlc[i].table_base = CAVLCTables.expandTable(CAVLCTables.run_vlc_table[i]); run_vlc[i].table_offset = 0; run_vlc[i].table_allocated = run_vlc_tables_size; /* GetBitContext.init_vlc(run_vlc[i], H264Context.RUN_VLC_BITS, 7, run_len [i],0, 1, 1, run_bits[i],0, 1, 1, GetBitContext.INIT_VLC_USE_NEW_STATIC); */ } // run7_vlc.table_base = run7_vlc_table; run7_vlc.table_base = CAVLCTables.expandTable(CAVLCTables.run7_vlc_table); run7_vlc.table_offset = 0; run7_vlc.table_allocated = run7_vlc_table_size; /* GetBitContext.init_vlc(run7_vlc, H264Context.RUN7_VLC_BITS, 16, run_len [6],0, 1, 1, run_bits[6],0, 1, 1, GetBitContext.INIT_VLC_USE_NEW_STATIC); */ init_cavlc_level_tab(); } }
/** * 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. */ public static int build_table(VLC vlc, int table_nb_bits, int nb_codes, VLCcode[] codes_base, int codes_offset, int flags) { int table_size, table_index, index, code_prefix, symbol, subtable_bits; int i, k, n, nb, inc; long j; //uint32_t code; long code; //VLC_TYPE (*table)[2]; short[][] table_base; int table_offset; table_size = 1 << table_nb_bits; table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC); /* #ifdef DEBUG_VLC * av_log(NULL,AV_LOG_DEBUG,"new table index=%d size=%d\n", * table_index, table_size); #endif */ if (table_index < 0) { return(-1); } table_base = vlc.table_base; table_offset = vlc.table_offset + table_index; for (i = 0; i < table_size; i++) { table_base[table_offset + i][1] = 0; //bits table_base[table_offset + i][0] = -1; //codes } /* first pass: map codes and compute auxillary table sizes */ for (i = 0; i < nb_codes; i++) { n = codes_base[codes_offset + i].bits; code = codes_base[codes_offset + i].code; symbol = codes_base[codes_offset + i].symbol; //Console.WriteLine("i="+i+" n="+n+" code="+code); if (n <= table_nb_bits) { /* no need to add another table */ //!!! Prevent 32-Bit value in negative interval long tmp = code & 0xffffffffL; j = (int)(tmp >> (32 - table_nb_bits)); nb = 1 << (table_nb_bits - n); inc = 1; if ((flags & INIT_VLC_LE) != 0) { j = bitswap_32(code); inc = 1 << n; } for (k = 0; k < nb; k++) { //Console.WriteLine("["+j+"]: code="+i+" n="+n); if (table_base[(int)(table_offset + j)][1] /*bits*/ != 0) { //Console.WriteLine("incorrect codes."); return(-1); } table_base[(int)(table_offset + j)][1] = (short)n; //bits table_base[(int)(table_offset + j)][0] = (short)symbol; j += inc; } } else { /* fill auxiliary table recursively */ n -= table_nb_bits; long tmp = code & 0xffffffffL; code_prefix = (int)(tmp >> (32 - table_nb_bits)); subtable_bits = n; codes_base[codes_offset + i].bits = (byte)n; codes_base[codes_offset + i].code = (uint)(code << table_nb_bits); for (k = i + 1; k < nb_codes; k++) { n = codes_base[codes_offset + k].bits - table_nb_bits; if (n <= 0) { break; } code = codes_base[codes_offset + k].code; if (code >> (32 - table_nb_bits) != code_prefix) { break; } codes_base[codes_offset + k].bits = (byte)n; codes_base[codes_offset + k].code = (uint)(code << table_nb_bits); subtable_bits = Math.Max(subtable_bits, n); } subtable_bits = Math.Min(subtable_bits, table_nb_bits); j = (flags & INIT_VLC_LE) != 0 ? bitswap_32(code_prefix) >> (32 - table_nb_bits) : code_prefix; table_base[(int)(table_offset + j)][1] = (short)-subtable_bits; //Console.WriteLine("["+j+"]: n="+codes_base[codes_offset + i].bits + table_nb_bits+"(subtable)"); index = build_table(vlc, subtable_bits, k - i, codes_base, codes_offset + i, flags); if (index < 0) { return(-1); } /* note: realloc has been done, so reload tables */ table_base = vlc.table_base; table_offset = vlc.table_offset + table_index; table_base[(int)(table_offset + j)][0] = (short)index; //code i = k - 1; } } return(table_index); }