path: root/Src/Plugins/Input/in_mp4/Main.cpp

#define PLUGIN_VERSION L"2.70"
#include "Main.h"
#include <windows.h>
#include <stdio.h>
#include <locale.h>
#include "resource.h"
#include "../Winamp/in2.h"
#include "../Winamp/wa_ipc.h"
#include "../nu/AutoChar.h"
#include "api__in_mp4.h"

#include <api/service/waservicefactory.h>

#pragma warning(disable:4786)
#include "mpeg4audio.h"

#include <shlwapi.h>
#include <malloc.h>
#include "VirtualIO.h"
#include "AlbumArt.h"
#include <assert.h>
#include "../in_wmvdrm/Remaining.h"
#include "VideoThread.h"
#include "RawMediaReader.h"
#include "../nu/Singleton.h"
#include <strsafe.h>

Remaining remaining;
nu::VideoClock video_clock;

AlbumArtFactory albumArtFactory;

wchar_t m_ini[MAX_PATH] = {0};
int infoDlg(const wchar_t *fn, HWND hwnd);
#define WM_WA_IPC WM_USER
#define WM_WA_MPEG_EOF WM_USER+2

HANDLE hThread;
static DWORD WINAPI playProc(LPVOID lpParameter);
static int paused, m_kill;
HANDLE killEvent, seekEvent, pauseEvent;
static int m_opened;


static RawMediaReaderService raw_media_reader_service;
static SingletonServiceFactory<svc_raw_media_reader, RawMediaReaderService> raw_factory;
static void stop();

// wasabi based services for localisation support
api_language *WASABI_API_LNG = 0;
HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0;

api_config *AGAVE_API_CONFIG = 0;
api_memmgr *WASABI_API_MEMMGR = 0;
api_application *WASABI_API_APP = 0;

int DoAboutMessageBox(HWND parent, wchar_t* title, wchar_t* message)
{
	MSGBOXPARAMS msgbx = {sizeof(MSGBOXPARAMS),0};
	msgbx.lpszText = message;
	msgbx.lpszCaption = title;
	msgbx.lpszIcon = MAKEINTRESOURCE(102);
	msgbx.hInstance = GetModuleHandle(0);
	msgbx.dwStyle = MB_USERICON;
	msgbx.hwndOwner = parent;
	return MessageBoxIndirect(&msgbx);
}

void about(HWND hwndParent)
{
	wchar_t message[1024] = {0}, text[1024] = {0};
	WASABI_API_LNGSTRINGW_BUF(IDS_NULLSOFT_MPEG4_AUDIO_DECODER_OLD,text,1024);
	StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_ABOUT_TEXT),
					 mod.description, TEXT(__DATE__));
	DoAboutMessageBox(hwndParent,text,message);
}

static const wchar_t defaultExtensions_nonpro[] = {L"M4A;MP4"};
static const wchar_t defaultExtensions_pro[] = {L"M4A;MP4;M4V"};
const wchar_t *defaultExtensions = defaultExtensions_pro;


// the return pointer has been malloc'd.  Use free() when you are done.
char *BuildExtensions(const char *extensions)
{
	char name[64] = {0};
	WASABI_API_LNGSTRING_BUF(IDS_MP4_FILE,name,64);
	size_t length = strlen(extensions) + 1 + strlen(name) + 2;
	char *newExt = (char *)calloc(length, sizeof(char));
	char *ret = newExt; // save because we modify newExt

	// copy extensions
	StringCchCopyExA(newExt, length, extensions, &newExt, &length, 0);
	newExt++;
	length--;

	// copy description
	StringCchCopyExA(newExt, length, name, &newExt, &length, 0);
	newExt++;
	length--;

	// double null terminate
	assert(length == 1);
	*newExt = 0;

	return ret;
}

