static void bs_write(bs_t s, int i_count, uint i_bits)
{
if (s.p >= s.p_end - 4)
{
return;
}
while (i_count > 0)
{
if (i_count < 32)
{
i_bits &= (uint)((1 << i_count) - 1);
}
if (i_count < s.i_left)
{
*s.p = (byte)((*s.p << i_count) | i_bits);
s.i_left -= i_count;
break;
}
else
{
*s.p = (byte)((*s.p << s.i_left) | (i_bits >> (i_count - s.i_left)));
i_count -= s.i_left;
s.p++;
s.i_left = 8;
}
}
}
public static void bs_init(bs_t s, void *p_data, int i_data)
{
s.p_start = (byte *)p_data;
s.p = (byte *)p_data;
s.p_end = s.p + i_data;
s.i_left = 8;
}
/* golomb functions */
static void bs_write_ue(bs_t s, uint val)
{
int i_size = 0;
if (val == 0)
{
bs_write1(s, 1);
}
else
{
uint tmp = ++val;
if (tmp >= 0x00010000)
{
i_size += 16;
tmp >>= 16;
}
if (tmp >= 0x100)
{
i_size += 8;
tmp >>= 8;
}
i_size += i_size0_255[tmp];
bs_write(s, 2 * i_size - 1, val);
}
}
static void bs_rbsp_trailing(bs_t s)
{
bs_write1(s, 1);
if (s.i_left != 8)
{
bs_write(s, s.i_left, 0x00);
}
}
static void bs_align_0(bs_t s)
{
if (s.i_left != 8)
{
*s.p <<= s.i_left;
s.i_left = 8;
s.p++;
}
}
static uint bs_show(bs_t s, int i_count)
{
if (s.p < s.p_end && i_count > 0)
{
uint i_cache = (uint)(((s.p[0] << 24) + (s.p[1] << 16) + (s.p[2] << 8) + s.p[3]) << (8 - s.i_left));
return(i_cache >> (32 - i_count));
}
return(0);
}
public static int bs_read_ue(bs_t s)
{
int i = 0;
while (bs_read1(s) == 0 && s.p < s.p_end && i < 32)
{
i++;
}
return((int)((1 << i) - 1 + bs_read(s, i)));
}
static void bs_align_1(bs_t s)
{
if (s.i_left != 8)
{
*s.p <<= s.i_left;
*s.p |= (byte)((1 << s.i_left) - 1);
s.i_left = 8;
s.p++;
}
}
/* TODO optimize */
public static void bs_skip(bs_t s, int i_count)
{
s.i_left -= i_count;
while (s.i_left <= 0)
{
s.p++;
s.i_left += 8;
}
}
static void bs_write_te(bs_t s, int x, int val)
{
if (x == 1)
{
bs_write1(s, (uint)(1 & ~val));
}
else if (x > 1)
{
bs_write_ue(s, (uint)val);
}
}
static int bs_read_te(bs_t s, int x)
{
if (x == 1)
{
return((int)(1 - bs_read1(s)));
}
else if (x > 1)
{
return(bs_read_ue(s));
}
return(0);
}
static void bs_write1(bs_t s, uint i_bit)
{
if (s.p < s.p_end)
{
*s.p <<= 1;
*s.p |= (byte)i_bit;
s.i_left--;
if (s.i_left == 0)
{
s.p++;
s.i_left = 8;
}
}
}
static uint bs_read1(bs_t s)
{
if (s.p < s.p_end)
{
uint i_result;
s.i_left--;
i_result = (uint)((*s.p >> s.i_left) & 0x01);
if (s.i_left == 0)
{
s.p++;
s.i_left = 8;
}
return(i_result);
}
return(0);
}
public static uint bs_read(bs_t s, int i_count)
{
int i_shr;
uint i_result = 0;
while (i_count > 0)
{
if (s.p >= s.p_end)
{
break;
}
if ((i_shr = s.i_left - i_count) >= 0)
{
/* more in the buffer than requested */
i_result |= (uint)((*s.p >> i_shr) & i_mask[i_count]);
s.i_left -= i_count;
if (s.i_left == 0)
{
s.p++;
s.i_left = 8;
}
return(i_result);
}
else
{
/* less in the buffer than requested */
i_result |= (*s.p & i_mask[s.i_left]) << -i_shr;
i_count -= s.i_left;
s.p++;
s.i_left = 8;
}
}
return(i_result);
}
public static int bs_eof(bs_t s)
{
return(s.p >= s.p_end ? 1 : 0);
}
public static int bs_read_se(bs_t s)
{
int val = bs_read_ue(s);
return((val & 0x01) != 0 ? (val + 1) / 2 : -(val / 2));
}
static void bs_write_se(bs_t s, int val)
{
bs_write_ue(s, (uint)(val <= 0 ? -val * 2 : val * 2 - 1));
}
public static int bs_pos(bs_t s)
{
return((int)(8 * (s.p - s.p_start) + 8 - s.i_left));
}
static void bs_align(bs_t s)
{
bs_align_0(s);
}
