winamp/Src/Plugins/Input/in_flac/DecodeThread.cpp

/*
** Copyright (C) 2007-2011 Nullsoft, Inc.
**
** This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held 
** liable for any damages arising from the use of this software. 
**
** Permission is granted to anyone to use this software for any purpose, including commercial applications, and to 
** alter it and redistribute it freely, subject to the following restrictions:
**
**   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. 
**      If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
**
**   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
**
**   3. This notice may not be removed or altered from any source distribution.
**
** Author: Ben Allison [email protected]
** Created: March 1, 2007
**
*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include "main.h"
#include <windows.h>
#include <math.h>
#include <assert.h>
#include <locale.h>
#include <FLAC/all.h>
#include "StreamFileWin32.h"
#include "../Winamp/wa_ipc.h"
#include "QuickBuf.h"
#include "api__in_flv.h"
#include "../nu/AudioOutput.h"
#include "../Agave/Language/api_language.h"
#include "FLACFileCallbacks.h"
#include "nx/nxpath.h"

int m_force_seek = -1; // el hacko grande
const DWORD PAUSE_TIMEOUT = 100; // number of milliseconds to sleep for when paused

static bool paused = false;

// could probably move this inside client_data
int realbits;
int bps;
int samplerate;
int channels;
volatile int currentSongLength=-1000;
int averageBitrate;

// if input plugins weren't single-instance only, we could put this in thread-local-storage
static FLAC__StreamDecoder *decoder = 0;
static uint64_t fileSize = 0;
static FLAC__uint64 decodePosition = 0;

double gain = 1.0;
static double buffer_scale=1.0;

class FLACWait
{
public:
	int WaitOrAbort(int time_in_ms)
	{
			if (WaitForSingleObject(killswitch, time_in_ms) == WAIT_OBJECT_0)
				return 1;
				return 0;
	}
};


volatile int bufferCount=0;
static void Buffering(int bufStatus, const wchar_t *displayString)
{
	if (bufStatus < 0 || bufStatus > 100)
		return;

	char tempdata[75*2] = {0, };

	int csa = plugin.SAGetMode();
	if (csa & 1)
	{
		for (int x = 0; x < bufStatus*75 / 100; x ++)
			tempdata[x] = x * 16 / 75;
	}
	else if (csa&2)
	{
		int offs = (csa & 1) ? 75 : 0;
		int x = 0;
		while (x < bufStatus*75 / 100)
		{
			tempdata[offs + x++] = -6 + x * 14 / 75;
		}
		while (x < 75)
		{
			tempdata[offs + x++] = 0;
		}
	}
	else if (csa == 4)
	{
		tempdata[0] = tempdata[1] = (bufStatus * 127 / 100);
	}
	if (csa)	plugin.SAAdd(tempdata, ++bufferCount, (csa == 3) ? 0x80000003 : csa);	

	/*
	TODO
	wchar_t temp[64] = {0};
	StringCchPrintf(temp, 64, L"%s: %d%%",displayString, bufStatus);
	SetStatus(temp);
	*/
	//SetVideoStatusText(temp); // TODO: find a way to set the old status back
	//	videoOutput->notifyBufferState(static_cast<int>(bufStatus*2.55f));
}

static nu::AudioOutput<FLACWait> audio_output(&plugin);

#pragma region Truncaters
inline static void clip(double &x, double a, double b)
{
	double x1 = fabs(x - a);
	double x2 = fabs(x - b);
	x = x1 + (a + b);
	x -= x2;
	x *= 0.5;
}

static void InterleaveAndTruncate32(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize, double gain)
{
	// TODO: this can be sped up significantly
	FLAC__int32 *output = (FLAC__int32 *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			double appliedGain = gain * (double)buffer[c][b];
			// TODO: add dither
			clip(appliedGain, -2147483648., 2147483647.);
			*output = (FLAC__int32)appliedGain;
			output++;
		}
	}
}