int init()
{
	if (!IsWindow(mod.hMainWindow))
		return IN_INIT_FAILURE;

	killEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	seekEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	pauseEvent = CreateEvent(NULL, TRUE, TRUE, NULL);

	mod.service->service_register(&albumArtFactory);
	raw_factory.Register(mod.service, &raw_media_reader_service);

	waServiceFactory *sf = mod.service->service_getServiceByGuid(AgaveConfigGUID);
	if (sf)
		AGAVE_API_CONFIG = (api_config *)sf->getInterface();
	sf = mod.service->service_getServiceByGuid(applicationApiServiceGuid);
	if (sf)
		WASABI_API_APP = (api_application *)sf->getInterface();
	sf = mod.service->service_getServiceByGuid(memMgrApiServiceGuid);
	if (sf)
		WASABI_API_MEMMGR = (api_memmgr *)sf->getInterface();
	sf = mod.service->service_getServiceByGuid(DownloadManagerGUID);
	if (sf)
		WAC_API_DOWNLOADMANAGER = (api_downloadManager *)sf->getInterface();
	sf = mod.service->service_getServiceByGuid(ThreadPoolGUID);
	if (sf)
		WASABI_API_THREADPOOL = (api_threadpool *)sf->getInterface();

	// loader so that we can get the localisation service api for use
	sf = mod.service->service_getServiceByGuid(languageApiGUID);
	if (sf) WASABI_API_LNG = reinterpret_cast<api_language*>(sf->getInterface());

	// need to have this initialised before we try to do anything with localisation features
	WASABI_API_START_LANG(mod.hDllInstance,InMp4LangGUID);

	static wchar_t szDescription[256];
	StringCchPrintfW(szDescription,256,WASABI_API_LNGSTRINGW(IDS_NULLSOFT_MPEG4_AUDIO_DECODER),PLUGIN_VERSION);
	mod.description = (char*)szDescription;

	const wchar_t *inipath = (wchar_t *)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW);

	PathCombineW(m_ini, inipath, L"Plugins");
	CreateDirectoryW(m_ini, NULL);
	PathAppendW(m_ini, L"in_mp4.ini");

	wchar_t exts[1024] = {0};
	GetPrivateProfileStringW(L"in_mp4", L"extensionlist", defaultExtensions, exts, 1024, m_ini);
	mod.FileExtensions = BuildExtensions(AutoChar(exts));
	return IN_INIT_SUCCESS;
}

void quit()
{
	CloseHandle(killEvent);
	CloseHandle(seekEvent);

	raw_factory.Deregister(mod.service);
	waServiceFactory *sf = mod.service->service_getServiceByGuid(AgaveConfigGUID);
	if (sf)
		sf->releaseInterface(AGAVE_API_CONFIG);
	sf = mod.service->service_getServiceByGuid(applicationApiServiceGuid);
	if (sf)
		sf->releaseInterface(WASABI_API_APP);
	sf = mod.service->service_getServiceByGuid(DownloadManagerGUID);
	if (sf)
		sf->releaseInterface( WAC_API_DOWNLOADMANAGER );
	mod.service->service_deregister(&albumArtFactory);

	free(mod.FileExtensions);
}

int isourfile(const wchar_t *fn)
{
	return 0;
}

void config(HWND hwndParent);

void setoutputtime(int time_in_ms)
{
	m_needseek = time_in_ms;
	SetEvent(seekEvent);
}

MP4TrackId GetVideoTrack(MP4FileHandle infile)
{
	int numTracks = MP4GetNumberOfTracks(infile, NULL,      /* subType */ 0);

	for (int i = 0; i < numTracks; i++)
	{
		MP4TrackId trackId = MP4FindTrackId(infile, i, NULL,      /* subType */ 0);
		const char* trackType = MP4GetTrackType(infile, trackId);

		if (!lstrcmpA(trackType, MP4_VIDEO_TRACK_TYPE))
			return trackId;
	}

	/* can't decode this */
	return MP4_INVALID_TRACK_ID;
}

MP4TrackId GetAudioTrack(MP4FileHandle infile)
{
	int ret = MP4_INVALID_TRACK_ID;
	__try
	{
			/* find AAC track */
	int numTracks = MP4GetNumberOfTracks(infile, NULL,      /* subType */ 0);

	for (int i = 0; i < numTracks; i++)
	{
		MP4TrackId trackId = MP4FindTrackId(infile, i, NULL,      /* subType */ 0);
		if (trackId != MP4_INVALID_TRACK_ID)
		{
			const char* trackType = MP4GetTrackType(infile, trackId);

			if (trackType && !lstrcmpA(trackType, MP4_AUDIO_TRACK_TYPE))
				return trackId;
		}

	}

	/* can't decode this */
	return MP4_INVALID_TRACK_ID;
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
		return MP4_INVALID_TRACK_ID;
	}
	return ret;
}

MP4SampleId numSamples, numVideoSamples;
MP4FileHandle MP4hFile;
MP4TrackId audio_track, video_track;

double m_length;
volatile int m_needseek = -1;
unsigned int audio_srate, audio_nch, audio_bps, audio_bitrate=0;
unsigned int video_bitrate=0;

