diff options
Diffstat (limited to 'Src/Plugins/Library/ml_local/SaveQuery.cpp')
| -rw-r--r-- | Src/Plugins/Library/ml_local/SaveQuery.cpp | 406 |
1 files changed, 406 insertions, 0 deletions
diff --git a/Src/Plugins/Library/ml_local/SaveQuery.cpp b/Src/Plugins/Library/ml_local/SaveQuery.cpp new file mode 100644 index 00000000..35cac30c --- /dev/null +++ b/Src/Plugins/Library/ml_local/SaveQuery.cpp @@ -0,0 +1,406 @@ +#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; +}
\ No newline at end of file |