static void InterleaveAndTruncate24(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize, double gain)
{
	char *output = (char *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			double appliedGain = gain * (double)buffer[c][b];
			// TODO: add dither
			clip(appliedGain, -8388608., 8388607.);
			FLAC__int32 sample = (FLAC__int32)appliedGain;

			// little endian specific code
			output[0] = (unsigned char)(sample);
			output[1] = (unsigned char)(sample >> 8);
			output[2] = (unsigned char)(sample >> 16);
			output += 3;
		}
	}
}

static void InterleaveAndTruncate16(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize, double gain)
{
	short *output = (short *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			double appliedGain = gain * (double)buffer[c][b];
			// TODO: add dither
			clip(appliedGain, -32768., 32767.);
			FLAC__int32 sample = (FLAC__int32)appliedGain;

			*output = (short) sample ;
			output ++;
		}
	}
}

static void InterleaveAndTruncate8(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize, double gain)
{
	unsigned char *output = (unsigned char *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			double appliedGain = gain * (double)buffer[c][b];
			// TODO: add dither
			clip(appliedGain, -128., 127.);
			FLAC__int32 sample = (FLAC__int32)appliedGain;

			*output = (unsigned char)(sample + 128); 
			output++;
		}
	}
}

/* --- Versions without gain adjustment --- */

static void InterleaveAndTruncate32(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize)
{
	FLAC__int32 *output = (FLAC__int32 *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			*output = buffer[c][b];
			output++;
		}
	}
}

static void InterleaveAndTruncate24(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize)
{
	char *output = (char *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			FLAC__int32 sample = buffer[c][b];

			// little endian specific code
			output[0] = (unsigned char)(sample);
			output[1] = (unsigned char)(sample >> 8);
			output[2] = (unsigned char)(sample >> 16);
			output += 3;
		}
	}
}

static void InterleaveAndTruncate16(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize)
{
	short *output = (short *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			*output = (short) buffer[c][b];
			output ++;
		}
	}
}

static void InterleaveAndTruncate8(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize)
{
	unsigned char *output = (unsigned char *)_output;

	for (int b = 0;b < blocksize;b++)
	{
		for (int c = 0;c < channels;c++)
		{
			*output = (unsigned char)(buffer[c][b] + 128); 
			output++;
		}
	}
}

void InterleaveAndTruncate(const FLAC__int32 *const buffer[], void *_output, int bps, int channels, int blocksize, double gain)
{
	if (gain == 1.0) // if it's EXACTLY 1.0, i.e. from a hardcoded value. not meant to be a "RG happens to be 1.0" check
	{
		switch(bps)
		{
		case 8:
			InterleaveAndTruncate8(buffer, _output, bps, channels, blocksize);
			break;
		case 16:
			InterleaveAndTruncate16(buffer, _output, bps, channels, blocksize);
			break;
		case 24:
			InterleaveAndTruncate24(buffer, _output, bps, channels, blocksize);
			break;
		case 32:
			InterleaveAndTruncate32(buffer, _output, bps, channels, blocksize);
			break;
		}
	}
	else // apply replay gain
	{
		switch(bps)
		{
		case 8:
			InterleaveAndTruncate8(buffer, _output, bps, channels, blocksize, gain);
			break;
		case 16:
			InterleaveAndTruncate16(buffer, _output, bps, channels, blocksize, gain);
			break;
		case 24:
			InterleaveAndTruncate24(buffer, _output, bps, channels, blocksize, gain);
			break;
		case 32:
			InterleaveAndTruncate32(buffer, _output, bps, channels, blocksize, gain);
			break;
		}
	}
}
#pragma endregion

