flake

CUETools.AccurateRip/AccurateRip.cs

@@ -271,9 +271,10 @@ All the other CRC's in this offset range are calculated by consequently adding s
 			return _offsetedFrame450CRC[iTrack, _arOffsetRange - oi];
 		}
 
-		public void Write(int[,] sampleBuffer, uint sampleCount)
+		public void Write(int[,] sampleBuffer, int offset, int count)
 		{
-			for (uint pos = 0; pos < sampleCount; )
+			uint sampleCount = (uint)count;
+			for (uint pos = (uint)offset; pos < sampleCount; )
 			{
 				uint copyCount = Math.Min(sampleCount - pos, (uint)_samplesRemTrack);
 				unsafe

CUETools.Codecs.APE/CUETools.Codecs.APE.cpp

@@ -354,11 +354,11 @@ namespace CUETools { namespace Codecs { namespace APE {
 			int get() { return _bitsPerSample;  }
 		}
 
-		virtual void Write(array<Int32,2>^ buff, UInt32 sampleCount) 
+		virtual void Write(array<Int32,2>^ buff, int offset, int sampleCount) 
 		{
 			if (_sampleBuffer == nullptr || _sampleBuffer.Length < sampleCount * _blockAlign)
 				_sampleBuffer = gcnew array<unsigned char>(sampleCount * _blockAlign);
-			AudioSamples::FLACSamplesToBytes(buff, 0, _sampleBuffer, 0, sampleCount, _channelCount, _bitsPerSample);
+			AudioSamples::FLACSamplesToBytes(buff, offset, _sampleBuffer, 0, sampleCount, _channelCount, _bitsPerSample);
 			if (!_initialized) Initialize();
 			pin_ptr<unsigned char> pSampleBuffer = &_sampleBuffer[0];
 			if (pAPECompress->AddData (pSampleBuffer, sampleCount * _blockAlign))

CUETools.Codecs.FLAC/CUETools.Codecs.FLAC.cpp

@@ -274,6 +274,8 @@ namespace CUETools { namespace Codecs { namespace FLAC {
 					_bufferLength = 0;
 					do
 					{
+						if (FLAC__stream_decoder_get_state(_decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
+							return sampleCount - samplesNeeded;
 						if (!FLAC__stream_decoder_process_single(_decoder))
 							throw gcnew Exception("An error occurred while decoding.");
 					} while (_bufferLength == 0);
@@ -529,10 +531,10 @@ namespace CUETools { namespace Codecs { namespace FLAC {
 			} 
 		}
 
-		virtual void Write(array<Int32, 2>^ sampleBuffer, UInt32 sampleCount) {
+		virtual void Write(array<Int32, 2>^ sampleBuffer, int offset, int sampleCount) {
 			if (!_initialized) Initialize();
 
-			pin_ptr<Int32> pSampleBuffer = &sampleBuffer[0, 0];
+			pin_ptr<Int32> pSampleBuffer = &sampleBuffer[offset, 0];
 
 			if (!FLAC__stream_encoder_process_interleaved(_encoder,
 				(const FLAC__int32*)pSampleBuffer, sampleCount))

CUETools.Codecs.FLAKE/Flake.cs

@@ -144,6 +144,7 @@ namespace CUETools.Codecs.FLAKE
 		public FlacSubframeInfo* subframes;
 		public uint frame_count;
 		public FlacSubframe current;
+		public double* window_buffer;
 	}
 
 	public enum OrderMethod

CUETools.Codecs.FLAKE/FlakeReader.cs

@@ -397,6 +397,8 @@ namespace CUETools.Codecs.FLAKE
 			// LPC coefficients
 			frame->subframes[ch].best.cbits = (int)bitreader.readbits(4) + 1; // lpc_precision
 			frame->subframes[ch].best.shift = bitreader.readbits_signed(5);
+			if (frame->subframes[ch].best.shift < 0)
+				throw new Exception("negative shift");
 			for (int i = 0; i < frame->subframes[ch].best.order; i++)
 				frame->subframes[ch].best.coefs[i] = bitreader.readbits_signed(frame->subframes[ch].best.cbits);
 

CUETools.Codecs.FLAKE/FlakeWriter.cs

@@ -44,8 +44,6 @@ namespace CUETools.Codecs.FLAKE
 
 		byte[] frame_buffer = null;
 
-		uint lpc_precision;
-
 		int frame_count = 0;
 
 		long first_frame_offset = 0;
@@ -95,8 +93,8 @@ namespace CUETools.Codecs.FLAKE
 			_IO = IO;
 
 			samplesBuffer = new int[Flake.MAX_BLOCKSIZE * (channels == 2 ? 4 : channels)];
-			residualBuffer = new int[Flake.MAX_BLOCKSIZE * (channels == 2 ? 5 : channels + 1)];
+			residualBuffer = new int[Flake.MAX_BLOCKSIZE * (channels == 2 ? 10 : channels + 1)];
-			windowBuffer = new double[Flake.MAX_BLOCKSIZE * lpc.MAX_LPC_WINDOWS];
+			windowBuffer = new double[Flake.MAX_BLOCKSIZE * 2 * lpc.MAX_LPC_WINDOWS];
 
 			eparams.flake_set_defaults(_compressionLevel);
 			eparams.padding_size = 8192;
@@ -133,6 +131,8 @@ namespace CUETools.Codecs.FLAKE
 			}
 			set
 			{
+				if (value < 0 || value > 11)
+					throw new Exception("unsupported compression level");
 				_compressionLevel = value;
 				eparams.flake_set_defaults(_compressionLevel);
 			}
@@ -147,7 +147,7 @@ namespace CUETools.Codecs.FLAKE
 		{
 			if (inited)
 			{
-				if (samplesInBuffer > 0)
+				while (samplesInBuffer > 0)
 				{
 					eparams.block_size = samplesInBuffer;
 					output_frame();
@@ -187,7 +187,12 @@ namespace CUETools.Codecs.FLAKE
 
 		public void Delete()
 		{
-			DoClose();
+			if (inited)
+			{
+				_IO.Close();
+				inited = false;
+			}
+
 			if (_path != "")
 				File.Delete(_path);
 		}
@@ -264,6 +269,12 @@ namespace CUETools.Codecs.FLAKE
 			set { eparams.do_seektable = value; }
 		}
 
+		public int VBRMode
+		{
+			get { return eparams.variable_block_size; }
+			set { eparams.variable_block_size = value; }
+		}
+
 		public int MinPredictionOrder
 		{
 			get
@@ -384,12 +395,7 @@ namespace CUETools.Codecs.FLAKE
 			get { return 16; }
 		}
 
-		int encode_frame_vbs()
+		unsafe uint get_wasted_bits(int* signal, int samples)
-		{
-			throw new Exception("vbs not supported");
-		}
-
-		unsafe int get_wasted_bits(int* signal, int samples)
 		{
 			int i, shift;
 			int x = 0;
@@ -413,10 +419,10 @@ namespace CUETools.Codecs.FLAKE
 					signal[i] >>= shift;
 			}
 
-			return shift;
+			return (uint)shift;
 		}
 
-		unsafe void init_frame(FlacFrame * frame)
+		unsafe void init_frame(FlacFrame * frame, int bs)
 		{
 			//if (channels == 2)
 			//max_frame_size =			
@@ -426,7 +432,7 @@ namespace CUETools.Codecs.FLAKE
 			{
 				for (i = 0; i < 15; i++)
 				{
-					if (eparams.block_size == Flake.flac_blocksizes[i])
+					if (bs == Flake.flac_blocksizes[i])
 					{
 						frame->blocksize = Flake.flac_blocksizes[i];
 						frame->bs_code0 = i;
@@ -437,7 +443,7 @@ namespace CUETools.Codecs.FLAKE
 			}
 			if (i == 15)
 			{
-				frame->blocksize = eparams.block_size;
+				frame->blocksize = bs;
 				if (frame->blocksize <= 256)
 				{
 					frame->bs_code0 = 6;
@@ -522,14 +528,13 @@ namespace CUETools.Codecs.FLAKE
 			return nbits;
 		}
 
-		unsafe void initialize_subframe(FlacFrame* frame, int ch, int *s, int * r, uint bps)
+		unsafe void initialize_subframe(FlacFrame* frame, int ch, int *s, int * r, uint bps, uint w)
 		{
-			int w = get_wasted_bits(s, frame->blocksize);
 			if (w > bps)
 				throw new Exception("internal error");
 			frame->subframes[ch].samples = s;
-			frame->subframes[ch].obits = bps - (uint)w;
+			frame->subframes[ch].obits = bps - w;
-			frame->subframes[ch].wbits = (uint)w;
+			frame->subframes[ch].wbits = w;
 			frame->subframes[ch].best.residual = r;
 			frame->subframes[ch].best.type = SubframeType.Verbatim;
 			frame->subframes[ch].best.size = UINT32_MAX;
@@ -728,6 +733,18 @@ namespace CUETools.Codecs.FLAKE
 
 		unsafe void encode_residual_lpc_sub(FlacFrame* frame, double * lpcs, int iWindow, int order, int ch)
 		{
+			// select LPC precision based on block size
+			uint lpc_precision;
+			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;
+			else lpc_precision = 15;
+
 			for (uint i_precision = 0; i_precision <= eparams.lpc_precision_search && lpc_precision + i_precision < 16; i_precision++)
 				// check if we already calculated with this order, window and precision
 				if ((frame->subframes[ch].done_lpcs[iWindow + i_precision * lpc.MAX_LPC_WINDOWS] & (1U << (order - 1))) == 0) 
@@ -743,6 +760,9 @@ namespace CUETools.Codecs.FLAKE
 					lpc.quantize_lpc_coefs(lpcs + (frame->current.order - 1) * lpc.MAX_LPC_ORDER,
 						frame->current.order, cbits, frame->current.coefs, out frame->current.shift);
 
+					if (frame->current.shift < 0 || frame->current.shift > 15)
+						throw new Exception("negative shift");
+
 					ulong csum = 0;
 					for (int i = frame->current.order; i > 0; i--)
 						csum += (ulong)Math.Abs(frame->current.coefs[i - 1]);
@@ -826,7 +846,6 @@ namespace CUETools.Codecs.FLAKE
 				int min_order = eparams.min_prediction_order;
 				int max_order = eparams.max_prediction_order;
 
-				fixed (double* window = windowBuffer)
 				for (int iWindow = 0; iWindow < _windowcount; iWindow++)
 				{
 					if (predict == PredictionType.Estimated && frame->subframes[ch].best.window != iWindow)
@@ -836,8 +855,7 @@ namespace CUETools.Codecs.FLAKE
 					if (frame->subframes[ch].lpcs_order[iWindow] != max_order)
 					{
 						double* autoc = stackalloc double[lpc.MAX_LPC_ORDER + 1];
-							lpc.compute_autocorr(smp, (uint)n, (uint)max_order + 1, autoc, 
+						lpc.compute_autocorr(smp, (uint)n, (uint)max_order + 1, autoc, frame->window_buffer + iWindow * Flake.MAX_BLOCKSIZE * 2);
-								window + iWindow * _windowsize);
 						lpc.compute_schur_reflection(autoc, (uint)max_order, reff);
 						frame->subframes[ch].lpcs_order[iWindow] = max_order;
 					}
@@ -1136,59 +1154,15 @@ namespace CUETools.Codecs.FLAKE
 				window[n] = 0.5 - 0.5 * Math.Cos(2.0 * Math.PI * n / N);
 		}
 
-		unsafe int encode_frame()
+		unsafe void estimate_frame(FlacFrame* frame, bool do_midside)
 		{
-			FlacFrame frame;
+			int subframes = do_midside ? channels * 2 : channels;
-			//= stackalloc FlacFrame[1];
-			FlacSubframeInfo* sf = stackalloc FlacSubframeInfo[channels * 2];
-
-			fixed (int* s = samplesBuffer, r = residualBuffer)
-			{
-				frame.subframes = sf;
-
-				init_frame(&frame);
-				if (frame.blocksize != _windowsize && frame.blocksize > 4)
-					fixed (double* window = windowBuffer)
-					{
-						_windowsize = frame.blocksize;
-						_windowcount = 0;
-						if ((eparams.window_function & WindowFunction.Welch) != 0)
-							window_welch(window + (_windowcount++)*_windowsize, _windowsize);
-						if ((eparams.window_function & WindowFunction.Tukey) != 0)
-							window_tukey(window + (_windowcount++) * _windowsize, _windowsize);
-						if ((eparams.window_function & WindowFunction.Hann) != 0)
-							window_hann(window + (_windowcount++) * _windowsize, _windowsize);
-						if ((eparams.window_function & WindowFunction.Flattop) != 0)
-							window_flattop(window + (_windowcount++) * _windowsize, _windowsize);
-						if (_windowcount == 0)
-							throw new Exception("invalid windowfunction");
-					}
-
-				if (channels != 2 || frame.blocksize <= 32 || eparams.stereo_method == StereoMethod.Independent)
-				{
-					frame.current.residual = r + channels * Flake.MAX_BLOCKSIZE;
-					frame.ch_mode = channels != 2 ? ChannelMode.NotStereo : ChannelMode.LeftRight;
-					for (int ch = 0; ch < channels; ch++)
-						initialize_subframe(&frame, ch, s + ch * Flake.MAX_BLOCKSIZE, r + ch * Flake.MAX_BLOCKSIZE, bits_per_sample);
-
-					for (int ch = 0; ch < channels; ch++)
-						encode_residual(&frame, ch, eparams.prediction_type, eparams.order_method);
-				}
-				else
-				{
-					channel_decorrelation(s, s + Flake.MAX_BLOCKSIZE, s + 2 * Flake.MAX_BLOCKSIZE, s + 3 * Flake.MAX_BLOCKSIZE, frame.blocksize);
-					frame.current.residual = r + 4 * Flake.MAX_BLOCKSIZE;
-					for (int ch = 0; ch < 4; ch++)
-						initialize_subframe(&frame, ch, s + ch * Flake.MAX_BLOCKSIZE, r + ch * Flake.MAX_BLOCKSIZE, bits_per_sample + (ch == 3 ? 1U : 0U));
-
-					uint bitsBest = UINT32_MAX;
-					ChannelMode modeBest = ChannelMode.LeftRight;
 
 			switch (eparams.stereo_method)
 			{
 				case StereoMethod.Estimate:
-							for (int ch = 0; ch < 4; ch++)
+					for (int ch = 0; ch < subframes; ch++)
-								frame.subframes[ch].best.size = (uint)frame.blocksize * 32 + calc_decorr_score(&frame, ch);
+						frame->subframes[ch].best.size = (uint)frame->blocksize * 32 + calc_decorr_score(frame, ch);
 					break;
 				case StereoMethod.Evaluate:
 					{
@@ -1202,8 +1176,8 @@ namespace CUETools.Codecs.FLAKE
 						eparams.lpc_precision_search = 0;
 						if (eparams.max_prediction_order > 12)
 							eparams.max_prediction_order = 8;
-								for (int ch = 0; ch < 4; ch++)
+						for (int ch = 0; ch < subframes; ch++)
-									encode_residual(&frame, ch, eparams.prediction_type, omethod);
+							encode_residual(frame, ch, eparams.prediction_type, omethod);
 						eparams.min_fixed_order = min_fixed_order;
 						eparams.max_fixed_order = max_fixed_order;
 						eparams.max_prediction_order = max_prediction_order;
@@ -1211,59 +1185,191 @@ namespace CUETools.Codecs.FLAKE
 						break;
 					}
 				case StereoMethod.Search:
-							for (int ch = 0; ch < 4; ch++)
+					for (int ch = 0; ch < subframes; ch++)
-								encode_residual(&frame, ch, eparams.prediction_type, eparams.order_method);
+						encode_residual(frame, ch, eparams.prediction_type, eparams.order_method);
 					break;
 			}
-					if (bitsBest > frame.subframes[2].best.size + frame.subframes[3].best.size)
+		}
+
+		unsafe uint measure_frame_size(FlacFrame* frame, bool do_midside)
 		{
-						bitsBest = frame.subframes[2].best.size + frame.subframes[3].best.size;
+			uint total = 48 + 16; // crude estimation of header/footer size;
+
+			if (do_midside)
+			{
+				uint bitsBest = UINT32_MAX;
+				ChannelMode modeBest = ChannelMode.LeftRight;
+
+				if (bitsBest > frame->subframes[2].best.size + frame->subframes[3].best.size)
+				{
+					bitsBest = frame->subframes[2].best.size + frame->subframes[3].best.size;
 					modeBest = ChannelMode.MidSide;
 				}
-					if (bitsBest > frame.subframes[3].best.size + frame.subframes[1].best.size)
+				if (bitsBest > frame->subframes[3].best.size + frame->subframes[1].best.size)
 				{
-						bitsBest = frame.subframes[3].best.size + frame.subframes[1].best.size;
+					bitsBest = frame->subframes[3].best.size + frame->subframes[1].best.size;
 					modeBest = ChannelMode.RightSide;
 				}
-					if (bitsBest > frame.subframes[3].best.size + frame.subframes[0].best.size)
+				if (bitsBest > frame->subframes[3].best.size + frame->subframes[0].best.size)
 				{
-						bitsBest = frame.subframes[3].best.size + frame.subframes[0].best.size;
+					bitsBest = frame->subframes[3].best.size + frame->subframes[0].best.size;
 					modeBest = ChannelMode.LeftSide;
 				}
-					if (bitsBest > frame.subframes[0].best.size + frame.subframes[1].best.size)
+				if (bitsBest > frame->subframes[0].best.size + frame->subframes[1].best.size)
 				{
-						bitsBest = frame.subframes[0].best.size + frame.subframes[1].best.size;
+					bitsBest = frame->subframes[0].best.size + frame->subframes[1].best.size;
 					modeBest = ChannelMode.LeftRight;
 				}
-					switch(modeBest)
+				frame->ch_mode = modeBest;
+				return total + bitsBest;
+			}
+
+			for (int ch = 0; ch < channels; ch++)
+				total += frame->subframes[ch].best.size;
+			return total;
+		}
+
+		unsafe void encode_estimated_frame(FlacFrame* frame, bool do_midside)
+		{
+			if (do_midside)
+				switch (frame->ch_mode)
 				{
 					case ChannelMode.MidSide:
-							frame.subframes[0] = frame.subframes[2];
+						frame->subframes[0] = frame->subframes[2];
-							frame.subframes[1] = frame.subframes[3];
+						frame->subframes[1] = frame->subframes[3];
 						break;
 					case ChannelMode.RightSide:
-							frame.subframes[0] = frame.subframes[3];
+						frame->subframes[0] = frame->subframes[3];
 						break;
 					case ChannelMode.LeftSide:
-							frame.subframes[1] = frame.subframes[3];
+						frame->subframes[1] = frame->subframes[3];
 						break;
 				}
-					frame.ch_mode = modeBest;
+
 			switch (eparams.stereo_method)
 			{
 				case StereoMethod.Estimate:
 					for (int ch = 0; ch < channels; ch++)
-								encode_residual(&frame, ch, eparams.prediction_type, eparams.order_method);
+					{
+						frame->subframes[ch].best.size = UINT32_MAX;
+						encode_residual(frame, ch, eparams.prediction_type, eparams.order_method);
+					}
 					break;
 				case StereoMethod.Evaluate:
 					for (int ch = 0; ch < channels; ch++)
-								encode_residual(&frame, ch, PredictionType.Estimated, eparams.order_method);
+						encode_residual(frame, ch, PredictionType.Estimated, eparams.order_method);
 					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 * Flake.MAX_BLOCKSIZE * 2;
+			do
+			{
+				func(pos, sz);
+				if ((sz & 1) != 0)
+					break;
+				pos += sz;
+				sz >>= 1;
+			} while (sz >= 32);
+			_windowcount++;
+		}
+
+		unsafe int encode_frame(out int size)
+		{
+			FlacFrame frame;
+			FlacFrame frame2, frame3;
+			FlacSubframeInfo* sf = stackalloc FlacSubframeInfo[channels * 6];
+
+			fixed (int* s = samplesBuffer, r = residualBuffer)
+			fixed (double* window = windowBuffer)
+			{
+				frame.subframes = sf;
+
+				init_frame(&frame, eparams.block_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");
+				}
+
+				if (channels != 2 || frame.blocksize <= 32 || eparams.stereo_method == StereoMethod.Independent)
+				{
+					frame.window_buffer = window;
+					frame.current.residual = r + channels * Flake.MAX_BLOCKSIZE;
+					frame.ch_mode = channels != 2 ? ChannelMode.NotStereo : ChannelMode.LeftRight;
+					for (int ch = 0; ch < channels; ch++)
+						initialize_subframe(&frame, ch, s + ch * Flake.MAX_BLOCKSIZE, r + ch * Flake.MAX_BLOCKSIZE,
+							bits_per_sample, get_wasted_bits(s + ch * Flake.MAX_BLOCKSIZE, frame.blocksize));
+
+					for (int ch = 0; ch < channels; ch++)
+						encode_residual(&frame, ch, eparams.prediction_type, eparams.order_method);
+				}
+				else
+				{
+					channel_decorrelation(s, s + Flake.MAX_BLOCKSIZE, s + 2 * Flake.MAX_BLOCKSIZE, s + 3 * Flake.MAX_BLOCKSIZE, frame.blocksize);
+					frame.window_buffer = window;
+					frame.current.residual = r + 4 * Flake.MAX_BLOCKSIZE;
+					for (int ch = 0; ch < 4; ch++)
+						initialize_subframe(&frame, ch, s + ch * Flake.MAX_BLOCKSIZE, r + ch * Flake.MAX_BLOCKSIZE, 
+							bits_per_sample + (ch == 3 ? 1U : 0U), get_wasted_bits(s + ch * Flake.MAX_BLOCKSIZE, frame.blocksize));
+					estimate_frame(&frame, true);
+					uint fs = measure_frame_size(&frame, true);
+
+					if (0 != eparams.variable_block_size)
+					{
+						int tumbler = 1;
+						while ((frame.blocksize & 1) == 0 && frame.blocksize >= 1024)
+						{
+							init_frame(&frame2, frame.blocksize / 2);
+							frame2.window_buffer = frame.window_buffer + frame.blocksize;
+							frame2.current.residual = r + tumbler * 5 * Flake.MAX_BLOCKSIZE;
+							frame2.subframes = sf + tumbler * channels * 2;
+							for (int ch = 0; ch < 4; ch++)
+								initialize_subframe(&frame2, ch, frame.subframes[ch].samples, frame2.current.residual + (ch + 1) * frame2.blocksize,
+									frame.subframes[ch].obits + frame.subframes[ch].wbits, frame.subframes[ch].wbits);
+							estimate_frame(&frame2, true);
+							uint fs2 = measure_frame_size(&frame2, true);
+							uint fs3 = fs2;
+							if (eparams.variable_block_size == 2 || eparams.variable_block_size == 4)
+							{
+								init_frame(&frame3, frame2.blocksize);
+								frame3.window_buffer = frame2.window_buffer;
+								frame3.current.residual = frame2.current.residual + 5 * frame2.blocksize;
+								frame3.subframes = sf + channels * 4;
+								for (int ch = 0; ch < 4; ch++)
+									initialize_subframe(&frame3, ch, frame2.subframes[ch].samples + frame2.blocksize, frame3.current.residual + (ch + 1) * frame3.blocksize,
+										frame.subframes[ch].obits + frame.subframes[ch].wbits, frame.subframes[ch].wbits);
+								estimate_frame(&frame3, true);
+								fs3 = measure_frame_size(&frame3, true);
+							}
+							if (fs2 + fs3 > fs)
+								break;
+							frame = frame2;
+							fs = fs2;
+							if (eparams.variable_block_size <= 2)
+								break;
+							tumbler = 1 - tumbler;
+						}
+					}
+
+					encode_estimated_frame(&frame, true);
+				}
+
 				BitWriter bitwriter = new BitWriter(frame_buffer, 0, max_frame_size);
 
 				output_frame_header(&frame, bitwriter);
@@ -1273,15 +1379,16 @@ namespace CUETools.Codecs.FLAKE
 				if (frame_buffer != null)
 				{
 					if (eparams.variable_block_size > 0)
-						frame_count += eparams.block_size;
+						frame_count += frame.blocksize;
 					else
 						frame_count++;
 				}
+				size = frame.blocksize;
 				return bitwriter.Length;
 			}
 		}
 
-		unsafe void output_frame()
+		unsafe int output_frame()
 		{
 			if (verify != null)
 			{
@@ -1290,11 +1397,11 @@ namespace CUETools.Codecs.FLAKE
 						Flake.memcpy(s + ch * Flake.MAX_BLOCKSIZE, r + ch * Flake.MAX_BLOCKSIZE, eparams.block_size);
 			}
 
-			int fs;
+			int fs, bs;
-			if (0 != eparams.variable_block_size && 0 == (eparams.block_size & 7) && eparams.block_size >= 128)
+			//if (0 != eparams.variable_block_size && 0 == (eparams.block_size & 7) && eparams.block_size >= 128)
-				fs = encode_frame_vbs();
+			//    fs = encode_frame_vbs();
-			else
+			//else
-				fs = encode_frame();
+			fs = encode_frame(out bs);
 
 			if (seek_table != null && _IO.CanSeek)
 			{
@@ -1302,33 +1409,44 @@ namespace CUETools.Codecs.FLAKE
 				{
 					if (seek_table[sp].framesize != 0)
 						continue;
-					if (seek_table[sp].number > (ulong)_position + (ulong)eparams.block_size)
+					if (seek_table[sp].number > (ulong)_position + (ulong)bs)
 						break;
 					if (seek_table[sp].number >= (ulong)_position)
 					{
 						seek_table[sp].number = (ulong)_position;
 						seek_table[sp].offset = (ulong)(_IO.Position - first_frame_offset);
-						seek_table[sp].framesize = (uint)eparams.block_size;
+						seek_table[sp].framesize = (uint)bs;
 					}
 				}
 			}
 
-			_position += eparams.block_size;
+			_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)eparams.block_size)
+				if (decoded != fs || verify.Remaining != (ulong)bs)
 					throw new Exception("validation failed!");
 				fixed (int* s = verifyBuffer, r = verify.Samples)
 				{
 					for (int ch = 0; ch < channels; ch++)
-						if (Flake.memcmp(s + ch * Flake.MAX_BLOCKSIZE, r +ch * Flake.MAX_BLOCKSIZE, decoded))
+						if (Flake.memcmp(s + ch * Flake.MAX_BLOCKSIZE, r + ch * Flake.MAX_BLOCKSIZE, bs))
 							throw new Exception("validation failed!");
 				}
 			}
+
+			if (bs < eparams.block_size)
+			{
+				fixed (int* s = samplesBuffer)
+					for (int ch = 0; ch < channels; ch++)
+						Flake.memcpy(s + ch * Flake.MAX_BLOCKSIZE, s + bs + ch * Flake.MAX_BLOCKSIZE, eparams.block_size - bs);
+			}
+
+			samplesInBuffer -= bs;
+
+			return bs;
 		}
 
 		public void Write(int[,] buff, int pos, int sampleCount)
@@ -1357,14 +1475,11 @@ namespace CUETools.Codecs.FLAKE
 					md5.TransformBlock(frame_buffer, 0, block * channels * ((int)bits_per_sample >> 3), null, 0);
 				}
 
-				if (samplesInBuffer < eparams.block_size)
-					return;
-
-				output_frame();
-
-				samplesInBuffer = 0;
 				len -= block;
 				pos += block;
+
+				while (samplesInBuffer >= eparams.block_size)
+					output_frame();
 			}
 		}
 
@@ -1553,23 +1668,15 @@ namespace CUETools.Codecs.FLAKE
 			if (bits_per_sample != 16)
 				throw new Exception("non-standard bps");
 
-			if (eparams.block_size == 0)
 			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;
 
-			// select LPC precision based on block size
-			if (eparams.block_size <= 192) lpc_precision = 7U;
-			else if (eparams.block_size <= 384) lpc_precision = 8U;
-			else if (eparams.block_size <= 576) lpc_precision = 9U;
-			else if (eparams.block_size <= 1152) lpc_precision = 10U;
-			else if (eparams.block_size <= 2304) lpc_precision = 11U;
-			else if (eparams.block_size <= 4608) lpc_precision = 12U;
-			else if (eparams.block_size <= 8192) lpc_precision = 13U;
-			else if (eparams.block_size <= 16384) lpc_precision = 14U;
-			else lpc_precision = 15;
-
 			// 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);
@@ -1832,13 +1939,8 @@ namespace CUETools.Codecs.FLAKE
 					max_partition_order = 6;
 					max_prediction_order = 32;
 					lpc_precision_search = 1;
-					break;
+					variable_block_size = 4;
-				case 99:
+					block_size = 4096;
-					order_method = OrderMethod.Search;
-					block_time_ms = 186;
-					max_prediction_order = 32;
-					max_partition_order = 8;
-					variable_block_size = 2;
 					break;
 			}
 

CUETools.Codecs.LossyWAV/LossyWAV.cs

@@ -90,12 +90,11 @@ namespace CUETools.Codecs.LossyWAV
 			if (_audioDest != null) _audioDest.Close();
 		}
 
-		public void Write(int[,] buff, uint sampleCount)
+		public void Write(int[,] buff, int pos, int sampleCount)
 		{
 			if (!initialized)
 				Initialize();
 
-			long pos = 0;
 			while (sampleCount + samplesInBuffer > codec_block_size)
 			{
 				shift_codec_blocks(); // next_codec_block_size is now zero
@@ -104,7 +103,7 @@ namespace CUETools.Codecs.LossyWAV
 				Array.Copy(buff, pos * channels, rotating_blocks_ptr[3], samplesInBuffer * channels, (codec_block_size - samplesInBuffer) * channels);
 				next_codec_block_size = codec_block_size;
 				pos += codec_block_size - samplesInBuffer;
-				sampleCount -= codec_block_size - (uint)samplesInBuffer;
+				sampleCount -= codec_block_size - samplesInBuffer;
 				samplesInBuffer = 0;
 				if (samplesWritten > 0)
 					process_this_codec_block();
@@ -683,9 +682,9 @@ namespace CUETools.Codecs.LossyWAV
 						for (int c = 0; c < channels; c++)
 							btrd_codec_block[i, c] >>= sh;
 				}
-				_audioDest.Write(btrd_codec_block, (uint)this_codec_block_size);
+				_audioDest.Write(btrd_codec_block, 0, this_codec_block_size);
 			}
-			if (_lwcdfDest != null) _lwcdfDest.Write(corr_codec_block, (uint)this_codec_block_size);
+			if (_lwcdfDest != null) _lwcdfDest.Write(corr_codec_block, 0, this_codec_block_size);
 		}
 
 		void shift_codec_blocks()

CUETools.Codecs.TTA/CUETools.Codecs.TTA.cpp

@@ -306,13 +306,13 @@ namespace TTA {
 			} 
 		}
 
-		virtual void Write(array<Int32, 2>^ sampleBuffer, UInt32 sampleCount) {
+		virtual void Write(array<Int32, 2>^ sampleBuffer, int offset, int sampleCount) {
 			if (!_initialized) Initialize();
 
 			if ((_sampleBuffer == nullptr) || (_sampleBuffer->Length < sampleCount * _channelCount))
 				_sampleBuffer = gcnew array<long> (sampleCount * _channelCount);
 
-			interior_ptr<Int32> pSampleBuffer = &sampleBuffer[0, 0];
+			interior_ptr<Int32> pSampleBuffer = &sampleBuffer[offset, 0];
 			interior_ptr<long> pTTABuffer = &_sampleBuffer[0];
 			for (int i = 0; i < sampleCount * _channelCount; i++) 
 				pTTABuffer[i] = pSampleBuffer[i];

CUETools.Codecs.WavPack/CUETools.Codecs.WavPack.cpp

@@ -376,7 +376,7 @@ namespace CUETools { namespace Codecs { namespace WavPack {
 			int get() { return _bitsPerSample;  }
 		}
 
-		virtual void Write(array<Int32, 2>^ sampleBuffer, UInt32 sampleCount) 
+		virtual void Write(array<Int32, 2>^ sampleBuffer, int offset, int sampleCount) 
 		{
 			if (!_initialized) 
 				Initialize();
@@ -385,8 +385,8 @@ namespace CUETools { namespace Codecs { namespace WavPack {
 			{
 				if (_sampleBuffer == nullptr || _sampleBuffer.Length < sampleCount * _blockAlign)
 					_sampleBuffer = gcnew array<unsigned char>(sampleCount * _blockAlign);
-				AudioSamples::FLACSamplesToBytes(sampleBuffer, 0, _sampleBuffer, 0, sampleCount, _channelCount, _bitsPerSample);
+				AudioSamples::FLACSamplesToBytes(sampleBuffer, offset, _sampleBuffer, 0, sampleCount, _channelCount, _bitsPerSample);
-				UpdateHash(_sampleBuffer, (int) sampleCount * _blockAlign);
+				UpdateHash(_sampleBuffer, sampleCount * _blockAlign);
 			}
 
 			if ((_bitsPerSample & 7) != 0)
@@ -395,13 +395,13 @@ namespace CUETools { namespace Codecs { namespace WavPack {
 					_shiftedSampleBuffer = gcnew array<int,2>(sampleCount, _channelCount);
 				for (int i = 0; i < sampleCount; i++)
 					for (int c = 0; c < _channelCount; c++)
-						_shiftedSampleBuffer[i,c] = sampleBuffer[i,c] << 8 - (_bitsPerSample & 7);
+						_shiftedSampleBuffer[i,c] = sampleBuffer[i+offset,c] << 8 - (_bitsPerSample & 7);
 				pin_ptr<Int32> pSampleBuffer = &_shiftedSampleBuffer[0, 0];
 				if (!WavpackPackSamples(_wpc, (int32_t*)pSampleBuffer, sampleCount))
 					throw gcnew Exception("An error occurred while encoding.");
 			} else
 			{
-				pin_ptr<Int32> pSampleBuffer = &sampleBuffer[0, 0];
+				pin_ptr<Int32> pSampleBuffer = &sampleBuffer[offset, 0];
 				if (!WavpackPackSamples(_wpc, (int32_t*)pSampleBuffer, sampleCount))
 					throw gcnew Exception("An error occurred while encoding.");
 			}

CUETools.Codecs/CRCs/CRC16.cs

@@ -8,22 +8,18 @@ namespace CUETools.Codecs
 	{
 		ushort[] table = new ushort[256];
 
-		public ushort ComputeChecksum(byte[] bytes, int pos, int count)
+		public unsafe ushort ComputeChecksum(byte[] bytes, int pos, int count)
 		{
-			ushort crc = 0;
+			fixed (byte* bs = bytes)
-			for (int i = pos; i < pos + count; i++)
+				return ComputeChecksum(bs + pos, count);
-			{
-				crc = (ushort)(((crc << 8) & 0xffff) ^ table[(crc >> 8) ^ bytes[i]]);
-			}
-			return crc;
 		}
 
-		public unsafe ushort ComputeChecksum(byte* bytes, int pos, int count)
+		public unsafe ushort ComputeChecksum(byte* bytes, int count)
 		{
 			ushort crc = 0;
 			fixed (ushort* t = table)
-				for (int i = pos; i < pos + count; i++)
+				for (int i = count; i > 0; i--)
-					crc = (ushort)(((crc << 8) & 0xffff) ^ t[(crc >> 8) ^ bytes[i]]);
+					crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ *(bytes++)]);
 			return crc;
 		}
 

CUETools.Codecs/CUETools.Codecs.csproj

@@ -83,6 +83,10 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Codecs.cs" />
+    <Compile Include="CRCs\CRC16.cs" />
+    <Compile Include="CRCs\CRC16CCITT.cs" />
+    <Compile Include="CRCs\CRC32.cs" />
+    <Compile Include="CRCs\CRC8.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />

CUETools.Codecs/Codecs.cs

@@ -23,7 +23,7 @@ namespace CUETools.Codecs
 
 	public interface IAudioDest
 	{
-		void Write(int[,] buff, uint sampleCount);
+		void Write(int[,] buff, int pos, int sampleCount);
 		void Close();
 		void Delete();
 		int BitsPerSample { get; }
@@ -34,10 +34,10 @@ namespace CUETools.Codecs
 
 	public class AudioSamples
 	{
-		public static unsafe void FLACSamplesToBytes_16(int[,] inSamples, uint inSampleOffset,
+		public static unsafe void FLACSamplesToBytes_16(int[,] inSamples, int inSampleOffset,
-			byte[] outSamples, uint outByteOffset, uint sampleCount, int channelCount)
+			byte[] outSamples, int outByteOffset, int sampleCount, int channelCount)
 		{
-			uint loopCount = sampleCount * (uint)channelCount;
+			int loopCount = sampleCount * channelCount;
 
 			if ((inSamples.GetLength(0) - inSampleOffset < sampleCount) ||
 				(outSamples.Length - outByteOffset < loopCount * 2))
@@ -60,10 +60,10 @@ namespace CUETools.Codecs
 			}
 		}
 		
-		public static unsafe void FLACSamplesToBytes_24(int[,] inSamples, uint inSampleOffset,
+		public static unsafe void FLACSamplesToBytes_24(int[,] inSamples, int inSampleOffset,
-			byte[] outSamples, uint outByteOffset, uint sampleCount, int channelCount, int wastedBits)
+			byte[] outSamples, int outByteOffset, int sampleCount, int channelCount, int wastedBits)
 		{
-			uint loopCount = sampleCount * (uint)channelCount;
+			int loopCount = sampleCount * channelCount;
 
 			if ((inSamples.GetLength(0) - inSampleOffset < sampleCount) ||
 				(outSamples.Length - outByteOffset < loopCount * 3))
@@ -91,8 +91,8 @@ namespace CUETools.Codecs
 			}
 		}
 
-		public static unsafe void FLACSamplesToBytes(int[,] inSamples, uint inSampleOffset,
+		public static unsafe void FLACSamplesToBytes(int[,] inSamples, int inSampleOffset,
-			byte[] outSamples, uint outByteOffset, uint sampleCount, int channelCount, int bitsPerSample)
+			byte[] outSamples, int outByteOffset, int sampleCount, int channelCount, int bitsPerSample)
 		{
 			if (bitsPerSample == 16)
 				AudioSamples.FLACSamplesToBytes_16(inSamples, inSampleOffset, outSamples, outByteOffset, sampleCount, channelCount);
@@ -209,7 +209,7 @@ namespace CUETools.Codecs
 			get { return _bitsPerSample;  }
 		}
 
-		public void Write(int[,] buff, uint sampleCount)
+		public void Write(int[,] buff, int pos, int sampleCount)
 		{
 		}
 
@@ -712,7 +712,7 @@ namespace CUETools.Codecs
 			get { return _bitsPerSample; }
 		}
 
-		public void Write(int[,] buff, uint sampleCount)
+		public void Write(int[,] buff, int pos, int sampleCount)
 		{
 			if (sampleCount == 0)
 				return;
@@ -720,7 +720,7 @@ namespace CUETools.Codecs
 				WriteHeaders();
 			if (_sampleBuffer == null || _sampleBuffer.Length < sampleCount * _blockAlign)
 				_sampleBuffer = new byte[sampleCount * _blockAlign];
-			AudioSamples.FLACSamplesToBytes(buff, 0, _sampleBuffer, 0,
+			AudioSamples.FLACSamplesToBytes(buff, pos, _sampleBuffer, 0,
 				sampleCount, _channelCount, _bitsPerSample);
 			_IO.Write(_sampleBuffer, 0, (int)sampleCount * _blockAlign);
 			_sampleLen += sampleCount;
@@ -729,11 +729,270 @@ namespace CUETools.Codecs
 		public string Path { get { return _path; } }
 	}
 
+	public class CyclicBuffer
+	{
+		public delegate void FlushOutput(byte[] buffer, int pos, int chunk, object to);
+		public delegate void CloseOutput(object to);
+
+		private byte[] _buffer;
+		private int _size;
+		private int _start = 0; // moved only by Write
+		private int _end = 0; // moved only by Read
+		private bool _eof = false;
+		private Thread _readThread = null, _writeThread = null;
+
+		public event FlushOutput flushOutput;
+		public event CloseOutput closeOutput;
+
+		public CyclicBuffer(int len)
+		{
+			_size = len;
+			_buffer = new byte[len];
+		}
+
+		public CyclicBuffer(int len, Stream input, Stream output)
+		{
+			_size = len;
+			_buffer = new byte[len];
+			ReadFrom(input);
+			WriteTo(output);
+		}
+
+		public void ReadFrom(Stream input)
+		{
+			_readThread = new Thread(PumpRead);
+			_readThread.Priority = ThreadPriority.Highest;
+			_readThread.IsBackground = true;
+			_readThread.Start(input);
+		}
+
+		public void WriteTo(Stream output)
+		{
+			WriteTo(flushOutputToStream, closeOutputToStream, ThreadPriority.Highest, output);
+		}
+
+		public void WriteTo(FlushOutput flushOutputDelegate, CloseOutput closeOutputDelegate, ThreadPriority priority, object to)
+		{
+			if (flushOutputDelegate != null)
+				flushOutput += flushOutputDelegate;
+			if (closeOutputDelegate != null)
+				closeOutput += closeOutputDelegate;
+			_writeThread = new Thread(FlushThread);
+			_writeThread.Priority = priority;
+			_writeThread.IsBackground = true;
+			_writeThread.Start(to);
+		}
+
+		void closeOutputToStream(object to)
+		{
+			((Stream)to).Close();
+		}
+
+		void flushOutputToStream(byte[] buffer, int pos, int chunk, object to)
+		{
+			((Stream)to).Write(buffer, pos, chunk);
+		}
+
+		int DataAvailable
+		{
+			get
+			{
+				return _end - _start;
+			}
+		}
+
+		int FreeSpace
+		{
+			get
+			{
+				return _size - DataAvailable;
+			}
+		}
+
+		private void PumpRead(object o)
+		{
+			while (Read((Stream)o))
+				;
+			SetEOF();
+		}
+
+		public void Close()
+		{
+			if (_readThread != null)
+			{
+				_readThread.Join();
+				_readThread = null;
+			}
+			SetEOF();
+			if (_writeThread != null)
+			{
+				_writeThread.Join();
+				_writeThread = null;
+			}
+		}
+
+		public void SetEOF()
+		{
+			lock (this)
+			{
+				_eof = true;
+				Monitor.Pulse(this);
+			}
+		}
+
+		public bool Read(Stream input)
+		{
+			int pos, chunk;
+			lock (this)
+			{
+				while (FreeSpace == 0)
+					Monitor.Wait(this);
+				pos = _end % _size;
+				chunk = Math.Min(FreeSpace, _size - pos);
+			}
+			chunk = input.Read(_buffer, pos, chunk);
+			if (chunk == 0)
+				return false;
+			lock (this)
+			{
+				_end += chunk;
+				Monitor.Pulse(this);
+			}
+			return true;
+		}
+
+		public void Read(byte[] array, int offset, int count)
+		{
+			int pos, chunk;
+			while (count > 0)
+			{
+				lock (this)
+				{
+					while (FreeSpace == 0)
+						Monitor.Wait(this);
+					pos = _end % _size;
+					chunk = Math.Min(FreeSpace, _size - pos);
+					chunk = Math.Min(chunk, count);
+				}
+				Array.Copy(array, offset, _buffer, pos, chunk);
+				lock (this)
+				{
+					_end += chunk;
+					Monitor.Pulse(this);
+				}
+				count -= chunk;
+				offset += chunk;
+			}
+		}
+
+		private void FlushThread(object to)
+		{
+			while (true)
+			{
+				int pos, chunk;
+				lock (this)
+				{
+					while (DataAvailable == 0 && !_eof)
+						Monitor.Wait(this);
+					if (DataAvailable == 0)
+						break;
+					pos = _start % _size;
+					chunk = Math.Min(DataAvailable, _size - pos);
+				}
+				if (flushOutput != null)
+					flushOutput(_buffer, pos, chunk, to);
+				lock (this)
+				{
+					_start += chunk;
+					Monitor.Pulse(this);
+				}
+			}
+			if (closeOutput != null)
+				closeOutput(to);
+		}
+	}
+
+	public class CycilcBufferOutputStream : Stream
+	{
+		CyclicBuffer _buffer;
+
+		public CycilcBufferOutputStream(CyclicBuffer buffer)
+		{
+			_buffer = buffer;
+		}
+
+		public CycilcBufferOutputStream(Stream output, int size)
+		{
+			_buffer = new CyclicBuffer(size);
+			_buffer.WriteTo(output);
+		}
+
+		public override bool CanRead
+		{
+			get { return false; }
+		}
+
+		public override bool CanSeek
+		{
+			get { return false; }
+		}
+
+		public override bool CanWrite
+		{
+			get { return true; }
+		}
+
+		public override long Length
+		{
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+		public override long Position
+		{
+			get { throw new NotSupportedException(); }
+			set { throw new NotSupportedException(); }
+		}
+
+		public override void Close()
+		{
+			_buffer.Close();
+		}
+
+		public override void Flush()
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength(long value)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override int Read(byte[] array, int offset, int count)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override long Seek(long offset, SeekOrigin origin)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void Write(byte[] array, int offset, int count)
+		{
+			_buffer.Read(array, offset, count);
+		}
+	}
+
 	public class UserDefinedWriter : IAudioDest
 	{
 		string _path, _encoder, _encoderParams, _encoderMode;
 		Process _encoderProcess;
 		WAVWriter wrt;
+		CyclicBuffer outputBuffer = null;
 
 		public UserDefinedWriter(string path, int bitsPerSample, int channelCount, int sampleRate, Stream IO, string encoder, string encoderParams, string encoderMode, int padding)
 		{
@@ -748,6 +1007,8 @@ namespace CUETools.Codecs
 			_encoderProcess.StartInfo.CreateNoWindow = true;
 			_encoderProcess.StartInfo.RedirectStandardInput = true;
 			_encoderProcess.StartInfo.UseShellExecute = false;
+			if (!_encoderParams.Contains("%O"))
+				_encoderProcess.StartInfo.RedirectStandardOutput = true;
 			bool started = false;
 			Exception ex = null;
 			try
@@ -762,7 +1023,13 @@ namespace CUETools.Codecs
 			}
 			if (!started)
 				throw new Exception(_encoder + ": " + (ex == null ? "please check the path" : ex.Message));
-			wrt = new WAVWriter(path, bitsPerSample, channelCount, sampleRate, _encoderProcess.StandardInput.BaseStream);
+			if (_encoderProcess.StartInfo.RedirectStandardOutput)
+			{
+				Stream outputStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read);
+				outputBuffer = new CyclicBuffer(2 * 1024 * 1024, _encoderProcess.StandardOutput.BaseStream, outputStream);
+			}
+			Stream inputStream = new CycilcBufferOutputStream(_encoderProcess.StandardInput.BaseStream, 128 * 1024);
+			wrt = new WAVWriter(path, bitsPerSample, channelCount, sampleRate, inputStream);
 		}
 
 		public void Close()
@@ -770,6 +1037,8 @@ namespace CUETools.Codecs
 			wrt.Close();
 			if (!_encoderProcess.HasExited)
 				_encoderProcess.WaitForExit();
+			if (outputBuffer != null)
+				outputBuffer.Close();
 			if (_encoderProcess.ExitCode != 0)
 				throw new Exception(String.Format("{0} returned error code {1}", _encoder, _encoderProcess.ExitCode));
 		}
@@ -803,9 +1072,9 @@ namespace CUETools.Codecs
 			get { return wrt.BitsPerSample; }
 		}
 
-		public void Write(int[,] buff, uint sampleCount)
+		public void Write(int[,] buff, int pos, int sampleCount)
 		{
-			wrt.Write(buff, sampleCount);
+			wrt.Write(buff, pos, sampleCount);
 			//_sampleLen += sampleCount;
 		}
 
@@ -1147,77 +1416,241 @@ namespace CUETools.Codecs
 		public string Path { get { return _source.Path; } }
 	}
 
-	public class Crc32
+	public class BufferedWriter: IAudioDest
 	{
-		uint[] table = new uint[256];
+		IAudioDest _writer;
+		Thread _flushThread = null;
+		private int[,] _buffer;
+		private int _size;
+		private int _channels = 2;
+		private int _start = 0; // moved only by Write
+		private int _end = 0; // moved only by Read
+		private bool _eof = false, _delete = false;
+		Exception exceptionOnFlush = null;
 
-		public uint ComputeChecksum(uint crc, byte val)
+		public long FinalSampleCount
 		{
-			return (crc >> 8) ^ table[(crc & 0xff) ^ val];
+			//get { return _writer.FinalSampleCount; }
+			set	{ _writer.FinalSampleCount = value; }
 		}
 
-		public uint ComputeChecksum(uint crc, byte[] bytes, int pos, int count)
+		public long BlockSize
 		{
-			for (int i = pos; i < pos + count; i++)
+			set	{ _writer.BlockSize = value; }
-				crc = ComputeChecksum(crc, bytes[i]);
-			return crc;
 		}
 
-		public uint ComputeChecksum(uint crc, uint s)
+		public int BitsPerSample
 		{
-			return ComputeChecksum(ComputeChecksum(ComputeChecksum(ComputeChecksum(
+			get { return _writer.BitsPerSample;  }
-				crc, (byte)s), (byte)(s >> 8)), (byte)(s >> 16)), (byte)(s >> 24));
 		}
 
-		public unsafe uint ComputeChecksum(uint crc, int * samples, uint count)
+		public int Channels
 		{
-			for (uint i = 0; i < count; i++)
+			get { return _channels; } // !!!! writer.Channels
-			{
-				int s1 = samples[2 * i], s2 = samples[2 * i + 1];
-				crc = ComputeChecksum(ComputeChecksum(ComputeChecksum(ComputeChecksum(
-					crc, (byte)s1), (byte)(s1 >> 8)), (byte)s2), (byte)(s2 >> 8));
-			}
-			return crc;
 		}
 
-		public unsafe uint ComputeChecksumWONULL(uint crc, int* samples, uint count)
+		// public bool ReadSource(IAudioSource input)
+
+		public void Write(int[,] samples, int offset, int count)
 		{
-			for (uint i = 0; i < count; i++)
+			int pos, chunk;
+			while (count > 0)
 			{
-				int s1 = samples[2 * i], s2 = samples[2 * i + 1];
+				lock (this)
-				if (s1 != 0)
+				{
-					crc = ComputeChecksum(ComputeChecksum(crc, (byte)s1), (byte)(s1 >> 8));
+					while (FreeSpace == 0 && exceptionOnFlush == null)
-				if (s2 != 0)
+						Monitor.Wait(this);
-					crc = ComputeChecksum(ComputeChecksum(crc, (byte)s2), (byte)(s2 >> 8));
+					if (exceptionOnFlush != null)
+					{
+						Exception ex = exceptionOnFlush;
+						exceptionOnFlush = null;
+						throw ex;
+					}
+					pos = _end % _size;
+					chunk = Math.Min(FreeSpace, _size - pos);
+					chunk = Math.Min(chunk, count);
+				}
+				Array.Copy(samples, offset * Channels, _buffer, pos * Channels, chunk * Channels);
+				lock (this)
+				{
+					_end += chunk;
+					Monitor.Pulse(this);
+				}
+				count -= chunk;
+				offset += chunk;
 			}
-			return crc;
 		}
 
-		uint Reflect(uint val, int ch)
+		public string Path { get { return _writer.Path; } }
+
+		public BufferedWriter(IAudioDest writer, int size)
 		{
-			uint value = 0;
+			_writer = writer;
-			// Swap bit 0 for bit 7
+			_size = size;
-			// bit 1 for bit 6, etc.
+			_buffer = new int[_size, Channels]; 
-			for (int i = 1; i < (ch + 1); i++)
+			_flushThread = new Thread(Flush);
-			{
+			//_writeThread.Priority = ThreadPriority.Normal;
-				if (0 != (val & 1))
+			_flushThread.IsBackground = true;
-					value |= 1U << (ch - i);
+			_flushThread.Start(_writer);
-				val >>= 1;
-			}
-			return value;
 		}
 
-		const uint ulPolynomial = 0x04c11db7;
+		int DataAvailable
-
-		public Crc32()
 		{
-			for (uint i = 0; i < table.Length; i++)
+			get
 			{
-				table[i] = Reflect(i, 8) << 24;
+				return _end - _start;
-				for (int j = 0; j < 8; j++)
-					table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : ulPolynomial);
-				table[i] = Reflect(table[i], 32);
 			}
 		}
+
+		int FreeSpace
+		{
+			get
+			{
+				return _size - DataAvailable;
+			}
+		}
+
+		public void Delete()
+		{
+			SetEOF(true);
+			if (_flushThread != null)
+			{
+				_flushThread.Join();
+				_flushThread = null;
+			}
+		}
+
+		public void Close()
+		{
+			SetEOF(false);
+			if (_flushThread != null)
+			{
+				_flushThread.Join();
+				_flushThread = null;
+			}
+			if (exceptionOnFlush != null)
+			{
+				Exception ex = exceptionOnFlush;
+				exceptionOnFlush = null;
+				throw ex;
+			}
+		}
+
+		public void SetEOF(bool delete)
+		{
+			lock (this)
+			{
+				_eof = true;
+				_delete = delete;
+				Monitor.Pulse(this);
+			}
+		}
+		
+		public void Flush(object o)
+		{
+			IAudioDest dest = (IAudioDest)o;
+			try
+			{
+				do
+				{
+					int pos, chunk;
+					lock (this)
+					{
+						while (DataAvailable == 0 && !_eof)
+							Monitor.Wait(this);
+						if (DataAvailable == 0)
+						{
+							if (_delete)
+								dest.Delete();
+							else
+								dest.Close();
+							return;
+						}
+						pos = _start % _size;
+						chunk = Math.Min(DataAvailable, _size - pos);
+					}
+					dest.Write(_buffer, pos, chunk);
+					lock (this)
+					{
+						_start += chunk;
+						Monitor.Pulse(this);
+					}
+				}
+				while (true);
+			}
+			catch (Exception ex)
+			{
+				lock (this)
+				{
+					exceptionOnFlush = ex;
+					Monitor.Pulse(this);
+					dest.Delete();
+				}
+			}
+		}
+	}
+	
+	public class NullStream : Stream
+	{
+		public NullStream()
+		{
+		}
+
+		public override bool CanRead
+		{
+			get { return false; }
+		}
+
+		public override bool CanSeek
+		{
+			get { return false; }
+		}
+
+		public override bool CanWrite
+		{
+			get { return true; }
+		}
+
+		public override long Length
+		{
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+		public override long Position
+		{
+			get { throw new NotSupportedException(); }
+			set { throw new NotSupportedException(); }
+		}
+
+		public override void Close()
+		{
+		}
+
+		public override void Flush()
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength(long value)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override int Read(byte[] array, int offset, int count)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override long Seek(long offset, SeekOrigin origin)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void Write(byte[] array, int offset, int count)
+		{
+		}
 	}
 }

CUETools.Converter/CUETools.Converter.csproj

@@ -85,6 +85,10 @@
       <Project>{4CC18776-125E-4318-9D24-D60110AD9697}</Project>
       <Name>taglib-sharp</Name>
     </ProjectReference>
+    <ProjectReference Include="..\CUETools.Codecs.FLAKE\CUETools.Codecs.FLAKE.csproj">
+      <Project>{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}</Project>
+      <Name>CUETools.Codecs.FLAKE</Name>
+    </ProjectReference>
     <ProjectReference Include="..\CUETools.Codecs\CUETools.Codecs.csproj">
       <Project>{6458A13A-30EF-45A9-9D58-E5031B17BEE2}</Project>
       <Name>CUETools.Codecs</Name>

CUETools.Converter/Program.cs

@@ -2,7 +2,9 @@ using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Text;
+using System.IO;
 using CUETools.Codecs;
+using CUETools.Codecs.FLAKE;
 using CUETools.Processor;
 
 namespace CUETools.Converter
@@ -19,6 +21,7 @@ namespace CUETools.Converter
 
 		static void Main(string[] args)
 		{
+			TextWriter stdout = Console.Out;
 			Console.SetOut(Console.Error);
 			Console.WriteLine("CUETools.Converter, Copyright (C) 2009 Gregory S. Chudov.");
 			Console.WriteLine("This is free software under the GNU GPLv3+ license; There is NO WARRANTY, to");
@@ -42,7 +45,28 @@ namespace CUETools.Converter
 #endif
 			{
 				IAudioSource audioSource = AudioReadWrite.GetAudioSource(sourceFile, null, config);
-				IAudioDest audioDest = AudioReadWrite.GetAudioDest(AudioEncoderType.Lossless, destFile, (long)audioSource.Length, audioSource.BitsPerSample, audioSource.SampleRate, 8192, config);
+				IAudioDest audioDest;
+				FlakeWriter flake = null;
+				if (destFile == "$flaketest$")
+				{					
+					flake = new FlakeWriter("", audioSource.BitsPerSample, audioSource.ChannelCount, audioSource.SampleRate, new NullStream());
+					//((FlakeWriter)audioDest).CompressionLevel = 6;
+					flake.PredictionType = Flake.LookupPredictionType(args[2]);
+					flake.StereoMethod = Flake.LookupStereoMethod(args[3]);
+					flake.OrderMethod = Flake.LookupOrderMethod(args[4]);
+					flake.WindowFunction = Flake.LookupWindowFunction(args[5]);
+					flake.MinPartitionOrder = Int32.Parse(args[6]);
+					flake.MaxPartitionOrder = Int32.Parse(args[7]);
+					flake.MinLPCOrder = Int32.Parse(args[8]);
+					flake.MaxLPCOrder = Int32.Parse(args[9]);
+					flake.MinFixedOrder = Int32.Parse(args[10]);
+					flake.MaxFixedOrder = Int32.Parse(args[11]);
+					flake.MaxPrecisionSearch = Int32.Parse(args[12]);
+					flake.BlockSize = Int32.Parse(args[13]);
+					audioDest = new BufferedWriter(flake, 512 * 1024);
+				}
+				else
+					audioDest = AudioReadWrite.GetAudioDest(AudioEncoderType.Lossless, destFile, (long)audioSource.Length, audioSource.BitsPerSample, audioSource.SampleRate, 8192, config);
 				int[,] buff = new int[0x4000, audioSource.ChannelCount];
 
 				Console.WriteLine("Filename  : {0}", sourceFile);
@@ -52,7 +76,7 @@ namespace CUETools.Converter
 				{
 					uint samplesRead = audioSource.Read(buff, Math.Min((uint)buff.GetLength(0), (uint)audioSource.Remaining));
 					if (samplesRead == 0) break;
-					audioDest.Write(buff, samplesRead);
+					audioDest.Write(buff, 0, (int)samplesRead);
 					TimeSpan elapsed = DateTime.Now - start;
 					if ((elapsed - lastPrint).TotalMilliseconds > 60)
 					{
@@ -75,6 +99,8 @@ namespace CUETools.Converter
 				audioSource.Close();
 				audioDest.Close();
 
+				if (destFile != "$flaketest$")
+				{
 					TagLib.UserDefined.AdditionalFileTypes.Config = config;
 					TagLib.File sourceInfo = TagLib.File.Create(new TagLib.File.LocalFileAbstraction(sourceFile));
 					TagLib.File destInfo = TagLib.File.Create(new TagLib.File.LocalFileAbstraction(destFile));
@@ -85,6 +111,29 @@ namespace CUETools.Converter
 						destInfo.Save();
 					}
 				}
+				else
+				{
+					Console.SetOut(stdout);
+					//Console.Out.WriteLine("{0}\t{6}\t{1}\t{2}\t{3}\t{4}\t{5}", 
+					//    "Size    ", "MaxPart", "MaxPred", "Pred      ", "Stereo", "Order", "Time  ");
+					Console.Out.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}..{7}\t{8}..{9}\t{10}..{11}\t{12}\t{13}",
+						flake.TotalSize,
+						flake.UserProcessorTime.TotalSeconds,
+						flake.PredictionType.ToString().PadRight(15),
+						flake.StereoMethod.ToString().PadRight(15),
+						flake.OrderMethod.ToString().PadRight(15),
+						flake.WindowFunction,
+						flake.MinPartitionOrder,
+						flake.MaxPartitionOrder,
+						flake.MinLPCOrder,
+						flake.MaxLPCOrder,
+						flake.MinFixedOrder,
+						flake.MaxFixedOrder,
+						flake.MaxPrecisionSearch,
+						flake.BlockSize
+						);
+				}
+			}
 #if !DEBUG
 			catch (Exception ex)
 			{

CUETools.Flake/CUETools.Flake.csproj

@@ -0,0 +1,57 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{2379BAAF-A406-4477-BF53-2D6A326C24C8}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>CUETools.Flake</RootNamespace>
+    <AssemblyName>CUETools.Flake</AssemblyName>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CUETools.Codecs.FLAKE\CUETools.Codecs.FLAKE.csproj">
+      <Project>{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}</Project>
+      <Name>CUETools.Codecs.FLAKE</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\CUETools.Codecs\CUETools.Codecs.csproj">
+      <Project>{6458A13A-30EF-45A9-9D58-E5031B17BEE2}</Project>
+      <Name>CUETools.Codecs</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

CUETools.Flake/Program.cs

@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using CUETools.Codecs;
+using CUETools.Codecs.FLAKE;
+
+namespace CUETools.FlakeExe
+{
+	class Program
+	{
+		static void Usage()
+		{
+			Console.WriteLine("Usage    : CUETools.Flake.exe [options] <input.wav>");
+			Console.WriteLine();
+			Console.WriteLine("Options:");
+			Console.WriteLine();
+			Console.WriteLine(" -0 .. -11            Compression level, default 5.");
+			Console.WriteLine(" -o <file>            Output filename, or \"-\" for stdout.");
+			Console.WriteLine(" -p #                 Padding bytes.");
+			Console.WriteLine(" -q --quiet           Quiet mode.");
+			Console.WriteLine(" --verify             Verify during encoding.");
+			Console.WriteLine(" --no-md5             Don't compute MD5 hash.");
+			Console.WriteLine(" --no-seektable       Don't generate a seektable.");
+			Console.WriteLine();
+			Console.WriteLine("Advanced Options:");
+			Console.WriteLine();
+			Console.WriteLine(" -b #                 Block size.");
+			Console.WriteLine(" -v #                 VBR mode.");
+			Console.WriteLine(" -t <type>            Prediction type (fixed,levinson,search).");
+			Console.WriteLine(" -s <method>          Stereo decorrelation (independent,estimate,evaluate,search).");
+			Console.WriteLine(" -r #[,#]             Rice partition order {max} or {min},{max} (0..8).");
+			Console.WriteLine();
+			Console.WriteLine("LPC options:");
+			Console.WriteLine();
+			Console.WriteLine(" -m <method>          Prediction order search (estimate,estsearch,logfast,search).");
+			Console.WriteLine(" -w <func>[,<func>]   One or more window functions (welch,hann,flattop,tukey).");
+			Console.WriteLine(" -l #[,#]             Prediction order {max} or {min},{max} (1..32).");
+			Console.WriteLine("    --max-precision   Coefficients precision search (0..1).");
+			Console.WriteLine();
+			Console.WriteLine("Fixed prediction options:");
+			Console.WriteLine();
+			Console.WriteLine(" -f #[,#]             Prediction order {max} or {min},{max} (0..4).");
+		}
+
+		static void Main(string[] args)
+		{
+			TextWriter stdout = Console.Out;
+			Console.SetOut(Console.Error);
+
+			DateTime start = DateTime.Now;
+			TimeSpan lastPrint = TimeSpan.FromMilliseconds(0);
+			bool debug = false, quiet = false;
+			string prediction_type = null;
+			string stereo_method = null;
+			string order_method = null;
+			string window_function = null;
+			string input_file = null;
+			string output_file = null;
+			int min_partition_order = -1, max_partition_order = -1,
+				min_lpc_order = -1, max_lpc_order = -1,
+				min_fixed_order = -1, max_fixed_order = -1,
+				max_precision = -1, blocksize = -1;
+			int level = -1, padding = -1, vbr_mode = -1;
+			bool do_md5 = true, do_seektable = true, do_verify = false;
+
+			for (int arg = 0; arg < args.Length; arg++)
+			{
+				bool ok = true;
+				if (args[arg].Length == 0)
+					ok = false;
+				else if (args[arg] == "--debug")
+					debug = true;
+				else if ((args[arg] == "-q" || args[arg] == "--quiet"))
+					quiet = true;
+				else if (args[arg] == "--verify")
+					do_verify = true;
+				else if (args[arg] == "--no-seektable")
+					do_seektable = false;
+				else if (args[arg] == "--no-md5")
+					do_seektable = false;
+				else if ((args[arg] == "-o" || args[arg] == "--output") && ++arg < args.Length)
+					output_file = args[arg];
+				else if ((args[arg] == "-t" || args[arg] == "--prediction-type") && ++arg < args.Length)
+					prediction_type = args[arg];
+				else if ((args[arg] == "-s" || args[arg] == "--stereo") && ++arg < args.Length)
+					stereo_method = args[arg];
+				else if ((args[arg] == "-m" || args[arg] == "--order-method") && ++arg < args.Length)
+					order_method = args[arg];
+				else if ((args[arg] == "-w" || args[arg] == "--window") && ++arg < args.Length)
+					window_function = args[arg];
+				else if ((args[arg] == "-r" || args[arg] == "--partition-order") && ++arg < args.Length)
+				{
+					ok = (args[arg].Split(',').Length == 2 &&
+						int.TryParse(args[arg].Split(',')[0], out min_partition_order) &&
+						int.TryParse(args[arg].Split(',')[1], out max_partition_order)) ||
+						int.TryParse(args[arg], out max_partition_order);
+				}
+				else if ((args[arg] == "-l" || args[arg] == "--lpc-order") && ++arg < args.Length)
+				{
+					ok = (args[arg].Split(',').Length == 2 &&
+						int.TryParse(args[arg].Split(',')[0], out min_lpc_order) &&
+						int.TryParse(args[arg].Split(',')[1], out max_lpc_order)) ||
+						int.TryParse(args[arg], out max_lpc_order);
+				}
+				else if ((args[arg] == "-f" || args[arg] == "--fixed-order") && ++arg < args.Length)
+				{
+					ok = (args[arg].Split(',').Length == 2 &&
+						int.TryParse(args[arg].Split(',')[0], out min_fixed_order) &&
+						int.TryParse(args[arg].Split(',')[1], out max_fixed_order)) ||
+						int.TryParse(args[arg], out max_fixed_order);
+				}
+				else if (args[arg] == "--max-precision" && ++arg < args.Length)
+					ok = int.TryParse(args[arg], out max_precision);
+				else if ((args[arg] == "-v" || args[arg] == "--vbr") && ++arg < args.Length)
+					ok = int.TryParse(args[arg], out vbr_mode);
+				else if ((args[arg] == "-b" || args[arg] == "--blocksize") && ++arg < args.Length)
+					ok = int.TryParse(args[arg], out blocksize);
+				else if ((args[arg] == "-p" || args[arg] == "--padding") && ++arg < args.Length)
+					ok = int.TryParse(args[arg], out padding);
+				else if (args[arg] != "-" && args[arg][0] == '-' && int.TryParse(args[arg].Substring(1), out level))
+					ok = level >= 0 && level <= 11;
+				else if ((args[arg][0] != '-' || args[arg] == "-") && input_file == null)
+					input_file = args[arg];
+				else
+					ok = false;
+				if (!ok)
+				{
+					Usage();
+					return;
+				}
+			}
+			if (input_file == null || ((input_file == "-" || Path.GetExtension(input_file) == ".flac") && output_file == null))
+			{
+				Usage();
+				return;
+			}
+
+			if (!quiet)
+			{
+				Console.WriteLine("CUETools.Flake, Copyright (C) 2009 Gregory S. Chudov.");
+				Console.WriteLine("Based on Flake encoder by Justin Ruggles, <http://flake-enc.sourceforge.net/>.");
+				Console.WriteLine("This is free software under the GNU GPLv3+ license; There is NO WARRANTY, to");
+				Console.WriteLine("the extent permitted by law. <http://www.gnu.org/licenses/> for details.");
+			}
+
+			IAudioSource audioSource;
+			if (input_file == "-")
+				audioSource = new WAVReader("", Console.OpenStandardInput());
+			else if (File.Exists(input_file) && Path.GetExtension(input_file) == ".wav")
+				audioSource = new WAVReader(input_file, null);
+			else if (File.Exists(input_file) && Path.GetExtension(input_file) == ".flac")
+				audioSource = new FlakeReader(input_file, null);
+			else
+			{
+				Usage();
+				return;
+			}
+			if (output_file == null)
+				output_file = Path.ChangeExtension(input_file, "flac");
+			FlakeWriter flake = new FlakeWriter((output_file == "-" || output_file == "nul") ? "" : output_file,
+				audioSource.BitsPerSample, audioSource.ChannelCount, audioSource.SampleRate,
+				output_file == "-" ? Console.OpenStandardOutput() :
+				output_file == "nul" ? new NullStream() : null);
+			flake.FinalSampleCount = (long)audioSource.Length;
+			IAudioDest audioDest = new BufferedWriter(flake, 512 * 1024);
+			int[,] buff = new int[0x10000, audioSource.ChannelCount];
+
+			if (level >= 0)
+				flake.CompressionLevel = level;
+			if (prediction_type != null)
+				flake.PredictionType = Flake.LookupPredictionType(prediction_type);
+			if (stereo_method != null)
+				flake.StereoMethod = Flake.LookupStereoMethod(stereo_method);
+			if (order_method != null)
+				flake.OrderMethod = Flake.LookupOrderMethod(order_method);
+			if (window_function != null)
+				flake.WindowFunction = Flake.LookupWindowFunction(window_function);
+			if (min_partition_order >= 0)
+				flake.MinPartitionOrder = min_partition_order;
+			if (max_partition_order >= 0)
+				flake.MaxPartitionOrder = max_partition_order;
+			if (min_lpc_order >= 0)
+				flake.MinLPCOrder = min_lpc_order;
+			if (max_lpc_order >= 0)
+				flake.MaxLPCOrder = max_lpc_order;
+			if (min_fixed_order >= 0)
+				flake.MinFixedOrder = min_fixed_order;
+			if (max_fixed_order >= 0)
+				flake.MaxFixedOrder = max_fixed_order;
+			if (max_precision >= 0)
+				flake.MaxPrecisionSearch = max_precision;
+			if (blocksize >= 0)
+				flake.BlockSize = blocksize;
+			if (padding >= 0)
+				flake.PaddingLength = padding;
+			if (vbr_mode >= 0)
+				flake.VBRMode = vbr_mode;
+			flake.DoMD5 = do_md5;
+			flake.DoSeekTable = do_seektable;
+			flake.DoVerify = do_verify;
+
+			if (!quiet)
+			{
+				Console.WriteLine("Filename  : {0}", input_file);
+				Console.WriteLine("File Info : {0}kHz; {1} channel; {2} bit; {3}", audioSource.SampleRate, audioSource.ChannelCount, audioSource.BitsPerSample, TimeSpan.FromSeconds(audioSource.Length * 1.0 / audioSource.SampleRate));
+			}
+
+			do
+			{
+				uint samplesRead = audioSource.Read(buff, Math.Min((uint)buff.GetLength(0), (uint)audioSource.Remaining));
+				if (samplesRead == 0) break;
+				audioDest.Write(buff, 0, (int)samplesRead);
+				TimeSpan elapsed = DateTime.Now - start;
+				if (!quiet)
+				{
+					if ((elapsed - lastPrint).TotalMilliseconds > 60)
+					{
+						Console.Error.Write("\rProgress  : {0:00}%; {1:0.00}x; {2}/{3}",
+							100.0 * audioSource.Position / audioSource.Length,
+							audioSource.Position / elapsed.TotalSeconds / audioSource.SampleRate,
+							elapsed,
+							TimeSpan.FromMilliseconds(elapsed.TotalMilliseconds / audioSource.Position * audioSource.Length)
+							);
+						lastPrint = elapsed;
+					}
+				}
+			} while (true);
+
+			if (!quiet)
+			{
+				TimeSpan totalElapsed = DateTime.Now - start;
+				Console.Error.Write("\r                                                                         \r");
+				Console.WriteLine("Results   : {0:0.00}x; {1}",
+					audioSource.Position / totalElapsed.TotalSeconds / audioSource.SampleRate,
+					totalElapsed
+					);
+			}
+			audioSource.Close();
+			audioDest.Close();
+
+			if (debug)
+			{
+				Console.SetOut(stdout);
+				Console.Out.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}..{7}\t{8}..{9}\t{10}..{11}\t{12}\t{13}\t{14}",
+					flake.TotalSize,
+					flake.UserProcessorTime.TotalSeconds,
+					flake.PredictionType.ToString().PadRight(15),
+					flake.StereoMethod.ToString().PadRight(15),
+					flake.OrderMethod.ToString().PadRight(15),
+					flake.WindowFunction,
+					flake.MinPartitionOrder,
+					flake.MaxPartitionOrder,
+					flake.MinLPCOrder,
+					flake.MaxLPCOrder,
+					flake.MinFixedOrder,
+					flake.MaxFixedOrder,
+					flake.MaxPrecisionSearch,
+					flake.BlockSize,
+					flake.VBRMode
+					);
+			}
+		}
+	}
+}

CUETools.Flake/Properties/AssemblyInfo.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("CUETools.Flake")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("CUETools.Flake")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2009")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e7034131-e6d0-4ecb-9157-5a1b5f7b925e")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

CUETools.Processor/AudioReadWrite.cs

@@ -2,6 +2,7 @@ using System;
 using System.IO;
 using CUETools.Codecs;
 using CUETools.Codecs.ALAC;
+using CUETools.Codecs.FLAKE;
 #if !MONO
 using CUETools.Codecs.FLAC;
 using CUETools.Codecs.WavPack;
@@ -29,6 +30,8 @@ namespace CUETools.Processor
 					return new WAVReader(path, IO);
 				case "ALACReader":
 					return new ALACReader(path, IO);
+				case "FlakeReader":
+					return new FlakeReader(path, IO);
 #if !MONO
 				case "FLACReader":
 					return new FLACReader(path, IO, config.disableAsm);
@@ -99,6 +102,12 @@ namespace CUETools.Processor
 					((FLACWriter)dest).Verify = config.flacVerify;
 					((FLACWriter)dest).DisableAsm = config.disableAsm;
 					break;
+				case "FlakeWriter":
+					dest = new FlakeWriter(path, bitsPerSample, channelCount, sampleRate, null);
+					((FlakeWriter)dest).PaddingLength = padding;
+					((FlakeWriter)dest).CompressionLevel = encoder.DefaultModeIndex;
+					dest = new BufferedWriter(dest, 128 * 1024);
+					break;
 				case "WavPackWriter":
 					dest = new WavPackWriter(path, bitsPerSample, channelCount, sampleRate);
 					((WavPackWriter)dest).CompressionMode = encoder.DefaultModeIndex;

CUETools.Processor/CUETools.Processor.csproj

@@ -120,6 +120,10 @@
       <Project>{9AE965C4-301E-4C01-B90F-297AF341ACC6}</Project>
       <Name>CUETools.Codecs.APE</Name>
     </ProjectReference>
+    <ProjectReference Include="..\CUETools.Codecs.FLAKE\CUETools.Codecs.FLAKE.csproj">
+      <Project>{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}</Project>
+      <Name>CUETools.Codecs.FLAKE</Name>
+    </ProjectReference>
     <ProjectReference Include="..\CUETools.Codecs.TTA\CUETools.Codecs.TTA.vcproj">
       <Project>{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}</Project>
       <Name>CUETools.Codecs.TTA</Name>

CUETools.Processor/Processor.cs

@@ -911,12 +911,13 @@ namespace CUETools.Processor
 			encoders = new CUEToolsUDCList();
 #if !MONO
 			encoders.Add(new CUEToolsUDC("libFLAC", "flac", true, "0 1 2 3 4 5 6 7 8", "5", "FLACWriter"));
+			encoders.Add(new CUEToolsUDC("libFlake", "flac", true, "0 1 2 3 4 5 6 7 8 9 10 11 12", "5", "FlakeWriter"));
 			encoders.Add(new CUEToolsUDC("libwavpack", "wv", true, "fast normal high high+", "normal", "WavPackWriter"));
 			encoders.Add(new CUEToolsUDC("MAC_SDK", "ape", true, "fast normal high extra insane", "high", "APEWriter"));
 			encoders.Add(new CUEToolsUDC("ttalib", "tta", true, "", "", "TTAWriter"));
 #endif
 			encoders.Add(new CUEToolsUDC("builtin wav", "wav", true, "", "", "WAVWriter"));
-			encoders.Add(new CUEToolsUDC("flake", "flac", true, "0 1 2 3 4 5 6 7 8 9 10 11 12", "10", "flake.exe", "-%M - -o %O"));
+			encoders.Add(new CUEToolsUDC("flake", "flac", true, "0 1 2 3 4 5 6 7 8 9 10 11", "10", "flake.exe", "-%M - -o %O -p %P"));
 			encoders.Add(new CUEToolsUDC("takc", "tak", true, "0 1 2 2e 2m 3 3e 3m 4 4e 4m", "2", "takc.exe", "-e -p%M -overwrite - %O"));
 			encoders.Add(new CUEToolsUDC("ffmpeg alac", "m4a", true, "", "", "ffmpeg.exe", "-i - -f ipod -acodec alac -y %O"));
 			encoders.Add(new CUEToolsUDC("lame vbr", "mp3", false, "V9 V8 V7 V6 V5 V4 V3 V2 V1 V0", "V2", "lame.exe", "--vbr-new -%M - %O"));
@@ -931,6 +932,7 @@ namespace CUETools.Processor
 			decoders.Add("MAC_SDK", new CUEToolsUDC("MAC_SDK", "ape", true, "", "", "APEReader"));
 			decoders.Add("ttalib", new CUEToolsUDC("ttalib", "tta", true, "", "", "TTAReader"));
 #endif
+			decoders.Add("libFlake", new CUEToolsUDC("libFlake", "flac", true, "", "", "FlakeReader"));
 			decoders.Add("builtin wav", new CUEToolsUDC("builtin wav", "wav", true, "", "", "WAVReader"));
 			decoders.Add("builtin alac", new CUEToolsUDC("builtin alac", "m4a", true, "", "", "ALACReader"));
 			decoders.Add("takc", new CUEToolsUDC("takc", "tak", true, "", "", "takc.exe", "-d %I -"));
@@ -1400,6 +1402,7 @@ return processor.Go();
 		public string status = string.Empty;
 		public double percentTrck = 0;
 		public double percentDisk = 0.0;
+		public int offset = 0;
 		public string input = string.Empty;
 		public string output = string.Empty;
 	}
@@ -1586,7 +1589,7 @@ return processor.Go();
 
 			if (useFreedb)
 			{
-				ShowProgress("Looking up album via freedb...", 0.0, 0.0, null, null);
+				ShowProgress("Looking up album via Freedb...", 0.0, 0.0, null, null);
 
 				FreedbHelper m_freedb = new FreedbHelper();
 
@@ -1633,6 +1636,8 @@ return processor.Go();
 
 			if (useMusicBrainz)
 			{
+				ShowProgress("Looking up album via MusicBrainz...", 0.0, 0.0, null, null);
+
 				StringCollection DiscIds = new StringCollection();
 				DiscIds.Add(_toc.MusicBrainzId);
 				//if (_tocFromLog != null && !DiscIds.Contains(_tocFromLog.MusicBrainzId))
@@ -1645,7 +1650,6 @@ return processor.Go();
 				}
 
 				MusicBrainzService.XmlRequest += new EventHandler<XmlRequestEventArgs>(MusicBrainz_LookupProgress);
-				_progress.percentDisk = 0;
 				foreach (string DiscId in DiscIds)
 				{
 					ReleaseQueryParameters p = new ReleaseQueryParameters();
@@ -2555,6 +2559,20 @@ return processor.Go();
 			_progress.status = status;
 			_progress.percentTrck = percentTrack;
 			_progress.percentDisk = percentDisk;
+			_progress.offset = 0;
+			_progress.input = input;
+			_progress.output = output;
+			this.CUEToolsProgress(this, _progress);
+		}
+
+		private void ShowProgress(string status, double percentTrack, int diskOffset, int diskLength, string input, string output)
+		{
+			if (this.CUEToolsProgress == null)
+				return;
+			_progress.status = status;
+			_progress.percentTrck = percentTrack;
+			_progress.percentDisk = (double)diskOffset / diskLength;
+			_progress.offset = diskOffset;
 			_progress.input = input;
 			_progress.output = output;
 			this.CUEToolsProgress(this, _progress);
@@ -2572,6 +2590,7 @@ return processor.Go();
 			double speed = elapsed.TotalSeconds > 0 ? processed / elapsed.TotalSeconds / 75 : 1.0;
 			_progress.percentDisk = (double)(e.PassStart + (processed + e.Pass * (e.PassEnd - e.PassStart)) / (audioSource.CorrectionQuality + 1)) / audioSource.TOC.AudioLength;
 			_progress.percentTrck = (double) (e.Position - e.PassStart) / (e.PassEnd - e.PassStart);
+			_progress.offset = 0;
 			_progress.status = string.Format("Ripping @{0:00.00}x {1}", speed, e.Pass > 0 ? " (Retry " + e.Pass.ToString() + ")" : "");
 			this.CUEToolsProgress(this, _progress);
 		}
@@ -2582,6 +2601,7 @@ return processor.Go();
 				return;
 			_progress.percentDisk = (1.0 + _progress.percentDisk) / 2;
 			_progress.percentTrck = 0;
+			_progress.offset = 0;
 			_progress.input = e.Uri.ToString();
 			_progress.output = null;
 			_progress.status = "Looking up album via MusicBrainz";
@@ -4100,9 +4120,8 @@ return processor.Go();
 							if (trackLength > 0 && !_isCD)
 							{
 								double trackPercent = (double)currentOffset / trackLength;
-								double diskPercent = (double)diskOffset / diskLength;
 								ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", iIndex > 0 ? iTrack + 1 : iTrack, (uint)(100*trackPercent),
-									noOutput ? "Verifying" : "Writing"), trackPercent, diskPercent,
+									noOutput ? "Verifying" : "Writing"), trackPercent, (int)diskOffset, (int)diskLength,
 									_isCD ? string.Format("{0}: {1:00} - {2}", audioSource.Path, iTrack + 1, _tracks[iTrack].Title) : audioSource.Path, discardOutput ? null : audioDest.Path);
 							}
 
@@ -4111,7 +4130,7 @@ return processor.Go();
 							if (!discardOutput)
 							{
 								if (!_config.detectHDCD || !_config.decodeHDCD)
-									audioDest.Write(sampleBuffer, copyCount);
+									audioDest.Write(sampleBuffer, 0, (int)copyCount);
 								if (_config.detectHDCD && hdcdDecoder != null)
 								{
 									if (_config.wait750FramesForHDCD && diskOffset > 750 * 588 && !hdcdDecoder.Detected)
@@ -4134,7 +4153,7 @@ return processor.Go();
 								}
 							}
 							if (_useAccurateRip)
-								_arVerify.Write(sampleBuffer, copyCount);
+								_arVerify.Write(sampleBuffer, 0, (int)copyCount);
 							if (iTrack > 0 || iIndex > 0)
 								Tracks[iTrack + (iIndex == 0 ? -1 : 0)].MeasurePeakLevel(sampleBuffer, copyCount);
 
@@ -4157,7 +4176,7 @@ return processor.Go();
 				try { if (audioSource != null && !_isCD) audioSource.Close(); }
 				catch { }
 				audioSource = null;
-				try { if (audioDest != null) audioDest.Close(); } 
+				try { if (audioDest != null) audioDest.Delete(); } 
 				catch { }
 				audioDest = null;
 				throw ex;

CUETools.Ripper.Console/Program.cs

@@ -220,8 +220,8 @@ namespace CUETools.ConsoleRipper
 					if (samplesRead == 0) break;
 					if (samplesRead != toRead)
 						throw new Exception("samples read != samples requested");
-					arVerify.Write(buff, samplesRead);
+					arVerify.Write(buff, 0, (int)samplesRead);
-					audioDest.Write(buff, samplesRead);
+					audioDest.Write(buff, 0, (int)samplesRead);
 				} while (true);
 
 				TimeSpan totalElapsed = DateTime.Now - meter.realStart;

CUETools.Ripper.SCSI/CRC16CCITT.cs

@@ -1,55 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace CUETools.Ripper.SCSI
-{
-	public enum InitialCrcValue { Zeros, NonZero1 = 0xffff, NonZero2 = 0x1D0F }
-
-	public class Crc16Ccitt
-	{
-		const ushort poly = 4129;
-		ushort[] table = new ushort[256];
-		ushort initialValue = 0;
-
-		public ushort ComputeChecksum(byte[] bytes, int pos, int count)
-		{
-			ushort crc = this.initialValue;
-			for (int i = pos; i < pos + count; i++)
-			{
-				crc = (ushort)((crc << 8) ^ table[((crc >> 8) ^ (0xff & bytes[i]))]);
-			}
-			return crc;
-		}
-
-		public byte[] ComputeChecksumBytes(byte[] bytes, int pos, int count)
-		{
-			ushort crc = ComputeChecksum(bytes, pos, count);
-			return new byte[] { (byte)(crc >> 8), (byte)(crc & 0x00ff) };
-		}
-
-		public Crc16Ccitt(InitialCrcValue initialValue)
-		{
-			this.initialValue = (ushort)initialValue;
-			ushort temp, a;
-			for (int i = 0; i < table.Length; i++)
-			{
-				temp = 0;
-				a = (ushort)(i << 8);
-				for (int j = 0; j < 8; j++)
-				{
-					if (((temp ^ a) & 0x8000) != 0)
-					{
-						temp = (ushort)((temp << 1) ^ poly);
-					}
-					else
-					{
-						temp <<= 1;
-					}
-					a <<= 1;
-				}
-				table[i] = temp;
-			}
-		}
-	}
-}

CUETools.Ripper.SCSI/CUETools.Ripper.SCSI.csproj

@@ -82,7 +82,6 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="CRC16CCITT.cs" />
     <Compile Include="Galois.cs" />
     <Compile Include="RsDecode.cs" />
     <Compile Include="RsEncode.cs" />

CUETools/CUETools.sln

@@ -87,14 +87,22 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "taglib-sharp", "..\..\tagli
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CUEControls", "..\CUEControls\CUEControls.csproj", "{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CUETools.Codecs.FLAKE", "..\CUETools.Codecs.FLAKE\CUETools.Codecs.FLAKE.csproj", "{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "flake", "..\flake\flake.vcproj", "{F53335A2-C013-4354-98CC-83E612EAEB60}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CUETools.Flake", "..\CUETools.Flake\CUETools.Flake.csproj", "{2379BAAF-A406-4477-BF53-2D6A326C24C8}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Debug|Mixed Platforms = Debug|Mixed Platforms
+		Debug|Win32 = Debug|Win32
 		Debug|x64 = Debug|x64
 		Debug|x86 = Debug|x86
 		Release|Any CPU = Release|Any CPU
 		Release|Mixed Platforms = Release|Mixed Platforms
+		Release|Win32 = Release|Win32
 		Release|x64 = Release|x64
 		Release|x86 = Release|x86
 	EndGlobalSection
@@ -103,6 +111,7 @@ Global
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|Win32.ActiveCfg = Debug|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|x64.ActiveCfg = Debug|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|x64.Build.0 = Debug|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Debug|x86.ActiveCfg = Debug|x86
@@ -111,6 +120,7 @@ Global
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|Any CPU.Build.0 = Release|Any CPU
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|Mixed Platforms.Build.0 = Release|x64
+		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|Win32.ActiveCfg = Release|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|x64.ActiveCfg = Release|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|x64.Build.0 = Release|x64
 		{EF351583-A9CD-4530-92C3-20AC02136BC2}.Release|x86.ActiveCfg = Release|x86
@@ -118,6 +128,8 @@ Global
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|Win32.Build.0 = Debug|Win32
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|x64.ActiveCfg = Debug|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|x64.Build.0 = Debug|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Debug|x86.ActiveCfg = Debug|Win32
@@ -125,6 +137,8 @@ Global
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|Any CPU.ActiveCfg = Release|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|Mixed Platforms.Build.0 = Release|x64
+		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|Win32.ActiveCfg = Release|Win32
+		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|Win32.Build.0 = Release|Win32
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|x64.ActiveCfg = Release|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|x64.Build.0 = Release|x64
 		{E70FA90A-7012-4A52-86B5-362B699D1540}.Release|x86.ActiveCfg = Release|Win32
@@ -132,6 +146,8 @@ Global
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|Win32.Build.0 = Debug|Win32
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|x64.ActiveCfg = Debug|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|x64.Build.0 = Debug|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Debug|x86.ActiveCfg = Debug|Win32
@@ -139,6 +155,8 @@ Global
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|Any CPU.ActiveCfg = Release|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|Mixed Platforms.Build.0 = Release|x64
+		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|Win32.ActiveCfg = Release|Win32
+		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|Win32.Build.0 = Release|Win32
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|x64.ActiveCfg = Release|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|x64.Build.0 = Release|x64
 		{9AE965C4-301E-4C01-B90F-297AF341ACC6}.Release|x86.ActiveCfg = Release|Win32
@@ -146,6 +164,8 @@ Global
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|Win32.Build.0 = Debug|Win32
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|x64.ActiveCfg = Debug|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|x64.Build.0 = Debug|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Debug|x86.ActiveCfg = Debug|Win32
@@ -153,6 +173,8 @@ Global
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|Any CPU.ActiveCfg = Release|Win32
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|Mixed Platforms.Build.0 = Release|x64
+		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|Win32.ActiveCfg = Release|Win32
+		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|Win32.Build.0 = Release|Win32
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|x64.ActiveCfg = Release|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|x64.Build.0 = Release|x64
 		{CC2E74B6-534A-43D8-9F16-AC03FE955000}.Release|x86.ActiveCfg = Release|Win32
@@ -160,6 +182,8 @@ Global
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|Win32.Build.0 = Debug|Win32
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|x64.ActiveCfg = Debug|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|x64.Build.0 = Debug|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Debug|x86.ActiveCfg = Debug|Win32
@@ -167,6 +191,8 @@ Global
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|Any CPU.ActiveCfg = Release|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|Mixed Platforms.Build.0 = Release|x64
+		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|Win32.ActiveCfg = Release|Win32
+		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|Win32.Build.0 = Release|Win32
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|x64.ActiveCfg = Release|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|x64.Build.0 = Release|x64
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779}.Release|x86.ActiveCfg = Release|Win32
@@ -174,6 +200,8 @@ Global
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|Win32.ActiveCfg = Debug|Win32
+		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|Win32.Build.0 = Debug|Win32
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|x64.ActiveCfg = Debug|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|x64.Build.0 = Debug|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Debug|x86.ActiveCfg = Debug|Win32
@@ -181,6 +209,8 @@ Global
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|Any CPU.ActiveCfg = Release|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|Mixed Platforms.Build.0 = Release|x64
+		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|Win32.ActiveCfg = Release|Win32
+		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|Win32.Build.0 = Release|Win32
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|x64.ActiveCfg = Release|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|x64.Build.0 = Release|x64
 		{4CEFBC84-C215-11DB-8314-0800200C9A66}.Release|x86.ActiveCfg = Release|Win32
@@ -188,6 +218,8 @@ Global
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|Win32.Build.0 = Debug|Win32
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|x64.ActiveCfg = Debug|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|x64.Build.0 = Debug|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Debug|x86.ActiveCfg = Debug|Win32
@@ -195,6 +227,8 @@ Global
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|Any CPU.ActiveCfg = Release|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|Mixed Platforms.Build.0 = Release|x64
+		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|Win32.ActiveCfg = Release|Win32
+		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|Win32.Build.0 = Release|Win32
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|x64.ActiveCfg = Release|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|x64.Build.0 = Release|x64
 		{5CCCB9CF-0384-458F-BA08-72B73866840F}.Release|x86.ActiveCfg = Release|Win32
@@ -203,6 +237,7 @@ Global
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|Win32.ActiveCfg = Debug|x86
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|x64.ActiveCfg = Debug|x64
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|x64.Build.0 = Debug|x64
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Debug|x86.ActiveCfg = Debug|x86
@@ -211,6 +246,7 @@ Global
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|Mixed Platforms.Build.0 = Release|x86
+		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|Win32.ActiveCfg = Release|x86
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|x64.ActiveCfg = Release|x64
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|x64.Build.0 = Release|x64
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728}.Release|x86.ActiveCfg = Release|x86
@@ -219,6 +255,7 @@ Global
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|Win32.ActiveCfg = Debug|x64
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|x64.ActiveCfg = Debug|x64
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|x64.Build.0 = Debug|x64
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Debug|x86.ActiveCfg = Debug|x86
@@ -227,6 +264,7 @@ Global
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|Any CPU.Build.0 = Release|Any CPU
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|Mixed Platforms.Build.0 = Release|x64
+		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|Win32.ActiveCfg = Release|x64
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|x64.ActiveCfg = Release|Any CPU
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|x64.Build.0 = Release|Any CPU
 		{4911BD82-49EF-4858-8B51-5394F86739A4}.Release|x86.ActiveCfg = Release|x86
@@ -235,6 +273,7 @@ Global
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|Win32.ActiveCfg = Debug|x86
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|x64.ActiveCfg = Debug|x64
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|x64.Build.0 = Debug|x64
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Debug|x86.ActiveCfg = Debug|x86
@@ -242,6 +281,7 @@ Global
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|Any CPU.ActiveCfg = Release|x64
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|Mixed Platforms.Build.0 = Release|x86
+		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|Win32.ActiveCfg = Release|x86
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|x64.ActiveCfg = Release|x64
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|x64.Build.0 = Release|x64
 		{32338A04-5B6B-4C63-8EE7-C6400F73B5D7}.Release|x86.ActiveCfg = Release|x86
@@ -250,6 +290,7 @@ Global
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|Win32.ActiveCfg = Debug|x86
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|x64.ActiveCfg = Debug|x64
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|x64.Build.0 = Debug|x64
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Debug|x86.ActiveCfg = Debug|x86
@@ -258,14 +299,16 @@ Global
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|Any CPU.Build.0 = Release|Any CPU
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|Mixed Platforms.Build.0 = Release|x86
-		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|x64.ActiveCfg = Release|x64
+		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|Win32.ActiveCfg = Release|x86
-		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|x64.Build.0 = Release|x64
+		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|x64.ActiveCfg = Release|Any CPU
+		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|x64.Build.0 = Release|Any CPU
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|x86.ActiveCfg = Release|x86
 		{6458A13A-30EF-45A9-9D58-E5031B17BEE2}.Release|x86.Build.0 = Release|x86
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|Win32.ActiveCfg = Debug|x86
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|x64.ActiveCfg = Debug|x64
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|x64.Build.0 = Debug|x64
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Debug|x86.ActiveCfg = Debug|x86
@@ -274,6 +317,7 @@ Global
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|Any CPU.Build.0 = Release|Any CPU
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|Mixed Platforms.Build.0 = Release|x86
+		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|Win32.ActiveCfg = Release|x86
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|x64.ActiveCfg = Release|x64
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|x64.Build.0 = Release|x64
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F}.Release|x86.ActiveCfg = Release|x86
@@ -281,6 +325,7 @@ Global
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|Win32.ActiveCfg = Debug|x86
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|x64.ActiveCfg = Debug|x64
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|x64.Build.0 = Debug|x64
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Debug|x86.ActiveCfg = Debug|x86
@@ -288,6 +333,7 @@ Global
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|Any CPU.ActiveCfg = Release|x64
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|Mixed Platforms.Build.0 = Release|x86
+		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|Win32.ActiveCfg = Release|x86
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|x64.ActiveCfg = Release|x64
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|x64.Build.0 = Release|x64
 		{8427CAA5-80B8-4952-9A68-5F3DFCFBDF40}.Release|x86.ActiveCfg = Release|x86
@@ -296,6 +342,7 @@ Global
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|Win32.ActiveCfg = Debug|x86
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|x64.ActiveCfg = Debug|x64
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|x64.Build.0 = Debug|x64
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Debug|x86.ActiveCfg = Debug|x86
@@ -304,6 +351,7 @@ Global
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|Any CPU.Build.0 = Release|Any CPU
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|Mixed Platforms.Build.0 = Release|x86
+		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|Win32.ActiveCfg = Release|x86
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|x64.ActiveCfg = Release|x64
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|x64.Build.0 = Release|x64
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19}.Release|x86.ActiveCfg = Release|x86
@@ -312,6 +360,7 @@ Global
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|Win32.ActiveCfg = Debug|x86
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|x64.ActiveCfg = Debug|x64
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|x64.Build.0 = Debug|x64
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Debug|x86.ActiveCfg = Debug|x86
@@ -320,6 +369,7 @@ Global
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|Mixed Platforms.Build.0 = Release|x86
+		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|Win32.ActiveCfg = Release|x86
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|x64.ActiveCfg = Release|x64
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|x64.Build.0 = Release|x64
 		{A574F3B1-E38B-4EE4-9394-49D6E2DF52EA}.Release|x86.ActiveCfg = Release|x86
@@ -328,6 +378,7 @@ Global
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|Win32.ActiveCfg = Debug|x86
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|x64.ActiveCfg = Debug|x64
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|x64.Build.0 = Debug|x64
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Debug|x86.ActiveCfg = Debug|x86
@@ -336,6 +387,7 @@ Global
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|Any CPU.Build.0 = Release|Any CPU
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|Mixed Platforms.Build.0 = Release|x86
+		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|Win32.ActiveCfg = Release|x86
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|x64.ActiveCfg = Release|x64
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|x64.Build.0 = Release|x64
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF}.Release|x86.ActiveCfg = Release|x86
@@ -344,6 +396,7 @@ Global
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|Win32.ActiveCfg = Debug|x86
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|x64.ActiveCfg = Debug|x64
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|x64.Build.0 = Debug|x64
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Debug|x86.ActiveCfg = Debug|x86
@@ -352,6 +405,7 @@ Global
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|Any CPU.Build.0 = Release|Any CPU
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|Mixed Platforms.Build.0 = Release|x86
+		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|Win32.ActiveCfg = Release|x86
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|x64.ActiveCfg = Release|x64
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|x64.Build.0 = Release|x64
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7}.Release|x86.ActiveCfg = Release|x86
@@ -360,6 +414,7 @@ Global
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|Win32.ActiveCfg = Debug|x86
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|x64.ActiveCfg = Debug|x64
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|x64.Build.0 = Debug|x64
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Debug|x86.ActiveCfg = Debug|x86
@@ -368,6 +423,7 @@ Global
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|Mixed Platforms.Build.0 = Release|x86
+		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|Win32.ActiveCfg = Release|x86
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|x64.ActiveCfg = Release|x64
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|x64.Build.0 = Release|x64
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8}.Release|x86.ActiveCfg = Release|x86
@@ -376,6 +432,7 @@ Global
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|Win32.ActiveCfg = Debug|x86
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|x64.ActiveCfg = Debug|x64
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|x64.Build.0 = Debug|x64
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Debug|x86.ActiveCfg = Debug|x86
@@ -384,6 +441,7 @@ Global
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|Any CPU.Build.0 = Release|Any CPU
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|Mixed Platforms.Build.0 = Release|x86
+		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|Win32.ActiveCfg = Release|x86
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|x64.ActiveCfg = Release|x64
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|x64.Build.0 = Release|x64
 		{8CF07381-BEA2-4AFC-B3DD-9B2F21C65A3A}.Release|x86.ActiveCfg = Release|x86
@@ -392,6 +450,7 @@ Global
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|Win32.ActiveCfg = Debug|x86
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|x64.ActiveCfg = Debug|x64
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|x64.Build.0 = Debug|x64
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Debug|x86.ActiveCfg = Debug|x86
@@ -400,6 +459,7 @@ Global
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|Any CPU.Build.0 = Release|Any CPU
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|Mixed Platforms.Build.0 = Release|x86
+		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|Win32.ActiveCfg = Release|x86
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|x64.ActiveCfg = Release|x64
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|x64.Build.0 = Release|x64
 		{9253A314-1821-42BF-B02F-2BF986B1765D}.Release|x86.ActiveCfg = Release|x86
@@ -408,6 +468,7 @@ Global
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|Win32.ActiveCfg = Debug|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|x64.ActiveCfg = Debug|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|x64.Build.0 = Debug|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Debug|x86.ActiveCfg = Debug|x86
@@ -416,6 +477,7 @@ Global
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|Any CPU.Build.0 = Release|Any CPU
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|Mixed Platforms.Build.0 = Release|x64
+		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|Win32.ActiveCfg = Release|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|x64.ActiveCfg = Release|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|x64.Build.0 = Release|x64
 		{1DD41038-D885-46C5-8DDE-E0B82F066584}.Release|x86.ActiveCfg = Release|x86
@@ -424,6 +486,7 @@ Global
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|Win32.ActiveCfg = Debug|x86
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|x64.ActiveCfg = Debug|x64
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|x64.Build.0 = Debug|x64
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Debug|x86.ActiveCfg = Debug|x86
@@ -432,6 +495,7 @@ Global
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|Any CPU.Build.0 = Release|Any CPU
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|Mixed Platforms.Build.0 = Release|x86
+		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|Win32.ActiveCfg = Release|x86
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|x64.ActiveCfg = Release|x64
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|x64.Build.0 = Release|x64
 		{5802C7E9-157E-4124-946D-70B5AE48A5A1}.Release|x86.ActiveCfg = Release|x86
@@ -440,6 +504,7 @@ Global
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|x64.ActiveCfg = Debug|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|x64.Build.0 = Debug|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Debug|x86.ActiveCfg = Debug|Any CPU
@@ -448,6 +513,7 @@ Global
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|Any CPU.Build.0 = Release|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|Win32.ActiveCfg = Release|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|x64.ActiveCfg = Release|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|x64.Build.0 = Release|Any CPU
 		{74C2036B-2C9B-4FC8-B7BD-AE81A8DCE533}.Release|x86.ActiveCfg = Release|Any CPU
@@ -456,6 +522,7 @@ Global
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|Mixed Platforms.Build.0 = Debug|x86
+		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|Win32.ActiveCfg = Debug|x86
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|x64.ActiveCfg = Debug|x64
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|x64.Build.0 = Debug|x64
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Debug|x86.ActiveCfg = Debug|x86
@@ -464,6 +531,7 @@ Global
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|Mixed Platforms.ActiveCfg = Release|x86
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|Mixed Platforms.Build.0 = Release|x86
+		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|Win32.ActiveCfg = Release|x86
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|x64.ActiveCfg = Release|x64
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|x64.Build.0 = Release|x64
 		{39B43BBB-BAFC-4D85-9BEA-3BCB7EFED89C}.Release|x86.ActiveCfg = Release|x86
@@ -472,6 +540,7 @@ Global
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|Win32.ActiveCfg = Debug|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|x64.ActiveCfg = Debug|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|x64.Build.0 = Debug|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Debug|x86.ActiveCfg = Debug|Any CPU
@@ -480,6 +549,7 @@ Global
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|Any CPU.Build.0 = Release|Any CPU
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|Mixed Platforms.Build.0 = Release|x64
+		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|Win32.ActiveCfg = Release|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|x64.ActiveCfg = Release|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|x64.Build.0 = Release|x64
 		{5ADCFD6D-BFEA-4B10-BB45-9083BBB56AF4}.Release|x86.ActiveCfg = Release|Any CPU
@@ -487,6 +557,8 @@ Global
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|Any CPU.ActiveCfg = Debug|Win32
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|Win32.Build.0 = Debug|Win32
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|x64.ActiveCfg = Debug|x64
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|x64.Build.0 = Debug|x64
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Debug|x86.ActiveCfg = Debug|Win32
@@ -494,6 +566,8 @@ Global
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|Any CPU.ActiveCfg = Release|Win32
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|Mixed Platforms.Build.0 = Release|x64
+		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|Win32.ActiveCfg = Release|Win32
+		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|Win32.Build.0 = Release|Win32
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|x64.ActiveCfg = Release|x64
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|x64.Build.0 = Release|x64
 		{B3DF599C-1C8F-451D-91E4-DD766210DA1F}.Release|x86.ActiveCfg = Release|Win32
@@ -501,6 +575,8 @@ Global
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|Any CPU.ActiveCfg = Debug|Win32
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|Win32.Build.0 = Debug|Win32
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|x64.ActiveCfg = Debug|x64
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|x64.Build.0 = Debug|x64
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Debug|x86.ActiveCfg = Debug|Win32
@@ -508,6 +584,8 @@ Global
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|Any CPU.ActiveCfg = Release|Win32
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|Mixed Platforms.Build.0 = Release|x64
+		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|Win32.ActiveCfg = Release|Win32
+		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|Win32.Build.0 = Release|Win32
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|x64.ActiveCfg = Release|x64
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|x64.Build.0 = Release|x64
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B}.Release|x86.ActiveCfg = Release|Win32
@@ -516,6 +594,7 @@ Global
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|Mixed Platforms.Build.0 = Debug|x64
+		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|Win32.ActiveCfg = Debug|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|x64.ActiveCfg = Debug|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|x64.Build.0 = Debug|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Debug|x86.ActiveCfg = Debug|x86
@@ -524,6 +603,7 @@ Global
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|Any CPU.Build.0 = Release|Any CPU
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|Mixed Platforms.ActiveCfg = Release|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|Mixed Platforms.Build.0 = Release|x64
+		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|Win32.ActiveCfg = Release|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|x64.ActiveCfg = Release|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|x64.Build.0 = Release|x64
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926}.Release|x86.ActiveCfg = Release|x86
@@ -532,6 +612,7 @@ Global
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|x64.ActiveCfg = Debug|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|x64.Build.0 = Debug|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Debug|x86.ActiveCfg = Debug|Any CPU
@@ -540,6 +621,7 @@ Global
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|Any CPU.Build.0 = Release|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|Win32.ActiveCfg = Release|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|x64.ActiveCfg = Release|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|x64.Build.0 = Release|Any CPU
 		{4CC18776-125E-4318-9D24-D60110AD9697}.Release|x86.ActiveCfg = Release|Any CPU
@@ -548,6 +630,7 @@ Global
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|Win32.ActiveCfg = Debug|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|x64.ActiveCfg = Debug|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|x64.Build.0 = Debug|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Debug|x86.ActiveCfg = Debug|Any CPU
@@ -556,10 +639,58 @@ Global
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|Any CPU.Build.0 = Release|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|Win32.ActiveCfg = Release|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|x64.ActiveCfg = Release|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|x64.Build.0 = Release|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|x86.ActiveCfg = Release|Any CPU
 		{CA4D64E6-6544-4A29-8BA5-7DB08D50D072}.Release|x86.Build.0 = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|Win32.ActiveCfg = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Debug|x86.Build.0 = Debug|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|Win32.ActiveCfg = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|x64.ActiveCfg = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|x64.Build.0 = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|x86.ActiveCfg = Release|Any CPU
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6}.Release|x86.Build.0 = Release|Any CPU
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|Win32.Build.0 = Debug|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|x64.ActiveCfg = Debug|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Debug|x86.ActiveCfg = Debug|x64
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|Any CPU.ActiveCfg = Release|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|Win32.ActiveCfg = Release|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|Win32.Build.0 = Release|Win32
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|x64.ActiveCfg = Release|x64
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|x64.Build.0 = Release|x64
+		{F53335A2-C013-4354-98CC-83E612EAEB60}.Release|x86.ActiveCfg = Release|Win32
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|Win32.ActiveCfg = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|Win32.ActiveCfg = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|x64.ActiveCfg = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|x64.Build.0 = Release|Any CPU
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -571,6 +702,7 @@ Global
 		{F2EC7193-D5E5-4252-9803-5CEB407E910F} = {85F88959-C9E9-4989-ACB1-67BA9D1BEFE7}
 		{8A0426FA-0BC2-4C49-A6E5-1F9A68156F19} = {85F88959-C9E9-4989-ACB1-67BA9D1BEFE7}
 		{1D1E99BC-6D22-41C0-BD94-FF4DD5EC725B} = {85F88959-C9E9-4989-ACB1-67BA9D1BEFE7}
+		{082D6B9E-326E-4D15-9798-EDAE9EDE70A6} = {85F88959-C9E9-4989-ACB1-67BA9D1BEFE7}
 		{0B9C97D4-61B8-4294-A1DF-BA90752A1779} = {8B179853-B7D6-479C-B8B2-6CBCE835D040}
 		{4CEFBC84-C215-11DB-8314-0800200C9A66} = {8B179853-B7D6-479C-B8B2-6CBCE835D040}
 		{5CCCB9CF-0384-458F-BA08-72B73866840F} = {8B179853-B7D6-479C-B8B2-6CBCE835D040}
@@ -579,6 +711,7 @@ Global
 		{9253A314-1821-42BF-B02F-2BF986B1765D} = {4B59E09C-A51F-4B80-91BE-987904DCEF7D}
 		{A5A8D8FA-9E32-4010-8AAF-AE580C5AF728} = {4B59E09C-A51F-4B80-91BE-987904DCEF7D}
 		{115CC5B0-0385-41CD-8A23-6A7EA4C51926} = {4B59E09C-A51F-4B80-91BE-987904DCEF7D}
+		{2379BAAF-A406-4477-BF53-2D6A326C24C8} = {4B59E09C-A51F-4B80-91BE-987904DCEF7D}
 		{B75FA7AD-968E-4990-B342-1B4B17C850DF} = {B36BE134-D85A-437E-AB61-2DA1CCDE06C1}
 		{F2DFEB00-BB35-4665-85EA-CB8C7729A6B7} = {B36BE134-D85A-437E-AB61-2DA1CCDE06C1}
 		{A05B6AA6-0EC3-495D-BCC4-ECE1210071A8} = {B36BE134-D85A-437E-AB61-2DA1CCDE06C1}

CUETools/frmBatch.cs

@@ -17,7 +17,6 @@ namespace JDP
 		public frmBatch()
 		{
 			InitializeComponent();
-			_config = new CUEConfig();
 			_batchPaths = new List<string>();
 		}
 
@@ -38,7 +37,6 @@ namespace JDP
 			set { _profileName = value; }
 		}
 
-		CUEConfig _config;
 		CUEToolsProfile _profile = null;
 		string _profileName = "verify";
 		Thread _workThread;
@@ -104,7 +102,7 @@ namespace JDP
 		private void WriteAudioFilesThread(object o)
 		{
 			CUESheet cueSheet = (CUESheet)o;
-			CUEToolsScript script = _profile._script == null || !_config.scripts.ContainsKey(_profile._script) ? null : _config.scripts[_profile._script];
+			CUEToolsScript script = _profile._script == null || !_profile._config.scripts.ContainsKey(_profile._script) ? null : _profile._config.scripts[_profile._script];
 
 			try
 			{
@@ -137,7 +135,7 @@ namespace JDP
 				if (useAR)
 					cueSheet.UseAccurateRip();
 
-				pathOut = CUESheet.GenerateUniqueOutputPath(_config, 
+				pathOut = CUESheet.GenerateUniqueOutputPath(_profile._config, 
 					_profile._outputTemplate, 
 					_profile._CUEStyle == CUEStyle.SingleFileWithCUE ? "." + _profile._outputAudioFormat : ".cue", 
 					_profile._action, 
@@ -227,7 +225,7 @@ namespace JDP
 		{
 			try
 			{
-				CUESheet cueSheet = new CUESheet(_config);
+				CUESheet cueSheet = new CUESheet(_profile._config);
 				cueSheet.PasswordRequired += new ArchivePasswordRequiredHandler(PasswordRequired);
 				cueSheet.CUEToolsProgress += new CUEToolsProgressHandler(SetStatus);
 
@@ -250,12 +248,13 @@ namespace JDP
 		private void frmBatch_Load(object sender, EventArgs e)
 		{
 			textBox1.Hide();
-			SettingsReader sr = new SettingsReader("CUE Tools", "settings.txt", Application.ExecutablePath);
+			//SettingsReader sr = new SettingsReader("CUE Tools", "settings.txt", Application.ExecutablePath);
-			_config.Load(sr);
+			//_profile.Load(sr);
-			_reducePriority = sr.LoadBoolean("ReducePriority") ?? true;
+			//_reducePriority = sr.LoadBoolean("ReducePriority") ?? true;
+			_reducePriority = true;
 
 			_profile = new CUEToolsProfile(_profileName);
-			sr = new SettingsReader("CUE Tools", string.Format("profile-{0}.txt", _profileName), Application.ExecutablePath);
+			SettingsReader sr = new SettingsReader("CUE Tools", string.Format("profile-{0}.txt", _profileName), Application.ExecutablePath);
 			_profile.Load(sr);
 			
 			if (_reducePriority)

CUETools/frmCUETools.Designer.cs

@@ -28,8 +28,8 @@ namespace JDP {
 			this.toolStripContainer1 = new System.Windows.Forms.ToolStripContainer();
 			this.statusStrip1 = new System.Windows.Forms.StatusStrip();
 			this.toolStripStatusLabel1 = new System.Windows.Forms.ToolStripStatusLabel();
-			this.toolStripStatusLabelProcessed = new System.Windows.Forms.ToolStripStatusLabel();
 			this.toolStripStatusLabelAR = new System.Windows.Forms.ToolStripStatusLabel();
+			this.toolStripStatusLabelProcessed = new System.Windows.Forms.ToolStripStatusLabel();
 			this.toolStripProgressBar1 = new System.Windows.Forms.ToolStripProgressBar();
 			this.toolStripProgressBar2 = new System.Windows.Forms.ToolStripProgressBar();
 			this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
@@ -177,8 +177,8 @@ namespace JDP {
 			resources.ApplyResources(this.statusStrip1, "statusStrip1");
 			this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
             this.toolStripStatusLabel1,
-            this.toolStripStatusLabelProcessed,
             this.toolStripStatusLabelAR,
+            this.toolStripStatusLabelProcessed,
             this.toolStripProgressBar1,
             this.toolStripProgressBar2});
 			this.statusStrip1.Name = "statusStrip1";
@@ -190,11 +190,6 @@ namespace JDP {
 			resources.ApplyResources(this.toolStripStatusLabel1, "toolStripStatusLabel1");
 			this.toolStripStatusLabel1.Spring = true;
 			// 
-			// toolStripStatusLabelProcessed
-			// 
-			this.toolStripStatusLabelProcessed.Name = "toolStripStatusLabelProcessed";
-			resources.ApplyResources(this.toolStripStatusLabelProcessed, "toolStripStatusLabelProcessed");
-			// 
 			// toolStripStatusLabelAR
 			// 
 			resources.ApplyResources(this.toolStripStatusLabelAR, "toolStripStatusLabelAR");
@@ -202,6 +197,15 @@ namespace JDP {
 			this.toolStripStatusLabelAR.Name = "toolStripStatusLabelAR";
 			this.toolStripStatusLabelAR.Padding = new System.Windows.Forms.Padding(0, 0, 5, 0);
 			// 
+			// toolStripStatusLabelProcessed
+			// 
+			this.toolStripStatusLabelProcessed.BorderSides = ((System.Windows.Forms.ToolStripStatusLabelBorderSides)((((System.Windows.Forms.ToolStripStatusLabelBorderSides.Left | System.Windows.Forms.ToolStripStatusLabelBorderSides.Top)
+						| System.Windows.Forms.ToolStripStatusLabelBorderSides.Right)
+						| System.Windows.Forms.ToolStripStatusLabelBorderSides.Bottom)));
+			this.toolStripStatusLabelProcessed.BorderStyle = System.Windows.Forms.Border3DStyle.SunkenOuter;
+			this.toolStripStatusLabelProcessed.Name = "toolStripStatusLabelProcessed";
+			resources.ApplyResources(this.toolStripStatusLabelProcessed, "toolStripStatusLabelProcessed");
+			// 
 			// toolStripProgressBar1
 			// 
 			this.toolStripProgressBar1.AutoToolTip = true;

CUETools/frmCUETools.cs

@@ -321,6 +321,7 @@ namespace JDP {
 		bool _outputPathUseTemplate = true;
 		bool _reportState = true;
 		CorrectorModeEnum _correctorMode;
+		DateTime _startedAt;
 		DateTime lastMOTD;
 		Image motdImage = null;
 		string profilePath;
@@ -917,6 +918,30 @@ namespace JDP {
 		public void SetStatus(object sender, CUEToolsProgressEventArgs e)
 		{
 			this.BeginInvoke((MethodInvoker)delegate() {
+				if (e.percentDisk == 0)
+				{
+					_startedAt = DateTime.Now;
+					toolStripStatusLabelProcessed.Visible = false;
+					toolStripProgressBar1.ToolTipText = "";
+					toolStripProgressBar2.ToolTipText = "";
+				}
+				else if (e.percentDisk > 0.02)
+				{
+					TimeSpan span = DateTime.Now - _startedAt;
+					TimeSpan eta = new TimeSpan((long)(span.Ticks / e.percentDisk));
+					if (span.TotalSeconds > 0 && e.offset > 0)
+					{
+						double speed = e.offset / span.TotalSeconds / 44100;
+						toolStripProgressBar1.ToolTipText = String.Format("{0:00.00}x", speed);
+					} else
+						toolStripProgressBar1.ToolTipText = "";
+					toolStripProgressBar2.ToolTipText = String.Format("{0}:{1:00}/{2}:{3:00}", (int)span.TotalMinutes, span.Seconds, (int)eta.TotalMinutes, eta.Seconds);
+					if (FileBrowserState != FileBrowserStateEnum.Hidden)
+					{
+						toolStripStatusLabelProcessed.Text = String.Format("{0}@{1}", toolStripProgressBar2.ToolTipText, toolStripProgressBar1.ToolTipText);
+						toolStripStatusLabelProcessed.Visible = true;
+					}
+				}
 				toolStripStatusLabel1.Text = e.status;
 				toolStripProgressBar1.Value = Math.Max(0,Math.Min(100,(int)(e.percentTrck*100)));
 				toolStripProgressBar2.Value = Math.Max(0,Math.Min(100,(int)(e.percentDisk*100)));
@@ -968,6 +993,7 @@ namespace JDP {
 			{
 				UpdateActions();
 				pictureBoxMotd.Image = motdImage;
+				toolStripStatusLabelProcessed.Visible = false;
 			}
 
 			//rbGapsLeftOut.Visible = 

HDCDDotNet/HDCDDotNet.cs

@@ -234,7 +234,7 @@ namespace HDCDDotNet
 				for (int i = 0; i < loopCount; i++)
 					*(pOutSamples++) = *(pInSamples++);
 			}
-			AudioDest.Write(_outSampleBuffer, (uint)samples);
+			AudioDest.Write(_outSampleBuffer, 0, samples);
 			return true;
 		}
 

LossyWAVSharp/Program.cs

@@ -105,7 +105,7 @@ namespace LossyWAVSharp
 				{
 					uint samplesRead = audioSource.Read(buff, Math.Min((uint)buff.GetLength(0), (uint)audioSource.Remaining));
 					if (samplesRead == 0) break;
-					lossyWAV.Write(buff, samplesRead);
+					lossyWAV.Write(buff, 0, (int)samplesRead);
 					TimeSpan elapsed = DateTime.Now - start;
 					if ((elapsed - lastPrint).TotalMilliseconds > 60)
 					{

flac/include/share/replaygain_analysis.h

@@ -1,59 +1,118 @@
 /*
+
  *  ReplayGainAnalysis - analyzes input samples and give the recommended dB change
+
  *  Copyright (C) 2001 David Robinson and Glen Sawyer
+
  *
+
  *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
  *
+
  *  concept and filter values by David Robinson (David@Robinson.org)
+
  *    -- blame him if you think the idea is flawed
+
  *  coding by Glen Sawyer (glensawyer@hotmail.com) 442 N 700 E, Provo, UT 84606 USA
+
  *    -- blame him if you think this runs too slowly, or the coding is otherwise flawed
+
  *  minor cosmetic tweaks to integrate with FLAC by Josh Coalson
+
  *
+
  *  For an explanation of the concepts and the basic algorithms involved, go to:
+
  *    http://www.replaygain.org/
+
  */
 
+
+
 #ifndef GAIN_ANALYSIS_H
+
 #define GAIN_ANALYSIS_H
 
+
+
 #include <stddef.h>
 
+
+
 #define GAIN_NOT_ENOUGH_SAMPLES  -24601
+
 #define GAIN_ANALYSIS_ERROR           0
+
 #define GAIN_ANALYSIS_OK              1
 
+
+
 #define INIT_GAIN_ANALYSIS_ERROR      0
+
 #define INIT_GAIN_ANALYSIS_OK         1
 
+
+
 #ifdef __cplusplus
+
 extern "C" {
+
 #endif
 
+
+
 typedef float   Float_t;         /* Type used for filtering */
 
+
+
 extern Float_t ReplayGainReferenceLoudness; /* in dB SPL, currently == 89.0 */
 
+
+
 int     InitGainAnalysis ( long samplefreq );
+
 int     AnalyzeSamples   ( const Float_t* left_samples, const Float_t* right_samples, size_t num_samples, int num_channels );
+
 int		ResetSampleFrequency ( long samplefreq );
+
 Float_t GetTitleGain     ( void );
+
 Float_t GetAlbumGain     ( void );
 
+
+
 #ifdef __cplusplus
+
 }
+
 #endif
 
+
+
 #endif /* GAIN_ANALYSIS_H */
+

flac/src/flac/flac.vcproj

@@ -46,7 +46,7 @@
 				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;FLAC__HAS_OGG;FLAC__NO_DLL;DEBUG"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
@@ -63,6 +63,85 @@
 			<Tool
 				Name="VCPreLinkEventTool"
 			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				IgnoreDefaultLibraryNames="uuid.lib"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=".;..\..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;FLAC__HAS_OGG;FLAC__NO_DLL;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalDependencies="..\..\obj\release\lib\ogg_static.lib"
@@ -70,7 +149,7 @@
 				IgnoreDefaultLibraryNames="uuid.lib"
 				GenerateDebugInformation="true"
 				SubSystem="1"
-				TargetMachine="1"
+				TargetMachine="17"
 			/>
 			<Tool
 				Name="VCALinkTool"
@@ -181,86 +260,6 @@
 				Name="VCPostBuildEventTool"
 			/>
 		</Configuration>
-		<Configuration
-			Name="Debug|x64"
-			OutputDirectory="$(PlatformName)\$(ConfigurationName)"
-			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
-			ConfigurationType="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-				TargetEnvironment="3"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories=".;..\..\include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;FLAC__HAS_OGG;FLAC__NO_DLL;DEBUG"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-				CompileAs="0"
-				DisableSpecificWarnings="4267;4996"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="..\..\obj\release\lib\ogg_static.lib"
-				LinkIncremental="2"
-				IgnoreDefaultLibraryNames="uuid.lib"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="17"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCWebDeploymentTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
 		<Configuration
 			Name="Release|x64"
 			OutputDirectory="$(PlatformName)\$(ConfigurationName)"

flac/src/share/getopt/getopt_static.vcproj

@@ -46,7 +46,7 @@
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
@@ -83,6 +83,72 @@
 				Name="VCPostBuildEventTool"
 			/>
 		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="4"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\..\..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\..\..\obj\debug\lib\$(ProjectName).lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
 		<Configuration
 			Name="Release|Win32"
 			OutputDirectory="..\..\..\obj\release\lib"
@@ -150,72 +216,6 @@
 				Name="VCPostBuildEventTool"
 			/>
 		</Configuration>
-		<Configuration
-			Name="Debug|x64"
-			OutputDirectory="$(PlatformName)\$(ConfigurationName)"
-			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
-			ConfigurationType="4"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-				TargetEnvironment="3"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories=".\include;..\..\..\include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-				CompileAs="0"
-				DisableSpecificWarnings="4267;4996"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="..\..\..\obj\debug\lib\$(ProjectName).lib"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
 		<Configuration
 			Name="Release|x64"
 			OutputDirectory="$(PlatformName)\$(ConfigurationName)"

flac/src/share/grabbag/grabbag_static.vcproj

@@ -46,7 +46,7 @@
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
+				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
@@ -83,6 +83,72 @@
 				Name="VCPostBuildEventTool"
 			/>
 		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="4"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\..\..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\..\..\obj\debug\lib\$(ProjectName).lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
 		<Configuration
 			Name="Release|Win32"
 			OutputDirectory="..\..\..\obj\release\lib"
@@ -150,72 +216,6 @@
 				Name="VCPostBuildEventTool"
 			/>
 		</Configuration>
-		<Configuration
-			Name="Debug|x64"
-			OutputDirectory="$(PlatformName)\$(ConfigurationName)"
-			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
-			ConfigurationType="4"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-				TargetEnvironment="3"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories=".\include;..\..\..\include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-				CompileAs="0"
-				DisableSpecificWarnings="4267;4996"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="..\..\..\obj\debug\lib\$(ProjectName).lib"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
 		<Configuration
 			Name="Release|x64"
 			OutputDirectory="$(PlatformName)\$(ConfigurationName)"