406 lines
13 KiB
C++
406 lines
13 KiB
C++
#include "main.h"
|
|
#include "ml_local.h"
|
|
#include <shlwapi.h>
|
|
#include <assert.h>
|
|
#include "../nu/sort.h"
|
|
|
|
/*
|
|
#ifdef _M_IX86
|
|
#undef min
|
|
static inline int min(int x, int y)
|
|
{
|
|
return y+((x-y)>>31)&(x-y);
|
|
}
|
|
#undef max
|
|
static inline int max(int x, int y)
|
|
{
|
|
return x-(((x-y)>>(31))&(x-y));
|
|
}
|
|
|
|
#elif defined(_WIN64)
|
|
#undef min
|
|
static inline int min(int x, int y)
|
|
{
|
|
return y+((x-y)>>63)&(x-y);
|
|
}
|
|
#undef max
|
|
static inline int max(int x, int y)
|
|
{
|
|
return x-(((x-y)>>(63))&(x-y));
|
|
}
|
|
#endif
|
|
*/
|
|
|
|
#ifdef _M_IX86
|
|
const size_t convert_max_characters = 16; // it's actually 11, but this probably causes less memory fragmentation
|
|
#elif defined(_M_X64)
|
|
const size_t convert_max_characters = 20;
|
|
#endif
|
|
|
|
static inline int Compare_Int_NegativeIsNull(int v1, int v2)
|
|
{
|
|
v1 = max(v1,0);
|
|
v2 = max(v2,0);
|
|
return(v1 - v2);
|
|
}
|
|
|
|
typedef int (__fastcall *SortFunction)(const itemRecordW *a, const itemRecordW *b);
|
|
#define SORT(field) SortBy ## field
|
|
#define STRING_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { return WCSCMP_NULLOK(a->field, b->field); }
|
|
#define EXT_STRING_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { wchar_t *a_field = getRecordExtendedItem_fast(a, extended_fields.field); wchar_t *b_field = getRecordExtendedItem_fast(b, extended_fields.field); return WCSCMP_NULLOK(a_field, b_field);}
|
|
#define TIME_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { time_t v1 = (time_t)a->field; time_t v2 = (time_t)b->field; if (v1 == -1) v1 = 0; if (v2 == -1) v2 = 0; return (int)(v1 - v2);}
|
|
#define EXT_TIME_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { wchar_t *a_field = getRecordExtendedItem_fast(a, extended_fields.dateadded); wchar_t *b_field = getRecordExtendedItem_fast(b, extended_fields.dateadded); time_t v1 = a_field?_wtoi(a_field):0; time_t v2 = b_field?_wtoi(b_field):0; if (v1 == -1) v1 = 0; if (v2 == -1) v2 = 0; return (int)(v1 - v2);}
|
|
#define INT_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { return Compare_Int_NegativeIsNull(a->field, b->field); }
|
|
#define EXT_INT_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { wchar_t *a_field = getRecordExtendedItem_fast(a, extended_fields.field); wchar_t *b_field = getRecordExtendedItem_fast(b, extended_fields.field); int v1 = a_field?_wtoi(a_field):0; int v2 = b_field?_wtoi(b_field):0; return (v1-v2);}
|
|
#define FLOAT_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { return FLOATWCMP_NULLOK(a->field, b->field); }
|
|
STRING_SORT(artist);
|
|
STRING_SORT(title);
|
|
STRING_SORT(album);
|
|
INT_SORT(length);
|
|
INT_SORT(track);
|
|
STRING_SORT(genre);
|
|
INT_SORT(year);
|
|
static int __fastcall SORT(filespec)(const itemRecordW *a, const itemRecordW *b)
|
|
{
|
|
// remove path before compare...
|
|
wchar_t * af = L"";
|
|
if (a->filename)
|
|
af = PathFindFileNameW(a->filename);
|
|
|
|
wchar_t * bf = L"";
|
|
if (b->filename)
|
|
bf = PathFindFileNameW(b->filename);
|
|
|
|
return _wcsicmp(af, bf);
|
|
}
|
|
|
|
INT_SORT(rating);
|
|
INT_SORT(playcount);
|
|
TIME_SORT(lastplay);
|
|
TIME_SORT(lastupd);
|
|
TIME_SORT(filetime);
|
|
STRING_SORT(comment);
|
|
INT_SORT(filesize);
|
|
INT_SORT(bitrate);
|
|
INT_SORT(type);
|
|
INT_SORT(disc);
|
|
STRING_SORT(albumartist);
|
|
STRING_SORT(filename);
|
|
FLOAT_SORT(replaygain_album_gain);
|
|
FLOAT_SORT(replaygain_track_gain);
|
|
STRING_SORT(publisher);
|
|
STRING_SORT(composer);
|
|
static int __fastcall SORT(extension)(const itemRecordW *a, const itemRecordW *b)
|
|
{
|
|
wchar_t *extA = PathFindExtensionW(a->filename);
|
|
wchar_t *extB = PathFindExtensionW(b->filename);
|
|
if (extA && *extA)
|
|
extA++;
|
|
if (extB && *extB)
|
|
extB++;
|
|
return WCSCMP_NULLOK(extA, extB);
|
|
}
|
|
EXT_INT_SORT(ispodcast);
|
|
EXT_STRING_SORT(podcastchannel);
|
|
EXT_STRING_SORT(podcastpubdate);
|
|
INT_SORT(bpm);
|
|
STRING_SORT(category);
|
|
EXT_STRING_SORT(director);
|
|
EXT_STRING_SORT(producer);
|
|
EXT_TIME_SORT(dateadded);
|
|
EXT_STRING_SORT(cloud);
|
|
|
|
static int __fastcall SORT(dimension)(const itemRecordW *a, const itemRecordW *b)
|
|
{
|
|
wchar_t *a_width = getRecordExtendedItem_fast(a, extended_fields.width);
|
|
wchar_t *b_width = getRecordExtendedItem_fast(b, extended_fields.width);
|
|
wchar_t *a_height = getRecordExtendedItem_fast(a, extended_fields.height);
|
|
wchar_t *b_height = getRecordExtendedItem_fast(b, extended_fields.height);
|
|
int w1 = a_width?_wtoi(a_width):0;
|
|
int w2 = b_width?_wtoi(b_width):0;
|
|
int h1 = a_height?_wtoi(a_height):0;
|
|
int h2 = b_height?_wtoi(b_height):0;
|
|
if (w1 != w2)
|
|
return (w1-w2);
|
|
else
|
|
return (h1-h2);
|
|
}
|
|
// DISABLED FOR 5.62 RELEASE - DRO
|
|
//EXT_STRING_SORT(codec);
|
|
|
|
#define FORCE_ASCENDING ((SortFunction)-2)
|
|
// this is where we define sort orders!
|
|
static const SortFunction sortOrder[MEDIAVIEW_COL_NUMS][MEDIAVIEW_COL_NUMS+2] =
|
|
{
|
|
{SORT(artist), FORCE_ASCENDING, SORT(album), SORT(disc), SORT(track), SORT(title), 0}, // Artist
|
|
{SORT(title), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(album), FORCE_ASCENDING, SORT(albumartist), SORT(disc), SORT(track), SORT(title), 0},
|
|
{SORT(length), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(track), FORCE_ASCENDING, SORT(title), SORT(artist), SORT(album), SORT(disc), 0},
|
|
{SORT(genre), FORCE_ASCENDING, SORT(albumartist), SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(year), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(filespec), SORT(filename),0},
|
|
{SORT(rating), SORT(playcount), SORT(lastplay), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(playcount), SORT(lastplay), FORCE_ASCENDING,SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(lastplay), FORCE_ASCENDING,SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(lastupd), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(filetime), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(comment), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(filesize),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(bitrate), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(type), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(disc), FORCE_ASCENDING, SORT(track), SORT(title), SORT(artist), SORT(album), SORT(disc), 0},
|
|
{SORT(albumartist), FORCE_ASCENDING, SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(filename), 0},
|
|
{SORT(replaygain_album_gain), FORCE_ASCENDING, SORT(album), SORT(disc), SORT(track), SORT(title), 0},
|
|
{SORT(replaygain_track_gain), FORCE_ASCENDING, SORT(title), 0},
|
|
{SORT(publisher),FORCE_ASCENDING,SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0},
|
|
{SORT(composer), FORCE_ASCENDING,SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(extension), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(ispodcast), FORCE_ASCENDING, SORT(podcastchannel), SORT(title), 0},
|
|
{SORT(podcastchannel), SORT(title), 0},
|
|
{SORT(podcastpubdate), 0},
|
|
{SORT(bpm), 0}, // TODO
|
|
{SORT(category),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0},
|
|
{SORT(director),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0},
|
|
{SORT(producer),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0},
|
|
{SORT(dimension), 0},
|
|
// DISABLED FOR 5.62 RELEASE - DRO
|
|
//{SORT(codec), 0},
|
|
{SORT(dateadded), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
{SORT(cloud), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0},
|
|
};
|
|
|
|
/* ---- */
|
|
struct SortRules
|
|
{
|
|
int by;
|
|
int dir;
|
|
};
|
|
static int __fastcall sortFuncW(const void *elem1, const void *elem2, const void *context)
|
|
{
|
|
assert(sizeof(sortOrder) / sizeof(*sortOrder) == MEDIAVIEW_COL_NUMS);
|
|
|
|
const itemRecordW *a = (const itemRecordW*)elem1;
|
|
const itemRecordW *b = (const itemRecordW*)elem2;
|
|
|
|
const SortRules *rules = (SortRules *)context;
|
|
int use_by = rules->by;
|
|
int use_dir = !!rules->dir;
|
|
|
|
int dir_values[] = {-1, 1};
|
|
|
|
#define RETIFNZ(v) if ((v)<0) return dir_values[use_dir]; if ((v)>0) return -dir_values[use_dir];
|
|
|
|
const SortFunction *order =sortOrder[use_by];
|
|
int i=0;
|
|
while (order[i])
|
|
{
|
|
if (order[i]==FORCE_ASCENDING)
|
|
{
|
|
use_dir=0;
|
|
i++;
|
|
continue;
|
|
}
|
|
int v = order[i](a, b);
|
|
RETIFNZ(v);
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void sortResults(int column, int dir, itemRecordListW *obj) // sorts the results based on the current sort mode
|
|
{
|
|
if (obj->Size > 1)
|
|
{
|
|
SortRules rules = {column, dir};
|
|
qsort_itemRecord(obj->Items, obj->Size, &rules, sortFuncW);
|
|
}
|
|
}
|
|
|
|
void sortResults(C_Config *viewconf, itemRecordListW *obj) // sorts the results based on the current sort mode
|
|
{
|
|
if (viewconf)
|
|
{
|
|
SortRules rules = {viewconf->ReadInt(L"mv_sort_by", MEDIAVIEW_COL_ARTIST), viewconf->ReadInt(L"mv_sort_dir", 0)};
|
|
if (obj->Size > 1)
|
|
qsort_itemRecord(obj->Items, obj->Size, &rules, sortFuncW);
|
|
}
|
|
}
|
|
|
|
void setCloudValue(itemRecordW *item, const wchar_t* value)
|
|
{
|
|
wchar_t *temp = ndestring_malloc(convert_max_characters*sizeof(wchar_t));
|
|
lstrcpynW(temp, value, convert_max_characters);
|
|
setRecordExtendedItem(item, extended_fields.cloud, temp);
|
|
ndestring_release(temp);
|
|
}
|
|
|
|
int saveQueryToListW(C_Config *viewconf, nde_scanner_t s, itemRecordListW *obj,
|
|
CloudFiles *uploaded, CloudFiles *uploading,
|
|
resultsniff_funcW cb, int user32, int *killswitch, __int64 *total_bytes)
|
|
{
|
|
__int64 total_kb = 0;
|
|
|
|
emptyRecordList(obj);
|
|
|
|
EnterCriticalSection(&g_db_cs);
|
|
NDE_Scanner_First(s, killswitch);
|
|
if (killswitch && *killswitch)
|
|
{
|
|
LeaveCriticalSection(&g_db_cs);
|
|
return 0;
|
|
}
|
|
|
|
int r = 0;
|
|
unsigned int total_length_s = 0;
|
|
unsigned int uncert_cnt = 0;
|
|
unsigned int cert_cnt = 0;
|
|
int recordCount = NDE_Scanner_GetRecordsCount(s);
|
|
allocRecordList(obj, recordCount);
|
|
do
|
|
{
|
|
nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME);
|
|
if (f)
|
|
{
|
|
allocRecordList(obj, obj->Size + 1);
|
|
if (!obj->Alloc) break;
|
|
|
|
obj->Items[obj->Size].filename = NDE_StringField_GetString(f);
|
|
ndestring_retain(obj->Items[obj->Size].filename);
|
|
total_kb += ScannerRefToObjCacheNFNW(s, obj, (cb == (resultsniff_funcW)-1 ? true : false));
|
|
|
|
// look for any files known to the cloud so the icon can be set accordingly
|
|
// TODO possibly need to do more here to better cope with transient states??
|
|
if (uploaded && uploaded->size() > 0)
|
|
{
|
|
bool found = false;
|
|
for(CloudFiles::iterator iter = uploaded->begin(); iter != uploaded->end(); iter++)
|
|
{
|
|
if (nde_wcsicmp_fn(obj->Items[obj->Size - 1].filename,(*iter)) == 0)
|
|
{
|
|
bool pending = false;
|
|
found = true;
|
|
|
|
// catches files being uploaded but not fully known to be in the cloud, etc
|
|
if (uploading && uploading->size() > 0)
|
|
{
|
|
for(CloudFiles::iterator iter2 = uploading->begin(); iter2 != uploading->end(); iter2++)
|
|
{
|
|
if (nde_wcsicmp_fn(obj->Items[obj->Size - 1].filename,(*iter2)) == 0)
|
|
{
|
|
pending = true;
|
|
setCloudValue(&obj->Items[obj->Size - 1], L"5");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!pending)
|
|
{
|
|
setCloudValue(&obj->Items[obj->Size - 1], L"0");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
// catches files being uploaded but not fully known to be in the cloud, etc
|
|
if (uploading && uploading->size() > 0)
|
|
{
|
|
for(CloudFiles::iterator iter = uploading->begin(); iter != uploading->end(); iter++)
|
|
{
|
|
if (nde_wcsicmp_fn(obj->Items[obj->Size - 1].filename,(*iter)) == 0)
|
|
{
|
|
found = true;
|
|
setCloudValue(&obj->Items[obj->Size - 1], L"5");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
setCloudValue(&obj->Items[obj->Size - 1], L"4");
|
|
}
|
|
}
|
|
}
|
|
|
|
int thisl = obj->Items[obj->Size - 1].length;
|
|
|
|
if (thisl > 0)
|
|
{
|
|
total_length_s += thisl;
|
|
cert_cnt++;
|
|
}
|
|
else
|
|
{
|
|
uncert_cnt++;
|
|
}
|
|
}
|
|
|
|
r = NDE_Scanner_Next(s, killswitch);
|
|
if (killswitch && *killswitch)
|
|
{
|
|
LeaveCriticalSection(&g_db_cs);
|
|
return 0;
|
|
}
|
|
}
|
|
while (r && !NDE_Scanner_EOF(s));
|
|
|
|
if (((Table *)g_table)->HasErrors()) // TODO: don't use C++ NDE API
|
|
{
|
|
wchar_t *last_query = NULL;
|
|
if (m_media_scanner)
|
|
{
|
|
const wchar_t *lq = NDE_Scanner_GetLastQuery(m_media_scanner);
|
|
if (lq) last_query = _wcsdup(lq);
|
|
NDE_Table_DestroyScanner(g_table, m_media_scanner);
|
|
}
|
|
NDE_Table_Compact(g_table);
|
|
if (m_media_scanner)
|
|
{
|
|
m_media_scanner = NDE_Table_CreateScanner(g_table);
|
|
if (last_query != NULL)
|
|
{
|
|
NDE_Scanner_Query(m_media_scanner, last_query);
|
|
free(last_query);
|
|
}
|
|
}
|
|
}
|
|
LeaveCriticalSection(&g_db_cs);
|
|
|
|
if (total_bytes)
|
|
{
|
|
// maintain compatibility as needed
|
|
if (cb == (resultsniff_funcW)-1)
|
|
*total_bytes = total_kb * 1024;
|
|
else
|
|
*total_bytes = total_kb;
|
|
}
|
|
compactRecordList(obj);
|
|
|
|
if (cb && cb != (resultsniff_funcW)-1)
|
|
{
|
|
cb(obj->Items, obj->Size, user32, killswitch);
|
|
}
|
|
|
|
if (killswitch && *killswitch) return 0;
|
|
|
|
sortResults(viewconf, obj);
|
|
|
|
if (killswitch && *killswitch) return 0;
|
|
|
|
if (uncert_cnt)
|
|
{
|
|
if (cert_cnt)
|
|
{
|
|
__int64 avg_len = (__int64)total_length_s / cert_cnt;
|
|
total_length_s += (DWORD)(avg_len * uncert_cnt);
|
|
}
|
|
total_length_s |= (1 << 31);
|
|
}
|
|
|
|
return total_length_s;
|
|
} |