wchar_t lastfn[MAX_PATH*4] = L"";

MP4AudioDecoder *audio = 0;
waServiceFactory *audioFactory = 0, *videoFactory = 0;
MP4VideoDecoder *video = 0;

uint32_t m_timescale = 0, m_video_timescale = 0;
static void *reader = 0;
bool audio_chunk = false;
enum
{
	READER_UNICODE=0,
	READER_HTTP=1,
};
int reader_type=READER_UNICODE;

bool open_mp4(const wchar_t *fn)
{
	audio = 0;
	video = 0;
	if (!_wcsnicmp(fn, L"http://", 7) || !_wcsnicmp(fn, L"https://", 8))
	{
		reader = CreateReader(fn, killEvent);
		reader_type=READER_HTTP;
		MP4hFile = MP4ReadEx(fn, reader, &HTTPIO);
	}
	else
	{
		reader = CreateUnicodeReader(fn);
		if (!reader)
			return false;
		reader_type=READER_UNICODE;
		MP4hFile = MP4ReadEx(fn, reader, &UnicodeIO);
	}

	if (!MP4hFile)
	{
		return false;
	}

	m_opened = 1;

	unsigned int output_bits = AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"bits", 16);
	if (output_bits  >= 24)	
		output_bits  = 24;
	else	
		output_bits  = 16;

	unsigned int max_channels;
		// get max channels
	if (AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"surround", true))
		max_channels = 6;
	else if (AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"mono", false))
		max_channels = 1;
	else
		max_channels = 2;

	audio_track = GetAudioTrack(MP4hFile);
	if (audio_track == MP4_INVALID_TRACK_ID || !CreateDecoder(MP4hFile, audio_track, audio, audioFactory)	|| audio->OpenMP4(MP4hFile, audio_track, output_bits, max_channels, false) != MP4_SUCCESS)
	{
		audio = 0;
		video_clock.Start();
	}

	video_track = GetVideoTrack(MP4hFile);
	if (video_track != MP4_INVALID_TRACK_ID)
	{
		CreateVideoDecoder(MP4hFile, video_track, video, videoFactory);
		if (video)
			video->Open(MP4hFile, video_track);
	}
	else
		video=0;

	if (!audio && !video)
	{
		return false;
	}

	numVideoSamples = MP4GetTrackNumberOfSamples(MP4hFile, video_track);
	m_video_timescale = MP4GetTrackTimeScale(MP4hFile, video_track);
	unsigned __int64 trackDuration;

	double lengthAudio = 0;
	double lengthVideo = 0;
	
	if (audio_track != MP4_INVALID_TRACK_ID)
	{
		if (audio)
		{
			ConfigureDecoderASC(MP4hFile, audio_track, audio);
			audio_chunk = !!audio->RequireChunks();
		}
		else
			audio_chunk = false;

		numSamples = audio_chunk?MP4GetTrackNumberOfChunks(MP4hFile, audio_track):MP4GetTrackNumberOfSamples(MP4hFile, audio_track);
		m_timescale = MP4GetTrackTimeScale(MP4hFile, audio_track);
		trackDuration = MP4GetTrackDuration(MP4hFile, audio_track);
		lengthAudio = (double)(__int64)trackDuration / (double)m_timescale;
	}
	else
	{
		numSamples = numVideoSamples;
		trackDuration = MP4GetTrackDuration(MP4hFile, video_track);
		lengthVideo = (double)(__int64)trackDuration / (double)m_video_timescale;
	}
	
	/* length in Sec. */
	m_length = max(lengthAudio, lengthVideo); //(double)(__int64)trackDuration / (double)m_timescale;

	audio_bitrate = MP4GetTrackBitRate(MP4hFile, audio_track) / 1000;
	if (video)
		video_bitrate = MP4GetTrackBitRate(MP4hFile, video_track) / 1000;
	else
	video_bitrate = 0;

	if (audio && audio->SetGain(GetGain(MP4hFile)) == MP4_SUCCESS)
		mod.UsesOutputPlug |= 8;
	else
		mod.UsesOutputPlug &= ~8;

	return true;
}

