mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-09-24 15:54:12 +00:00
1022 lines
No EOL
30 KiB
C++
1022 lines
No EOL
30 KiB
C++
#include "main.h"
|
|
#include "VirtualIO.h"
|
|
#include "../nu/ns_wc.h"
|
|
#include "../nu/AutoChar.h"
|
|
#include <vector>
|
|
#include "../Winamp/wa_ipc.h"
|
|
#include "api__in_mp4.h"
|
|
#include "Stopper.h"
|
|
#include <shlwapi.h>
|
|
#include <strsafe.h>
|
|
#include "resource.h"
|
|
|
|
static inline wchar_t *IncSafe(wchar_t *val, int x)
|
|
{
|
|
while (x--)
|
|
{
|
|
if (*val)
|
|
val++;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
bool KeywordMatch(const char *mainString, const char *keyword)
|
|
{
|
|
return !_stricmp(mainString, keyword);
|
|
}
|
|
|
|
bool GetCustomMetadata(MP4FileHandle mp4, char *metadata, wchar_t *dest, int destlen, const char *owner)
|
|
{
|
|
u_int8_t *value;
|
|
u_int32_t size;
|
|
bool success = MP4GetMetadataFreeForm(mp4, metadata, &value, &size, owner);
|
|
if (success)
|
|
{
|
|
int cnt = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)value, size, dest, destlen - 1);
|
|
dest[cnt] = 0;
|
|
MP4Free(value);
|
|
}
|
|
else
|
|
dest[0] = 0;
|
|
|
|
return success;
|
|
}
|
|
|
|
bool HasVideo(MP4FileHandle infile)
|
|
{
|
|
/* find Video track */
|
|
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 true;
|
|
|
|
}
|
|
|
|
/* can't decode this */
|
|
return false;
|
|
}
|
|
typedef struct __INFOKEYWORD
|
|
{
|
|
LPCWSTR buffer;
|
|
INT len;
|
|
} INFOKEYWORD;
|
|
|
|
typedef std::vector<INFOKEYWORD> KeywordList;
|
|
|
|
/*static void KeywordList_PushBack(KeywordList *list, LPCWSTR buffer, INT len)
|
|
{
|
|
if (NULL == list) return;
|
|
|
|
INFOKEYWORD kw = { buffer, len };
|
|
list->push_back(kw);
|
|
}
|
|
|
|
static LPCWSTR ParseFormatInfoLine(LPCWSTR line, KeywordList *list)
|
|
{
|
|
if (NULL == line || L'\0' == *line) return line;
|
|
LPCWSTR cursor = line;
|
|
|
|
for(;;)
|
|
{
|
|
switch(*cursor)
|
|
{
|
|
case L'\r':
|
|
if (L'\n' == *(cursor + 1))
|
|
{
|
|
KeywordList_PushBack(list, line, (INT)(cursor - line));
|
|
cursor += 2;
|
|
return cursor;
|
|
}
|
|
case L'\0':
|
|
KeywordList_PushBack(list, line, (INT)(cursor - line));
|
|
return NULL;
|
|
case L'\t':
|
|
KeywordList_PushBack(list, line, (INT)(cursor - line));
|
|
line = ++cursor;
|
|
break;
|
|
default:
|
|
cursor++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static HRESULT FormatInformationString(LPWSTR pszBuffer, INT cchBufferMax, LPCSTR formatInfo)
|
|
{
|
|
if (NULL == pszBuffer) return E_POINTER;
|
|
*pszBuffer = L'\0';
|
|
|
|
if (NULL == formatInfo)
|
|
return S_OK;
|
|
|
|
INT cchFormat = lstrlenA(formatInfo);
|
|
if (0 == cchFormat) return S_OK;
|
|
|
|
LPWSTR pszFormat = (LPWSTR)malloc(sizeof(WCHAR) * (cchFormat + 1));
|
|
if (NULL == pszFormat) return E_OUTOFMEMORY;
|
|
|
|
INT result = MultiByteToWideCharSZ(CP_UTF8, 0, formatInfo, cchFormat, pszFormat, cchFormat + 1);
|
|
if (0 == result)
|
|
{
|
|
DWORD errorCode = GetLastError();
|
|
return HRESULT_FROM_WIN32(errorCode);
|
|
}
|
|
|
|
HRESULT hr(S_OK);
|
|
KeywordList keys;
|
|
KeywordList values;
|
|
LPCWSTR line = pszFormat;
|
|
line = ParseFormatInfoLine(line, &keys);
|
|
line = ParseFormatInfoLine(line, &values);
|
|
|
|
size_t count = keys.size();
|
|
if (0 != count && count == values.size())
|
|
{
|
|
LPWSTR cursor = pszBuffer;
|
|
size_t remaining = cchBufferMax;
|
|
for (size_t index = 0; index < count; index++)
|
|
{
|
|
if (cursor != pszBuffer)
|
|
hr = StringCchCopyEx(cursor, remaining, L"\r\n", &cursor, &remaining, 0);
|
|
|
|
if (SUCCEEDED(hr) && 0 != keys[index].len)
|
|
{
|
|
hr = StringCchCopyNEx(cursor, remaining, keys[index].buffer, keys[index].len, &cursor, &remaining, 0);
|
|
if (SUCCEEDED(hr))
|
|
hr = StringCchCopyEx(cursor, remaining, L":", &cursor, &remaining, 0);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && 0 != values[index].len)
|
|
{
|
|
if (SUCCEEDED(hr) && 0 != keys[index].len)
|
|
hr = StringCchCopyEx(cursor, remaining, L" ", &cursor, &remaining, 0);
|
|
|
|
hr = StringCchCopyNEx(cursor, remaining, values[index].buffer, values[index].len, &cursor, &remaining, 0);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = StringCchCopy(pszBuffer, cchBufferMax, pszFormat);
|
|
}
|
|
|
|
if (NULL != pszFormat)
|
|
free(pszFormat);
|
|
|
|
return hr;
|
|
}*/
|
|
|
|
static MP4FileHandle getFileInfoMP4 = 0;
|
|
static wchar_t getFileInfoFn[MAX_PATH]=L"";
|
|
static void *getFileInfoReader=0;
|
|
static FILETIME ftLastWriteTime;
|
|
|
|
// is used to determine if the last write time of the file has changed when
|
|
// asked to get the metadata for the same cached file so we can update things
|
|
BOOL HasFileTimeChanged(const wchar_t *fn)
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA fileData = {0};
|
|
if (GetFileAttributesExW(fn, GetFileExInfoStandard, &fileData) == TRUE)
|
|
{
|
|
if(CompareFileTime(&ftLastWriteTime, &fileData.ftLastWriteTime))
|
|
{
|
|
ftLastWriteTime = fileData.ftLastWriteTime;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void UpdateFileTimeChanged(const wchar_t *fn)
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA fileData;
|
|
if (GetFileAttributesExW(fn, GetFileExInfoStandard, &fileData) == TRUE)
|
|
{
|
|
ftLastWriteTime = fileData.ftLastWriteTime;
|
|
}
|
|
}
|
|
|
|
extern "C"
|
|
{
|
|
__declspec( dllexport ) int winampGetExtendedFileInfoW(const wchar_t *fn, const char *data, wchar_t *dest, size_t destlen)
|
|
{
|
|
if (KeywordMatch(data, "type"))
|
|
{
|
|
if (!fn || (fn && !fn[0]) || !PathFileExistsW(fn))
|
|
{
|
|
const wchar_t *e = PathFindExtensionW(fn);
|
|
DWORD lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
|
|
// check known video extensions
|
|
if ((CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L".M4V", -1))
|
|
|| (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L".MOV", -1))
|
|
|| (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L".F4V", -1))
|
|
|| (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L".MP4", -1)))
|
|
dest[0] = '1';
|
|
else
|
|
dest[0] = '0';
|
|
dest[1] = 0;
|
|
return 1;
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "rateable"))
|
|
{
|
|
dest[0] = '1';
|
|
dest[1] = 0;
|
|
return 1;
|
|
}
|
|
|
|
if (!fn || (fn && !fn[0])) return 0;
|
|
|
|
if (KeywordMatch(data, "family"))
|
|
{
|
|
LPCWSTR e;
|
|
int pID = -1;
|
|
e = PathFindExtensionW(fn);
|
|
if (L'.' != *e) return 0;
|
|
e++;
|
|
DWORD lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
|
|
if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"M4A", -1)) pID = IDS_FAMILY_STRING_M4A;
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"MP4", -1)) pID = IDS_FAMILY_STRING_MPEG4;
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"M4V", -1)) pID = IDS_FAMILY_STRING_M4V;
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"MOV", -1)) pID = IDS_FAMILY_STRING_QUICKTIME;
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"3GP", -1)) pID = IDS_FAMILY_STRING_3GPP;
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"F4V", -1)) pID = IDS_FAMILY_STRING_FLV;
|
|
if (pID != -1 && S_OK == StringCchCopyW(dest, destlen, WASABI_API_LNGSTRINGW(pID))) return 1;
|
|
return 0;
|
|
}
|
|
|
|
if (KeywordMatch(data, "mime"))
|
|
{
|
|
LPCWSTR e;
|
|
e = PathFindExtensionW(fn);
|
|
if (L'.' != *e) return 0;
|
|
e++;
|
|
DWORD lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
|
|
if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"M4A", -1)) { StringCchCopyW(dest, destlen, L"audio/mp4"); return 1; }
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"MP4", -1)) { StringCchCopyW(dest, destlen, L"audio/mp4"); return 1; }
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"M4V", -1)) { StringCchCopyW(dest, destlen, L"video/mp4"); return 1; }
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"MOV", -1)) { StringCchCopyW(dest, destlen, L"video/quicktime"); return 1; }
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"3GP", -1)) { StringCchCopyW(dest, destlen, L"video/3gp"); return 1; }
|
|
else if (CSTR_EQUAL == CompareStringW(lcid, NORM_IGNORECASE, e, -1, L"F4V", -1)) { StringCchCopyW(dest, destlen, L"video/f4v"); return 1; }
|
|
return 0;
|
|
}
|
|
|
|
if (!getFileInfoMP4 || lstrcmpi(getFileInfoFn, fn) || HasFileTimeChanged(fn)) // different file than last time?
|
|
{
|
|
lstrcpyn(getFileInfoFn, fn, MAX_PATH);
|
|
|
|
if (getFileInfoMP4)
|
|
MP4Close(getFileInfoMP4);
|
|
getFileInfoMP4=0;
|
|
|
|
if (getFileInfoReader)
|
|
DestroyUnicodeReader(getFileInfoReader);
|
|
|
|
getFileInfoReader = CreateUnicodeReader(fn);
|
|
if (!getFileInfoReader)
|
|
{
|
|
getFileInfoFn[0]=0;
|
|
return 0;
|
|
}
|
|
|
|
getFileInfoMP4 = MP4ReadEx(fn, getFileInfoReader, &UnicodeIO);
|
|
if (!getFileInfoMP4)
|
|
{
|
|
DestroyUnicodeReader(getFileInfoReader);
|
|
getFileInfoReader=0;
|
|
getFileInfoFn[0]=0;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
UnicodeClose(getFileInfoReader); // go ahead and close the file so we don't lock it
|
|
}
|
|
}
|
|
|
|
bool success = false;
|
|
char *pVal = NULL;
|
|
uint16_t *pVal_utf16 = NULL;
|
|
|
|
if (KeywordMatch(data, "type"))
|
|
{
|
|
if (GetVideoTrack(getFileInfoMP4) != MP4_INVALID_TRACK_ID) // check for a video track
|
|
dest[0] = '1';
|
|
else // assume no video mean audio (not necessarily true, for weird mp4 stuff like systems & text)
|
|
dest[0] = '0';
|
|
dest[1] = 0;
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "lossless"))
|
|
{
|
|
dest[0]='0';
|
|
dest[1]=0;
|
|
MP4TrackId track = GetAudioTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
{
|
|
// TODO: benski> We should check more than just ALAC
|
|
// potentially asking the mpeg4audio services
|
|
// but for now this should suffice.
|
|
const char *media_data_name = MP4GetTrackMediaDataName(getFileInfoMP4, track);
|
|
if (media_data_name && KeywordMatch (media_data_name, "alac"))
|
|
dest[0]='1';
|
|
}
|
|
success=true;
|
|
}
|
|
else if (KeywordMatch(data, "title"))
|
|
{
|
|
success = MP4GetMetadataName(getFileInfoMP4, &pVal);
|
|
if (!success)
|
|
success = MP4Get3GPMetadata(getFileInfoMP4, "titl", &pVal_utf16);
|
|
}
|
|
else if (KeywordMatch(data, "album"))
|
|
{
|
|
success = MP4GetMetadataAlbum(getFileInfoMP4, &pVal);
|
|
if (!success)
|
|
success = MP4Get3GPMetadata(getFileInfoMP4, "albm", &pVal_utf16);
|
|
}
|
|
else if (KeywordMatch(data, "artist"))
|
|
{
|
|
success = MP4GetMetadataArtist(getFileInfoMP4, &pVal);
|
|
if (!success)
|
|
success = MP4Get3GPMetadata(getFileInfoMP4, "perf", &pVal_utf16);
|
|
}
|
|
else if (KeywordMatch(data, "rating"))
|
|
{
|
|
success = MP4GetMetadataRating(getFileInfoMP4, &pVal);
|
|
// add a /* to enable reading from 3GP metadata, otherwise is only used on normal MP4
|
|
if (success)/*/
|
|
if (!success)
|
|
{
|
|
if ((success = MP4Get3GPMetadata(getFileInfoMP4, "rate", &pVal_utf16)))
|
|
{
|
|
wchar_t *value = (wchar_t*)pVal_utf16;
|
|
if(value && *value) {
|
|
int rating = _wtoi(value);
|
|
|
|
// keeps things limited to our range of 0-100
|
|
if (rating >= 100) {
|
|
rating = 5;
|
|
}
|
|
// 1-100 case
|
|
else if (rating > 0 && rating < 100) {
|
|
rating = (rating /= 20);
|
|
// shift up by one rating when in next band
|
|
// 1-20 = 1, 21-40 = 2, 41-60 = 3, 61-80 = 4, 81-100 = 5
|
|
rating += ((_wtoi(value) - (rating * 20)) > 0);
|
|
}
|
|
// otherwise just make sure and set zero
|
|
else {
|
|
rating = 0;
|
|
}
|
|
|
|
StringCchPrintfW(dest, destlen, L"%u", rating);
|
|
MP4Free(pVal_utf16);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
else/**/
|
|
{
|
|
char *value = (char*)pVal;
|
|
if(value && *value) {
|
|
int rating = atoi(value);
|
|
|
|
// keeps things limited to our range of 0-100
|
|
if (rating >= 100) {
|
|
rating = 5;
|
|
}
|
|
// 1-100 case
|
|
else if (rating > 0 && rating < 100) {
|
|
rating = (rating /= 20);
|
|
// shift up by one rating when in next band
|
|
// 1-20 = 1, 21-40 = 2, 41-60 = 3, 61-80 = 4, 81-100 = 5
|
|
rating += ((atoi(value) - (rating * 20)) > 0);
|
|
}
|
|
// otherwise just make sure and set zero
|
|
else {
|
|
rating = 0;
|
|
}
|
|
|
|
StringCchPrintfW(dest, destlen, L"%u", rating);
|
|
MP4Free(pVal);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "comment"))
|
|
success = MP4GetMetadataComment(getFileInfoMP4, &pVal);
|
|
else if (KeywordMatch(data, "albumartist"))
|
|
success = MP4GetMetadataAlbumArtist(getFileInfoMP4, &pVal);
|
|
else if (KeywordMatch(data, "gain"))
|
|
{
|
|
StringCchPrintfW(dest, destlen, L"%+-.2f dB", (float)log10f(GetGain(getFileInfoMP4, false))*20.0f);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_track_gain"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "replaygain_track_gain", dest, destlen);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_album_gain"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "replaygain_album_gain", dest, destlen);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_track_peak"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "replaygain_track_peak", dest, destlen);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_album_peak"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "replaygain_album_peak", dest, destlen);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "bpm"))
|
|
{
|
|
unsigned __int16 tempo = 0;
|
|
success = MP4GetMetadataTempo(getFileInfoMP4, &tempo);
|
|
if (success && tempo)
|
|
StringCchPrintf(dest, destlen, L"%u", tempo);
|
|
}
|
|
else if (KeywordMatch(data, "year"))
|
|
{
|
|
success = MP4GetMetadataYear(getFileInfoMP4, &pVal);
|
|
if (!success)
|
|
{
|
|
uint64_t val = 0;
|
|
success = MP4Get3GPMetadataInteger(getFileInfoMP4, "yrrc", &val);
|
|
if (success)
|
|
{
|
|
StringCchPrintf(dest, destlen, L"%I64u", val);
|
|
}
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "bitrate"))
|
|
{
|
|
uint32_t audio_bitrate = 0, video_bitrate = 0;
|
|
MP4TrackId track = GetAudioTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
audio_bitrate = MP4GetTrackBitRate(getFileInfoMP4, track) / 1000;
|
|
|
|
track = GetVideoTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
video_bitrate = MP4GetTrackBitRate(getFileInfoMP4, track) / 1000;
|
|
|
|
|
|
if (audio_bitrate || video_bitrate)
|
|
StringCchPrintf(dest, destlen, L"%u", audio_bitrate+video_bitrate);
|
|
else
|
|
dest[0] = 0;
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "height"))
|
|
{
|
|
MP4TrackId track = GetVideoTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
{
|
|
uint16_t height = MP4GetTrackVideoHeight(getFileInfoMP4, track);
|
|
if (height)
|
|
{
|
|
StringCchPrintf(dest, destlen, L"%u", height);
|
|
}
|
|
else
|
|
dest[0]=0;
|
|
success=true;
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "width"))
|
|
{
|
|
|
|
MP4TrackId track = GetVideoTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
{
|
|
uint16_t width = MP4GetTrackVideoWidth(getFileInfoMP4, track);
|
|
if (width)
|
|
{
|
|
StringCchPrintf(dest, destlen, L"%u", width);
|
|
}
|
|
else
|
|
dest[0]=0;
|
|
success=true;
|
|
}
|
|
}
|
|
//else if(KeywordMatch(data,"srate")) wsprintf(dest,"%d",srate);
|
|
//else if(KeywordMatch(data,"stereo")) wsprintf(dest,"%d",is_stereo);
|
|
//else if(KeywordMatch(data,"vbr")) wsprintf(dest,"%d",is_vbr);
|
|
else if (KeywordMatch(data, "genre"))
|
|
{
|
|
success = MP4GetMetadataGenre(getFileInfoMP4, &pVal);
|
|
if (!success)
|
|
success = MP4Get3GPMetadata(getFileInfoMP4, "gnre", &pVal_utf16);
|
|
}
|
|
else if (KeywordMatch(data, "disc"))
|
|
{
|
|
unsigned __int16 dummy = 0, dummy2 = 0;
|
|
success = MP4GetMetadataDisk(getFileInfoMP4, &dummy, &dummy2);
|
|
if (success && dummy)
|
|
{
|
|
if (dummy2)
|
|
StringCchPrintf(dest, destlen, L"%u/%u", dummy, dummy2);
|
|
else
|
|
StringCchPrintf(dest, destlen, L"%u", dummy);
|
|
}
|
|
else
|
|
dest[0] = 0;
|
|
}
|
|
else if (KeywordMatch(data, "track"))
|
|
{
|
|
unsigned __int16 dummy = 0, dummy2 = 0;
|
|
success = MP4GetMetadataTrack(getFileInfoMP4, &dummy, &dummy2);
|
|
if (success && dummy)
|
|
{
|
|
if (dummy2)
|
|
StringCchPrintf(dest, destlen, L"%u/%u", dummy, dummy2);
|
|
else
|
|
StringCchPrintf(dest, destlen, L"%u", dummy);
|
|
}
|
|
else
|
|
dest[0] = 0;
|
|
}
|
|
else if (KeywordMatch(data, "length"))
|
|
{
|
|
/* TODO: use sample rate and number of samples from iTunSMPB to get a more exact length */
|
|
//MP4TrackId track = GetAudioTrack(getFileInfoMP4);
|
|
//if (track != MP4_INVALID_TRACK_ID)
|
|
//{
|
|
// int m_timescale = MP4GetTrackTimeScale(getFileInfoMP4, track);
|
|
// unsigned __int64 trackDuration = MP4GetTrackDuration(getFileInfoMP4, track);
|
|
// double m_length = (double)(__int64)trackDuration / (double)m_timescale;
|
|
// StringCchPrintf(dest, destlen, L"%d", (int)(m_length*1000));
|
|
// success = true;
|
|
//}
|
|
|
|
double lengthAudio = 0;
|
|
double lengthVideo = 0;
|
|
double m_length = 0;
|
|
MP4TrackId audio_track = GetAudioTrack(getFileInfoMP4);
|
|
if (audio_track != -1)
|
|
{
|
|
int timescale = MP4GetTrackTimeScale(getFileInfoMP4, audio_track);
|
|
unsigned __int64 trackDuration = MP4GetTrackDuration(getFileInfoMP4, audio_track);
|
|
lengthAudio = (double)(__int64)trackDuration / (double)timescale;
|
|
}
|
|
MP4TrackId video_track = GetVideoTrack(getFileInfoMP4);
|
|
if (video_track != -1)
|
|
{
|
|
int timescale = MP4GetTrackTimeScale(getFileInfoMP4, video_track);
|
|
unsigned __int64 trackDuration = MP4GetTrackDuration(getFileInfoMP4, video_track);
|
|
lengthVideo = (double)(__int64)trackDuration / (double)timescale;
|
|
}
|
|
m_length = (max(lengthAudio, lengthVideo));
|
|
StringCchPrintf(dest, destlen, L"%d", (int)(m_length * 1000));
|
|
success = true;
|
|
|
|
}
|
|
else if (KeywordMatch(data, "tool"))
|
|
success = MP4GetMetadataTool(getFileInfoMP4, &pVal);
|
|
else if (KeywordMatch(data, "composer"))
|
|
success = MP4GetMetadataWriter(getFileInfoMP4, &pVal);
|
|
else if (KeywordMatch(data, "category"))
|
|
success = MP4GetMetadataGrouping(getFileInfoMP4, &pVal);
|
|
else if (KeywordMatch(data, "GracenoteFileID"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "gnid", dest, destlen);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "GracenoteExtData"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "gnxd", dest, destlen);
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "publisher"))
|
|
{
|
|
GetCustomMetadata(getFileInfoMP4, "publisher", dest, destlen, "com.nullsoft.winamp");
|
|
success = true;
|
|
}
|
|
else if (KeywordMatch(data, "pregap"))
|
|
{
|
|
wchar_t gap_data[128] = {0};
|
|
if (GetCustomMetadata(getFileInfoMP4, "iTunSMPB", gap_data, 128) && gap_data[0])
|
|
{
|
|
wchar_t *itr = IncSafe(gap_data, 9);
|
|
|
|
unsigned int pregap = wcstoul(itr, 0, 16);
|
|
StringCchPrintfW(dest, destlen, L"%u",pregap);
|
|
success=true;
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "postgap"))
|
|
{
|
|
wchar_t gap_data[128] = {0};
|
|
if (GetCustomMetadata(getFileInfoMP4, "iTunSMPB", gap_data, 128) && gap_data[0])
|
|
{
|
|
wchar_t *itr = IncSafe(gap_data, 18);
|
|
|
|
unsigned int postgap = wcstoul(itr, 0, 16);
|
|
StringCchPrintfW(dest, destlen, L"%u",postgap);
|
|
success=true;
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "numsamples"))
|
|
{
|
|
wchar_t gap_data[128] = {0};
|
|
if (GetCustomMetadata(getFileInfoMP4, "iTunSMPB", gap_data, 128) && gap_data[0])
|
|
{
|
|
wchar_t *itr = IncSafe(gap_data,27);
|
|
|
|
unsigned __int64 numsamples = _wcstoui64(itr, 0, 16);
|
|
StringCchPrintfW(dest, destlen, L"%I64u", numsamples);
|
|
success=true;
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "formatinformation"))
|
|
{
|
|
MP4TrackId track = GetAudioTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
{
|
|
char *track_type = MP4PrintAudioInfo(getFileInfoMP4, track);
|
|
if (track_type)
|
|
{
|
|
uint32_t bitrate = MP4GetTrackBitRate(getFileInfoMP4, track);
|
|
StringCchPrintfEx(dest, destlen, &dest, &destlen, 0, WASABI_API_LNGSTRINGW(IDS_AUDIO_INFO), track_type, (bitrate + 500) / 1000);
|
|
MP4Free(track_type);
|
|
}
|
|
}
|
|
|
|
track = GetVideoTrack(getFileInfoMP4);
|
|
if (track != MP4_INVALID_TRACK_ID)
|
|
{
|
|
char *track_type = MP4PrintVideoInfo(getFileInfoMP4, track);
|
|
if (track_type)
|
|
{
|
|
uint32_t bitrate = MP4GetTrackBitRate(getFileInfoMP4, track);
|
|
StringCchPrintfEx(dest, destlen, &dest, &destlen, 0, WASABI_API_LNGSTRINGW(IDS_VIDEO_INFO), track_type, (bitrate + 500) / 1000);
|
|
u_int16_t width = MP4GetTrackVideoWidth(getFileInfoMP4, track);
|
|
u_int16_t height = MP4GetTrackVideoHeight(getFileInfoMP4, track);
|
|
if (width && height)
|
|
{
|
|
// TODO: framerate, but the MP4GetTrackVideoFrameRate method just guesses based on duration and samples
|
|
StringCchPrintfEx(dest, destlen, &dest, &destlen, 0, L"\t%ux%u\n", width, height);
|
|
}
|
|
MP4Free(track_type);
|
|
}
|
|
}
|
|
|
|
success=true;
|
|
}
|
|
else // don't understand the name
|
|
{
|
|
// MP4Close(getFileInfoMP4);
|
|
return 0;
|
|
}
|
|
|
|
if (pVal)
|
|
{
|
|
MultiByteToWideCharSZ(CP_UTF8, 0, pVal, -1, dest, destlen);
|
|
MP4Free(pVal);
|
|
}
|
|
else if (pVal_utf16)
|
|
{
|
|
StringCchCopyW(dest, destlen, (const wchar_t *)pVal_utf16);
|
|
MP4Free(pVal_utf16);
|
|
}
|
|
|
|
if (!success)
|
|
dest[0] = 0;
|
|
|
|
//MP4Close(getFileInfoMP4);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
static MP4FileHandle setFileInfoMP4 = 0;
|
|
static int m_last_err = 0;
|
|
static wchar_t m_last_ext_fn[MAX_PATH] = L"";
|
|
static void *setFileInfoReader = 0;
|
|
static bool setFile3GP=false;
|
|
|
|
/*static int SetExtendedInfo3GP(const char *data, const wchar_t *val)
|
|
{
|
|
if (KeywordMatch(data, "title"))
|
|
{
|
|
if (val && *val) MP4Set3GPMetadata(setFileInfoMP4, "titl", (const uint16_t *)val);
|
|
else MP4Delete3GPMetadata(setFileInfoMP4, "titl");
|
|
}
|
|
else if (KeywordMatch(data, "album"))
|
|
{
|
|
if (val && *val) MP4Set3GPMetadata(setFileInfoMP4, "albm", (const uint16_t *)val);
|
|
else MP4Delete3GPMetadata(setFileInfoMP4, "albm");
|
|
}
|
|
else if (KeywordMatch(data, "genre"))
|
|
{
|
|
if (val && *val) MP4Set3GPMetadata(setFileInfoMP4, "gnre", (const uint16_t *)val);
|
|
else MP4Delete3GPMetadata(setFileInfoMP4, "gnre");
|
|
}
|
|
else if (KeywordMatch(data, "artist"))
|
|
{
|
|
if (val && *val) MP4Set3GPMetadata(setFileInfoMP4, "perf", (const uint16_t *)val);
|
|
else MP4Delete3GPMetadata(setFileInfoMP4, "perf");
|
|
}
|
|
else if (KeywordMatch(data, "year"))
|
|
{
|
|
if (val && *val) MP4Set3GPMetadataInteger(setFileInfoMP4, "yrrc", _wtoi64(val));
|
|
else MP4Delete3GPMetadata(setFileInfoMP4, "yrrc");
|
|
}
|
|
else
|
|
return 0;
|
|
|
|
return 1;
|
|
}*/
|
|
|
|
static int SetExtendedInfoMP4(const char *data, const wchar_t *val)
|
|
{
|
|
if (KeywordMatch(data, "title"))
|
|
{
|
|
if (val && *val) MP4SetMetadataName(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataName(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "album"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataAlbum(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataAlbum(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "artist"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataArtist(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataArtist(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "rating"))
|
|
{
|
|
if (val && *val)
|
|
{
|
|
char temp[128] = {0};
|
|
StringCchPrintfA(temp, 128, "%u", _wtoi(val) * 20);
|
|
MP4SetMetadataRating(setFileInfoMP4, temp);
|
|
}
|
|
else MP4DeleteMetadataRating(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "comment"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataComment(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataComment(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "year"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataYear(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataYear(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "genre"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataGenre(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataGenre(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "albumartist"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataAlbumArtist(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataAlbumArtist(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_track_gain"))
|
|
{
|
|
if (val && *val)
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_track_gain", "com.apple.iTunes");
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "replaygain_track_gain", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "org.hydrogenaudio.replaygain");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_track_gain", "com.apple.iTunes");
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_track_gain", "org.hydrogenaudio.replaygain");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_track_peak"))
|
|
{
|
|
if (val && *val)
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_track_peak", "com.apple.iTunes");
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "replaygain_track_peak", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "org.hydrogenaudio.replaygain");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_track_peak", "com.apple.iTunes");
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_track_peak", "org.hydrogenaudio.replaygain");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_album_gain"))
|
|
{
|
|
if (val && *val)
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_album_gain", "com.apple.iTunes");
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "replaygain_album_gain", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "org.hydrogenaudio.replaygain");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_album_gain", "com.apple.iTunes");
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_album_gain", "org.hydrogenaudio.replaygain");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "replaygain_album_peak"))
|
|
{
|
|
if (val && *val)
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_album_peak", "com.apple.iTunes");
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "replaygain_album_peak", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "org.hydrogenaudio.replaygain");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_album_peak", "com.apple.iTunes");
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "replaygain_album_peak", "org.hydrogenaudio.replaygain");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "track"))
|
|
{
|
|
int track = _wtoi(val);
|
|
if (track)
|
|
{
|
|
int tracks = 0;
|
|
const wchar_t *_tracks = wcschr(val, L'/');
|
|
if (_tracks) tracks = _wtoi(_tracks + 1);
|
|
MP4SetMetadataTrack(setFileInfoMP4, track, tracks);
|
|
}
|
|
else
|
|
MP4DeleteMetadataTrack(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "disc"))
|
|
{
|
|
int disc = _wtoi(val);
|
|
if (disc)
|
|
{
|
|
int discs = 0;
|
|
const wchar_t *_discs = wcschr(val, L'/');
|
|
if (_discs) discs = _wtoi(_discs + 1);
|
|
MP4SetMetadataDisk(setFileInfoMP4, disc, discs);
|
|
}
|
|
else
|
|
MP4DeleteMetadataDisk(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "tool"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataTool(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataTool(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "bpm"))
|
|
{
|
|
if (val && *val && *val != '0')
|
|
MP4SetMetadataTempo(setFileInfoMP4, _wtoi(val));
|
|
else
|
|
MP4DeleteMetadataTempo(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "composer"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataWriter(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataWriter(setFileInfoMP4);
|
|
}
|
|
else if (KeywordMatch(data, "GracenoteFileID"))
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "gnid", "com.apple.iTunes"); // delete obselete metadata storage scheme
|
|
if (val && *val)
|
|
{
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "gnid", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "com.gracenote.cddb");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "gnid", "com.gracenote.cddb");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "GracenoteExtData"))
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "gnxd", "com.apple.iTunes");// delete obselete metadata storage scheme
|
|
if (val && *val)
|
|
{
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "gnxd", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "com.gracenote.cddb");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "gnxd", "com.gracenote.cddb");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "publisher"))
|
|
{
|
|
if (val && *val)
|
|
{
|
|
AutoChar utf8(val, CP_UTF8);
|
|
MP4SetMetadataFreeForm(setFileInfoMP4, "publisher", (u_int8_t *)(char *)utf8, lstrlenA(utf8), "com.nullsoft.winamp");
|
|
}
|
|
else
|
|
{
|
|
MP4DeleteMetadataFreeForm(setFileInfoMP4, "publisher", "com.nullsoft.winamp");
|
|
}
|
|
}
|
|
else if (KeywordMatch(data, "category"))
|
|
{
|
|
if (val && *val)
|
|
MP4SetMetadataGrouping(setFileInfoMP4, AutoChar(val, CP_UTF8));
|
|
else MP4DeleteMetadataGrouping(setFileInfoMP4);
|
|
}
|
|
else
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static Stopper stopper;
|
|
|
|
__declspec( dllexport ) int winampSetExtendedFileInfoW(const wchar_t *fn, const char *data, const wchar_t *val)
|
|
{
|
|
if (!setFileInfoMP4 || lstrcmpi(m_last_ext_fn, fn)) // different file than last time?
|
|
{
|
|
m_last_err = 0;
|
|
lstrcpyn(m_last_ext_fn, fn, MAX_PATH);
|
|
|
|
if (setFileInfoMP4)
|
|
MP4Close(setFileInfoMP4);
|
|
|
|
/* TODO: make MP4ModifyEx so we can use this
|
|
if (setFileInfoReader)
|
|
DestroyUnicodeReader(setFileInfoReader);
|
|
|
|
setFileInfoReader = CreateUnicodeReader(fn);
|
|
if (!setFileInfoReader)
|
|
return 0;
|
|
*/
|
|
|
|
if (!_wcsicmp(m_last_ext_fn, lastfn))
|
|
stopper.Stop();
|
|
|
|
setFileInfoMP4 = MP4Modify(m_last_ext_fn, 0, 0);
|
|
if (!setFileInfoMP4)
|
|
{
|
|
stopper.ChangeTracking(1); // enable stats updating
|
|
//DestroyUnicodeReader(setFileInfoReader);
|
|
m_last_err = 1;
|
|
return 0;
|
|
}
|
|
|
|
setFile3GP = false;
|
|
const char *brand=0;
|
|
if (MP4GetStringProperty(setFileInfoMP4, "ftyp.majorBrand", &brand))
|
|
{
|
|
if (!strncmp(brand, "3gp6", 4))
|
|
setFile3GP=true;
|
|
}
|
|
}
|
|
/*
|
|
if (setFile3GP)
|
|
return SetExtendedInfo3GP(data, val);
|
|
else*/
|
|
return SetExtendedInfoMP4(data, val);
|
|
|
|
}
|
|
|
|
__declspec(dllexport) int winampWriteExtendedFileInfo()
|
|
{
|
|
int err = m_last_err;
|
|
m_last_err = 0;
|
|
|
|
// clear this as well, so dirty info isn't read back
|
|
if (getFileInfoMP4)
|
|
MP4Close(getFileInfoMP4);
|
|
getFileInfoMP4=0;
|
|
|
|
if (getFileInfoReader)
|
|
DestroyUnicodeReader(getFileInfoReader);
|
|
getFileInfoReader=0;
|
|
|
|
if (setFileInfoMP4)
|
|
{
|
|
MP4Close(setFileInfoMP4);
|
|
MP4Optimize(m_last_ext_fn, NULL, 0); //put the fields at the beginning of the file
|
|
setFileInfoMP4 = 0;
|
|
m_last_ext_fn[0] = 0;
|
|
stopper.Play();
|
|
}
|
|
|
|
// update last modified so we're not re-queried on our own updates
|
|
UpdateFileTimeChanged(m_last_ext_fn);
|
|
|
|
return !err;
|
|
}
|
|
} |