Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-18 13:55:51 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
09cb3a54ed
winamp/Src/Winamp/PlayList.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

2126 lines
51 KiB
C++
Raw Blame History

#include "Main.h"
#include <assert.h>
#include "MoreItems.h"
#include "AdData.h"
#include "../nu/AutoLock.h"
#include "strutil.h"
#include "../nu/AutoCharFn.h"
#include "../nu/AutoChar.h"
#include "../nu/AutoWide.h"
#include "../nu/ns_wc.h"
#include "WinampPlaylist.h"
#include <algorithm>
#include "api.h"
#include "../WAT/WAT.h"
using namespace Nullsoft::Utility;
LockGuard playlistGuard(512);
#define MALLOC_CHUNK 512
static int _lastlen = -1;
extern "C"
{
static wchar_t *_plstring_wcsdup( const wchar_t *str )
{
if ( !str )
return 0;
size_t len = wcslen( str );
size_t *self = (size_t *)malloc( sizeof( size_t ) + ( len + 1 ) * sizeof( wchar_t ) );
*self = 1;
wchar_t *new_str = (wchar_t *)( ( (int8_t *)self ) + sizeof( size_t ) );
memcpy( new_str, str, ( len + 1 ) * sizeof( wchar_t ) );
return new_str;
}
static wchar_t *_plstring_malloc( size_t str_size )
{
size_t *self = (size_t *)malloc( sizeof( size_t ) + ( str_size ) );
*self = 1;
wchar_t *new_str = (wchar_t *)( ( (int8_t *)self ) + sizeof( size_t ) );
return new_str;
}
static void _plstring_release( wchar_t *str )
{
if ( str )
{
size_t *self = (size_t *)( ( (int8_t *)str ) - sizeof( size_t ) );
( *self )--;
if ( *self == 0 )
{
free( self );
}
}
}
static void _plstring_retain( wchar_t *str )
{
if ( str )
{
size_t *self = (size_t *)( ( (int8_t *)str ) - sizeof( size_t ) );
( *self )++;
}
}
__declspec( dllexport ) wchar_t *( *plstring_wcsdup )( const wchar_t *str ) = _plstring_wcsdup;
__declspec( dllexport ) wchar_t *( *plstring_malloc )( size_t str_size ) = _plstring_malloc;
__declspec( dllexport ) void ( *plstring_release )( wchar_t *str ) = _plstring_release;
__declspec( dllexport ) void ( *plstring_retain )( wchar_t *str ) = _plstring_retain;
}
static bool ndestring_tried_load = false;
void plstring_init()
{
if ( !ndestring_tried_load )
{
wchar_t path[ MAX_PATH ] = { 0 };
PathCombineW( path, SHAREDDIR, L"nde.dll" );
HMODULE ndelib = LoadLibraryW( path );
if ( ndelib )
{
FARPROC ndestring_wcsdup = GetProcAddress( ndelib, "ndestring_wcsdup" );
FARPROC ndestring_malloc = GetProcAddress( ndelib, "ndestring_malloc" );
FARPROC ndestring_release = GetProcAddress( ndelib, "ndestring_release" );
FARPROC ndestring_retain = GetProcAddress( ndelib, "ndestring_retain" );
if ( ndestring_wcsdup && ndestring_malloc && ndestring_release && ndestring_retain )
{
*(FARPROC *)&plstring_wcsdup = ndestring_wcsdup;
*(FARPROC *)&plstring_malloc = ndestring_malloc;
*(FARPROC *)&plstring_release = ndestring_release;
*(FARPROC *)&plstring_retain = ndestring_retain;
}
}
ndestring_tried_load = true;
}
}
#define CHECK_STUFF()
/* { \
if (list_pos >= list_size && list_size>0) { MessageBox(NULL,"SHIT2!","a",0); } \
if (list_size > malloced_size) MessageBox(NULL,"SHIT!","a",0); }
*/
static void Playlist_notifyModified();
struct pl_entry
{
pl_entry();
void Free();
void Create( int length, const wchar_t *filename, const wchar_t *title, const char *curtain, const wchar_t *ext, int is_nde_string = 0 );
void CreateMore( int length, const wchar_t *filename, const wchar_t *title, const char *curtain/*, const char *browser*/ );
void SetTitle( const wchar_t *title );
void SetFile( const wchar_t *file );
wchar_t *strFile = 0; // file name oct-17-2005-maksim
wchar_t *strTitle = 0; // title oct-17-2005-maksim
wchar_t *strExt = 0;
size_t cbTitle = 0; // title length oct-17-2005-maksim
int length = 0;
int8_t selected:1;
int8_t cached:1;
int8_t tmp:1;
int more = 0; // number of subitems in the playlist (or 0 for none) mar-16-2005-benski
int curitems = 0; // number of hidden items in this entry
int curindex = 0; // Current index of item we're playing (0 for 1st/none hidden item)
int repeatCount = 0; // number of times to repeat
int repeatCurrent = 0; // where we're at...
unsigned long starttime = 0; // Start time in MS (0, begin of file)
unsigned long endtime = 0; // End time in MS (0, end of file)
moreitems *moreStuff = NULL; // added for subitems in a playlist mar-16-2005-benski
ad_data *ads = NULL; // advertisement struct oct-17-2005-maksim
};
void pl_entry::Free()
{
more = 0;
if ( moreStuff )
{
delete moreStuff;
moreStuff = NULL;
}
if ( ads )
{
delete ads;
ads = 0;
}
plstring_release( strFile );
strFile = 0;
plstring_release( strExt );
strExt = 0;
plstring_release( strTitle );
strTitle = 0;
cbTitle = 0;
}
pl_entry::pl_entry()
{}
void pl_entry::Create( int length, const wchar_t *filename, const wchar_t *title, const char *curtain, const wchar_t *ext, int is_nde_string )
{
assert( filename );
assert( title );
if ( is_nde_string & 1 )
{
strFile = plstring_wcsdup( filename );
}
else
{
while ( filename && *filename && IsCharSpaceW( *filename ) )
filename = CharNextW( filename );
strFile = plstring_wcsdup( filename );
wchar_t *end = GetLastCharacterW( strFile );
while ( end && IsCharSpaceW( *end ) )
{
*end = 0;
end = CharPrevW( strFile, end );
}
}
cbTitle = wcslen( title ) + 1;
strTitle = _wcsdup( title );
if ( ext && *ext )
strExt = _wcsdup( ext );
if ( ( curtain && curtain[ 0 ] ) /*|| (browser && browser[0])*/ )
{
ads = new ad_data;
if ( curtain && curtain[ 0 ] != 0 )
{
ads->cbCurtain = (int)strlen( curtain ) + 1;
ads->strCurtain = new char[ ads->cbCurtain ];
StringCchCopyA( ads->strCurtain, ads->cbCurtain, curtain );
}
}
else
{
ads = NULL;
}
this->length = length;
selected = 0;
cached = 1;
more = 0;
curindex = 0;
curitems = 0;
moreStuff = NULL;
repeatCount = 0;
repeatCurrent = 0;
}
void pl_entry::CreateMore( int length, const wchar_t *filename, const wchar_t *title, const char *curtain/*, const char *browser*/ )
{
Create( length, filename, title, curtain, L""/*, browser*/);
more = 1;
moreStuff = new moreitems;
}
void pl_entry::SetTitle( const wchar_t *title )
{
size_t newSize = wcslen( title ) + 1;
if ( newSize > cbTitle )
{
delete[] strTitle;
strTitle = new wchar_t[ newSize ];
}
cbTitle = newSize;
StringCchCopyW( strTitle, cbTitle, title );
}
void pl_entry::SetFile( const wchar_t *file )
{
plstring_release( strFile );
while ( file && *file && IsCharSpaceW( *file ) )
file = CharNextW( file );
strFile = plstring_wcsdup( file );
wchar_t *end = GetLastCharacterW( strFile );
while ( end && IsCharSpaceW( *end ) )
{
*end = 0;
end = CharPrevW( strFile, end );
}
}
static pl_entry *list = 0;
static int list_size = 0;
static int list_pos = 0;
static int malloced_size = 0;
static pl_entry *tlist = 0;
static int t_len = 0;
static int rnd_listmodified = 1;
static int rnd_lastls = -1023;
static int rnd_i = 0;
static int *rnd_rtable;
extern "C"
{
int PlayList_get_lastlen()
{
return _lastlen;
}
static void Playlist_rnd_deleteitem(int item);
static void Playlist_rnd_additem();
wchar_t *remove_urlcodesW(wchar_t *p)
{
assert(p);
if (!config_fixtitles)
return p;
wchar_t buf[FILENAME_SIZE] = {0}, *i = buf, *p2 = p;
StringCchCopyW(buf, FILENAME_SIZE, p);
while (i && *i)
{
if (*i == L'_' && (config_fixtitles&2))
{
*p = L' ';
i = CharNextW(i);
}
else if (!StrCmpNW(i, L"%20", 3) && (config_fixtitles&1))
{
*p = L' ';
i += 3;
}
else
{
CopyCharW(p, i);
i = CharNextW(i);
}
p = CharNextW(p);
}
*p = 0;
return p2;
}
static void PlayList_allocmem(int newsize);
void PlayList_resetcurrent( void )
{
AutoLock lock( playlistGuard );
if ( list_pos < 0 || list_pos >= list_size )
return;
if ( list )
list[ list_pos ].curindex = 0;
}
void PlayList_saveend( int start )
{
AutoLock lock( playlistGuard );
if ( tlist )
{
// scan and remove subitems in a playlist mar-16-2005-benski
for ( int i = 0; i < t_len; i++ )
tlist[ i ].Free();
delete[] tlist;
tlist = 0;
}
if ( start < list_size )
{
t_len = ( list_size - start );
assert( t_len > 0 );
tlist = new pl_entry[ t_len ];
memcpy( tlist, list + start, sizeof( pl_entry ) * t_len );
list_size = start;
}
}
void PlayList_restoreend( void )
{
AutoLock lock( playlistGuard );
if ( tlist )
{
if ( t_len )
{
PlayList_allocmem( list_size + t_len );
memcpy( list + list_size, tlist, t_len * sizeof( pl_entry ) );
list_size += t_len;
}
delete[] tlist; // note: we *don't* want to clean up the moreStuff linked list here
tlist = NULL;
t_len = 0;
}
}
int PlayList_getselect( int x )
{
AutoLock lock( playlistGuard );
if ( x < 0 || x >= list_size )
return 0;
CHECK_STUFF();
return list[ x ].selected;
}
int PlayList_getselect2( int x, wchar_t *filename )
{
AutoLock lock( playlistGuard );
if ( x < 0 || x >= list_size )
return 0;
CHECK_STUFF();
if ( filename )
lstrcpynW( filename, list[ x ].strFile, FILENAME_SIZE );
return list[ x ].selected;
}
int PlayList_GetNextSelected( int start )
{
AutoLock lock( playlistGuard );
start++;
if ( start < 0 || start >= list_size )
return -1;
while ( start < list_size )
{
if ( list[ start ].selected )
return start;
start++;
}
return -1;
}
int PlayList_GetSelectedCount()
{
AutoLock lock( playlistGuard );
int num = 0;
for ( int i = 0; i < list_size; i++ )
{
if ( list[ i ].selected )
num++;
}
return num;
}
void PlayList_setselect( int x, int sel )
{
AutoLock lock( playlistGuard );
if ( x < 0 || x >= list_size )
return;
CHECK_STUFF();
list[ x ].selected = sel;
}
int PlayList_getcached( int x )
{
AutoLock lock( playlistGuard );
if ( x < 0 || x >= list_size )
return 0;
CHECK_STUFF();
return list[ x ].cached;
}
void PlayList_setcached( int x, int cached )
{
AutoLock lock( playlistGuard );
if ( x < 0 || x >= list_size )
return;
CHECK_STUFF();
list[ x ].cached = cached;
}
int PlayList_getsonglength( int x )
{
AutoLock lock( playlistGuard );
if ( x < 0 || x >= list_size )
return -1;
CHECK_STUFF();
return list[ x ].length;
}
int PlayList_gettotallength( void )
{
AutoLock lock( playlistGuard );
int l = 0;
CHECK_STUFF();
for ( int x = 0; x < list_size; x++ )
{
if ( list[ x ].length >= 0 )
l += list[ x ].length;
else
return -1;
}
return l;
}
int PlayList_getcurrentlength( void )
{
AutoLock lock( playlistGuard );
return ( PlayList_getsonglength( list_pos ) );
}
static void PlayList_allocmem( int newsize )
{
assert( newsize );
int os = malloced_size;
if ( newsize > malloced_size )
malloced_size = newsize + MALLOC_CHUNK;
else if ( newsize < malloced_size - MALLOC_CHUNK )
malloced_size = newsize;
else return;
if ( !malloced_size )
{
if ( list )
{
delete[] list;
list = 0;
}
}
else if ( list )
{
pl_entry *ol = list;
assert( malloced_size > 0 );
list = new pl_entry[ malloced_size ];
assert( min( os, malloced_size ) > 0 );
assert( min( os, malloced_size ) <= malloced_size );
memcpy( list, ol, min( os, malloced_size ) * sizeof( pl_entry ) );
delete[] ol;
}
else
{
assert( malloced_size > 0 );
list = new pl_entry[ malloced_size ];
memset( list, 0, sizeof( pl_entry ) * ( malloced_size ) );
}
}
int PlayList_gethidden( int pos )
{
AutoLock lock( playlistGuard );
if ( pos < 0 || pos >= list_size )
return 0;
if ( list )
return list[ pos ].curitems;
else
return 0;
}
int PlayList_ishidden( int pos )
{
AutoLock lock( playlistGuard );
if ( pos < 0 || pos >= list_size )
return 0;
if ( list )
if ( list[ pos ].curitems )
{
if ( list[ pos ].curindex != list[ pos ].curitems )
return 1;
}
return 0;
}
int PlayList_alldone( int pos )
{
AutoLock lock( playlistGuard );
if ( pos < 0 || pos >= list_size )
return 1;
if ( list )
{
if ( list[ pos ].curitems )
{
if ( list[ pos ].curindex == 0 )
return 1;
}
}
return 0;
}
int PlayList_hasanycurtain( int pos )
{
AutoLock lock( playlistGuard );
if ( pos < 0 || pos >= list_size )
return 0;
if ( list )
{
if ( list[ pos ].ads && list[ pos ].ads->strCurtain )
return 1;
}
return 0;
}
const char *PlayList_getcurtain( int pos )
{
AutoLock lock( playlistGuard );
if ( pos < 0 || pos >= list_size )
return NULL;
if ( list )
{
if ( list[ pos ].ads && list[ pos ].ads->strCurtain && list[ pos ].curindex == 0 )
return list[ pos ].ads->strCurtain;
if ( list[ pos ].curindex && list[ pos ].curitems )
return list[ pos ].moreStuff->GetHiddenCurtain( list[ pos ].curindex );
}
return NULL;
}
const char *PlayList_getExtInf( int pos )
{
AutoLock lock( playlistGuard );
if ( pos < 0 || pos >= list_size )
return NULL;
if ( list )
{
pl_entry l_entry = list[ pos ];
if ( l_entry.strExt && *l_entry.strExt )
{
wa::strings::wa_string l_ext_inf( " ext=\"" );
l_ext_inf.append( l_entry.strExt );
l_ext_inf.append( "\"" );
return _strdup( l_ext_inf.GetA().c_str() );
}
}
return NULL;
}
/*
const char *PlayList_getbrowser(int pos)
{
AutoLock lock (playlistGuard);
if (pos < 0 || pos >= list_size) return NULL;
if ( list )
{
if ( list[pos].ads && list[pos].ads->cbBrowser ) return list[pos].ads->strBrowser;
}
return NULL;
}
*/
int PlayList_current_hidden( void )
{
AutoLock lock( playlistGuard );
if ( list_pos < 0 || list_pos >= list_size )
return 0;
if ( list && list[ list_pos ].curitems )
{
if ( list[ list_pos ].curitems && list[ list_pos ].curindex < list[ list_pos ].curitems )
{
list[ list_pos ].curindex++;
return 1;
}
}
return 0;
}
int PlayList_getitem( int position, wchar_t *filename, wchar_t *filetitle )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return 1;
CHECK_STUFF();
if ( filename )
StringCchCopyW( filename, FILENAME_SIZE, list[ position ].strFile );
if ( filetitle )
StringCchPrintfW( filetitle, FILETITLE_SIZE, L"%d. %s", position + 1, list[ position ].strTitle );
if ( list[ position ].length >= 0 )
{
wchar_t tmp[ 512 ] = { 0 };
StringCchPrintfW( tmp, 512, L" - [%d:%02d]", list[ position ].length / 60, list[ position ].length % 60 );
if ( filetitle )
StringCchCatW( filetitle, FILETITLE_SIZE, tmp );
}
return 0;
}
/* this function call specifically has 256 characters max because of the data structure in ipc_pe.h (fileinfo2) */
int PlayList_getitem3( int position, char *filetitle, char *filelength )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return 1;
CHECK_STUFF();
if ( filetitle )
WideCharToMultiByteSZ( CP_ACP, 0, list[ position ].strTitle, -1, filetitle, 256, 0, 0 );
if ( filelength && list[ position ].length >= 0 )
StringCchPrintfA( filelength, 16, "%d:%02d", list[ position ].length / 60, list[ position ].length % 60 );
return 0;
}
/* this function call specifically has 256 characters max because of the data structure in ipc_pe.h (fileinfo2) */
int PlayList_getitem3W( int position, wchar_t *filetitle, wchar_t *filelength )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return 1;
CHECK_STUFF();
if ( filetitle )
lstrcpynW( filetitle, list[ position ].strTitle, 256 );
if ( filelength && list[ position ].length >= 0 )
StringCchPrintfW( filelength, 16, L"%d:%02d", list[ position ].length / 60, list[ position ].length % 60 );
return 0;
}
void PlayList_updateitem( int position )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return;
_lastlen = -1;
wchar_t *str = remove_urlcodesW( PlayList_gettitle( list[ position ].strFile, 1 ) );
list[ position ].SetTitle( str );
PlayList_setcached( position, 1 );
if ( _lastlen != -1 )
list[ position ].length = _lastlen;
}
int PlayList_getitem_pl( int position, wchar_t *filetitle )
{
AutoLock lock( playlistGuard );
// static int i;
CHECK_STUFF();
if ( !list || position < 0 || position >= list_size )
return 1;
/*
if (!PlayList_getcached(position) && config_riol==0 && !i)
{
i=1;
_lastlen=-1;
lstrcpy(list[position].filetitle,remove_urlcodes(PlayList_gettitle(list[position].filename,1)));
PlayList_setcached(position,1);
if (_lastlen != -1) list[position].length = _lastlen;
i=0;
}
*/
if ( filetitle && config_shownumsinpl )
{
if ( list_size >= 10000 )
StringCchPrintfW( filetitle, FILETITLE_SIZE, ( config_zeropadplnum ? L"%05u. %s" : L"%5u. %s" ), position + 1, list[ position ].strTitle );
else if ( list_size >= 1000 )
StringCchPrintfW( filetitle, FILETITLE_SIZE, ( config_zeropadplnum ? L"%04u. %s" : L"%4u. %s" ), position + 1, list[ position ].strTitle );
else if ( list_size >= 100 )
StringCchPrintfW( filetitle, FILETITLE_SIZE, ( config_zeropadplnum ? L"%03u. %s" : L"%3u. %s" ), position + 1, list[ position ].strTitle );
else if ( list_size >= 10 )
StringCchPrintfW( filetitle, FILETITLE_SIZE, ( config_zeropadplnum ? L"%02u. %s" : L"%2u. %s" ), position + 1, list[ position ].strTitle );
else
StringCchPrintfW( filetitle, FILETITLE_SIZE, L"%1u. %s", position + 1, list[ position ].strTitle );
}
else if ( filetitle )
StringCchCopyW( filetitle, FILETITLE_SIZE, list[ position ].strTitle );
return 0;
}
int PlayList_getitem2( int position, char *filename, char *filetitle )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return 1;
CHECK_STUFF();
if ( filename )
StringCchCopyA( filename, FILENAME_SIZE, AutoCharFn( list[ position ].strFile ) );
if ( filetitle )
WideCharToMultiByteSZ( CP_ACP, 0, list[ position ].strTitle, -1, filetitle, FILETITLE_SIZE, 0, 0 );
return 0;
}
int PlayList_getitem2W( int position, wchar_t *filename, wchar_t *filetitle )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return 1;
CHECK_STUFF();
if ( filename )
{
if ( list[ position ].strFile )
StringCchCopyW( filename, FILENAME_SIZE, list[ position ].strFile );
else
return 1;
}
if ( filetitle )
{
if ( list[ position ].strTitle )
StringCchCopyW( filetitle, FILETITLE_SIZE, list[ position ].strTitle );
else
return 1;
}
return 0;
}
int PlayList_getitem_jtfW( int position, wchar_t *str )
{
AutoLock lock( playlistGuard );
if ( !list || position < 0 || position >= list_size )
return 1;
CHECK_STUFF();
StringCchPrintfW( str, FILENAME_SIZE + FILETITLE_SIZE + 1, L"%s %s", list[ position ].strFile, list[ position ].strTitle );
return 0;
}
int PlayList_getlength( void )
{
AutoLock lock( playlistGuard );
return list_size;
}
int plmodified = 0, plcleared = 0, plneedsave = 0;
int g_has_deleted_current;
// returns:
// 1, last item in list
// 0 not
// -1 no items in list
int PlayList_deleteitem( int item )
{
AutoLock lock( playlistGuard );
if ( !list ) return -1;
CHECK_STUFF();
if ( item < 0 || item >= list_size ) return -1;
list[ item ].Free();
list_size--;
if ( list_size != item )
memmove( list + item, list + item + 1, sizeof( list[ 0 ] ) * ( list_size - item ) );
if ( item == list_pos )
g_has_deleted_current = 1;
if ( item <= list_pos )
list_pos--;
if ( list_pos < 0 ) list_pos = 0;
PlayList_allocmem( list_size + 1 );
Playlist_notifyModified();
Playlist_rnd_deleteitem( item );
return list ? 0 : 1;
}
void PlayList_delete( void )
{
AutoLock lock( playlistGuard );
CHECK_STUFF();
//if (GetPrivateProfileIntW(L"Winamp", L"rmudhack", 0, INI_FILE) == 666) return ;
if ( list )
{
// code to cleanup subitems in a playlist entry mar-16-2005-benski
for ( int i = 0; i < list_size; i++ )
list[ i ].Free();
// delete[] list;
}
// list=0;
list_size = 0;
list_pos = 0;
plcleared = 1;
// malloced_size=0;
Playlist_notifyModified();
}
void PlayList_destroy(void)
{
AutoLock lock (playlistGuard);
PlayList_delete();
delete[] list;
list = 0;
}
void PlayList_setlastlen(int x)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if (x >= 0 && x < list_size) list[x].length = _lastlen;
}
static wchar_t *GetFileInfo(const wchar_t *filename, wchar_t *title, size_t titleCch)
{
In_Module *mod = in_setmod_noplay(filename, 0);
_lastlen = -1;
if (!mod)
{
StringCchCopyW(title, GETFILEINFO_TITLE_LENGTH, filename);
return title;
}
InW_GetFileInfo(mod, (filename == FileName) ? 0 : filename, title, &_lastlen);
if (!title[0])
{
StringCchCopyW(title, titleCch, filename);
if (!PathIsURLW(filename))
{
PathStripPathW(title);
PathRemoveExtensionW(title);
}
}
if (_lastlen != -1) _lastlen /= 1000;
return 0;
}
static wchar_t *GetExtendedTitle( const wchar_t *filename, wchar_t *title, size_t titleCch, bool active = false )
{
AutoCharFn narrowFile( filename );
// make sure the title is inited otherwise it'll be filled/set with rubbish noticeable
// on 5.3+ due to nothing internally using this api now and a retval = 1 done for it
// basically for 3rd party/legacy handling now - 13 May 07
char narrowTitle[ GETFILEINFO_TITLE_LENGTH ] = { 0 };
waHookTitleStruct hts = { 0 };
hts.filename = narrowFile;
hts.length = -1;
hts.title = narrowTitle;
if ( PathIsURLW( filename ) )
{
wchar_t buf[ 32 ] = { 0 };
extendedFileInfoStructW s = { filename, L"streammetadata", buf, sizeof( buf ) / sizeof( wchar_t ) };
if ( 0 != SendMessageW( hMainWindow, WM_WA_IPC, (WPARAM)&s, IPC_GET_EXTENDED_FILE_INFOW_HOOKABLE ) && L'1' == buf[ 0 ] )
{
hts.force_useformatting = 1;
}
}
/*
wchar_t buf[32]=L"";
if (PathIsURLW(filename) && in_get_extended_fileinfoW(filename, L"streammetadata", buf, sizeof(buf)/sizeof(wchar_t)) && buf[0]=='1')
hts.force_useformatting = 1;
*/
if ( config_useexttitles && SendMessageW( hMainWindow, WM_WA_IPC, (WPARAM)&hts, IPC_HOOK_TITLES ) )
{
MultiByteToWideCharSZ( CP_ACP, 0, narrowTitle, -1, title, (int)titleCch );
if ( hts.length != -1 )
{
_lastlen = hts.length;
return title;
}
else
{
In_Module *mod = in_setmod_noplay( filename, 0 );
_lastlen = -1;
if ( mod )
{
wchar_t title2[ GETFILEINFO_TITLE_LENGTH ] = { 0 };
InW_GetFileInfo( mod, filename, title2, &_lastlen );
}
if ( _lastlen != -1 ) _lastlen /= 1000;
}
return title;
}
return 0;
}
static wchar_t *GetExtendedTitleW(const wchar_t *filename, wchar_t *title, size_t titleCch, bool active=false)
{
waHookTitleStructW hts = {0};
hts.filename = filename;
hts.length = -1;
hts.title = title;
if (PathIsURLW(filename))
{
wchar_t buf[32] = {0};
extendedFileInfoStructW s = {filename, L"streammetadata", buf, sizeof(buf)/sizeof(wchar_t)};
if (0 != SendMessageW(hMainWindow, WM_WA_IPC, (WPARAM)&s, IPC_GET_EXTENDED_FILE_INFOW_HOOKABLE) &&
L'1' == buf[0])
{
hts.force_useformatting = 1;
}
}
/*
wchar_t buf[32]=L"";
if (PathIsURLW(filename) && in_get_extended_fileinfoW(filename, L"streammetadata", buf, 32) && buf[0]=='1')
hts.force_useformatting = 1;
*/
if (config_useexttitles && SendMessageW(hMainWindow, WM_WA_IPC, (WPARAM)&hts, IPC_HOOK_TITLESW))
{
if (hts.length != -1)
{
_lastlen = hts.length;
return title;
}
else
{
In_Module *mod = in_setmod_noplay(filename, 0);
_lastlen = -1;
if (mod)
{
wchar_t title2[GETFILEINFO_TITLE_LENGTH] = {0};
InW_GetFileInfo(mod, filename, title2, &_lastlen);
}
if (_lastlen != -1) _lastlen /= 1000;
}
return title;
}
return 0;
}
wchar_t *PlayList_gettitle(const wchar_t *filename, int useID3)
{
/* OK, this function is going to get ugly */
AutoLock lock (playlistGuard);
static wchar_t title[GETFILEINFO_TITLE_LENGTH] = {0};
CHECK_STUFF();
if (useID3 || (filename[0] && !StrCmpIW(PathFindExtensionW(filename), L"aip")))
{
if (filename[0])
{
wchar_t *ret = GetExtendedTitle(filename, title, GETFILEINFO_TITLE_LENGTH);
if (ret)
return ret;
else
{
ret = GetExtendedTitleW(filename, title, GETFILEINFO_TITLE_LENGTH);
if (ret)
return ret;
else
{
ret = GetFileInfo(filename, title, GETFILEINFO_TITLE_LENGTH);
if (ret)
return ret;
}
}
}
else
{
wchar_t *ret = GetExtendedTitle(FileName, title, GETFILEINFO_TITLE_LENGTH, true);
if (ret)
return ret;
else
{
ret = GetExtendedTitleW(FileName, title, GETFILEINFO_TITLE_LENGTH, true);
if (ret)
return ret;
else
{
ret = GetFileInfo(FileName, title, GETFILEINFO_TITLE_LENGTH);
if (ret)
return ret;
}
}
}
}
else
{
_lastlen = -1;
if (filename[0] && PathIsURLW(filename))
{
if (title) StringCchCopyW(title, GETFILEINFO_TITLE_LENGTH, filename);
}
else if (title)
{
wchar_t buf[1024] = {0};
StringCchCopyW(buf, 1024, filename);
StringCchCopyW(title, GETFILEINFO_TITLE_LENGTH, PathFindFileNameW(buf));
PathRemoveExtensionW(title);
}
}
return title;
}
void PlayList_append_withinfo_curtain(const wchar_t *filename, const wchar_t *title, int length, char *curtain, const wchar_t *ext, int is_nde_string)
{
AutoLock lock (playlistGuard);
bool cached = true;
wchar_t fn[FILENAME_SIZE] = {0};
CHECK_STUFF();
if (!(is_nde_string & 1) && !PathIsURLW(filename))
{
if (wcsstr(fn, L"\\"))
{
int ret = GetLongPathNameW(filename, fn, FILENAME_SIZE);
if (ret && ret < FILENAME_SIZE)
filename=fn;
}
}
if (!title)
{
title = remove_urlcodesW(PlayList_gettitle(filename, (config_riol == 1 ? 1 : 0)));
// changed 5.64 - if we have a length but no title, use the length and build the title
if (length < 0)
{
_lastlen = -1;
// added post 5.65 to ensure read on loading will work
// after some of the other changes made in 5.64 / 5.65
if (config_riol == 1)
{
In_Module *mod = in_setmod_noplay(filename, 0);
if (mod)
{
wchar_t title2[GETFILEINFO_TITLE_LENGTH] = {0};
InW_GetFileInfo(mod, filename, title2, &_lastlen);
if (_lastlen != -1) _lastlen /= 1000;
}
}
}
length = _lastlen;
cached = config_riol == 1;
}
if (list_size && list[list_size - 1].more)
{
// We have the final item to add to the last index
// Add it to the more items list
// Reset more flag
// and do not adjust the list_size;
list[list_size - 1].moreStuff->AddHiddenItem(filename, title, length, list[list_size - 1].more, curtain);
list[list_size - 1].curitems = list[list_size - 1].more;
list[list_size - 1].curindex = 0;
list[list_size - 1].more = 0;
}
else
{
PlayList_allocmem(list_size + 1);
if (list_pos == -1)
list_pos = 0;
list[list_size].Create(length, filename, title, curtain, ext, is_nde_string);
list[list_size].cached = cached ? 1 : 0;
Playlist_rnd_additem();
list_size++;
}
Playlist_notifyModified();
}
void PlayList_append_withinfo(const wchar_t *filename, const wchar_t *title, const wchar_t *ext, int length, int is_nde_string)
{
AutoLock lock (playlistGuard);
PlayList_append_withinfo_curtain(filename, title, length, NULL, ext, is_nde_string);
}
void PlayList_append_withinfo_hidden(const wchar_t *filename, const wchar_t *title, int length, char *curtain/*, char *browser*/)
{
AutoLock lock (playlistGuard);
bool cached = true;
wchar_t fn[FILENAME_SIZE] = {0};
CHECK_STUFF();
if (!PathIsURLW(filename))
{
if (wcsstr(fn, L"\\"))
{
int ret = GetLongPathNameW(filename, fn, FILENAME_SIZE);
if (ret && ret < FILENAME_SIZE)
filename=fn;
}
}
if (!title)
{
title = remove_urlcodesW(PlayList_gettitle(filename, (config_riol == 1 ? 1 : 0)));
// changed 5.64 - if we have a length but no title, use the length and build the title
if (length < 0)
{
_lastlen = -1;
// added post 5.65 to ensure read on loading will work
// after some of the other changes made in 5.64 / 5.65
if (config_riol == 1)
{
In_Module *mod = in_setmod_noplay(filename, 0);
if (mod)
{
wchar_t title2[GETFILEINFO_TITLE_LENGTH] = {0};
InW_GetFileInfo(mod, filename, title2, &_lastlen);
if (_lastlen != -1) _lastlen /= 1000;
}
}
}
length = _lastlen;
cached = config_riol == 1;
}
if (list_size && list[list_size - 1].more)
{
// add item with info to more list
// increment more flag so another item may be added to the hidden list
list[list_size - 1].moreStuff->AddHiddenItem(filename, title, length, list[list_size - 1].more, curtain);
list[list_size - 1].more++;
}
else
{
// Create a new entry, but set the more flag. so the next item gets added to
// more list
PlayList_allocmem(list_size + 1);
if (list_pos == -1)
list_pos = 0;
list[list_size].CreateMore(length, filename, title, curtain/*, browser*/);
list[list_size].cached = cached ? 1 : 0;
Playlist_rnd_additem();
list_size++;
}
Playlist_notifyModified();
}
static void _appendcd(const wchar_t *url)
{
AutoLock lock (playlistGuard);
wchar_t buf2[32] = {0};
in_get_extended_fileinfoW(url, L"ntracks", buf2, 32);
int n = _wtoi(buf2);
if (n > 0 && n < 256)
{
for (int x = 0; x < n; x ++)
{
wchar_t s[64] = {0};
StringCchPrintfW(s, 64, L"%s,%d",url, x + 1);
PlayList_append(s, 0);
}
}
}
void PlayList_check_unknown(const wchar_t *url, int is_nde_string)
{
if (!_wcsicmp(extensionW(url), L"")) // no extension, check for pls/m3u signatures
{
// TODO: move to its own function
FILE *fp = _wfopen(url,L"r");
char buf[21] = {0};
if (fp)
{
fread(buf, 1, 21, fp);
fclose(fp);
buf[20] = 0;
}
if (!_strnicmp(buf, "[Reference]", 11))
LoadPlaylistByExtension(url, L".asx", 1, 0);
else if (!_strnicmp(buf, "[playlist]", 10))
LoadPlaylistByExtension(url, L".pls", 1, 0);
else if (!memcmp(buf, L"[playlist]", 20))
LoadPlaylistByExtension(url, L".pls", 1, 0);
else if (!_strnicmp(buf, "#EXTM3U", 7))
LoadPlaylistByExtension(url, L".m3u", 1, 0);
else if (!_strnicmp(buf, "<ASX", 4))
LoadPlaylistByExtension(url, L".asx", 1, 0);
else if (!_strnicmp(buf, "<?wpl", 5))
LoadPlaylistByExtension(url, L".wpl", 1, 0);
else if (!_strnicmp(buf, "<?zpl", 5))
LoadPlaylistByExtension(url, L".zpl", 1, 0);
else PlayList_append(url, is_nde_string);
}
else
PlayList_append(url, is_nde_string);
}
void PlayList_appendthing(const wchar_t *url, int doMIMEcheck, int is_nde_string)
{
wchar_t temp2[MAX_PATH] = {0};
AutoLock lock (playlistGuard);
if (!_wcsicmp(extensionW(url), L"lnk"))
{
if (ResolveShortCut(hMainWindow, url, temp2))
{
url = temp2; //StringCchCopy(url, MAX_PATH, temp2);
is_nde_string &= ~1;
}
else
return ;
}
if (!_wcsnicmp(url, L"cda://", 6))
{
if ( wcslen(url) == 7)
_appendcd(url);
else
PlayList_append(url, is_nde_string);
}
else if (PathIsURLW(url))
{
if (LoadPlaylist(url, 1, doMIMEcheck) == -1) // if it's not a playlist file
PlayList_append(url, is_nde_string);
}
else if (!lstrcmpW(url + 1, L":\\"))
PlayList_adddir(url, 1);
else
{
WIN32_FIND_DATAW d = {0};
HANDLE h = FindFirstFileW(url, &d);
if (h != INVALID_HANDLE_VALUE)
{
FindClose(h);
if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
PlayList_adddir(url, 1);
else if (LoadPlaylist(url, 1, 0) == -1) // if it's not a playlist file
{
PlayList_check_unknown(url, is_nde_string); // no extension, check for pls/m3u signatures
}
}
else
PlayList_append(url, is_nde_string);
}
}
int PlayList_getrepeatcount(int pos)
{
AutoLock lock (playlistGuard);
if ( list_size )
{
return list[pos].repeatCount;
}
else return 0;
}
void PlayList_SetLastItem_RepeatCount(int count)
{
AutoLock lock (playlistGuard);
if ( list_size )
{
list[list_size -1].repeatCount = count;
}
}
void PlayList_SetLastItem_Range(unsigned long start, unsigned long end)
{
int index = 0;
if ( list[list_size - 1].curitems ) index = list[list_size - 1].curitems;
else if ( list[list_size - 1].more - 1 > 0 ) index = list[list_size - 1].more - 1;
if ( list_size && index )
{
list[list_size - 1].moreStuff->SetRange(index, start, end);
}
else if ( list_size )
{
list[list_size - 1].starttime = start;
list[list_size - 1].endtime = end;
}
Playlist_notifyModified();
}
unsigned long PlayList_GetItem_Start(int pos)
{
if (pos >= 0 && pos < list_size)
{
if ( !list[pos].curindex )
return list[pos].starttime;
else
{
return list[pos].moreStuff->GetStart(list[pos].curindex);
}
}
else
return 0;
}
unsigned long PlayList_GetItem_End(int pos)
{
if (pos >= 0 && pos < list_size)
{
if ( !list[pos].curindex )
return list[pos].endtime;
else
{
return list[pos].moreStuff->GetEnd(list[pos].curindex);
}
}
else
return 0;
}
void PlayList_terminate_lasthidden(void)
{
AutoLock lock (playlistGuard);
if ( list_size && list[list_size - 1].more )
{
// Reset more flag
// and do not adjust the list_size;
list[list_size - 1].curitems = list[list_size - 1].more - 1;
list[list_size - 1].curindex = 0;
list[list_size - 1].more = 0;
Playlist_notifyModified();
}
}
void PlayList_append(const wchar_t *filename, int is_nde_string)
{
AutoLock lock (playlistGuard);
PlayList_append_withinfo_curtain(filename, NULL, 0, NULL, L"", 0);
}
void PlayList_getcurrent_onstop(wchar_t *filename, wchar_t *filetitle)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if (list_pos >= 0 && list_pos < list_size)
{
int position = list_pos;
if (!PlayList_getcached(position))
{
_lastlen = -1;
wchar_t *str = remove_urlcodesW(PlayList_gettitle(list[position].strFile, 1));
list[position].SetTitle(str);
PlayList_setcached(position, 1);
if (_lastlen != -1)
list[position].length = _lastlen;
}
StringCchCopyW(filename, FILENAME_SIZE, list[list_pos].strFile);
StringCchCopyW(filetitle, FILETITLE_SIZE, list[list_pos].strTitle);
//StringCchPrintfW(filetitle, FILETITLE_SIZE, L"%d. %s", list_pos + 1, list[list_pos].strTitle);
}
else *filename = *filetitle = 0;
}
void PlayList_GetCurrentTitle(wchar_t *filetitle, int cchLen)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if (list_pos >= 0 && list_pos < list_size)
{
StringCchCopyW(filetitle, cchLen, list[list_pos].strTitle);
//StringCchPrintfW(filetitle, cchLen, L"%d. %s", list_pos + 1, list[list_pos].strTitle);
}
else *filetitle = 0;
}
void PlayList_getcurrent(wchar_t *filename, wchar_t *filetitle, wchar_t *filetitlenum)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if (list_pos >= 0 && list_pos < list_size)
{
if ( !list[ list_pos ].curindex )
{
wa::strings::wa_string l_filename( L"" );
wa::strings::wa_string l_original_filename( list[ list_pos ].strFile );
if ( list[ list_pos ].strExt && *list[ list_pos ].strExt && l_original_filename.contains( "://" ) )
{
wa::strings::wa_string l_ext( "." );
l_ext.append( list[ list_pos ].strExt );
l_ext.toUpper();
wa::strings::wa_string l_strFile( list[ list_pos ].strFile );
l_filename.append( "http://client.winamp.com/fileproxy?destination=" );
l_filename.append( list[ list_pos ].strFile );
wa::strings::wa_string l_upper_case_filename( l_strFile.GetW() );
l_upper_case_filename.toUpper();
if ( !l_upper_case_filename.contains( l_ext.GetW() ) )
{
if ( !l_strFile.contains( "?" ) )
l_filename.append( "?" );
else
l_filename.append( "&" );
l_filename.append( "ext=" );
l_filename.append( l_ext );
}
StringCchCopyW( filename, FILENAME_SIZE, l_filename.GetW().c_str() );
}
else
StringCchCopyW( filename, FILENAME_SIZE, list[ list_pos ].strFile );
}
else
{
StringCchCopyW(filename, FILENAME_SIZE, list[list_pos].moreStuff->GetHiddenFilename(list[list_pos].curindex));
}
StringCchCopyW(filetitle, FILETITLE_SIZE, list[list_pos].strTitle);
StringCchPrintfW(FileTitleNum, FILETITLE_SIZE, L"%d. %s", list_pos + 1, list[list_pos].strTitle);
}
else *filename = *filetitle = 0;
}
void PlayList_setcurrent(const wchar_t *filename, wchar_t *filetitle)
{
AutoLock lock (playlistGuard);
PlayList_setitem(list_pos, filename, filetitle);
}
void PlayList_setitem(int x, const wchar_t *filename, wchar_t *filetitle)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if (x >= 0 && x < list_size)
{
list[x].SetFile(filename);
// Dont allow update of the title if there is hidden elements
if ( !list[x].curitems )
{
wchar_t *str = remove_urlcodesW(filetitle);
list[x].SetTitle(str);
}
list[x].cached = 1;
if (x != list_pos) Playlist_notifyModified();
}
}
void PlayList_swap(int e1, int e2)
{
AutoLock lock (playlistGuard);
pl_entry p;
if (e1 < 0 || e2 < 0 || e1 >= list_size || e2 >= list_size || e1 == e2) return ;
p = list[e1];
list[e1] = list[e2];
list[e2] = p;
Playlist_notifyModified();
}
int PlayList_setposition(int pos)
{
AutoLock lock (playlistGuard);
if (list_pos >= 0 && list_pos < list_size)
list[list_pos].curindex = 0;
list_pos = 0;
if (pos >= 0 && pos < list_size)
list[pos].curindex = 0;
return (PlayList_advance(pos));
}
int PlayList_getPosition()
{
AutoLock lock (playlistGuard); // to let any pending actions finish
return list_pos;
}
int PlayList_getNextPosition()
{
AutoLock lock (playlistGuard); // to let any pending actions finish
// rnd
int pl_len = PlayList_getlength();
if (pl_len > 0)
{
// repeat track is enabled so will be current one
if (!config_pladv && config_repeat)
{
// manual playlist advance is on so should be the current track
// (may change but won't unless user does a prev / next action)
return list_pos;
}
else
{
// shuffle is off so can determine next entry
if (!config_shuffle)
{
// if at the end then loop to the start
// otherwise it will be the next entry
// butif repeat is off then we don't know
return ((list_pos + 1 >= pl_len) ? (!config_repeat ? -1 : 0) : list_pos + 1);
}
// shuffle is on so need to find out from table
else
{
// keep things in check when at end of table
if (!rnd_listmodified && rnd_i >= 0 && rnd_i + 1 != rnd_lastls)
{
return (rnd_rtable ? rnd_rtable[rnd_i + 1] : 0);
}
// otherwise if at the end and repeat on go to start
else
{
if(config_repeat)
{
return (rnd_rtable ? rnd_rtable[0] : 0);
}
}
}
}
}
// if nothing or only one item then default to the first entry
else if(!pl_len)
{
return (!config_repeat ? -1 : 0);
}
// not sure what is the next so fail nicely
return -1;
}
int PlayList_advance(int byval)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if ( byval == HIDDEN_TRAP )
{
if ( list_size )
{
// Our hidden trap
if ( list[list_pos].curitems && list[list_pos].curindex < list[list_pos].curitems )
{
list[list_pos].curindex++;
return list_pos;
}
byval = 1;
list[list_pos].curindex = 0;
if ( list[list_pos].repeatCount && list[list_pos].repeatCurrent++ != list[list_pos].repeatCount )
{
return list_pos;
}
list[list_pos].repeatCurrent = 0;
}
}
if (!byval) return list_pos;
//if ( list_size && byval != 1 ) for ( x = 0; x < list_size; x++ ) list[x].curindex = 0;
//if ( list_size && byval == 1 ) list[list_pos].curindex = 0;
if (list_size > 1 && list_pos >= 0 && list_pos < list_size)
{
list[list_pos].curindex = 0;
list[list_pos].repeatCurrent = 0;
}
list_pos += byval;
if (list_pos < 0) list_pos = 0;
else if (list_pos >= list_size) list_pos = list_size - 1;
else return list_pos;
return -1;
}
void PlayList_addfromdlg(const wchar_t *fns)
{
AutoLock lock (playlistGuard);
WinampPlaylist playlist;
playlistManager->LoadFromDialog(fns, &playlist);
}
void PlayList_getcurrent_tupdate(wchar_t *FileName, wchar_t *FileTitle)
{
AutoLock lock (playlistGuard);
if (!g_has_deleted_current)
{
PlayList_refreshtitle(); // removed for evil vbr fix. ? ?
PlayList_getcurrent(FileName, FileTitle, FileTitleNum);
}
else
{
_lastlen = -1;
StringCchCopyW(FileTitle, FILETITLE_SIZE, remove_urlcodesW(PlayList_gettitle(L"", 1)));
}
}
void PlayList_refreshtitle(void)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
if (list_pos >= 0 && list_pos < list_size)
{
_lastlen = -1;
// TODO: benski> tag probably needs this, but MN radio can't have it: if ( !list[list_pos].curitems )
{
wchar_t *title = remove_urlcodesW(PlayList_gettitle(L"", 1));
list[list_pos].SetTitle(title);
}
PlayList_setcached(list_pos, 1);
if (_lastlen != -1) list[list_pos].length = _lastlen;
//JF100500 SendMessageW(hPLWindow,WM_USER+1,0,0);
}
}
const wchar_t *PlayList_GetCachedTitle(const wchar_t *filename)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
for (int i = 0;i < list_size;i++)
{
if (!lstrcmpiW(filename, list[i].strFile))
{
if (list[i].cached)
{
_lastlen = list[i].length;
return list[i].strTitle;
}
else
return 0;
}
}
return 0;
}
void PlayList_UpdateTitle(const wchar_t *filename)
{
AutoLock lock (playlistGuard);
CHECK_STUFF();
for (int i = 0;i < list_size;i++)
{
if (!lstrcmpiW(filename, list[i].strFile))
PlayList_updateitem(i);
}
Playlist_notifyModified();
}
void PlayList_updaterandpos(void)
{
AutoLock lock (playlistGuard);
//MessageBox(NULL,"updaterandpos","b",0);
rnd_listmodified = 1;
}
void Playlist_rnd_additem()
{
AutoLock lock (playlistGuard);
if (!rnd_listmodified && rnd_rtable && rnd_lastls > 0)
{
int x, newpos;
rnd_lastls++;
int *newtable = (int*)realloc(rnd_rtable, sizeof(int) * (rnd_lastls));
if (!newtable)
{
newtable = (int*)malloc(sizeof(int) * (rnd_lastls));
if (newtable)
{
memcpy(newtable, rnd_rtable, sizeof(int)*(rnd_lastls - 1));
free(rnd_rtable);
rnd_rtable = newtable;
}
else return ;
}
else rnd_rtable = newtable;
newpos = warand() % rnd_lastls;
for (x = rnd_lastls - 1; x > newpos; x --)
{
rnd_rtable[x] = rnd_rtable[x - 1];
if (rnd_rtable[x] >= list_size) rnd_rtable[x]++;
}
rnd_rtable[x] = list_size;
while (x > 0)
{
x--;
if (rnd_rtable[x] >= list_size) rnd_rtable[x]++;
}
}
else rnd_listmodified = 1;
}
void Playlist_rnd_deleteitem(int item)
{
AutoLock lock (playlistGuard);
if (!rnd_listmodified && rnd_rtable && rnd_lastls > 0)
{
for (int x = 0; x < rnd_lastls; x ++)
{
if (rnd_rtable[x] > item)
{
rnd_rtable[x]--;
}
else if (rnd_rtable[x] == item)
{
std::rotate(&rnd_rtable[x], &rnd_rtable[x + 1], &rnd_rtable[rnd_lastls]);
if (rnd_rtable[x] > item) rnd_rtable[x]--;
if (rnd_i >= x) rnd_i--;
if (rnd_i < 0) rnd_i = 0;
rnd_lastls--;
}
}
}
else rnd_listmodified = 1;
}
static int Rand(int n)
{
return warand() % n ;
}
int PlayList_randpos(int x)
{
AutoLock lock (playlistGuard);
int ls;
if (x == -666) // exiting winamp
{
rnd_i = 0;
free(rnd_rtable);
rnd_rtable = 0;
return 0;
}
if (ls = PlayList_getlength())
{
if (ls != rnd_lastls || rnd_listmodified)
{
int first_run = (rnd_lastls < 0);
//init table;
rnd_lastls = ls;
rnd_listmodified = 0;
if (!ls) return 0;
free(rnd_rtable);
rnd_rtable = (int *) malloc(ls * sizeof(int));
for (x = 0; x < ls; x ++)
{
rnd_rtable[x] = x;
}
x = 0;
if (first_run && list_pos >= 0 && list_pos < ls)
{
// at startup, go back to current song from last session:
rnd_rtable[list_pos] = 0;
rnd_rtable[0] = list_pos;
x = 1; // (don't re-randomize this entry)
}
std::random_shuffle(&rnd_rtable[x], &rnd_rtable[ls], Rand);
rnd_i = 0;
}
else rnd_i += x;
if (rnd_i >= ls)
{
if (config_repeat)
{
rnd_i = 0;
if (ls > 2)
{
// note: config_shuffle_morph_rate==0 means slow morph, and minimal changes to playlist each time through [window_size==2]
// config_shuffle_morph_rate==50 means fast morph, and guarantees that HALF of the other songs will play before any one song repeats [ideal]
int window_size = max(MulDiv(ls, config_shuffle_morph_rate, 100), 2);
for (x = 0; x < ls - 1; x ++)
{
std::random_shuffle(&rnd_rtable[x], &rnd_rtable[min(x + window_size, ls)], Rand);
}
}
}
else rnd_i = ls - 1;
PlayList_setposition(rnd_rtable[rnd_i]);
return 1;
}
if (rnd_i < 0)
{
rnd_i = 0;
PlayList_setposition(rnd_rtable[rnd_i]);
return 1;
}
PlayList_setposition(rnd_rtable[rnd_i]);
}
else rnd_lastls = 0;
return 0;
}
static bool PlayList_sortByFile(pl_entry &a, pl_entry &b) //const void *a, const void *b)
{
const wchar_t *file1 = PathFindFileNameW(a.strFile);
const wchar_t *file2 = PathFindFileNameW(b.strFile);
// int comp = CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE | /*NORM_IGNOREKANATYPE |*/ NORM_IGNOREWIDTH, file1, -1, file2 , -1);
//return comp == CSTR_LESS_THAN;
return FileCompareLogical(file1, file2) < 0;
}
static bool PlayList_sortByTitle(pl_entry &a, pl_entry &b)
{
// int comp = CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE/*|NORM_IGNOREKANATYPE*/|NORM_IGNOREWIDTH, a.strTitle, -1, b.strTitle, -1);
// return comp == CSTR_LESS_THAN;
return CompareStringLogical(a.strTitle, b.strTitle) < 0;
}
static bool PlayList_sortByDirectory(pl_entry &a, pl_entry &b) // by dir, then by title
{
const wchar_t *directory1 = a.strFile;
const wchar_t *directory2 = b.strFile;
const wchar_t *directoryEnd1 = scanstr_backcW(directory1, L"\\", 0);
const wchar_t *directoryEnd2 = scanstr_backcW(directory2 , L"\\", 0);
size_t dirLen1 = directoryEnd1 - directory1;
size_t dirLen2 = directoryEnd2 - directory2;
if (!dirLen1 && !dirLen2) // both in the current directory?
return PlayList_sortByFile(a, b); // not optimized, because the function does another scanstr_back, but easy for now :)
if (!dirLen1) // only the first dir is empty?
return true; // sort it first
if (!dirLen2) // only the second dir empty?
return false; // empty dirs go first
int comp = FileCompareLogicalN(directory1, dirLen1, directory2, dirLen2);
if (comp == 0)
return PlayList_sortByFile(a, b);
else
return comp < 0;
#if 0 // old way
int comp = CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE | /*NORM_IGNOREKANATYPE | */NORM_IGNOREWIDTH, directory1, dirLen1, directory2 , dirLen2);
if (comp == CSTR_EQUAL) // same dir
return PlayList_sortByFile(a, b); // do second sort
else // different dirs
return comp == CSTR_LESS_THAN;
#endif
}
void PlayList_mark()
{
for (int x = 0; x < list_size; x++)
list[x].tmp = 0;
list[list_pos].tmp = 1;
}
void PlayList_restore()
{
for (int x = 0; x < list_size; x ++)
{
if (list[x].tmp)
{
list_pos = x;
break;
}
}
}
void PlayList_sort(int bytitle, int start_p)
{
AutoLock lock (playlistGuard);
if (start_p >= list_size || list_size < 2 || !list) return ;
PlayList_mark();
if (bytitle == 0)
std::sort(&list[start_p], &list[list_size], PlayList_sortByFile);
else if (bytitle == 1)
std::sort(&list[start_p], &list[list_size], PlayList_sortByTitle);
else
std::sort(&list[start_p], &list[list_size], PlayList_sortByDirectory);
PlayList_restore();
Playlist_notifyModified();
}
void PlayList_reverse(void)
{
AutoLock lock (playlistGuard);
if (!list || list_size <= 1)
return ;
PlayList_mark();
std::reverse(list, &list[list_size]);
PlayList_restore();
Playlist_notifyModified();
}
void PlayList_randomize(void)
{
AutoLock lock (playlistGuard);
if (!list || list_size <= 1)
return ;
PlayList_mark();
std::random_shuffle(list, &list[list_size], Rand);
PlayList_restore();
Playlist_notifyModified();
}
void PlayList_adddir(const wchar_t *path, int recurse)
{
if (playlistManager)
{
AutoLock lock (playlistGuard);
WinampDirectoryLoad dir(recurse!=0, 0);
WinampPlaylist playlist(0);
playlistManager->LoadDirectory(path, &playlist, &dir);
}
}
void PlayList_makerelative(const wchar_t *listfile, wchar_t *filename, int useBase)
{
if (useBase)
MakeRelativePathName(filename, filename, M3UBASE);
else
{
wchar_t path[MAX_PATH] = {0};
StringCchCopyW(path, MAX_PATH, listfile);
PathRemoveFileSpecW(path);
PathRemoveBackslashW(path);
MakeRelativePathName(filename, filename, path);
}
}
}
static void Playlist_notifyModified()
{
plneedsave = plmodified = 1;
SendMessageW(hMainWindow, WM_WA_IPC, 0, IPC_PLAYLIST_MODIFIED);
}
int IsPlaylistExtension(const wchar_t *ext)
{
wchar_t temp[32] = {0};
StringCchPrintfW(temp, 32, L"hi.%s", ext);
if (playlistManager && playlistManager->CanLoad(temp)) // TODO: make a "valid extension" method
return 1;
else
return 0;
}
int IsPlaylistExtensionA(const char *ext)
{
return IsPlaylistExtension(AutoWide(ext));
}
void GetMIMEType(const char *url, char *mimeType, int mimeTypeCch);
int LoadPlaylistByExtension(const wchar_t *fn, const wchar_t *ext, int whattodo, int useBase)
{
if (!playlistManager || !playlistManager->CanLoad(ext))
return -1;
//if (useBase)
// WASABI_API_APP->path_setWorkingPath(M3UBASE);
//cut: SetCurrentDirectoryW(M3UBASE);
int i = 0;
if (PathIsURLW(fn))
{
int rval = 1;
if (!httpRetrieveFileW(hMainWindow, AutoChar(fn), TEMP_FILE, getStringW(IDS_RETRPL, NULL, 0)))
{
rval = LoadPlaylistByExtension(TEMP_FILE, ext, whattodo, useBase);
}
DeleteFileW(TEMP_FILE);
return rval;
}
if (PlayList_getlength())
{
if (whattodo < 1)
{
PlayList_delete();
i = 1;
}
}
WinampPlaylist playlist(useBase?M3UBASE:0, !useBase);
playlistManager->LoadAs(fn, ext, &playlist);
if (i)
{
StopPlaying(0);
if (config_shuffle) PlayList_randpos( -BIGINT);
PlayList_getcurrent(FileName, FileTitle, FileTitleNum);
if (whattodo == 0) StartPlaying();
}
return 0;
}
int LoadPlaylist(const wchar_t *filename, int whattodo, int doMIMEcheck)
{
wchar_t ext[65]=L".";
extension_exW(filename, ext+1, 64); // TODO: make api_playlistmanager use this function
int x = LoadPlaylistByExtension(filename, ext, whattodo, 0);
if (doMIMEcheck && x == -1 && PathIsURLW(filename))
{
/*
benski> disabled for now
GetMIMEType(AutoChar(filename), ext, 64);
if (*ext)
{
if (!_stricmp(ext, "video/x-ms-asf"))
return LoadPlaylistByExtension(filename, L".asx", whattodo, 0); // TODO: make "load playlist by MIME type" API
else if (!_stricmp(ext, "video/asx"))
return LoadPlaylistByExtension(filename, L".asx", whattodo, 0);
}
*/
}
return x;
}
void PlayList_insert(int position, const wchar_t *filename)
{
AutoLock lock (playlistGuard);
PlayList_saveend(position);
PlayList_appendthing(filename, 0, 0);
PlayList_restoreend();
}
Reference in New Issue View Git Blame Copy Permalink