mirror of
https://github.com/claunia/cuetools.net.git
synced 2025-12-16 18:14:25 +00:00
354 lines
10 KiB
C#
354 lines
10 KiB
C#
using System;
|
|
|
|
namespace CUETools.Codecs
|
|
{
|
|
public class BitWriter
|
|
{
|
|
private uint bit_buf;
|
|
private int bit_left;
|
|
private byte[] buffer;
|
|
private int buf_start, buf_ptr, buf_end;
|
|
private bool eof;
|
|
|
|
public byte[] Buffer
|
|
{
|
|
get
|
|
{
|
|
return buffer;
|
|
}
|
|
}
|
|
|
|
public int Length
|
|
{
|
|
get
|
|
{
|
|
return buf_ptr - buf_start;
|
|
}
|
|
set
|
|
{
|
|
flush();
|
|
buf_ptr = buf_start + value;
|
|
}
|
|
}
|
|
|
|
public int BitLength
|
|
{
|
|
get
|
|
{
|
|
return buf_ptr * 8 + 32 - bit_left;
|
|
}
|
|
}
|
|
|
|
public BitWriter(byte[] buf, int pos, int len)
|
|
{
|
|
buffer = buf;
|
|
buf_start = pos;
|
|
buf_ptr = pos;
|
|
buf_end = pos + len;
|
|
bit_left = 32;
|
|
bit_buf = 0;
|
|
eof = false;
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
buf_ptr = buf_start;
|
|
bit_left = 32;
|
|
bit_buf = 0;
|
|
eof = false;
|
|
}
|
|
|
|
public void writebytes(int bytes, byte c)
|
|
{
|
|
for (; bytes > 0; bytes--)
|
|
{
|
|
writebits(8, c);
|
|
}
|
|
}
|
|
|
|
public unsafe void writeints(int len, int pos, byte* buf)
|
|
{
|
|
int old_pos = BitLength;
|
|
int start = old_pos / 8;
|
|
int start1 = pos / 8;
|
|
int end = (old_pos + len) / 8;
|
|
int end1 = (pos + len) / 8;
|
|
flush();
|
|
byte start_val = old_pos % 8 != 0 ? buffer[start] : (byte)0;
|
|
fixed (byte* buf1 = &buffer[0])
|
|
AudioSamples.MemCpy(buf1 + start, buf + start1, end - start);
|
|
buffer[start] |= start_val;
|
|
buf_ptr = end;
|
|
if ((old_pos + len) % 8 != 0)
|
|
writebits((old_pos + len) % 8, buf[end1] >> (8 - ((old_pos + len) % 8)));
|
|
}
|
|
|
|
public void write(params char[] chars)
|
|
{
|
|
foreach (char c in chars)
|
|
writebits(8, (byte)c);
|
|
}
|
|
|
|
public void write(string s)
|
|
{
|
|
for (int i = 0; i < s.Length; i++)
|
|
writebits(8, (byte)s[i]);
|
|
}
|
|
|
|
public void writebits_signed(int bits, int val)
|
|
{
|
|
writebits(bits, val & ((1 << bits) - 1));
|
|
}
|
|
|
|
public void writebits_signed(uint bits, int val)
|
|
{
|
|
writebits((int)bits, val & ((1 << (int)bits) - 1));
|
|
}
|
|
|
|
public void writebits(int bits, int val)
|
|
{
|
|
writebits(bits, (uint)val);
|
|
}
|
|
|
|
public void writebits(DateTime val)
|
|
{
|
|
TimeSpan span = val.ToUniversalTime() - new DateTime(1904, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
|
|
writebits(32, (uint)span.TotalSeconds);
|
|
}
|
|
|
|
public void writebits64(int bits, ulong val)
|
|
{
|
|
if (bits > 32)
|
|
{
|
|
writebits(bits - 32, (uint)(val >> 32));
|
|
val &= 0xffffffffL;
|
|
bits = 32;
|
|
}
|
|
writebits(bits, (uint)val);
|
|
}
|
|
|
|
public void writebits(int bits, uint val)
|
|
{
|
|
//assert(bits == 32 || val < (1U << bits));
|
|
|
|
if (bits == 0 || eof) return;
|
|
if ((buf_ptr + 3) >= buf_end)
|
|
{
|
|
eof = true;
|
|
return;
|
|
}
|
|
if (bits < bit_left)
|
|
{
|
|
bit_buf = (bit_buf << bits) | val;
|
|
bit_left -= bits;
|
|
}
|
|
else
|
|
{
|
|
uint bb = 0;
|
|
if (bit_left == 32)
|
|
{
|
|
//assert(bits == 32);
|
|
bb = val;
|
|
}
|
|
else
|
|
{
|
|
bb = (bit_buf << bit_left) | (val >> (bits - bit_left));
|
|
bit_left += (32 - bits);
|
|
}
|
|
if (buffer != null)
|
|
{
|
|
buffer[buf_ptr + 3] = (byte)(bb & 0xFF); bb >>= 8;
|
|
buffer[buf_ptr + 2] = (byte)(bb & 0xFF); bb >>= 8;
|
|
buffer[buf_ptr + 1] = (byte)(bb & 0xFF); bb >>= 8;
|
|
buffer[buf_ptr + 0] = (byte)(bb & 0xFF);
|
|
}
|
|
buf_ptr += 4;
|
|
bit_buf = val;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Assumes there's enough space, buffer != null and bits is in range 1..31
|
|
/// </summary>
|
|
/// <param name="bits"></param>
|
|
/// <param name="val"></param>
|
|
// unsafe void writebits_fast(int bits, uint val, ref byte* buf)
|
|
// {
|
|
//#if DEBUG
|
|
// if ((buf_ptr + 3) >= buf_end)
|
|
// {
|
|
// eof = true;
|
|
// return;
|
|
// }
|
|
//#endif
|
|
// if (bits < bit_left)
|
|
// {
|
|
// bit_buf = (bit_buf << bits) | val;
|
|
// bit_left -= bits;
|
|
// }
|
|
// else
|
|
// {
|
|
// uint bb = (bit_buf << bit_left) | (val >> (bits - bit_left));
|
|
// bit_left += (32 - bits);
|
|
|
|
// *(buf++) = (byte)(bb >> 24);
|
|
// *(buf++) = (byte)(bb >> 16);
|
|
// *(buf++) = (byte)(bb >> 8);
|
|
// *(buf++) = (byte)(bb);
|
|
|
|
// bit_buf = val;
|
|
// }
|
|
// }
|
|
|
|
public void write_utf8(int val)
|
|
{
|
|
write_utf8((uint)val);
|
|
}
|
|
|
|
public void write_utf8(uint val)
|
|
{
|
|
if (val < 0x80)
|
|
{
|
|
writebits(8, val);
|
|
return;
|
|
}
|
|
int bytes = (BitReader.log2i(val) + 4) / 5;
|
|
int shift = (bytes - 1) * 6;
|
|
writebits(8, (256U - (256U >> bytes)) | (val >> shift));
|
|
while (shift >= 6)
|
|
{
|
|
shift -= 6;
|
|
writebits(8, 0x80 | ((val >> shift) & 0x3F));
|
|
}
|
|
}
|
|
|
|
public void write_unary_signed(int val)
|
|
{
|
|
// convert signed to unsigned
|
|
int v = -2 * val - 1;
|
|
v ^= (v >> 31);
|
|
|
|
// write quotient in unary
|
|
int q = v + 1;
|
|
while (q > 31)
|
|
{
|
|
writebits(31, 0);
|
|
q -= 31;
|
|
}
|
|
writebits(q, 1);
|
|
}
|
|
|
|
public void write_rice_signed(int k, int val)
|
|
{
|
|
// convert signed to unsigned
|
|
int v = -2 * val - 1;
|
|
v ^= (v >> 31);
|
|
|
|
// write quotient in unary
|
|
int q = (v >> k) + 1;
|
|
while (q + k > 31)
|
|
{
|
|
int b = Math.Min(q + k - 31, 31);
|
|
writebits(b, 0);
|
|
q -= b;
|
|
}
|
|
|
|
// write remainder in binary using 'k' bits
|
|
writebits(k + q, (v & ((1 << k) - 1)) | (1 << k));
|
|
}
|
|
|
|
public unsafe void write_rice_block_signed(byte* fixedbuf, int k, int* residual, int count)
|
|
{
|
|
byte* buf = &fixedbuf[buf_ptr];
|
|
//fixed (byte* fixbuf = &buffer[buf_ptr])
|
|
{
|
|
//byte* buf = fixbuf;
|
|
for (int i = count; i > 0; i--)
|
|
{
|
|
int v = *(residual++);
|
|
v = (v << 1) ^ (v >> 31);
|
|
|
|
// write quotient in unary
|
|
int q = (v >> k) + 1;
|
|
int bits = k + q;
|
|
while (bits > 31)
|
|
{
|
|
#if DEBUG
|
|
if (buf + 3 >= fixedbuf + buf_end)
|
|
{
|
|
eof = true;
|
|
return;
|
|
}
|
|
#endif
|
|
int b = Math.Min(bits - 31, 31);
|
|
if (b < bit_left)
|
|
{
|
|
bit_buf = (bit_buf << b);
|
|
bit_left -= b;
|
|
}
|
|
else
|
|
{
|
|
uint bb = bit_buf << bit_left;
|
|
bit_buf = 0;
|
|
bit_left += (32 - b);
|
|
*(buf++) = (byte)(bb >> 24);
|
|
*(buf++) = (byte)(bb >> 16);
|
|
*(buf++) = (byte)(bb >> 8);
|
|
*(buf++) = (byte)(bb);
|
|
}
|
|
bits -= b;
|
|
}
|
|
|
|
#if DEBUG
|
|
if (buf + 3 >= fixedbuf + buf_end)
|
|
{
|
|
eof = true;
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
// write remainder in binary using 'k' bits
|
|
//writebits_fast(k + q, (uint)((v & ((1 << k) - 1)) | (1 << k)), ref buf);
|
|
uint val = (uint)((v & ((1 << k) - 1)) | (1 << k));
|
|
if (bits < bit_left)
|
|
{
|
|
bit_buf = (bit_buf << bits) | val;
|
|
bit_left -= bits;
|
|
}
|
|
else
|
|
{
|
|
uint bb = (bit_buf << bit_left) | (val >> (bits - bit_left));
|
|
bit_buf = val;
|
|
bit_left += (32 - bits);
|
|
*(buf++) = (byte)(bb >> 24);
|
|
*(buf++) = (byte)(bb >> 16);
|
|
*(buf++) = (byte)(bb >> 8);
|
|
*(buf++) = (byte)(bb);
|
|
}
|
|
}
|
|
buf_ptr = (int)(buf - fixedbuf);
|
|
}
|
|
}
|
|
|
|
public void flush()
|
|
{
|
|
bit_buf <<= bit_left;
|
|
while (bit_left < 32 && !eof)
|
|
{
|
|
if (buf_ptr >= buf_end)
|
|
{
|
|
eof = true;
|
|
break;
|
|
}
|
|
if (buffer != null)
|
|
buffer[buf_ptr] = (byte)(bit_buf >> 24);
|
|
buf_ptr++;
|
|
bit_buf <<= 8;
|
|
bit_left += 8;
|
|
}
|
|
bit_left = 32;
|
|
bit_buf = 0;
|
|
}
|
|
}
|
|
}
|