/* pack side */
static public int _vorbis_pack_info(ref Ogg.oggpack_buffer opb, ref vorbis_info vi)
{
codec_setup_info ci = vi.codec_setup as codec_setup_info;
if (ci == null)
{
return(OV_EFAULT);
}
/* preamble */
Ogg.oggpack_write(ref opb, 0x01, 8);
_v_writestring(ref opb, new char[] { 'v', 'o', 'r', 'b', 'i', 's' }, 6);
/* basic information about the stream */
Ogg.oggpack_write(ref opb, 0x00, 32);
Ogg.oggpack_write(ref opb, (uint)vi.channels, 8);
Ogg.oggpack_write(ref opb, (uint)vi.rate, 32);
Ogg.oggpack_write(ref opb, (uint)vi.bitrate_upper, 32);
Ogg.oggpack_write(ref opb, (uint)vi.bitrate_nominal, 32);
Ogg.oggpack_write(ref opb, (uint)vi.bitrate_lower, 32);
Ogg.oggpack_write(ref opb, (uint)ilog2((uint)ci.blocksizes[0]), 4);
Ogg.oggpack_write(ref opb, (uint)ilog2((uint)ci.blocksizes[1]), 4);
Ogg.oggpack_write(ref opb, 1, 1);
return(0);
}
/* helpers */
static void _v_writestring(ref Ogg.oggpack_buffer o, char[] s, int bytes)
{
for (int i = 0; i < bytes; i++)
{
Ogg.oggpack_write(ref o, s[i], 8);
}
}
static void mapping0_pack(ref vorbis_info vi, vorbis_info_mapping vm, ref Ogg.oggpack_buffer opb)
{
int i;
vorbis_info_mapping0 info = vm as vorbis_info_mapping0;
/* another 'we meant to do it this way' hack... up to beta 4, we packed 4 binary zeros here to signify one submapping in use. We
* now redefine that to mean four bitflags that indicate use of deeper features; bit0:submappings, bit1:coupling,
* bit2,3: reserved. This is backward compatable with all actual uses of the beta code. */
if (info.submaps > 1)
{
Ogg.oggpack_write(ref opb, 1, 1);
Ogg.oggpack_write(ref opb, (uint)(info.submaps - 1), 4);
}
else
{
Ogg.oggpack_write(ref opb, 0, 1);
}
if (info.coupling_steps > 0)
{
Ogg.oggpack_write(ref opb, 1, 1);
Ogg.oggpack_write(ref opb, (uint)(info.coupling_steps - 1), 8);
for (i = 0; i < info.coupling_steps; i++)
{
Ogg.oggpack_write(ref opb, (uint)info.coupling_mag[i], ilog((uint)vi.channels));
Ogg.oggpack_write(ref opb, (uint)info.coupling_ang[i], ilog((uint)vi.channels));
}
}
else
{
Ogg.oggpack_write(ref opb, 0, 1);
}
Ogg.oggpack_write(ref opb, 0, 2); /* 2,3:reserved */
/* we don't write the channel submappings if we only have one... */
if (info.submaps > 1)
{
for (i = 0; i < vi.channels; i++)
{
Ogg.oggpack_write(ref opb, (uint)info.chmuxlist[i], 4);
}
}
for (i = 0; i < info.submaps; i++)
{
Ogg.oggpack_write(ref opb, 0, 8); /* time submap unused */
Ogg.oggpack_write(ref opb, (uint)info.floorsubmap[i], 8);
Ogg.oggpack_write(ref opb, (uint)info.residuesubmap[i], 8);
}
}
static void ClipTest(uint[] b, int vals, int bits, uint[] comp, int compsize)
{
int bytes;
byte *buffer;
Ogg.oggpack_reset(ref o);
for (int i = 0; i < vals; i++)
{
Ogg.oggpack_write(ref o, b[i], bits > 0 ? bits : iLog(b[i]));
}
buffer = Ogg.oggpack_get_buffer(ref o);
bytes = Ogg.oggpack_bytes(ref o);
if (bytes != compsize)
{
throw new Exception("wrong number of bytes!");
}
for (int i = 0; i < bytes; i++)
{
if (buffer[i] != comp[i])
{
for (int j = 0; j < bytes; j++)
{
Console.WriteLine(buffer[j] + " , " + comp[j]);
}
throw new Exception("wrote incorrect value!");
}
}
Ogg.oggpack_readinit(ref r, buffer, bytes);
for (int i = 0; i < vals; i++)
{
int tbit = bits > 0 ? bits : iLog(b[i]);
if (Ogg.oggpack_look(ref r, tbit) == -1)
{
throw new Exception("out of data!");
}
if (Ogg.oggpack_look(ref r, tbit) != (b[i] & mask[tbit]))
{
throw new Exception("looked at incorrect value!");
}
if (tbit == 1)
{
if (Ogg.oggpack_look1(ref r) != (b[i] & mask[tbit]))
{
throw new Exception("looked at single bit incorrect value!");
}
}
if (tbit == 1)
{
if (Ogg.oggpack_read1(ref r) != (b[i] & mask[tbit]))
{
throw new Exception("read incorrect single bit value!");
}
}
else if (Ogg.oggpack_read(ref r, tbit) != (b[i] & mask[tbit]))
{
throw new Exception("read incorrect value!");
}
}
if (Ogg.oggpack_bytes(ref r) != bytes)
{
throw new Exception("leftover bytes after read!");
}
}
static public void Test()
{
byte *buffer;
int bytes = 0;
/* Test read/write together */
/* Later we test against pregenerated bitstreams */
Ogg.oggpack_writeinit(ref o);
Console.Write("Small preclipped packing (LSb): ");
ClipTest(testBuffer1, testSize1, 0, one, oneSize);
Console.WriteLine("ok.");
Console.Write("Null bit call (LSb): ");
ClipTest(testBuffer3, testSize3, 0, two, twoSize);
Console.WriteLine("ok.");
Console.Write("Large preclipped packing (LSb): ");
ClipTest(testBuffer2, testSize2, 0, three, threeSize);
Console.WriteLine("ok.");
Console.Write("32 bit precliiped packing (LSb): ");
{
Ogg.oggpack_reset(ref o);
for (int i = 0; i < testSize2; i++)
{
Ogg.oggpack_write(ref o, large[i], 32);
}
buffer = Ogg.oggpack_get_buffer(ref o);
bytes = Ogg.oggpack_bytes(ref o);
Ogg.oggpack_readinit(ref r, buffer, bytes);
for (int i = 0; i < testSize2; i++)
{
if (Ogg.oggpack_look(ref r, 32) == -1)
{
throw new Exception("out of data. failed!");
}
if (Ogg.oggpack_look(ref r, 32) != large[i])
{
throw new Exception("read incorrect value! " + Ogg.oggpack_look(ref r, 32) + " != " + large[1]);
}
Ogg.oggpack_adv(ref r, 32);
}
if (Ogg.oggpack_bytes(ref r) != bytes)
{
throw new Exception("leftover bytes after read!");
}
Console.WriteLine("ok.");
}
Console.Write("Small unclipped packing (LSb): ");
ClipTest(testBuffer1, testSize1, 7, four, fourSize);
Console.WriteLine("ok.");
Console.Write("Large unclipped packing (LSb): ");
ClipTest(testBuffer2, testSize2, 17, five, fiveSize);
Console.WriteLine("ok.");
Console.Write("Single bit unclipped packing (LSb): ");
ClipTest(testBuffer3, testSize3, 1, six, sixSize);
Console.WriteLine("ok.");
Console.Write("Testing read past end (LSb): ");
{
byte *temp = (byte *)Ogg._ogg_malloc(8);
try
{
for (int i = 0; i < 8; i++)
{
temp[i] = 0;
}
Ogg.oggpack_readinit(ref r, temp, 8);
for (int i = 0; i < 64; i++)
{
if (Ogg.oggpack_read(ref r, 1) != 0)
{
throw new Exception("failed; got -1 prematurely.");
}
}
if (Ogg.oggpack_look(ref r, 1) != -1 || Ogg.oggpack_read(ref r, 1) != -1)
{
throw new Exception("failed; read past end without -1");
}
for (int i = 0; i < 8; i++)
{
temp[i] = 0;
}
Ogg.oggpack_readinit(ref r, temp, 8);
if (Ogg.oggpack_read(ref r, 30) != 0 || Ogg.oggpack_read(ref r, 16) != 0)
{
throw new Exception("failed 2; got -1 prematurely.");
}
if (Ogg.oggpack_look(ref r, 18) != 0 || Ogg.oggpack_look(ref r, 18) != 0)
{
throw new Exception("failed 3; got -1 prematurely.");
}
if (Ogg.oggpack_look(ref r, 19) != -1 || Ogg.oggpack_look(ref r, 19) != -1)
{
throw new Exception("failed 3; got -1 prematurely.");
}
if (Ogg.oggpack_look(ref r, 32) != -1 || Ogg.oggpack_look(ref r, 32) != -1)
{
throw new Exception("failed 3; got -1 prematurely.");
}
Ogg.oggpack_writeclear(ref o);
Console.WriteLine("ok.");
}
finally
{
Ogg._ogg_free(temp);
}
}
/********** lazy, cut-n-paste retest with MSb packing ***********/
/* Test read/write together */
/* Later we test against pregenerated bitstreams */
Ogg.oggpackB_writeinit(ref o);
Console.Write("Small preclipped packing (MSb): ");
ClipTestB(testBuffer1, testSize1, 0, oneB, oneSize);
Console.WriteLine("ok.");
Console.Write("Null bit call (LSb): ");
ClipTestB(testBuffer3, testSize3, 0, twoB, twoSize);
Console.WriteLine("ok.");
Console.Write("Large preclipped packing (LSb): ");
ClipTestB(testBuffer2, testSize2, 0, threeB, threeSize);
Console.WriteLine("ok.");
Console.Write("32 bit precliiped packing (LSb): ");
{
Ogg.oggpackB_reset(ref o);
for (int i = 0; i < testSize2; i++)
{
Ogg.oggpackB_write(ref o, large[i], 32);
}
buffer = Ogg.oggpackB_get_buffer(ref o);
bytes = Ogg.oggpackB_bytes(ref o);
Ogg.oggpackB_readinit(ref r, buffer, bytes);
for (int i = 0; i < testSize2; i++)
{
if (Ogg.oggpackB_look(ref r, 32) == -1)
{
throw new Exception("out of data. failed!");
}
if (Ogg.oggpackB_look(ref r, 32) != large[i])
{
throw new Exception("read incorrect value! " + Ogg.oggpackB_look(ref r, 32) + " != " + large[1]);
}
Ogg.oggpackB_adv(ref r, 32);
}
if (Ogg.oggpackB_bytes(ref r) != bytes)
{
throw new Exception("leftover bytes after read!");
}
Console.WriteLine("ok.");
}
Console.Write("Small unclipped packing (LSb): ");
ClipTestB(testBuffer1, testSize1, 7, fourB, fourSize);
Console.WriteLine("ok.");
Console.Write("Large unclipped packing (LSb): ");
ClipTestB(testBuffer2, testSize2, 17, fiveB, fiveSize);
Console.WriteLine("ok.");
Console.Write("Single bit unclipped packing (LSb): ");
ClipTestB(testBuffer3, testSize3, 1, sixB, sixSize);
Console.WriteLine("ok.");
Console.Write("Testing read past end (LSb): ");
{
byte *temp = (byte *)Ogg._ogg_malloc(8);
try
{
for (int i = 0; i < 8; i++)
{
temp[i] = 0;
}
Ogg.oggpackB_readinit(ref r, temp, 8);
for (int i = 0; i < 64; i++)
{
if (Ogg.oggpackB_read(ref r, 1) != 0)
{
throw new Exception("failed; got -1 prematurely.");
}
}
if (Ogg.oggpackB_look(ref r, 1) != -1 || Ogg.oggpackB_read(ref r, 1) != -1)
{
throw new Exception("failed; read past end without -1");
}
for (int i = 0; i < 8; i++)
{
temp[i] = 0;
}
Ogg.oggpackB_readinit(ref r, temp, 8);
if (Ogg.oggpackB_read(ref r, 30) != 0 || Ogg.oggpackB_read(ref r, 16) != 0)
{
throw new Exception("failed 2; got -1 prematurely.");
}
if (Ogg.oggpackB_look(ref r, 18) != 0 || Ogg.oggpackB_look(ref r, 18) != 0)
{
throw new Exception("failed 3; got -1 prematurely.");
}
if (Ogg.oggpackB_look(ref r, 19) != -1 || Ogg.oggpackB_look(ref r, 19) != -1)
{
throw new Exception("failed 3; got -1 prematurely.");
}
if (Ogg.oggpackB_look(ref r, 32) != -1 || Ogg.oggpackB_look(ref r, 32) != -1)
{
throw new Exception("failed 3; got -1 prematurely.");
}
Ogg.oggpackB_writeclear(ref o);
Console.WriteLine("ok.");
}
finally
{
Ogg._ogg_free(temp);
}
}
}
static int mapping0_forward(ref vorbis_block vb)
{
vorbis_dsp_state vd = vb.vd;
vorbis_info vi = vd.vi;
codec_setup_info ci = vi.codec_setup as codec_setup_info;
private_state b = vb.vd.backend_state as private_state;
vorbis_block_internal vbi = vb._internal as vorbis_block_internal;
int n = vb.pcmend;
int i, j, k;
int * nonzero = stackalloc int[vi.channels];
float **gmdct = (float **)_vorbis_block_alloc(ref vb, vi.channels * sizeof(float *));
int ** iwork = (int **)_vorbis_block_alloc(ref vb, vi.channels * sizeof(int *));
int *** floor_posts = (int ***)_vorbis_block_alloc(ref vb, vi.channels * sizeof(int **));
float global_ampmax = vbi.ampmax;
float *local_ampmax = stackalloc float[vi.channels];
int blocktype = vbi.blocktype;
int modenumber = vb.W;
vorbis_info_mapping0 info = ci.map_param[modenumber] as vorbis_info_mapping0;
vorbis_look_psy psy_look = b.psy[blocktype + (vb.W != 0 ? 2 : 0)];
vb.mode = modenumber;
for (i = 0; i < vi.channels; i++)
{
float scale = 4.0f / n;
float scale_dB;
float *pcm = vb.pcm[i];
float *logfft = pcm;
iwork[i] = (int *)_vorbis_block_alloc(ref vb, (n / 2) * sizeof(int));
gmdct[i] = (float *)_vorbis_block_alloc(ref vb, (n / 2) * sizeof(float));
/* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that
* returned dB values about a third of a decibel too high. The bug was harmless because tunings
* implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well.
* For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */
scale_dB = todB(scale) + 0.345f;
/* window the PCM data */
_vorbis_apply_window(pcm, ref b.window, ref ci.blocksizes, vb.lW, vb.W, vb.nW);
/* transform the PCM data */
/* only MDCT right now.... */
mdct_forward(b.transform[vb.W][0] as mdct_lookup, pcm, gmdct[i]);
/* FFT yields more accurate tonal estimation (not phase sensitive) */
drft_forward(ref b.fft_look[vb.W], pcm);
/* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that
* returned dB values about a third of a decibel too high. The bug was harmless because tunings
* implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well.
* For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */
logfft[0] = scale_dB + todB(*pcm) + 0.345f;
local_ampmax[i] = logfft[0];
for (j = 1; j < n - 1; j += 2)
{
float temp = pcm[j] * pcm[j] + pcm[j + 1] * pcm[j + 1];
/* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that
* returned dB values about a third of a decibel too high. The bug was harmless because tunings
* implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well.
* For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */
temp = logfft[(j + 1) >> 1] = scale_dB + 0.5f * todB(temp) + 0.345f;
if (temp > local_ampmax[i])
{
local_ampmax[i] = temp;
}
}
if (local_ampmax[i] > 0.0f)
{
local_ampmax[i] = 0.0f;
}
if (local_ampmax[i] > global_ampmax)
{
global_ampmax = local_ampmax[i];
}
}
{
float *noise = (float *)_vorbis_block_alloc(ref vb, n / 2 * sizeof(float));
float *tone = (float *)_vorbis_block_alloc(ref vb, n / 2 * sizeof(float));
for (i = 0; i < vi.channels; i++)
{
/* the encoder setup assumes that all the modes used by any
* specific bitrate tweaking use the same floor */
int submap = info.chmuxlist[i];
/* the following makes things clearer to *me* anyway */
float *mdct = gmdct[i];
float *logfft = vb.pcm[i];
float *logmdct = logfft + n / 2;
float *logmask = logfft;
vb.mode = modenumber;
floor_posts[i] = (int **)_vorbis_block_alloc(ref vb, PACKETBLOBS * sizeof(int *));
ZeroMemory(floor_posts[i], sizeof(int *) * PACKETBLOBS);
for (j = 0; j < n / 2; j++)
{
/* + .345 is a hack; the original todB estimation used on IEEE 754 compliant machines had a bug that
* returned dB values about a third of a decibel too high. The bug was harmless because tunings
* implicitly took that into account. However, fixing the bug in the estimator requires changing all the tunings as well.
* For now, it's easier to sync things back up here, and recalibrate the tunings in the next major model upgrade. */
logmdct[j] = todB(mdct[j]) + 0.345f;
/* first step; noise masking. Not only does 'noise masking' give us curves from which we can decide how much resolution
* to give noise parts of the spectrum, it also implicitly hands us a tonality estimate (the larger the value in the
* 'noise_depth' vector, the more tonal that area is) */
_vp_noisemask(ref psy_look, logmdct, noise); /* noise does not have by-frequency offset bias applied yet */
/* second step: 'all the other crap'; all the stuff that isn't computed/fit for bitrate management goes in the second psy
* vector. This includes tone masking, peak limiting and ATH */
_vp_tonemask(ref psy_look, logfft, tone, global_ampmax, local_ampmax[i]);
/* third step; we offset the noise vectors, overlay tone masking. We then do a floor1-specific line fit. If we're
* performing bitrate management, the line fit is performed multiple times for up/down tweakage on demand. */
_vp_offset_and_mix(ref psy_look, noise, tone, 1, logmask, mdct, logmdct);
/* this algorithm is hardwired to floor 1 for now; abort out if we're *not* floor1. This won't happen unless someone has
* broken the encode setup lib. Guard it anyway. */
if (ci.floor_type[info.floorsubmap[submap]] != 1)
{
return(-1);
}
floor_posts[i][PACKETBLOBS / 2] = floor1_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, logmdct, logmask);
/* are we managing bitrate? If so, perform two more fits for later rate tweaking (fits represent hi/lo) */
if (vorbis_bitrate_managed(ref vb) != 0 && floor_posts[i][PACKETBLOBS / 2] != null)
{
/* higher rate by way of lower noise curve */
_vp_offset_and_mix(ref psy_look, noise, tone, 2, logmask, mdct, logmdct);
floor_posts[i][PACKETBLOBS - 1] = floor1_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, logmdct, logmask);
/* lower rate by way of higher noise curve */
_vp_offset_and_mix(ref psy_look, noise, tone, 0, logmask, mdct, logmdct);
floor_posts[i][0] = floor1_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, logmdct, logmask);
/* we also interpolate a range of intermediate curves for
* intermediate rates */
for (k = 1; k < PACKETBLOBS / 2; k++)
{
floor_posts[i][k] = floor1_interpolate_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, floor_posts[i][0], floor_posts[i][PACKETBLOBS / 2], k * 65536 / (PACKETBLOBS / 2));
}
for (k = PACKETBLOBS / 2 + 1; k < PACKETBLOBS - 1; k++)
{
floor_posts[i][k] = floor1_interpolate_fit(ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, floor_posts[i][PACKETBLOBS / 2], floor_posts[i][PACKETBLOBS - 1], (k - PACKETBLOBS / 2) * 65536 / (PACKETBLOBS / 2));
}
}
}
}
vbi.ampmax = global_ampmax;
/*
* the next phases are performed once for vbr-only and PACKETBLOB
* times for bitrate managed modes.
*
* 1) encode actual mode being used
* 2) encode the floor for each channel, compute coded mask curve/res
* 3) normalize and couple.
* 4) encode residue
* 5) save packet bytes to the packetblob vector
*/
/* iterate over the many masking curve fits we've created */
{
int **couple_bundle = stackalloc int *[vi.channels];
int * zerobundle = stackalloc int[vi.channels];
for (k = (vorbis_bitrate_managed(ref vb) != 0 ? 0 : PACKETBLOBS / 2); k <= (vorbis_bitrate_managed(ref vb) != 0 ? PACKETBLOBS - 1 : PACKETBLOBS / 2); k++)
{
Ogg.oggpack_buffer opb = vbi.packetblob[k];
/* start out our new packet blob with packet type and mode */
/* Encode the packet type */
Ogg.oggpack_write(ref opb, 0, 1);
/* Encode the modenumber */
/* Encode frame mode, pre,post windowsize, then dispatch */
Ogg.oggpack_write(ref opb, (uint)modenumber, b.modebits);
if (vb.W != 0)
{
Ogg.oggpack_write(ref opb, (uint)vb.lW, 1);
Ogg.oggpack_write(ref opb, (uint)vb.nW, 1);
}
/* encode floor, compute masking curve, sep out residue */
for (i = 0; i < vi.channels; i++)
{
int submap = info.chmuxlist[i];
int *ilogmask = iwork[i];
nonzero[i] = floor1_encode(ref opb, ref vb, b.flr[info.floorsubmap[submap]] as vorbis_look_floor1, floor_posts[i][k], ilogmask);
}
/* our iteration is now based on masking curve, not prequant and coupling. Only one prequant/coupling step */
/* quantize/couple */
/* incomplete implementation that assumes the tree is all depth one, or no tree at all */
_vp_couple_quantize_normalize(k, ci.psy_g_param, ref psy_look, info, gmdct, iwork, nonzero, ci.psy_g_param.sliding_lowpass[vb.W, k], vi.channels);
/* classify and encode by submap */
for (i = 0; i < info.submaps; i++)
{
int ch_in_bundle = 0;
int **classifications;
int resnum = info.residuesubmap[i];
for (j = 0; j < vi.channels; j++)
{
if (info.chmuxlist[j] == i)
{
zerobundle[ch_in_bundle] = 0;
if (nonzero[j] != 0)
{
zerobundle[ch_in_bundle] = 1;
}
couple_bundle[ch_in_bundle++] = iwork[j];
}
}
classifications = _residue_P[ci.residue_type[resnum]]._class(ref vb, b.residue[resnum], couple_bundle, zerobundle, ch_in_bundle);
ch_in_bundle = 0;
for (j = 0; j < vi.channels; j++)
{
if (info.chmuxlist[j] == i)
{
couple_bundle[ch_in_bundle++] = iwork[j];
}
}
_residue_P[ci.residue_type[resnum]].forward(ref opb, ref vb, b.residue[resnum], couple_bundle, zerobundle, ch_in_bundle, classifications, i);
}
/* ok, done encoding. Next protopacket. */
}
}
return(0);
}
}