int play(const wchar_t *fn)
{
	video_clock.Reset();
	if (!videoOutput) // grab this now while we're on the main thread
		videoOutput = (IVideoOutput *)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GET_IVIDEOOUTPUT);
	audio = 0;
	video = 0;
	paused = 0;
	m_kill = 0;
	ResetEvent(killEvent);
	m_length = 0;
	ResetEvent(seekEvent);
	m_needseek = -1;
	SetEvent(pauseEvent);
	if (m_force_seek != -1)
	{
		setoutputtime(m_force_seek);
	}
	m_opened = 0;

	lstrcpynW(lastfn, fn, MAX_PATH*4);

	DWORD thread_id;
	HANDLE threadCreatedEvent = CreateEvent(0, FALSE, FALSE, 0);
	hThread = CreateThread(NULL, NULL, PlayProc, (LPVOID)threadCreatedEvent, NULL, &thread_id);
	SetThreadPriority(hThread, AGAVE_API_CONFIG->GetInt(playbackConfigGroupGUID, L"priority", THREAD_PRIORITY_HIGHEST));
	WaitForSingleObject(threadCreatedEvent, INFINITE);
	CloseHandle(threadCreatedEvent);

	return 0;
}

static inline wchar_t *IncSafe(wchar_t *val, int x)
{
	while (x--)
	{
		if (*val)
			val++;
	}

	return val;
}

void GetGaps(MP4FileHandle mp4, unsigned __int32 &pre, unsigned __int32 &post)
{
	wchar_t gap_data[128] = {0};
	if (GetCustomMetadata(mp4, "iTunSMPB", gap_data, 128) && gap_data[0])
	{
		wchar_t *itr = IncSafe(gap_data, 9);

		pre = wcstoul(itr, 0, 16);

		itr = IncSafe(itr, 9);
		post = wcstoul(itr, 0, 16);

		// don't care about total number of samples, really
		/*
		itr+=9;
		unsigned int numSamples = wcstoul(itr, 0, 16);*/

	}
	else
	{
		pre = 0;
		post = 0;
	}
}

