claunia/cuetools.net
1
0
Fork 0
mirror of https://github.com/claunia/cuetools.net.git synced 2025-12-16 18:14:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
5e37052bc1045485e1a310477cc8219c38bdc604
cuetools.net/CUETools.Codecs.ALAC/ALACWriter.cs
chudov 5e37052bc1 ALAC encoder
2009-08-30 21:58:54 +00:00

1726 lines
52 KiB
C#
Raw Blame History

/**
* CUETools.Codecs.ALAC: pure managed ALAC audio encoder
* Copyright (c) 2009 Gregory S. Chudov
* Based on ffdshow ALAC audio encoder
* Copyright (c) 2008 Jaikrishnan Menon, realityman@gmx.net
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
using System;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Collections.Specialized;
//using System.Runtime.InteropServices;
using CUETools.Codecs;
namespace CUETools.Codecs.ALAC
{
public class ALACWriter : IAudioDest
{
Stream _IO = null;
string _path;
long _position;
// number of audio channels
// valid values are 1 to 8
int channels, ch_code;
// audio sample rate in Hz
int sample_rate;
// sample size in bits
// only 16-bit is currently supported
uint bits_per_sample;
// total stream samples
// if 0, stream length is unknown
int sample_count;
ALACEncodeParams eparams;
// maximum frame size in bytes
// this can be used to allocate memory for output
int max_frame_size;
int initial_history, history_mult, k_modifier;
byte[] frame_buffer = null;
int frame_count = 0;
long first_frame_offset = 0;
TimeSpan _userProcessorTime;
// header bytes
byte[] header;
uint[] _sample_byte_size;
int[] samplesBuffer;
int[] verifyBuffer;
int[] residualBuffer;
double[] windowBuffer;
int samplesInBuffer = 0;
int _compressionLevel = 4;
int _blocksize = 0;
int _totalSize = 0;
int _windowsize = 0, _windowcount = 0;
Crc8 crc8;
Crc16 crc16;
ALACFrame frame;
ALACReader verify;
int mdat_pos;
bool inited = false;
List<int> chunk_pos;
public ALACWriter(string path, int bitsPerSample, int channelCount, int sampleRate, Stream IO)
{
if (bitsPerSample != 16)
throw new Exception("Bits per sample must be 16.");
if (channelCount != 2)
throw new Exception("ChannelCount must be 2.");
channels = channelCount;
sample_rate = sampleRate;
bits_per_sample = (uint) bitsPerSample;
_path = path;
_IO = IO;
samplesBuffer = new int[Alac.MAX_BLOCKSIZE * (channels == 2 ? 5 : channels)];
residualBuffer = new int[Alac.MAX_BLOCKSIZE * (channels == 2 ? 6 : channels + 1)];
windowBuffer = new double[Alac.MAX_BLOCKSIZE * 2 * lpc.MAX_LPC_WINDOWS];
eparams.set_defaults(_compressionLevel);
eparams.padding_size = 8192;
crc8 = new Crc8();
crc16 = new Crc16();
frame = new ALACFrame(channels == 2 ? 5 : channels);
chunk_pos = new List<int>();
}
public int TotalSize
{
get
{
return _totalSize;
}
}
public int PaddingLength
{
get
{
return eparams.padding_size;
}
set
{
eparams.padding_size = value;
}
}
public int CompressionLevel
{
get
{
return _compressionLevel;
}
set
{
if (value < 0 || value > 11)
throw new Exception("unsupported compression level");
_compressionLevel = value;
eparams.set_defaults(_compressionLevel);
}
}
//[DllImport("kernel32.dll")]
//static extern bool GetThreadTimes(IntPtr hThread, out long lpCreationTime, out long lpExitTime, out long lpKernelTime, out long lpUserTime);
//[DllImport("kernel32.dll")]
//static extern IntPtr GetCurrentThread();
void chunk_start(BitWriter bitwriter)
{
bitwriter.flush();
chunk_pos.Add(bitwriter.Length);
bitwriter.writebits(32, 0); // length placeholder
}
void chunk_end(BitWriter bitwriter)
{
bitwriter.flush();
int pos = chunk_pos[chunk_pos.Count - 1];
chunk_pos.RemoveAt(chunk_pos.Count - 1);
int chunk_end = bitwriter.Length;
bitwriter.Length = pos;
bitwriter.writebits(32, chunk_end - pos);
bitwriter.Length = chunk_end;
}
void DoClose()
{
if (inited)
{
while (samplesInBuffer > 0)
output_frame(samplesInBuffer);
if (_IO.CanSeek)
{
int mdat_len = (int)_IO.Position - mdat_pos;
_IO.Position = mdat_pos;
BitWriter bitwriter = new BitWriter(header, 0, 4);
bitwriter.writebits(32, mdat_len);
bitwriter.flush();
_IO.Write(header, 0, 4);
_IO.Position = _IO.Length;
int trailer_len = write_trailers();
_IO.Write(header, 0, trailer_len);
}
_IO.Close();
inited = false;
}
//long fake, KernelStart, UserStart;
//GetThreadTimes(GetCurrentThread(), out fake, out fake, out KernelStart, out UserStart);
//_userProcessorTime = new TimeSpan(UserStart);
}
public void Close()
{
DoClose();
if (sample_count != 0 && _position != sample_count)
throw new Exception("Samples written differs from the expected sample count.");
}
public void Delete()
{
if (inited)
{
_IO.Close();
inited = false;
}
if (_path != "")
File.Delete(_path);
}
public long Position
{
get
{
return _position;
}
}
public long FinalSampleCount
{
set { sample_count = (int)value; }
}
public long BlockSize
{
set { _blocksize = (int)value; }
get { return _blocksize == 0 ? eparams.block_size : _blocksize; }
}
public OrderMethod OrderMethod
{
get { return eparams.order_method; }
set { eparams.order_method = value; }
}
public StereoMethod StereoMethod
{
get { return eparams.stereo_method; }
set { eparams.stereo_method = value; }
}
public WindowFunction WindowFunction
{
get { return eparams.window_function; }
set { eparams.window_function = value; }
}
public bool DoVerify
{
get { return eparams.do_verify; }
set { eparams.do_verify = value; }
}
public bool DoSeekTable
{
get { return eparams.do_seektable; }
set { eparams.do_seektable = value; }
}
public int MinLPCOrder
{
get
{
return eparams.min_prediction_order;
}
set
{
if (value < 1)
throw new Exception("invalid MinLPCOrder " + value.ToString());
eparams.min_prediction_order = value;
if (eparams.max_prediction_order < value)
eparams.max_prediction_order = value;
}
}
public int MaxLPCOrder
{
get
{
return eparams.max_prediction_order;
}
set
{
if (value > 30 || value < eparams.min_prediction_order)
throw new Exception("invalid MaxLPCOrder " + value.ToString());
eparams.max_prediction_order = value;
if (eparams.min_prediction_order > value)
eparams.min_prediction_order = value;
}
}
public int MinHistoryModifier
{
get
{
return eparams.min_modifier;
}
set
{
if (value < 1)
throw new Exception("invalid MinHistoryModifier " + value.ToString());
eparams.min_modifier = value;
if (eparams.max_modifier < value)
eparams.max_modifier = value;
}
}
public int MaxHistoryModifier
{
get
{
return eparams.max_modifier;
}
set
{
if (value > 100)
throw new Exception("invalid MaxHistoryModifier " + value.ToString());
eparams.max_modifier = value;
if (eparams.min_modifier > value)
eparams.min_modifier = value;
}
}
public int EstimationDepth
{
get
{
return eparams.estimation_depth;
}
set
{
if (value > 32 || value < 1)
throw new Exception("invalid estimation_depth " + value.ToString());
eparams.estimation_depth = value;
}
}
public TimeSpan UserProcessorTime
{
get { return _userProcessorTime; }
}
public int BitsPerSample
{
get { return 16; }
}
/// <summary>
/// Copy channel-interleaved input samples into separate subframes
/// </summary>
/// <param name="samples"></param>
/// <param name="pos"></param>
/// <param name="block"></param>
unsafe void copy_samples(int[,] samples, int pos, int block)
{
fixed (int* fsamples = samplesBuffer, src = &samples[pos, 0])
{
if (channels == 2)
AudioSamples.Deinterlace(fsamples + samplesInBuffer, fsamples + Alac.MAX_BLOCKSIZE + samplesInBuffer, src, block);
else
for (int ch = 0; ch < channels; ch++)
{
int* psamples = fsamples + ch * Alac.MAX_BLOCKSIZE + samplesInBuffer;
for (int i = 0; i < block; i++)
psamples[i] = src[i * channels + ch];
}
}
samplesInBuffer += block;
}
unsafe static void channel_decorrelation(int* leftS, int* rightS, int *leftM, int *rightM, int blocksize)
{
for (int i = 0; i < blocksize; i++)
{
leftM[i] = (leftS[i] + rightS[i]) >> 1;
rightM[i] = leftS[i] - rightS[i];
}
}
unsafe static void channel_decorrelation(int* leftS, int* rightS, int* leftM, int* rightM, int blocksize, int leftweight, int shift)
{
for (int i = 0; i < blocksize; i++)
{
leftM[i] = rightS[i] + ((leftS[i] - rightS[i]) * leftweight >> shift);
rightM[i] = leftS[i] - rightS[i];
}
}
private static int extend_sign32(int val, int bits)
{
return (val << (32 - bits)) >> (32 - bits);
}
private static short sign_only(int val)
{
return (short)((val >> 31) + ((val - 1) >> 31) + 1);
}
unsafe static void alac_encode_residual_31(int* res, int* smp, int n)
{
res[0] = smp[0];
for (int i = 1; i < n; i++)
res[i] = smp[i] - smp[i - 1];
}
unsafe static void alac_encode_residual_0(int* res, int* smp, int n)
{
AudioSamples.MemCpy(res, smp, n);
}
unsafe static void alac_encode_residual(int* res, int* smp, int n, int order, int* coefs, int shift, int bps)
{
int csum = 0;
for (int i = order - 1; i >= 0; i--)
csum += coefs[i];
if (n <= order || order <= 0 || order > 30)
throw new Exception("invalid output");
/* generate warm-up samples */
res[0] = smp[0];
for (int i = 1; i <= order; i++)
res[i] = smp[i] - smp[i - 1];
/* general case */
for (int i = order + 1; i < n; i++)
{
int sample = *(smp++);
int/*long*/ sum = (1 << (shift - 1)) -csum * sample;
int sum2 = 0;
for (int j = 0; j < order; j+= 2)
{
sum += smp[j] * coefs[j];
sum2 += smp[j+1] * coefs[j+1];
}
int resval = extend_sign32(smp[order] - (int)((sum + sum2) >> shift) - sample, bps);
res[i] = resval;
int error_sign = sign_only(resval);
for (int j = 0; j < order && resval * error_sign > 0; j++)
{
int val = sample - smp[j];
int sign = error_sign * sign_only(val);
coefs[j] -= sign;
csum -= sign;
resval -= ((val * sign) >> shift) * (j + 1);
//error_sign = (error_sign + sign_only(resval)) / 2;
}
}
res[n] = 1; // Stop byte to help alac_entropy_coder;
}
unsafe static int encode_scalar(int x, int k, int bps)
{
int divisor = (1 << k) - 1;
int q = x / divisor;
int r = x % divisor;
return q > 8 ? 9 + bps : q + k + (r - 1 >> 31) + 1;//== 0 ? 0 : 1);
}
unsafe void encode_scalar(BitWriter bitwriter, int x, int k, int bps)
{
k = Math.Min(k, k_modifier);
int divisor = (1 << k) - 1;
int q = x / divisor;
int r = x % divisor;
if (q > 8)
{
// write escape code and sample value directly
bitwriter.writebits(9, 0x1ff);
bitwriter.writebits(bps, x);
return;
}
// q times one, then 1 zero, e.g. q == 3 is written as 1110
int unary = ((1 << (q + 1)) - 2);
if (r == 0)
{
bitwriter.writebits(q + k, unary << (k - 1));
return;
}
bitwriter.writebits(q + 1 + k, (unary << k) + r + 1);
}
unsafe int alac_entropy_coder(int* res, int n, int bps, out int modifier)
{
int size = 1 << 30;
modifier = eparams.min_modifier;
for (int i = eparams.min_modifier; i <= eparams.max_modifier; i++)
{
int newsize = alac_entropy_coder(res, n, bps, i);
if (size > newsize)
{
size = newsize;
modifier = i;
}
}
return size;
}
unsafe int alac_entropy_coder(int* res, int n, int bps, int modifier)
{
int history = initial_history;
int sign_modifier = 0;
int rice_historymult = modifier * history_mult / 4;
int size = 0;
for (int i = 0; i < n; )
{
int k = BitReader.log2i((history >> 9) + 3);
int x = -2 * (*res) - 1;
x ^= (x >> 31);
res++;
i++;
size += encode_scalar(x - sign_modifier, Math.Min(k, k_modifier), bps);
history += x * rice_historymult - ((history * rice_historymult) >> 9);
sign_modifier = 0;
if (x > 0xFFFF)
history = 0xFFFF;
if (history < 128 && i < n)
{
k = 7 - BitReader.log2i(history) + ((history + 16) >> 6);
int block_size = 0;
while (res[block_size] == 0) // we have a stop byte, so need not check if i + blocksize < n
block_size++;
res += block_size;
i += block_size;
size += encode_scalar(block_size, Math.Min(k, k_modifier), 16);
//sign_modifier = (block_size <= 0xFFFF) ? 1 : 0; //never happens
sign_modifier = 1;
history = 0;
}
}
return size;
}
unsafe void alac_entropy_coder(BitWriter bitwriter, int* res, int n, int bps, int modifier)
{
int history = initial_history;
int sign_modifier = 0;
int rice_historymult = modifier * history_mult / 4;
for (int i = 0; i < n; )
{
int k = BitReader.log2i((history >> 9) + 3);
int x = -2 * (*res) - 1;
x ^= (x >> 31);
res++;
i++;
encode_scalar(bitwriter, x - sign_modifier, k, bps);
history += x * rice_historymult - ((history * rice_historymult) >> 9);
sign_modifier = 0;
if (x > 0xFFFF)
history = 0xFFFF;
if (history < 128 && i < n)
{
k = 7 - BitReader.log2i(history) + ((history + 16) >> 6);
int block_size = 0;
while (res[block_size] == 0) // we have a stop byte, so need not check if i + blocksize < n
block_size++;
res += block_size;
i += block_size;
encode_scalar(bitwriter, block_size, k, 16);
sign_modifier = (block_size <= 0xFFFF) ? 1 : 0;
history = 0;
}
}
}
unsafe void encode_residual_lpc_sub(ALACFrame frame, double * lpcs, int iWindow, int order, int ch)
{
// select LPC precision based on block size
uint lpc_precision = 15;
int i_precision = 0;
//if (frame.blocksize <= 192) lpc_precision = 7U;
//else if (frame.blocksize <= 384) lpc_precision = 8U;
//else if (frame.blocksize <= 576) lpc_precision = 9U;
//else if (frame.blocksize <= 1152) lpc_precision = 10U;
//else if (frame.blocksize <= 2304) lpc_precision = 11U;
//else if (frame.blocksize <= 4608) lpc_precision = 12U;
//else if (frame.blocksize <= 8192) lpc_precision = 13U;
//else if (frame.blocksize <= 16384) lpc_precision = 14U;
//for (int i_precision = eparams.lpc_min_precision_search; i_precision <= eparams.lpc_max_precision_search && lpc_precision + i_precision < 16; i_precision++)
// check if we already calculated with this order, window and precision
if ((frame.subframes[ch].lpc_ctx[iWindow].done_lpcs[i_precision] & (1U << (order - 1))) == 0)
{
frame.subframes[ch].lpc_ctx[iWindow].done_lpcs[i_precision] |= (1U << (order - 1));
uint cbits = lpc_precision + (uint)i_precision;
frame.current.order = order;
frame.current.window = iWindow;
int bps = (int)bits_per_sample + channels - 1;
int* coefs = stackalloc int[lpc.MAX_LPC_ORDER];
lpc.quantize_lpc_coefs(lpcs + (frame.current.order - 1) * lpc.MAX_LPC_ORDER,
frame.current.order, cbits, coefs, out frame.current.shift, 15, 1);
if (frame.current.shift < 0 || frame.current.shift > 15)
throw new Exception("negative shift");
for (int i = 0; i < frame.current.order; i++)
frame.current.coefs[i] = coefs[i];
for (int i = 0; i < frame.current.order; i++)
coefs[i] = frame.current.coefs[frame.current.order - 1 - i];
coefs[frame.current.order] = 0;
alac_encode_residual(frame.current.residual, frame.subframes[ch].samples, frame.blocksize,
frame.current.order, coefs, frame.current.shift, bps);
frame.current.size = (uint)(alac_entropy_coder(frame.current.residual, frame.blocksize, bps, out frame.current.ricemodifier) + 16 + 16 * order);
frame.ChooseBestSubframe(ch);
}
}
unsafe void encode_residual(ALACFrame frame, int ch, OrderMethod omethod, int pass)
{
int* smp = frame.subframes[ch].samples;
int i, n = frame.blocksize;
int best_window = frame.subframes[ch].best.window;
int bps = (int)bits_per_sample + channels - 1;
// FIXED
//if (0 == (2 & frame.subframes[ch].done_fixed) && (pass != 1 || n < eparams.max_prediction_order))
//{
// frame.subframes[ch].done_fixed |= 2;
// frame.current.order = 31;
// frame.current.window = -1;
// alac_encode_residual_31(frame.current.residual, frame.subframes[ch].samples, frame.blocksize);
// frame.current.size = (uint)(alac_entropy_coder(frame.current.residual, frame.blocksize, bps, out frame.current.ricemodifier) + 16);
// frame.ChooseBestSubframe(ch);
//}
//if (0 == (1 & frame.subframes[ch].done_fixed) && (pass != 1 || n < eparams.max_prediction_order))
//{
// frame.subframes[ch].done_fixed |= 1;
// frame.current.order = 0;
// frame.current.window = -1;
// alac_encode_residual_0(frame.current.residual, frame.subframes[ch].samples, frame.blocksize);
// frame.current.size = (uint)(alac_entropy_coder(frame.current.residual, frame.blocksize, bps, out frame.current.ricemodifier) + 16);
// frame.ChooseBestSubframe(ch);
//}
// LPC
if (n < eparams.max_prediction_order)
return;
double* lpcs = stackalloc double[lpc.MAX_LPC_ORDER * lpc.MAX_LPC_ORDER];
int min_order = eparams.min_prediction_order;
int max_order = eparams.max_prediction_order;
for (int iWindow = 0; iWindow < _windowcount; iWindow++)
{
if (pass == 2 && iWindow != best_window)
continue;
LpcContext lpc_ctx = frame.subframes[ch].lpc_ctx[iWindow];
lpc_ctx.GetReflection(max_order, smp, n, frame.window_buffer + iWindow * Alac.MAX_BLOCKSIZE * 2);
lpc_ctx.ComputeLPC(lpcs);
switch (omethod)
{
case OrderMethod.Max:
// always use maximum order
encode_residual_lpc_sub(frame, lpcs, iWindow, max_order, ch);
break;
case OrderMethod.Estimate:
// estimated orders
// Search at reflection coeff thresholds (where they cross 0.10)
{
int found = 0;
for (i = max_order; i >= min_order && found < eparams.estimation_depth; i--)
if (lpc_ctx.IsInterestingOrder(i))
{
encode_residual_lpc_sub(frame, lpcs, iWindow, i, ch);
found++;
}
if (0 == found)
encode_residual_lpc_sub(frame, lpcs, iWindow, min_order, ch);
}
break;
case OrderMethod.EstSearch2:
// Search at reflection coeff thresholds (where they cross 0.10)
{
int found = 0;
for (i = min_order; i <= max_order && found < eparams.estimation_depth; i++)
if (lpc_ctx.IsInterestingOrder(i))
{
encode_residual_lpc_sub(frame, lpcs, iWindow, i, ch);
found++;
}
if (0 == found)
encode_residual_lpc_sub(frame, lpcs, iWindow, min_order, ch);
}
break;
case OrderMethod.Search:
// brute-force optimal order search
for (i = max_order; i >= min_order; i--)
encode_residual_lpc_sub(frame, lpcs, iWindow, i, ch);
break;
case OrderMethod.LogFast:
// Try max, est, 32,16,8,4,2,1
encode_residual_lpc_sub(frame, lpcs, iWindow, max_order, ch);
for (i = lpc.MAX_LPC_ORDER; i >= min_order; i >>= 1)
if (i < max_order)
encode_residual_lpc_sub(frame, lpcs, iWindow, i, ch);
break;
default:
throw new Exception("unknown ordermethod");
}
}
}
unsafe void output_frame_header(ALACFrame frame, BitWriter bitwriter)
{
bitwriter.writebits(3, channels - 1);
bitwriter.writebits(16, 0);
bitwriter.writebits(1, frame.blocksize != eparams.block_size ? 1 : 0); // sample count is in the header
bitwriter.writebits(2, 0); // wasted bytes
bitwriter.writebits(1, frame.type == FrameType.Verbatim ? 1 : 0); // is verbatim
if (frame.blocksize != eparams.block_size)
bitwriter.writebits(32, frame.blocksize);
if (frame.type != FrameType.Verbatim)
{
bitwriter.writebits(8, frame.interlacing_shift);
bitwriter.writebits(8, frame.interlacing_leftweight);
for (int ch = 0; ch < channels; ch++)
{
bitwriter.writebits(4, 0); // prediction type
bitwriter.writebits(4, frame.subframes[ch].best.shift);
bitwriter.writebits(3, frame.subframes[ch].best.ricemodifier);
bitwriter.writebits(5, frame.subframes[ch].best.order);
if (frame.subframes[ch].best.order != 31)
for (int c = 0; c < frame.subframes[ch].best.order; c++)
bitwriter.writebits_signed(16, frame.subframes[ch].best.coefs[c]);
}
}
}
void output_frame_footer(BitWriter bitwriter)
{
bitwriter.writebits(3, 7);
bitwriter.flush();
}
unsafe void window_welch(double* window, int L)
{
int N = L - 1;
double N2 = (double)N / 2.0;
for (int n = 0; n <= N; n++)
{
double k = 1 / N2 - 1.0 - Math.Min(n, N - n);
//double k = ((double)n - N2) / N2;
window[n] = 1.0 - k * k;
}
}
unsafe void window_rectangle(double* window, int L)
{
for (int n = 0; n < L; n++)
window[n] = 1.0;
}
unsafe void window_flattop(double* window, int L)
{
int N = L - 1;
for (int n = 0; n < L; n++)
window[n] = 1.0 - 1.93 * Math.Cos(2.0 * Math.PI * n / N) + 1.29 * Math.Cos(4.0 * Math.PI * n / N) - 0.388 * Math.Cos(6.0 * Math.PI * n / N) + 0.0322 * Math.Cos(8.0 * Math.PI * n / N);
}
unsafe void window_tukey(double* window, int L)
{
window_rectangle(window, L);
double p = 0.5;
int Np = (int)(p / 2.0 * L) - 1;
if (Np > 0)
{
for (int n = 0; n <= Np; n++)
{
window[n] = 0.5 - 0.5 * Math.Cos(Math.PI * n / Np);
window[L - Np - 1 + n] = 0.5 - 0.5 * Math.Cos(Math.PI * (n + Np) / Np);
}
}
}
unsafe void window_hann(double* window, int L)
{
int N = L - 1;
for (int n = 0; n < L; n++)
window[n] = 0.5 - 0.5 * Math.Cos(2.0 * Math.PI * n / N);
}
unsafe void encode_residual_pass1(ALACFrame frame, int ch)
{
int max_prediction_order = eparams.max_prediction_order;
int estimation_depth = eparams.estimation_depth;
int min_modifier = eparams.min_modifier;
eparams.max_prediction_order = Math.Min(8,eparams.max_prediction_order);
eparams.estimation_depth = 1;
eparams.min_modifier = eparams.max_modifier;
encode_residual(frame, ch, OrderMethod.Estimate, 1);
eparams.max_prediction_order = max_prediction_order;
eparams.estimation_depth = estimation_depth;
eparams.min_modifier = min_modifier;
}
unsafe void encode_residual_pass2(ALACFrame frame, int ch)
{
encode_residual(frame, ch, eparams.order_method, 2);
}
unsafe void encode_residual_onepass(ALACFrame frame, int ch)
{
if (_windowcount > 1)
{
encode_residual_pass1(frame, ch);
encode_residual_pass2(frame, ch);
}
else
encode_residual(frame, ch, eparams.order_method, 0);
}
unsafe void estimate_frame(ALACFrame frame, bool do_midside)
{
int subframes = do_midside ? 5 : channels;
switch (eparams.stereo_method)
{
case StereoMethod.Evaluate:
for (int ch = 0; ch < subframes; ch++)
{
int windowcount = _windowcount;
_windowcount = 1;
encode_residual_pass1(frame, ch);
_windowcount = windowcount;
}
break;
case StereoMethod.Search:
for (int ch = 0; ch < subframes; ch++)
encode_residual_onepass(frame, ch);
break;
}
}
unsafe uint measure_frame_size(ALACFrame frame, bool do_midside)
{
// crude estimation of header/footer size
uint total = 16 + 3;
if (do_midside)
{
uint bitsBest = frame.subframes[0].best.size + frame.subframes[1].best.size;
frame.interlacing_leftweight = 0;
frame.interlacing_shift = 0;
if (bitsBest > frame.subframes[3].best.size + frame.subframes[0].best.size) // leftside
{
bitsBest = frame.subframes[3].best.size + frame.subframes[0].best.size;
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 0;
}
if (bitsBest > frame.subframes[3].best.size + frame.subframes[2].best.size) // midside
{
bitsBest = frame.subframes[3].best.size + frame.subframes[2].best.size;
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 1;
}
if (bitsBest > frame.subframes[3].best.size + frame.subframes[4].best.size) // rightside
{
bitsBest = frame.subframes[3].best.size + frame.subframes[4].best.size;
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 31;
}
return total + bitsBest;
}
for (int ch = 0; ch < channels; ch++)
total += frame.subframes[ch].best.size;
return total;
}
unsafe void encode_estimated_frame(ALACFrame frame)
{
switch (eparams.stereo_method)
{
case StereoMethod.Evaluate:
for (int ch = 0; ch < channels; ch++)
{
if (_windowcount > 1)
encode_residual_pass1(frame, ch);
encode_residual_pass2(frame, ch);
}
break;
case StereoMethod.Search:
break;
}
}
unsafe delegate void window_function(double* window, int size);
unsafe void calculate_window(double* window, window_function func, WindowFunction flag)
{
if ((eparams.window_function & flag) == 0 || _windowcount == lpc.MAX_LPC_WINDOWS)
return;
int sz = _windowsize;
double* pos = window + _windowcount * Alac.MAX_BLOCKSIZE * 2;
do
{
func(pos, sz);
if ((sz & 1) != 0)
break;
pos += sz;
sz >>= 1;
} while (sz >= 32);
_windowcount++;
}
unsafe int encode_frame(ref int size)
{
fixed (int* s = samplesBuffer, r = residualBuffer)
fixed (double* window = windowBuffer)
{
frame.InitSize(size);
if (frame.blocksize != _windowsize && frame.blocksize > 4)
{
_windowsize = frame.blocksize;
_windowcount = 0;
calculate_window(window, window_welch, WindowFunction.Welch);
calculate_window(window, window_tukey, WindowFunction.Tukey);
calculate_window(window, window_hann, WindowFunction.Hann);
calculate_window(window, window_flattop, WindowFunction.Flattop);
if (_windowcount == 0)
throw new Exception("invalid windowfunction");
}
frame.window_buffer = window;
int bps = (int)bits_per_sample + channels - 1;
if (channels != 2 || frame.blocksize <= 32 || eparams.stereo_method == StereoMethod.Independent)
{
frame.current.residual = r + channels * Alac.MAX_BLOCKSIZE;
for (int ch = 0; ch < channels; ch++)
frame.subframes[ch].Init(s + ch * Alac.MAX_BLOCKSIZE, r + ch * Alac.MAX_BLOCKSIZE);
for (int ch = 0; ch < channels; ch++)
encode_residual_onepass(frame, ch);
}
else if (eparams.stereo_method == StereoMethod.Estimate || eparams.stereo_method == StereoMethod.Estimate2)
{
int* sl = s;
int* sr = s + Alac.MAX_BLOCKSIZE;
int n = frame.blocksize;
ulong lsum = 0, rsum = 0, dsum = 0, s31 = 0, s1 = 0, s2 = 0, s3 = 0;
if (eparams.stereo_method == StereoMethod.Estimate)
for (int i = 2; i < n; i++)
{
int lt = sl[i] - 2 * sl[i - 1] + sl[i - 2];
int rt = sr[i] - 2 * sr[i - 1] + sr[i - 2];
int df = lt - rt;
lsum += (ulong)Math.Abs(lt);
rsum += (ulong)Math.Abs(rt);
dsum += (ulong)Math.Abs(df);
s1 += (ulong)Math.Abs(rt + (df >> 1));
s31 += (ulong)Math.Abs(rt + (df >> 31));
}
else
for (int i = 2; i < n; i++)
{
int lt = sl[i] - 2 * sl[i - 1] + sl[i - 2];
int rt = sr[i] - 2 * sr[i - 1] + sr[i - 2];
int df = lt - rt;
lsum += (ulong)Math.Abs(lt);
rsum += (ulong)Math.Abs(rt);
dsum += (ulong)Math.Abs(df);
s1 += (ulong)Math.Abs(rt + (df >> 1));
s2 += (ulong)Math.Abs(rt + (df >> 2));
s3 += (ulong)Math.Abs(rt + (df * 3 >> 2));
s31 += (ulong)Math.Abs(rt + (df >> 31));
}
frame.interlacing_leftweight = 0;
frame.interlacing_shift = 0;
ulong score = lsum + rsum;
if (lsum + dsum < score) //leftside
{
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 0;
score = lsum + dsum;
}
if (s1 + dsum < score) // midside
{
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 1;
score = s1 + dsum;
}
if (s31 + dsum < score) // rightside
{
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 31;
score = s31 + dsum;
}
if (eparams.stereo_method == StereoMethod.Estimate2)
{
if (s2 + dsum < score) // close to rightside
{
frame.interlacing_leftweight = 1;
frame.interlacing_shift = 2;
score = s2 + dsum;
}
if (s3 + dsum < score) // close to leftside
{
frame.interlacing_leftweight = 3;
frame.interlacing_shift = 2;
score = s3 + dsum;
}
}
if (frame.interlacing_leftweight == 0)
{
frame.current.residual = r + channels * Alac.MAX_BLOCKSIZE;
for (int ch = 0; ch < channels; ch++)
frame.subframes[ch].Init(s + ch * Alac.MAX_BLOCKSIZE, r + ch * Alac.MAX_BLOCKSIZE);
}
else
{
frame.current.residual = r + 2 * channels * Alac.MAX_BLOCKSIZE;
channel_decorrelation(s, s + Alac.MAX_BLOCKSIZE, s + 2 * Alac.MAX_BLOCKSIZE, s + 3 * Alac.MAX_BLOCKSIZE, frame.blocksize,
frame.interlacing_leftweight, frame.interlacing_shift);
for (int ch = 0; ch < channels; ch++)
frame.subframes[ch].Init(s + (channels + ch) * Alac.MAX_BLOCKSIZE, r + (channels + ch) * Alac.MAX_BLOCKSIZE);
}
for (int ch = 0; ch < channels; ch++)
encode_residual_onepass(frame, ch);
}
else
{
channel_decorrelation(s, s + Alac.MAX_BLOCKSIZE, s + 2 * Alac.MAX_BLOCKSIZE, s + 3 * Alac.MAX_BLOCKSIZE, frame.blocksize, 1, 1);
channel_decorrelation(s, s + Alac.MAX_BLOCKSIZE, s + 4 * Alac.MAX_BLOCKSIZE, s + 3 * Alac.MAX_BLOCKSIZE, frame.blocksize, 1, 31);
frame.current.residual = r + 5 * Alac.MAX_BLOCKSIZE;
for (int ch = 0; ch < 5; ch++)
frame.subframes[ch].Init(s + ch * Alac.MAX_BLOCKSIZE, r + ch * Alac.MAX_BLOCKSIZE);
estimate_frame(frame, true);
measure_frame_size(frame, true);
frame.ChooseSubframes();
encode_estimated_frame(frame);
}
uint fs = measure_frame_size(frame, false);
frame.type = ((int)fs > frame.blocksize * channels * bps) ? FrameType.Verbatim : FrameType.Compressed;
BitWriter bitwriter = new BitWriter(frame_buffer, 0, max_frame_size);
output_frame_header(frame, bitwriter);
if (frame.type == FrameType.Verbatim)
{
for (int i = 0; i < frame.blocksize; i++)
for (int ch = 0; ch < channels; ch++)
bitwriter.writebits_signed((int)bits_per_sample, frame.subframes[ch].samples[i]);
}
else if (frame.type == FrameType.Compressed)
{
for (int ch = 0; ch < channels; ch++)
alac_entropy_coder(bitwriter, frame.subframes[ch].best.residual, frame.blocksize,
bps, frame.subframes[ch].best.ricemodifier);
}
output_frame_footer(bitwriter);
_sample_byte_size[frame_count++] = (uint)bitwriter.Length;
size = frame.blocksize;
return bitwriter.Length;
}
}
unsafe int output_frame(int blocksize)
{
if (verify != null)
{
fixed (int* s = verifyBuffer, r = samplesBuffer)
for (int ch = 0; ch < channels; ch++)
AudioSamples.MemCpy(s + ch * Alac.MAX_BLOCKSIZE, r + ch * Alac.MAX_BLOCKSIZE, eparams.block_size);
}
//if (0 != eparams.variable_block_size && 0 == (eparams.block_size & 7) && eparams.block_size >= 128)
// fs = encode_frame_vbs();
//else
int bs = blocksize;
int fs = encode_frame(ref bs);
_position += bs;
_IO.Write(frame_buffer, 0, fs);
_totalSize += fs;
if (verify != null)
{
int decoded = verify.DecodeFrame(frame_buffer, 0, fs);
if (decoded != fs || verify.Remaining != (ulong)bs)
throw new Exception("validation failed!");
int [,] deinterlaced = new int[bs,channels];
verify.deinterlace(deinterlaced, 0, (uint)bs);
fixed (int* s = verifyBuffer, r = deinterlaced)
{
for (int i = 0; i < bs; i++)
for (int ch = 0; ch < channels; ch++)
if (r[i * channels + ch] != s[ch * Alac.MAX_BLOCKSIZE + i])
throw new Exception("validation failed!");
}
}
if (bs < blocksize)
{
fixed (int* s = samplesBuffer)
for (int ch = 0; ch < channels; ch++)
AudioSamples.MemCpy(s + ch * Alac.MAX_BLOCKSIZE, s + bs + ch * Alac.MAX_BLOCKSIZE, eparams.block_size - bs);
}
samplesInBuffer -= bs;
return bs;
}
public void Write(int[,] buff, int pos, int sampleCount)
{
if (!inited)
{
if (_IO == null)
_IO = new FileStream(_path, FileMode.Create, FileAccess.Write, FileShare.Read);
int header_size = encode_init();
_IO.Write(header, 0, header_size);
if (_IO.CanSeek)
first_frame_offset = _IO.Position;
inited = true;
}
int len = sampleCount;
while (len > 0)
{
int block = Math.Min(len, eparams.block_size - samplesInBuffer);
copy_samples(buff, pos, block);
len -= block;
pos += block;
while (samplesInBuffer >= eparams.block_size)
output_frame(eparams.block_size);
}
}
public string Path { get { return _path; } }
string vendor_string = "CUETools.2.05";
int select_blocksize(int samplerate, int time_ms)
{
int target = (samplerate * time_ms) / 1000;
int blocksize = 1024;
while (target >= blocksize)
blocksize <<= 1;
return blocksize >> 1;
}
void write_chunk_mvhd(BitWriter bitwriter, TimeSpan UnixTime)
{
chunk_start(bitwriter);
{
bitwriter.write('m', 'v', 'h', 'd');
bitwriter.writebits(32, 0);
bitwriter.writebits(32, (int)UnixTime.TotalSeconds);
bitwriter.writebits(32, (int)UnixTime.TotalSeconds);
bitwriter.writebits(32, 1000);
bitwriter.writebits(32, sample_count);
bitwriter.writebits(32, 0x00010000); // reserved (preferred rate) 1.0 = normal
bitwriter.writebits(16, 0x0100); // reserved (preferred volume) 1.0 = normal
bitwriter.writebytes(10, 0); // reserved
bitwriter.writebits(32, 0x00010000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00010000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x40000000); // reserved (matrix structure)
bitwriter.writebits(32, 0); // preview time
bitwriter.writebits(32, 0); // preview duration
bitwriter.writebits(32, 0); // poster time
bitwriter.writebits(32, 0); // selection time
bitwriter.writebits(32, 0); // selection duration
bitwriter.writebits(32, 0); // current time
bitwriter.writebits(32, 2); // next track ID
}
chunk_end(bitwriter);
}
void write_chunk_minf(BitWriter bitwriter)
{
chunk_start(bitwriter);
{
bitwriter.write('m', 'i', 'n', 'f');
chunk_start(bitwriter);
{
bitwriter.write('s', 'm', 'h', 'd');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(16, 0); // reserved (balance)
bitwriter.writebits(16, 0); // reserved
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('d', 'i', 'n', 'f');
chunk_start(bitwriter);
{
bitwriter.write('d', 'r', 'e', 'f');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, 1); // entry count
chunk_start(bitwriter);
{
bitwriter.write('u', 'r', 'l', ' ');
bitwriter.writebits(32, 1); // version & flags
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('s', 't', 'b', 'l');
chunk_start(bitwriter);
{
bitwriter.write('s', 't', 's', 'd');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, 1); // entry count
chunk_start(bitwriter);
{
bitwriter.write('a', 'l', 'a', 'c');
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(16, 0); // reserved
bitwriter.writebits(16, 1); // data reference index
bitwriter.writebits(16, 0); // version
bitwriter.writebits(16, 0); // revision
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(16, 2); // reserved channels
bitwriter.writebits(16, 16); // reserved bps
bitwriter.writebits(16, 0); // reserved compression ID
bitwriter.writebits(16, 0); // packet size
bitwriter.writebits(16, sample_rate); // time scale
bitwriter.writebits(16, 0); // reserved
chunk_start(bitwriter);
{
bitwriter.write('a', 'l', 'a', 'c');
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(32, eparams.block_size); // max frame size
bitwriter.writebits(8, 0); // reserved
bitwriter.writebits(8, bits_per_sample);
bitwriter.writebits(8, history_mult);
bitwriter.writebits(8, initial_history);
bitwriter.writebits(8, k_modifier);
bitwriter.writebits(8, channels); // channels
bitwriter.writebits(16, 0); // reserved
bitwriter.writebits(32, max_frame_size);
bitwriter.writebits(32, sample_rate * channels * (int)bits_per_sample); // average bitrate
bitwriter.writebits(32, sample_rate);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('s', 't', 't', 's');
bitwriter.writebits(32, 0); // version & flags
if (sample_count % eparams.block_size == 0)
{
bitwriter.writebits(32, 1); // entries
bitwriter.writebits(32, sample_count / eparams.block_size);
bitwriter.writebits(32, eparams.block_size);
}
else
{
bitwriter.writebits(32, 2); // entries
bitwriter.writebits(32, sample_count / eparams.block_size);
bitwriter.writebits(32, eparams.block_size);
bitwriter.writebits(32, 1);
bitwriter.writebits(32, sample_count % eparams.block_size);
}
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('s', 't', 's', 'c');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, 1); // entry count
bitwriter.writebits(32, 1); // first chunk
bitwriter.writebits(32, 1); // samples in chunk
bitwriter.writebits(32, 1); // sample description index
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('s', 't', 's', 'z');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, 0); // sample size (0 == variable)
bitwriter.writebits(32, frame_count); // entry count
for (int i = 0; i < frame_count; i++)
bitwriter.writebits(32, _sample_byte_size[i]);
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('s', 't', 'c', 'o');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, frame_count); // entry count
uint pos = (uint)mdat_pos + 8;
for (int i = 0; i < frame_count; i++)
{
bitwriter.writebits(32, pos);
pos += _sample_byte_size[i];
}
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
void write_chunk_mdia(BitWriter bitwriter, TimeSpan UnixTime)
{
chunk_start(bitwriter);
{
bitwriter.write('m', 'd', 'i', 'a');
chunk_start(bitwriter);
{
bitwriter.write('m', 'd', 'h', 'd');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, (int)UnixTime.TotalSeconds);
bitwriter.writebits(32, (int)UnixTime.TotalSeconds);
bitwriter.writebits(32, sample_rate);
bitwriter.writebits(32, sample_count);
bitwriter.writebits(16, 0x55c4); // language
bitwriter.writebits(16, 0); // quality
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('h', 'd', 'l', 'r');
bitwriter.writebits(32, 0); // version & flags
bitwriter.writebits(32, 0); // hdlr
bitwriter.write('s', 'o', 'u', 'n');
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(8, "SoundHandler".Length);
bitwriter.write("SoundHandler");
}
chunk_end(bitwriter);
write_chunk_minf(bitwriter);
}
chunk_end(bitwriter);
}
void write_chunk_trak(BitWriter bitwriter, TimeSpan UnixTime)
{
chunk_start(bitwriter);
{
bitwriter.write('t', 'r', 'a', 'k');
chunk_start(bitwriter);
{
bitwriter.write('t', 'k', 'h', 'd');
bitwriter.writebits(32, 15); // version
bitwriter.writebits(32, (int)UnixTime.TotalSeconds);
bitwriter.writebits(32, (int)UnixTime.TotalSeconds);
bitwriter.writebits(32, 1); // track ID
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(32, sample_count / sample_rate);
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(32, 0); // reserved
bitwriter.writebits(32, 0); // reserved (layer & alternate group)
bitwriter.writebits(16, 0x0100); // reserved (preferred volume) 1.0 = normal
bitwriter.writebits(16, 0); // reserved
bitwriter.writebits(32, 0x00010000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00010000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x00000000); // reserved (matrix structure)
bitwriter.writebits(32, 0x40000000); // reserved (matrix structure)
bitwriter.writebits(32, 0); // reserved (width)
bitwriter.writebits(32, 0); // reserved (height)
}
chunk_end(bitwriter);
write_chunk_mdia(bitwriter, UnixTime);
}
chunk_end(bitwriter);
}
void write_chunk_udta(BitWriter bitwriter)
{
chunk_start(bitwriter);
{
bitwriter.write('u', 'd', 't', 'a');
chunk_start(bitwriter);
{
bitwriter.write('m', 'e', 't', 'a');
bitwriter.writebits(32, 0);
chunk_start(bitwriter);
{
bitwriter.write('h', 'd', 'l', 'r');
bitwriter.writebits(32, 0);
bitwriter.writebits(32, 0);
bitwriter.write('m', 'd', 'i', 'r');
bitwriter.write('a', 'p', 'p', 'l');
bitwriter.writebits(32, 0);
bitwriter.writebits(32, 0);
bitwriter.writebits(16, 0);
}
chunk_end(bitwriter);
chunk_start(bitwriter);
{
bitwriter.write('i', 'l', 's', 't');
chunk_start(bitwriter);
{
bitwriter.write((char)0xA9, 't', 'o', 'o');
chunk_start(bitwriter);
{
bitwriter.write('d', 'a', 't', 'a');
bitwriter.writebits(32, 1);
bitwriter.writebits(32, 0);
bitwriter.write(vendor_string);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
chunk_end(bitwriter);
}
int write_trailers()
{
TimeSpan UnixTime = DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
header = new byte[0x1000 + frame_count * 8]; // FIXME!!! Possible buffer overrun
BitWriter bitwriter = new BitWriter(header, 0, header.Length);
chunk_start(bitwriter);
{
bitwriter.write('m', 'o', 'o', 'v');
write_chunk_mvhd(bitwriter, UnixTime);
write_chunk_trak(bitwriter, UnixTime);
write_chunk_udta(bitwriter);
}
chunk_end(bitwriter);
return bitwriter.Length;
}
int write_headers()
{
BitWriter bitwriter = new BitWriter(header, 0, header.Length);
chunk_start(bitwriter);
bitwriter.write('f', 't', 'y', 'p');
bitwriter.write('M', '4', 'A', ' ');
bitwriter.writebits(32, 0x200); // minor version
bitwriter.write('M', '4', 'A', ' ');
bitwriter.write('m', 'p', '4', '2');
bitwriter.write('i', 's', 'o', 'm');
bitwriter.writebits(32, 0);
chunk_end(bitwriter);
chunk_start(bitwriter); // padding in case we need extended mdat len
bitwriter.write('f', 'r', 'e', 'e');
chunk_end(bitwriter);
mdat_pos = bitwriter.Length;
chunk_start(bitwriter); // mdat len placeholder
bitwriter.write('m', 'd', 'a', 't');
chunk_end(bitwriter);
return bitwriter.Length;
}
int encode_init()
{
int i, header_len;
//if(flake_validate_params(s) < 0)
ch_code = channels - 1;
// FIXME: For now, only 44100 samplerate is supported
if (sample_rate != 44100)
throw new Exception("non-standard samplerate");
// FIXME: For now, only 16-bit encoding is supported
if (bits_per_sample != 16)
throw new Exception("non-standard bps");
if (_blocksize == 0)
{
if (eparams.block_size == 0)
eparams.block_size = select_blocksize(sample_rate, eparams.block_time_ms);
_blocksize = eparams.block_size;
}
else
eparams.block_size = _blocksize;
// set maximum encoded frame size (if larger, re-encodes in verbatim mode)
if (channels == 2)
max_frame_size = 16 + ((eparams.block_size * (int)(bits_per_sample + bits_per_sample + 1) + 7) >> 3);
else
max_frame_size = 16 + ((eparams.block_size * channels * (int)bits_per_sample + 7) >> 3);
//if (_IO.CanSeek && eparams.do_seektable)
//{
//}
// output header bytes
header = new byte[eparams.padding_size + 0x1000];
header_len = write_headers();
frame_buffer = new byte[max_frame_size];
_sample_byte_size = new uint[sample_count / eparams.block_size + 1];
initial_history = 10;
history_mult = 40;
k_modifier = 14;
if (eparams.do_verify)
{
verify = new ALACReader(channels, (int)bits_per_sample, history_mult, initial_history, k_modifier, eparams.block_size);
verifyBuffer = new int[Alac.MAX_BLOCKSIZE * channels];
}
return header_len;
}
}
struct ALACEncodeParams
{
// compression quality
// set by user prior to calling encode_init
// standard values are 0 to 8
// 0 is lower compression, faster encoding
// 8 is higher compression, slower encoding
// extended values 9 to 12 are slower and/or use
// higher prediction orders
public int compression;
// prediction order selection method
// set by user prior to calling encode_init
// if set to less than 0, it is chosen based on compression.
// valid values are 0 to 5
// 0 = use maximum order only
// 1 = use estimation
// 2 = 2-level
// 3 = 4-level
// 4 = 8-level
// 5 = full search
// 6 = log search
public OrderMethod order_method;
// stereo decorrelation method
// set by user prior to calling encode_init
// if set to less than 0, it is chosen based on compression.
// valid values are 0 to 2
// 0 = independent L+R channels
// 1 = mid-side encoding
public StereoMethod stereo_method;
// block size in samples
// set by the user prior to calling encode_init
// if set to 0, a block size is chosen based on block_time_ms
// can also be changed by user before encoding a frame
public int block_size;
// block time in milliseconds
// set by the user prior to calling encode_init
// used to calculate block_size based on sample rate
// can also be changed by user before encoding a frame
public int block_time_ms;
// padding size in bytes
// set by the user prior to calling encode_init
// if set to less than 0, defaults to 4096
public int padding_size;
// minimum LPC order
// set by user prior to calling encode_init
// if set to less than 0, it is chosen based on compression.
// valid values are 1 to 32
public int min_prediction_order;
// maximum LPC order
// set by user prior to calling encode_init
// if set to less than 0, it is chosen based on compression.
// valid values are 1 to 32
public int max_prediction_order;
// Number of LPC orders to try (for estimate mode)
// set by user prior to calling encode_init
// if set to less than 0, it is chosen based on compression.
// valid values are 1 to 32
public int estimation_depth;
public int min_modifier, max_modifier;
public WindowFunction window_function;
public bool do_verify;
public bool do_seektable;
public int set_defaults(int lvl)
{
compression = lvl;
if ((lvl < 0 || lvl > 12) && (lvl != 99))
{
return -1;
}
// default to level 5 params
window_function = WindowFunction.Flattop | WindowFunction.Tukey;
order_method = OrderMethod.Estimate;
stereo_method = StereoMethod.Evaluate;
block_size = 0;
block_time_ms = 105;
min_modifier = 4;
max_modifier = 4;
min_prediction_order = 1;
max_prediction_order = 12;
estimation_depth = 1;
do_verify = false;
do_seektable = false;
// differences from level 6
switch (lvl)
{
case 0:
block_time_ms = 53;
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Welch;
max_prediction_order = 6;
break;
case 1:
stereo_method = StereoMethod.Independent;
window_function = WindowFunction.Welch;
max_prediction_order = 8;
break;
case 2:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Welch;
max_prediction_order = 6;
break;
case 3:
stereo_method = StereoMethod.Estimate;
window_function = WindowFunction.Welch;
max_prediction_order = 8;
break;
case 4:
stereo_method = StereoMethod.Estimate2;
window_function = WindowFunction.Welch;
break;
case 5:
stereo_method = StereoMethod.Estimate2;
break;
case 6:
break;
case 7:
estimation_depth = 3;
min_modifier = 3;
break;
case 8:
estimation_depth = 5;
max_prediction_order = 30;
min_modifier = 2;
break;
}
return 0;
}
}
}
Reference in New Issue View Git Blame Copy Permalink