723 lines
18 KiB
C++
723 lines
18 KiB
C++
#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;
|
|
}
|
|
} |