winamp/Src/Plugins/Library/ml_local/ReIndexUI.cpp

333 lines
9.3 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
#include "Main.h"
#include "ml_local.h"
#include "resource.h"
static INT_PTR CALLBACK CompactWndProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, lParam);
SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETRANGE, 0, MAKELPARAM(0, 400));
SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, 0, 0);
int *progress = (int *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
if (progress[1] == -102)
{
progress[1] = -101;
SetWindowTextW(hwndDlg, WASABI_API_LNGSTRINGW(IDS_REFRESH_FILESIZE_DATEADDED));
}
SetTimer(hwndDlg, 666, 500, 0);
break;
}
case WM_TIMER:
if (wParam == 666)
{
int *progress = (int *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
if (progress[0] == 666)
{
KillTimer(hwndDlg, 666);
EndDialog(hwndDlg, 0);
}
else if (progress[1] != -101)
{
SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, progress[1] + 300, 0);
}
else
{
SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, progress[0] + 100, 0);
}
}
break;
}
return 0;
}
static DWORD CALLBACK CompactThread(LPVOID param)
{
WASABI_API_DIALOGBOXPARAMW(IDD_REINDEX, NULL, CompactWndProc, (LPARAM)param);
return 0;
}
static int sortFunc(const void *a, const void *b)
{
const wchar_t **fn1 = (const wchar_t **)a;
const wchar_t **fn2 = (const wchar_t **)b;
return _wcsicmp(*fn1, *fn2);
}
void RetypeFilename(nde_table_t table)
{
int totalRecords = NDE_Table_GetRecordsCount(g_table);
if (totalRecords == 0) // bail out early so we don't flash a dialog
return;
int progress[2] = {-100, -101};
DWORD threadId = 0;
HANDLE compactThread = 0;
nde_scanner_t pruneScanner = NDE_Table_CreateScanner(table);
if (pruneScanner)
{
bool first=true;
int recordNum = 0;
NDE_Scanner_First(pruneScanner);
while (!NDE_Scanner_EOF(pruneScanner))
{
progress[0] = MulDiv(recordNum, 100, totalRecords)-100;
nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, MAINTABLE_ID_FILENAME);
if (f && NDE_Field_GetType(f) == FIELD_STRING)
{
wchar_t *s = NDE_StringField_GetString(f);
ndestring_retain(s);
NDE_Scanner_DeleteField(pruneScanner, f);
nde_field_t new_f = NDE_Scanner_NewFieldByID(pruneScanner, MAINTABLE_ID_FILENAME);
NDE_StringField_SetString(new_f, s);
ndestring_release(s);
NDE_Scanner_Post(pruneScanner);
}
else if (f)
{
first = false; // skips creating the thread
break;
}
recordNum++;
NDE_Scanner_Next(pruneScanner);
if (first)
{
compactThread = CreateThread(0, 0, CompactThread, progress, 0, &threadId);
DumpArtCache(); // go ahead and dump the album art cache if we had to rebuild this table. ideally we could perform the same logic but this is easier and it's 1 in the morning and i don't feel like doing it :)
}
first=false;
}
NDE_Table_DestroyScanner(table, pruneScanner);
if (compactThread)
NDE_Table_Sync(table);
}
progress[0] = 666;
if (compactThread)
{
WaitForSingleObject(compactThread, INFINITE);
CloseHandle(compactThread);
}
}
void RefreshFileSizeAndDateAddedTable(nde_table_t table)
{
int totalRecords = NDE_Table_GetRecordsCount(g_table);
if (totalRecords == 0) // bail out early so we don't flash a dialog
return;
int progress[2] = {-100, -102};
DWORD threadId = 0;
HANDLE compactThread = 0;
nde_scanner_t scanner = NDE_Table_CreateScanner(table);
if (scanner)
{
bool first=true;
int recordNum = 0;
NDE_Scanner_First(scanner);
while (!NDE_Scanner_EOF(scanner))
{
progress[0] = MulDiv(recordNum, 400, totalRecords);
// converts filesize from a int and kb scaled value to the actual filesize as a int64
nde_field_t f = NDE_Scanner_GetFieldByID(scanner, MAINTABLE_ID_FILESIZE);
if (f && NDE_Field_GetType(f) == FIELD_INTEGER)
{
__int64 size = NDE_IntegerField_GetValue(f);
if (size) size *= 1024;
NDE_Scanner_DeleteField(scanner, f);
nde_field_t new_f = NDE_Scanner_NewFieldByType(scanner, FIELD_INT64, MAINTABLE_ID_FILESIZE);
NDE_Int64Field_SetValue(new_f, size);
NDE_Scanner_Post(scanner);
}
// takes the lastupd value and applies it to dateadded so we've got something to use
f = NDE_Scanner_GetFieldByID(scanner, MAINTABLE_ID_LASTUPDTIME);
if (f && NDE_Field_GetType(f) == FIELD_DATETIME)
{
int lastupd = NDE_IntegerField_GetValue(f);
nde_field_t new_f = NDE_Scanner_NewFieldByID(scanner, MAINTABLE_ID_DATEADDED);
NDE_IntegerField_SetValue(new_f, lastupd);
NDE_Scanner_Post(scanner);
}
NDE_Scanner_Next(scanner);
recordNum++;
if (first)
{
compactThread = CreateThread(0, 0, CompactThread, progress, 0, &threadId);
}
first=false;
}
NDE_Table_DestroyScanner(table, scanner);
if (compactThread)
NDE_Table_Sync(table);
}
progress[0] = 666;
if (compactThread)
{
WaitForSingleObject(compactThread, INFINITE);
CloseHandle(compactThread);
}
}
void ReindexTable(nde_table_t table)
{
int totalRecords = NDE_Table_GetRecordsCount(g_table);
if (totalRecords == 0) // bail out early so we don't flash a dialog
return;
int progress[2] = {-100, -101};
DWORD threadId;
HANDLE compactThread = CreateThread(0, 0, CompactThread, progress, 0, &threadId);
nde_scanner_t pruneScanner = NDE_Table_CreateScanner(table);
if (pruneScanner)
{
int recordNum = 0;
NDE_Scanner_First(pruneScanner);
while (!NDE_Scanner_EOF(pruneScanner))
{
int total = MulDiv(recordNum, 100, totalRecords);
progress[0] = total - 100;
#ifndef elementsof
#define elementsof(x) (sizeof(x)/sizeof(*x))
#endif
unsigned char STR_IDS[] = {MAINTABLE_ID_TITLE, MAINTABLE_ID_ARTIST, MAINTABLE_ID_ALBUM, MAINTABLE_ID_GENRE,
MAINTABLE_ID_COMMENT, MAINTABLE_ID_GRACENOTE_ID, MAINTABLE_ID_ALBUMARTIST,
MAINTABLE_ID_TRACKGAIN, MAINTABLE_ID_PUBLISHER, MAINTABLE_ID_COMPOSER,
MAINTABLE_ID_PODCASTCHANNEL, MAINTABLE_ID_GRACENOTEFILEID, MAINTABLE_ID_GRACENOTEEXTDATA,
MAINTABLE_ID_CATEGORY, MAINTABLE_ID_CODEC, MAINTABLE_ID_DIRECTOR, MAINTABLE_ID_PRODUCER
};
for (size_t i = 0;i != elementsof(STR_IDS);i++)
{
nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, STR_IDS[i]);
if (f)
{
const wchar_t *s = NDE_StringField_GetString(f);
if (!s || !*s)
{
NDE_Scanner_DeleteField(pruneScanner, f);
NDE_Scanner_Post(pruneScanner);
}
}
}
unsigned char INT_IDS_ZEROOK[] = {MAINTABLE_ID_LENGTH, MAINTABLE_ID_PLAYCOUNT, MAINTABLE_ID_FILESIZE,
MAINTABLE_ID_TYPE, MAINTABLE_ID_ISPODCAST, MAINTABLE_ID_LOSSLESS
};
for (size_t i = 0;i != elementsof(INT_IDS_ZEROOK);i++)
{
nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, INT_IDS_ZEROOK[i]);
if (f)
{
int s = NDE_IntegerField_GetValue(f);
if (s < 0)
{
NDE_Scanner_DeleteField(pruneScanner, f);
NDE_Scanner_Post(pruneScanner);
}
}
}
unsigned char INT_IDS[] = {MAINTABLE_ID_TRACKNB, MAINTABLE_ID_LASTUPDTIME, MAINTABLE_ID_LASTPLAY, MAINTABLE_ID_RATING,
MAINTABLE_ID_FILETIME, MAINTABLE_ID_BITRATE, MAINTABLE_ID_DISC, MAINTABLE_ID_BPM, MAINTABLE_ID_DISCS,
MAINTABLE_ID_TRACKS, MAINTABLE_ID_PODCASTPUBDATE, MAINTABLE_ID_FILESIZE, MAINTABLE_ID_DATEADDED
};
for (size_t i = 0;i != elementsof(INT_IDS);i++)
{
nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, INT_IDS[i]);
if (f)
{
int s = NDE_IntegerField_GetValue(f);
if (s <= 0)
{
NDE_Scanner_DeleteField(pruneScanner, f);
NDE_Scanner_Post(pruneScanner);
}
}
}
NDE_Scanner_Next(pruneScanner);
recordNum++;
}
NDE_Table_DestroyScanner(table, pruneScanner);
NDE_Table_Sync(table);
}
NDE_Table_Compact(table, &progress[0]);
assert(((Table *)table)->CheckIndexing());
// now remove duplicates
nde_scanner_t dupscanner = NDE_Table_CreateScanner(table);
if (dupscanner)
{
int count = NDE_Scanner_GetRecordsCount(dupscanner);
wchar_t **filenames = new wchar_t *[count];
int i = 0;
for (NDE_Scanner_First(dupscanner);!NDE_Scanner_EOF(dupscanner);NDE_Scanner_Next(dupscanner))
{
nde_field_t fileName = NDE_Scanner_GetFieldByID(dupscanner, MAINTABLE_ID_FILENAME);
if (fileName)
{
filenames[i] = NDE_StringField_GetString(fileName);
ndestring_retain(filenames[i]);
i++;
}
}
count = i;
if (count)
{
qsort(filenames, count, sizeof(wchar_t *), sortFunc);
for (int x = 0;x < (count - 1);x++)
{
int total = MulDiv(x, 100, count);
progress[1] = total - 100;
if (!_wcsicmp(filenames[x], filenames[x+1]))
{
wchar_t query[1024] = {0};
wnsprintfW(query, 1024, L"filename == \"%s\"", filenames[x]);
nde_scanner_t scanner = NDE_Table_CreateScanner(table);
NDE_Scanner_Query(scanner, query);
NDE_Scanner_First(scanner);
NDE_Scanner_Next(scanner);
while (!NDE_Scanner_EOF(scanner))
{
NDE_Scanner_Delete(scanner);
NDE_Scanner_Post(scanner);
NDE_Scanner_Next(scanner);
}
NDE_Table_DestroyScanner(table, scanner);
}
ndestring_release(filenames[x]);
filenames[x]=0;
}
}
delete[] filenames;
}
NDE_Table_DestroyScanner(table, dupscanner);
NDE_Table_Sync(table);
NDE_Table_Compact(table, &progress[1]);
progress[0] = 666;
WaitForSingleObject(compactThread, INFINITE);
CloseHandle(compactThread);
}