float GetGain(MP4FileHandle mp4, bool allowDefault)
{
	if (AGAVE_API_CONFIG && AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain", false))
	{
		float dB = 0, peak = 1.0f;
		wchar_t gain[128] = L"", peakVal[128] = L"";
		_locale_t C_locale = WASABI_API_LNG->Get_C_NumericLocale();

		switch (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"replaygain_source", 0))
		{
		case 0:   // track
			if ((!GetCustomMetadata(mp4, "replaygain_track_gain", gain, 128) || !gain[0])
			    && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
				GetCustomMetadata(mp4, "replaygain_album_gain", gain, 128);

			if ((!GetCustomMetadata(mp4, "replaygain_track_peak", peakVal, 128) || !peakVal[0])
			    && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
				GetCustomMetadata(mp4, "replaygain_album_peak", peakVal, 128);
			break;
		case 1:
			if ((!GetCustomMetadata(mp4, "replaygain_album_gain", gain, 128) || !gain[0])
			    && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
				GetCustomMetadata(mp4, "replaygain_track_gain", gain, 128);

			if ((!GetCustomMetadata(mp4, "replaygain_album_peak", peakVal, 128) || !peakVal[0])
			    && !AGAVE_API_CONFIG->GetBool(playbackConfigGroupGUID, L"replaygain_preferred_only", false))
				GetCustomMetadata(mp4, "replaygain_track_peak", peakVal, 128);
			break;
		}

		if (gain[0])
		{
			if (gain[0] == L'+')
				dB = (float)_wtof_l(&gain[1],C_locale);
			else
				dB = (float)_wtof_l(gain,C_locale);
		}
		else if (allowDefault)
		{
			dB = AGAVE_API_CONFIG->GetFloat(playbackConfigGroupGUID, L"non_replaygain", -6.0);
			return powf(10.0f, dB / 20.0f);
		}

		if (peakVal[0])
		{
			peak = (float)_wtof_l(peakVal,C_locale);
		}

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

	}

	return 1.0f; // no gain
}




bool first;

void pause()
{
	paused = 1;
	if (audio)
	{
		mod.outMod->Pause(1);
	}
	else
	{
		video_clock.Pause();
	}
	ResetEvent(pauseEvent); // pauseEvent signal state is opposite of pause state
}

void unpause()
{
	paused = 0;
	if (audio)
	{
		mod.outMod->Pause(0);
	}
	else
	{
		video_clock.Unpause();
	}
	SetEvent(pauseEvent); // pauseEvent signal state is opposite of pause state
}

int ispaused()
{
	return paused;
}

void stop()
{
	if (reader && reader_type==READER_HTTP) StopReader(reader);

	lastfn[0] = 0;
	SetEvent(killEvent);
	m_kill = 1;
	WaitForSingleObject(hThread, INFINITE);

	mod.outMod->Close();
	mod.SAVSADeInit();

	if (m_opened) MP4Close(MP4hFile);
	MP4hFile = 0;
	m_opened = 0;

	if (audio)
	{
		audio->Close();
		audioFactory->releaseInterface(audio);
	}

	audioFactory = 0;
	audio = 0;

	if (video)
	{
		video->Close();
		videoFactory->releaseInterface(video);
	}
	videoFactory=0;
	video = 0;

	if (reader) 
	{
		if (reader_type == READER_HTTP)
			DestroyReader(reader);
		else
			DestroyUnicodeReader(reader);
	}
	reader = 0;
}

int getlength()
{
	return (int)(m_length*1000);
}

int getoutputtime()
{
	if (m_needseek == -1)
			return (int)GetClock();
	else
		return m_needseek; // this prevents the seekbar from jumping around while the playthread is seeking
}

void setvolume(int volume)
{
	mod.outMod->SetVolume(volume);
}
void setpan(int pan)
{
	mod.outMod->SetPan(pan);
}
/*
void FillInfo(HWND hwndDlg, MP4FileHandle hMp4);
void CALLBACK CurrentlyPlayingInfoBox(ULONG_PTR param)
{
	ThreadInfoBox *threadInfo = (ThreadInfoBox *)param;
	FillInfo(threadInfo->hwndDlg, MP4hFile);
	SetEvent(threadInfo->completionEvent);
}
*/
void getfileinfo(const wchar_t *filename, wchar_t *title, int *length_in_ms)
{
	if (!filename || !*filename)  // currently playing file
	{
		if (length_in_ms) *length_in_ms = getlength();
		if (title) // get non-path portion.of filename
		{
			lstrcpynW(title, lastfn, GETFILEINFO_TITLE_LENGTH);
			PathStripPathW(title);
			PathRemoveExtensionW(title);
		}
	}
	else // some other file
	{
		if (length_in_ms) // calculate length
		{
			*length_in_ms = -1000; // the default is unknown file length (-1000).

			MP4FileHandle hMp4 = MP4Read(filename);
			if (hMp4)
			{
				double lengthAudio = 0;
				double lengthVideo = 0;
				MP4TrackId audio_track = GetAudioTrack(hMp4);
				if (audio_track != -1)
				{
					int timescale = MP4GetTrackTimeScale(hMp4, audio_track);
					unsigned __int64 trackDuration = MP4GetTrackDuration(hMp4, audio_track);
					lengthAudio = (double)(__int64)trackDuration / (double)timescale;
				}
				MP4TrackId video_track = GetVideoTrack(hMp4);
				if (video_track != -1)
				{
					int timescale = MP4GetTrackTimeScale(hMp4, video_track);
					unsigned __int64 trackDuration = MP4GetTrackDuration(hMp4, video_track);
					lengthVideo = (double)(__int64)trackDuration / (double)timescale;
				}
				*length_in_ms = (int)(max(lengthAudio, lengthVideo) * 1000);
				MP4Close(hMp4);
			}
		}
		if (title) // get non path portion of filename
		{
			lstrcpynW(title, filename, GETFILEINFO_TITLE_LENGTH);
			PathStripPathW(title);
			PathRemoveExtensionW(title);
		}
	}
}

void eq_set(int on, char data[10], int preamp)
{}

// module definition.

In_Module mod =
{
	IN_VER_RET, // defined in IN2.H
	"nullsoft(in_mp4.dll)",		//"Nullsoft MPEG-4 Audio Decoder v1.22"
	0,    	// hMainWindow (filled in by winamp)
	0,      // hDllInstance (filled in by winamp)
	0,	    // this is a double-null limited list. "EXT\0Description\0EXT\0Description\0" etc.
	1,    	// is_seekable
	1,    	// uses output plug-in system
	config,
	about,
	init,
	quit,
	getfileinfo,
	infoDlg,
	isourfile,
	play,
	pause,
	unpause,
	ispaused,
	stop,

	getlength,
	getoutputtime,
	setoutputtime,

	setvolume,
	setpan,

	0, 0, 0, 0, 0, 0, 0, 0, 0,     // visualization calls filled in by winamp

	0, 0,     // dsp calls filled in by winamp

	eq_set,

	NULL,    		// setinfo call filled in by winamp

	0 // out_mod filled in by winamp
};

extern "C"
{
	__declspec(dllexport) In_Module * winampGetInModule2()
	{
		return &mod;
	}
}