QuickBuf output;
FLAC__uint64 lastoutputtime;
static FLAC__StreamDecoderWriteStatus OnAudio(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
{
	// TODO: if frame bps/samplerate/channels doesn't equal our own, we'll probably have to close & re-open the audio output
	// mux buffer into interleaved samples
	FLAC__uint64 newPosition;
	FLAC__stream_decoder_get_decode_position(decoder, &newPosition);
	FLAC__uint64 delta = newPosition - decodePosition;
	decodePosition = newPosition;
	if (!config_average_bitrate)
		plugin.SetInfo((int)(delta / (125.*frame->header.blocksize / samplerate)), -1, -1, -1);
	else if (fixBitrate)
	{
		fixBitrate = false;
		plugin.SetInfo(averageBitrate, -1, -1, -1);
	}

	if (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER)
		lastoutputtime = 1000ULL*frame->header.number.sample_number / (FLAC__uint64)samplerate;
	else
		lastoutputtime = 0;

	int byteLength = (bps / 8) * channels * frame->header.blocksize;
	output.Reserve(byteLength*2);
	InterleaveAndTruncate(buffer, output, bps, channels, frame->header.blocksize, gain);

		audio_output.Write(output, byteLength);
	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}

static int GetBits(int incoming)
{
	int bits = AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"bits", 16);
	if (bits > 16 && AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain", false))
		return bits;

	return min(bits, incoming);
}

static double GetGain(const FLAC__StreamMetadata *metadata)
{
	if (AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain", false))
	{
		if (metadata)
		{
			int gainPos = -1, peakPos = -1;
			switch (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"replaygain_source", 0))
			{
			case 0:  // track
				gainPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_TRACK_GAIN");
				if (gainPos < 0	 && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
					gainPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_ALBUM_GAIN");

				peakPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_TRACK_PEAK");
				if (peakPos < 0	 && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
					peakPos  = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_ALBUM_PEAK");

				break;
			case 1:
				gainPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_ALBUM_GAIN");
				if (gainPos < 0	 && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
					gainPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_TRACK_GAIN");

				peakPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_ALBUM_PEAK");
				if (peakPos < 0 && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
					peakPos = FLAC__metadata_object_vorbiscomment_find_entry_from(metadata, 0, "REPLAYGAIN_TRACK_PEAK");
				break;
			}

			double dB = 0, peak = 1.0;
			_locale_t C_locale = WASABI_API_LNG->Get_C_NumericLocale();
			if (gainPos >= 0)
			{
				const char *entry = (const char *)metadata->data.vorbis_comment.comments[gainPos].entry;
				const char *value = strchr(entry, '='); // find the first equal
				if (value++)
				{
					if (value[0] == '+')
						dB = _atof_l(&value[1], C_locale);
					else
						dB = _atof_l(value, C_locale);
				}
			}
			else
			{
				dB = AGAVE_API_CONFIG->GetFloat(playbackConfigGroupGUID, L"non_replaygain", -6.0);
				return pow(10.0, dB / 20.0);
			}

			if (peakPos >= 0)
			{
				const char *entry = (const char *)metadata->data.vorbis_comment.comments[peakPos].entry;
				const char *value = strchr(entry, '='); // find the first equal
				if (value++)
				{
					peak = _atof_l(value, C_locale);
				}
			}

			switch (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"replaygain_mode", 1))
			{
			case 0:  // apply gain
				return pow(10.0, dB / 20.0);
				break;
			case 1:  // apply gain, but don't clip
				return min(pow(10.0, dB / 20.0), 1.0 / peak);
				break;
			case 2:  // normalize
				return 1.0 / peak;
				break;
			case 3:  // prevent clipping
				if (peak > 1.0)
					return 1.0 / peak;
				else
					return 1.0;
			}
		}
		else
		{
			double dB = AGAVE_API_CONFIG->GetFloat(playbackConfigGroupGUID, L"non_replaygain", -6.0);
			return pow(10.0, dB / 20.0);
		}
	}

	return 1.0;
}

static void OnMetadata(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
	switch (metadata->type)
	{
	case FLAC__METADATA_TYPE_STREAMINFO:
		{
			realbits = metadata->data.stream_info.bits_per_sample;
			channels = metadata->data.stream_info.channels;
			samplerate = metadata->data.stream_info.sample_rate;
			bps = GetBits(metadata->data.stream_info.bits_per_sample);
			gain = GetGain(0) * pow(2., (double)(bps - realbits));
			if (metadata->data.stream_info.total_samples)
			{
				currentSongLength = (int)((metadata->data.stream_info.total_samples*1000ULL)/(uint64_t)samplerate);
				averageBitrate = (int)(fileSize / (125 * metadata->data.stream_info.total_samples / (__int64)samplerate));
			}
			else
			{
				currentSongLength=-1000;
				averageBitrate=0;
			}
		}
		break;
	case FLAC__METADATA_TYPE_VORBIS_COMMENT:
		gain = GetGain(metadata) * pow(2., (double)(bps - realbits));
		break;
	}
}

static void OnError(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
{
	//client_data = client_data; // dummy line so i can set a breakpoint
}

void CALLBACK APCPause(ULONG_PTR data)
{
	paused = !!data;
	plugin.outMod->Pause(!!paused);
}

void CALLBACK APCSeek(ULONG_PTR data)
{
	// TODO: break out of end-of-file handling if necessary
	buffer_scale=1.0;
	int time_in_ms = (int)data;
	lastoutputtime=time_in_ms; // cheating a bit here :)
	audio_output.Flush(time_in_ms);
	__int64 frames = Int32x32To64(time_in_ms, samplerate) / 1000;
	FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(decoder);
	plugin.outMod->Pause(0);
	FLAC__stream_decoder_seek_absolute(decoder, frames);
	plugin.outMod->Pause(paused);
	if (FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_SEEK_ERROR)
	{
		FLAC__stream_decoder_flush(decoder);
	}
}

static const double prebuffer_seconds = 0.5;
static bool DoBuffering(nx_file_t file)
{
	// TODO: check for disconnect, etc.

		// anything less than half-a-second and we'll rebuffer.  but when we rebuffer, we'll get 2 seconds worth of audio
	// also, every time we're forced to re-buffer, we'll double the buffer amount

	uint64_t required;
	if (averageBitrate > 0)
	{
		required = (uint64_t)((double)averageBitrate * 1000.0 * buffer_scale  * prebuffer_seconds  / 8.0);  
	}
	else /* no bitrate specified, let's assume 1000kbps */
	{
		required = (uint64_t)(1000.0 * 1000.0 * buffer_scale * prebuffer_seconds / 8.0);
	}

	uint64_t available;	
	if (NXFileProgressiveDownloaderAvailable(file, required, &available) == NErr_True)
		return true;
																													
	Buffering(0, 0);
	bufferCount=lastoutputtime;
	required *= 4;
	buffer_scale *= 2.0;

	while (NXFileProgressiveDownloaderAvailable(file, required, &available) == NErr_False)
	{
		int percent = (int)((double)available * 100.0 / (double)required);
		if (percent <= 0)
			percent=1;
		if (percent > 99)
			percent=99;
		
		Buffering(percent, 0);
		if (WaitForSingleObject(killswitch, 10) == WAIT_OBJECT_0)
		{
			return false;
		}
	}
		Buffering(100, 0);
		bufferCount=0;
		return true;	
}

extern HANDLE threadStarted;
DWORD CALLBACK FLACThread(LPVOID param)
{
	buffer_scale=1.0;
	bool streaming=false;
	nx_file_t file;
	FLACClientData state;
	audio_output.Init(plugin.outMod);
	paused=false;
	SetEvent(threadStarted);
	nx_uri_t filename = (nx_uri_t)param;
	decodePosition = 0;
	gain = 1.0;
	bufferCount = 0;
	decoder = FLAC__stream_decoder_new();
	if (decoder == 0)
	{
		if (WaitForSingleObject(killswitch, 200) != WAIT_OBJECT_0)
			PostMessage(plugin.hMainWindow, WM_WA_MPEG_EOF, 0, 0);

		free(filename);
		return 0;
	}

	FLAC__stream_decoder_set_md5_checking(decoder, false);
	FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);

	plugin.is_seekable = 1; 


	int ret;
		
	if (NXPathIsURL(filename) == NErr_True)
	{
		// Display a window to request to download
		// 
		MessageBox(NULL, L"Cannot stream flac file, please download it", NULL, 0);
		/*
			char agent[256] = { 0 };
			snprintf(agent, 256, "User-Agent: %S/%S", "Winamp", "5.9.1");
			ret = NXFileOpenProgressiveDownloader(&file, filename, nx_file_FILE_read_binary, 0, agent); // TODO: calculate real user agent
		*/
		return NErr_Disabled;
	}
	else
	{
		ret = NXFileOpenFile(&file, filename, nx_file_FILE_read_binary);
	}

	if (ret != NErr_Success)
	{
		FLAC__stream_decoder_delete(decoder);
		if (WaitForSingleObject(killswitch, 200) != WAIT_OBJECT_0)
			PostMessage(plugin.hMainWindow, WM_WA_MPEG_EOF, 0, 0);

		NXURIRelease(filename);
		return 0;
	}

	state.SetFile(file);

	NXFileLength(file, &fileSize);

	if (FLAC__stream_decoder_init_stream(
		decoder,
		FLAC_NXFile_Read,
		FLAC_NXFile_Seek,
		FLAC_NXFile_Tell,
		FLAC_NXFile_Length,
		FLAC_NXFile_EOF,
		OnAudio,
		OnMetadata,  // or NULL
		OnError,
		&state
		) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
	{
		FLAC__stream_decoder_delete(decoder);
		NXFileRelease(file);
		if (WaitForSingleObject(killswitch, 200) != WAIT_OBJECT_0)
			PostMessage(plugin.hMainWindow, WM_WA_MPEG_EOF, 0, 0);

		NXURIRelease(filename);
		return 0;
	}

	FLAC__stream_decoder_process_until_end_of_metadata(decoder);



	if (!audio_output.Open(0, channels, samplerate, bps))
	{
		FLAC__stream_decoder_finish(decoder);
		FLAC__stream_decoder_delete(decoder);
		NXFileRelease(file);
		if (WaitForSingleObject(killswitch, 200) != WAIT_OBJECT_0)
			PostMessage(plugin.hMainWindow, WM_WA_MPEG_EOF, 0, 0);

		NXURIRelease(filename);
		return 0;
	}

	plugin.SetInfo(averageBitrate, -1, -1, -1);
	plugin.outMod->SetVolume(volume);
	plugin.outMod->SetPan(pan);

	if (streaming && !DoBuffering(file))
	{
		FLAC__stream_decoder_finish(decoder);
		FLAC__stream_decoder_delete(decoder);
		NXFileRelease(file);
		NXURIRelease(filename);
		
		return 0;
	}

	if (m_force_seek != -1)
		APCSeek((ULONG_PTR)m_force_seek);
	m_force_seek = -1;

	HANDLE events[] = {killswitch};
	DWORD timeout = 0;
	while (true)
	{
		DWORD result = WaitForMultipleObjectsEx(sizeof(events) / sizeof(*events), events, FALSE, timeout, TRUE);
		switch (result)
		{
		case WAIT_OBJECT_0:// kill thread
			FLAC__stream_decoder_finish(decoder);
			FLAC__stream_decoder_delete(decoder);
			NXFileRelease(file);
			NXURIRelease(filename);
			return 0;

		case WAIT_TIMEOUT:
			timeout = paused ? PAUSE_TIMEOUT : 0;
				if (streaming && !DoBuffering(file))
	{
		FLAC__stream_decoder_finish(decoder);
		FLAC__stream_decoder_delete(decoder);
		NXFileRelease(file);
		NXURIRelease(filename);
		
		return 0;
	}

			if (!paused)
			{
				FLAC__bool decode_successful = FLAC__stream_decoder_process_single(decoder);

				FLAC__StreamDecoderState FLACstate = FLAC__stream_decoder_get_state(decoder);

				if (FLACstate == FLAC__STREAM_DECODER_END_OF_STREAM)
				{
					audio_output.Write(0, 0);
					if (audio_output.WaitWhilePlaying())
					{
							FLAC__stream_decoder_finish(decoder);
							FLAC__stream_decoder_delete(decoder);
							NXFileRelease(file);
							NXURIRelease(filename);
							return 0;
					}
					PostMessage(plugin.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
					timeout = INFINITE; // sit and wait for killswitch
				} 
				else if (!decode_successful)
				{
					// some other error - abort playback
					// if we can find FLAC files with errors, we might be able to gracefully handle some errors
					PostMessage(plugin.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
					timeout = INFINITE; // sit and wait for killswitch
				}
			}
			break;
		}
	}

	return 0;
}