开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
CPI_Playlist.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：62k
源码类别：

多媒体编程

开发平台：

Visual C++

CPI_Playlist.c：源码内容
  2. ////////////////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  7. #include "globals.h"
  8. #include "CPI_Playlist.h"
  9. #include "CPI_PlaylistItem.h"
  10. #include "CPI_PlaylistItem_Internal.h"
  11. #include "CPI_Player.h"
  14. #define CPC_TRACKSTACK_BUFFER_QUANTISATION 32
  15. typedef int (__cdecl *wp_SortFN)(const void *elem1, const void *elem2);
  16. int __cdecl exp_CompareStrings(const void *elem1, const void *elem2);
  17. DWORD WINAPI CPI_PlaylistWorkerThreadEP(void* pCookie);
  18. ////////////////////////////////////////////////////////////////////////////////
  19. //
  20. typedef struct _CPs_PlaylistWorkerThreadInfo
  21. {
  22.     DWORD m_dwHostThreadID;
  23.     DWORD m_dwCurrentBatchID;
  25. } CPs_PlaylistWorkerThreadInfo;
  26. //
  27. //
  28. typedef struct _CPs_Playlist
  29. {
  30.     CP_HPLAYLISTITEM m_hFirst;
  31.     CP_HPLAYLISTITEM m_hLast;
  32.     CP_HPLAYLISTITEM m_hCurrent;
  34.     CP_HPLAYLISTITEM* m_pTrackStack;
  35.     unsigned int m_iTrackStackSize;
  36.     unsigned int m_iTrackStackBufferSize;
  37.     unsigned int m_iTrackStackCursor;
  39.     HANDLE m_hWorkerThread;
  40.     DWORD m_dwWorkerThreadID;
  41.     CPs_PlaylistWorkerThreadInfo m_WorkerThreadInfo;
  42.     BOOL m_bSyncLoadNextFile;
  43.     BOOL m_bAutoActivateInitial;
  45. } CPs_Playlist;
  46. //
  47. //
  48. typedef enum _CPe_PlayListFileType
  49. {
  50.     pftUnknown,
  51.     pftPLS,
  52.     pftM3U
  53. } CPe_PlayListFileType;
  54. //
  55. typedef struct _CPs_FilenameLLItem
  56. {
  57.     char* m_pcFilename;
  58.     void* m_pNextItem;
  59. } CPs_FilenameLLItem;
  60. //
  61. //
  62. #define CPC_PLAYLISTWORKER_NOTIFYCHUNKSIZE 32
  63. typedef struct _CPs_NotifyChunk
  64. {
  65.     int m_iNumberInChunk;
  66.     CP_HPLAYLISTITEM m_aryItems[CPC_PLAYLISTWORKER_NOTIFYCHUNKSIZE];
  67.     DWORD m_aryBatchIDs[CPC_PLAYLISTWORKER_NOTIFYCHUNKSIZE];
  69. } CPs_NotifyChunk;
  70. //
  71. ////////////////////////////////////////////////////////////////////////////////
  75. ////////////////////////////////////////////////////////////////////////////////
  76. //
  77. //
  78. //
  79. CP_HPLAYLIST CPL_CreatePlaylist()
  80. {
  81.     CPs_Playlist* pNewPlaylist = (CPs_Playlist*)malloc(sizeof(CPs_Playlist));
  82.     pNewPlaylist->m_hFirst = NULL;
  83.     pNewPlaylist->m_hLast = NULL;
  84.     pNewPlaylist->m_hCurrent = NULL;
  86.     pNewPlaylist->m_pTrackStack = NULL;
  87.     pNewPlaylist->m_iTrackStackSize = 0;
  88.     pNewPlaylist->m_iTrackStackBufferSize = 0;
  89.     pNewPlaylist->m_iTrackStackCursor = 0;
  90.     pNewPlaylist->m_bSyncLoadNextFile = FALSE;
  91.     pNewPlaylist->m_bAutoActivateInitial = FALSE;
  93.     pNewPlaylist->m_WorkerThreadInfo.m_dwHostThreadID = GetCurrentThreadId();
  94.     pNewPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID = 0;
  96.     // Create worker thread
  97.     pNewPlaylist->m_hWorkerThread = CreateThread(NULL, 0, CPI_PlaylistWorkerThreadEP, &pNewPlaylist->m_WorkerThreadInfo, 0, &(pNewPlaylist->m_dwWorkerThreadID) );
  98.     CP_ASSERT(pNewPlaylist->m_hWorkerThread);
  100.     return pNewPlaylist;
  101. }
  102. //
  103. //
  104. //
  105. void CPL_DestroyPlaylist(CP_HPLAYLIST hPlaylist)
  106. {
  107.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  108.     CP_CHECKOBJECT(pPlaylist);
  110.     // Stop the worker thread from processing any more pending ID3 reads
  111.     pPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID++;
  113.     // Request worker thread to shutdown
  114.     PostThreadMessage(pPlaylist->m_dwWorkerThreadID, CPPLWT_TERMINATE, 0, 0);
  116.     // Clean up list
  117.     CPL_Empty(hPlaylist);
  119.     // Delete an unattached active item
  120.     if(pPlaylist->m_hCurrent && CPLII_DECODEHANDLE(pPlaylist->m_hCurrent)->m_bDestroyOnDeactivate)
  121.         CPLII_DestroyItem(pPlaylist->m_hCurrent);
  123.     // Wait for shutdown to actually happen
  124.     WaitForSingleObject(pPlaylist->m_hWorkerThread, INFINITE);
  125.     CloseHandle(pPlaylist->m_hWorkerThread);
  127.     // Remove any read ID3s from our message queue
  128.     {
  129.         MSG msg;
  130.         while(PeekMessage(&msg, NULL, CPPLNM_TAGREAD, CPPLNM_TAGREAD, PM_REMOVE) )
  131.         {
  132.             CPs_NotifyChunk* pChunk = (CPs_NotifyChunk*)msg.wParam;
  133.             int iChunkItemIDX;
  135.             // Add all of the items in the chunk
  136.             for(iChunkItemIDX = 0; iChunkItemIDX < pChunk->m_iNumberInChunk; iChunkItemIDX++)
  137.                 CPLII_DestroyItem(pChunk->m_aryItems[iChunkItemIDX]);
  138.             free(pChunk);
  139.         }
  140.     }
  142.     // Clean up object
  143.     free(pPlaylist);
  144. }
  145. //
  146. //
  147. //
  148. void CPL_UnlinkItem(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  149. {
  150.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  151.     CPs_PlaylistItem* pItemToUnlink = CPLII_DECODEHANDLE(hItem);
  152.     CP_CHECKOBJECT(pPlaylist);
  154.     // Remove item from list
  155.     if(pItemToUnlink->m_hPrev)
  156.         CPLII_DECODEHANDLE(pItemToUnlink->m_hPrev)->m_hNext = pItemToUnlink->m_hNext;
  157.     else
  158.     {
  159.         CP_ASSERT(pPlaylist->m_hFirst == hItem);
  160.         pPlaylist->m_hFirst = pItemToUnlink->m_hNext;
  161.     }
  163.     if(pItemToUnlink->m_hNext)
  164.         CPLII_DECODEHANDLE(pItemToUnlink->m_hNext)->m_hPrev = pItemToUnlink->m_hPrev;
  165.     else
  166.     {
  167.         CP_ASSERT(pPlaylist->m_hLast == hItem);
  168.         pPlaylist->m_hLast = pItemToUnlink->m_hPrev;
  169.     }
  170. }
  171. //
  172. //
  173. //
  174. void CPL_Empty(CP_HPLAYLIST hPlaylist)
  175. {
  176.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  177.     CP_HPLAYLISTITEM hCursor, hNext;
  179.     CP_CHECKOBJECT(pPlaylist);
  181.     // Stop the worker thread from processing any more pending ID3 reads
  182.     pPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID++;
  184.     // Unlink the active item
  185.     if(pPlaylist->m_hCurrent)
  186.     {
  187.         // This is the active item - clear it's next and prev entries and mark it
  188.         // so that it's destroyed when activation next changes
  189.         CPs_PlaylistItem* pActiveItem = CPLII_DECODEHANDLE(pPlaylist->m_hCurrent);
  190.         if(pActiveItem->m_bDestroyOnDeactivate == FALSE)
  191.         {
  192.             CPL_UnlinkItem(hPlaylist, pPlaylist->m_hCurrent);
  193.             pActiveItem->m_hNext = NULL;
  194.             pActiveItem->m_hPrev = NULL;
  195.             pActiveItem->m_bDestroyOnDeactivate = TRUE;
  196.             CPL_cb_OnPlaylistActivationChange(pPlaylist->m_hCurrent, FALSE);
  197.             pActiveItem->m_iCookie = CPC_INVALIDITEM;
  198.         }
  199.     }
  201.     // Callback
  202.     CPL_cb_OnPlaylistEmpty();
  204.     // Clean up items
  205.     hCursor = pPlaylist->m_hFirst;
  206.     while(hCursor)
  207.     {
  208.         hNext = CPLI_Next(hCursor);
  209.         CPLII_DestroyItem(hCursor);
  210.         hCursor = hNext;
  211.     }
  213.     // Reset state
  214.     pPlaylist->m_hFirst = NULL;
  215.     pPlaylist->m_hLast = NULL;
  217.     // Clean up the trackstack
  218.     if(pPlaylist->m_pTrackStack)
  219.         free(pPlaylist->m_pTrackStack);
  220.     pPlaylist->m_pTrackStack = NULL;
  221.     pPlaylist->m_iTrackStackSize = 0;
  222.     pPlaylist->m_iTrackStackBufferSize = 0;
  223.     pPlaylist->m_iTrackStackCursor = 0;
  224. }
  225. //
  226. //
  227. //
  228. void CPL_AddSingleFile_pt2(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hNewFile, const DWORD dwBatchID)
  229. {
  230.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  231.     const char* pcPath = CPLI_GetPath(hNewFile);
  233.     CP_CHECKOBJECT(pPlaylist);
  235.     // Batch has changed since this message was sent
  236.     if(dwBatchID != pPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID)
  237.     {
  238.         CPLII_DestroyItem(hNewFile);
  239.         return;
  240.     }
  242.     // If items are only allowed once - look for another instance of this item
  243.     // and skip this add if it is found
  244.     if(options.allow_file_once_in_playlist)
  245.     {
  246.         CP_HPLAYLISTITEM hCursor;
  247.         hCursor = pPlaylist->m_hFirst;
  248.         while(hCursor)
  249.         {
  250.             // Is this item in the list already?
  251.             if(stricmp(CPLII_DECODEHANDLE(hCursor)->m_pcPath, pcPath) == 0)
  252.             {
  253.                 CPLII_DestroyItem(hNewFile);
  254.                 return;
  255.             }
  257.             hCursor = CPLI_Next(hCursor);
  258.         }
  259.     }
  261.     // Add item to the list
  262.     CPLII_DECODEHANDLE(hNewFile)->m_hPrev = pPlaylist->m_hLast;
  263.     if(pPlaylist->m_hLast)
  264.         CPLII_DECODEHANDLE(pPlaylist->m_hLast)->m_hNext = hNewFile;
  265.     pPlaylist->m_hLast = hNewFile;
  266.     if(pPlaylist->m_hFirst == NULL)
  267.         pPlaylist->m_hFirst = hNewFile;
  269.     // If there is no track name (ID3 read off or failed) - create one from the path
  270.     if(CPLII_DECODEHANDLE(hNewFile)->m_pcTrackName == NULL)
  271.     {
  272.         int iNumChars;
  273.         int iCharIDX;
  274.         int iLastSlashIDX = CPC_INVALIDCHAR;
  275.         int iLastDotIDX = CPC_INVALIDCHAR;
  276.         int iLastCharIDX = CPC_INVALIDCHAR;
  277. if(strnicmp(pcPath,CIC_HTTPHEADER,strlen(CIC_HTTPHEADER)) == 0)
  278.             iLastCharIDX = strlen(pcPath);
  279. else
  280.         for(iCharIDX=0; pcPath[iCharIDX]; iCharIDX++)
  281.         {
  282.             if(pcPath[iCharIDX] == '\')
  283.                 iLastSlashIDX = iCharIDX;
  284.             if(pcPath[iCharIDX] == '.')
  285.                 iLastDotIDX = iCharIDX;
  286.             iLastCharIDX = iCharIDX;
  287.         }
  289.         // Correct indices
  290.         if(iLastSlashIDX == CPC_INVALIDCHAR)
  291.             iLastSlashIDX = 0;
  292.         else
  293.             iLastSlashIDX++; // We want the char after the last slash
  294.         if(iLastDotIDX == CPC_INVALIDCHAR || iLastDotIDX < iLastSlashIDX)
  295.             iLastDotIDX = iLastCharIDX;
  296.         else
  297.             iLastDotIDX--; // We want the string up to the char before the last dot
  299.         // Create title buffer
  300.         iNumChars = (iLastDotIDX-iLastSlashIDX)+1;
  301.         CPLII_DECODEHANDLE(hNewFile)->m_pcTrackName = (char*)malloc(iNumChars+1);
  302.         memcpy(CPLII_DECODEHANDLE(hNewFile)->m_pcTrackName, pcPath+iLastSlashIDX, iNumChars);
  303.         CPLII_DECODEHANDLE(hNewFile)->m_pcTrackName[iNumChars] = '';
  304.     }
  306.     // Add to track stack
  307.     CPL_Stack_Append(hPlaylist, hNewFile);
  309.     // Callback
  310.     CPL_cb_OnPlaylistAppend(hNewFile);
  311. }
  312. //
  313. //
  314. //
  315. void CPL_AddSingleFile(CP_HPLAYLIST hPlaylist, const char* pcPath, const char* pcTitle)
  316. {
  317.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  318.     CP_HPLAYLISTITEM hNewFile;
  319.     CP_CHECKOBJECT(pPlaylist);
  321.     hNewFile = CPLII_CreateItem(pcPath);
  323.     // There was a title passed - setup the item accordingly
  324.     if(pcTitle && pcTitle[0])
  325.         STR_AllocSetString(&CPLII_DECODEHANDLE(hNewFile)->m_pcTrackName, pcTitle, FALSE);
  327.     // Defer this add to the worker thread if we are reading tags
  328.     if(options.read_id3_tag && options.read_id3_tag_in_background && !pPlaylist->m_bSyncLoadNextFile)
  329.     {
  330.         while(!PostThreadMessage(pPlaylist->m_dwWorkerThreadID, CPPLWT_READTAG, (WPARAM)pPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID, (LPARAM)hNewFile))
  331.         { 
  332. Sleep(50); 
  333. }       
  334. if(pPlaylist->m_bAutoActivateInitial && stricmp(pcPath, options.initial_file) == 0)
  335.             PostThreadMessage(pPlaylist->m_dwWorkerThreadID, CPPLWT_SETACTIVE, (WPARAM)pPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID, (LPARAM)hNewFile);
  336.     }
  337.     else
  338.     {
  339.         pPlaylist->m_bSyncLoadNextFile = FALSE;
  340.         if(options.read_id3_tag)
  341.             CPLI_ReadTag(hNewFile);
  343.         // If we didn't get a track length from the tag - work it out
  344.         if(CPLI_GetTrackLength(hNewFile) == 0
  345.                 && options.work_out_track_lengths)
  346.         {
  347.             CPLI_CalculateLength(hNewFile);
  348.         }
  350.         CPL_AddSingleFile_pt2(hPlaylist, hNewFile, pPlaylist->m_WorkerThreadInfo.m_dwCurrentBatchID);
  351.     }
  352. }
  353. //
  354. //
  355. //
  356. void CPL_HandleAsyncNotify(CP_HPLAYLIST hPlaylist, WPARAM wParam, LPARAM lParam)
  357. {
  358.     CPs_NotifyChunk* pChunk = (CPs_NotifyChunk*)wParam;
  359.     int iChunkItemIDX;
  361.     // Add all of the items in the chunk
  362.     CLV_BeginBatch(globals.m_hPlaylistViewControl);
  363.     for(iChunkItemIDX = 0; iChunkItemIDX < pChunk->m_iNumberInChunk; iChunkItemIDX++)
  364.         CPL_AddSingleFile_pt2(globals.m_hPlaylist, pChunk->m_aryItems[iChunkItemIDX], pChunk->m_aryBatchIDs[iChunkItemIDX]);
  365.     CLV_EndBatch(globals.m_hPlaylistViewControl);
  367.     // Cleanup
  368.     free(pChunk);
  369. }
  370. //
  371. //
  372. //
  373. void CPL_RemoveDuplicates(CP_HPLAYLIST hPlaylist)
  374. {
  375.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  376.     CP_HPLAYLISTITEM hCursor;
  377.     CP_CHECKOBJECT(pPlaylist);
  379.     // Scan the playlist removing duplicates
  380.     hCursor = pPlaylist->m_hFirst;
  381.     while(hCursor)
  382.     {
  383.         CP_HPLAYLISTITEM hCursor_Scan;
  385.         // Look for duplicates after this item (as all items will be scanned
  386.         // in this way there is no need to look for duplicates before this item)
  387.         hCursor_Scan = CPLI_Next(hCursor);
  388.         while(hCursor_Scan)
  389.         {
  390.             // Is this a duplicate
  391.             if(stricmp( CPLII_DECODEHANDLE(hCursor_Scan)->m_pcPath,
  392.                         CPLII_DECODEHANDLE(hCursor)->m_pcPath) == 0)
  393.             {
  394.                 CPL_RemoveItem(hPlaylist, hCursor_Scan);
  396.                 // Items before the current are already unique - stop scanning
  397.                 break;
  398.             }
  400.             hCursor_Scan = CPLI_Next(hCursor_Scan);
  401.         }
  403.         hCursor = CPLI_Next(hCursor);
  404.     }
  405. }
  406. //
  407. //
  408. //
  409. void CPL_PlayActiveItem(CP_HPLAYLIST hPlaylist, const BOOL bStopFirst)
  410. {
  411.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  412.     CP_CHECKOBJECT(pPlaylist);
  414.     // Stop
  415.     if(bStopFirst == TRUE)
  416.         CPI_Player__Stop(globals.m_hPlayer);
  418.     // Start playing
  419.     if(pPlaylist->m_hCurrent)
  420.     {
  421.         CPI_Player__OpenFile(globals.m_hPlayer, CPLI_GetPath(pPlaylist->m_hCurrent));
  422.         CPI_Player__Play(globals.m_hPlayer);
  423.     }
  424. }
  425. //
  426. //
  427. //
  428. void CPL_RemoveItem(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  429. {
  430.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  431.     CP_CHECKOBJECT(pPlaylist);
  433.     // Callback
  434.     CPL_cb_OnPlaylistItemDelete(hItem);
  435.     CPL_UnlinkItem(hPlaylist, hItem);
  437.     // Remove item from track stack
  438.     CPL_Stack_Remove(hPlaylist, hItem);
  440.     if(hItem == pPlaylist->m_hCurrent)
  441.     {
  442.         // This is the active item - clear it's next and prev entries and mark it
  443.         // so that it's destroyed when activation next changes
  444.         CPs_PlaylistItem* pActiveItem = CPLII_DECODEHANDLE(hItem);
  445.         pActiveItem->m_hNext = NULL;
  446.         pActiveItem->m_hPrev = NULL;
  447.         pActiveItem->m_bDestroyOnDeactivate = TRUE;
  448.         CPL_cb_OnPlaylistActivationChange(hItem, FALSE);
  449.         pActiveItem->m_iCookie = CPC_INVALIDITEM;
  450.     }
  451.     else
  452.     {
  453.         // Cleanup
  454.         CPLII_DestroyItem(hItem);
  455.     }
  456. }
  457. //
  458. //
  459. //
  460. void CPL_SetActiveItem(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  461. {
  462.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  463.     CP_CHECKOBJECT(pPlaylist);
  465.     if(pPlaylist->m_hCurrent == hItem)
  466.         return;
  468.     // Unset any previous activation state
  469.     if(pPlaylist->m_hCurrent)
  470.     {
  471.         if(CPLII_DECODEHANDLE(pPlaylist->m_hCurrent)->m_bDestroyOnDeactivate)
  472.             CPLII_DestroyItem(pPlaylist->m_hCurrent);
  473.         else
  474.             CPL_cb_OnPlaylistActivationChange(pPlaylist->m_hCurrent, FALSE);
  475.     }
  477.     pPlaylist->m_hCurrent = hItem;
  479.     // Set new activation state
  480.     if(pPlaylist->m_hCurrent)
  481.     {
  482.         CPL_cb_OnPlaylistActivationChange(pPlaylist->m_hCurrent, TRUE);
  483.         if(options.read_id3_tag_of_selected == TRUE)
  484.             CPLI_ReadTag(hItem);
  485.     }
  486.     else
  487.         CPL_cb_OnPlaylistActivationEmpty();
  489.     // Update track stack
  490.     CPL_Stack_SetCursor(hPlaylist, pPlaylist->m_hCurrent);
  492.     // Setup the initial file buffer (for remember last played)
  493.     if(pPlaylist->m_hCurrent)
  494.         strncpy(options.initial_file, CPLI_GetPath(hItem), sizeof(options.initial_file));
  495. }
  496. //
  497. //
  498. //
  499. void CPL_PlayItem(CP_HPLAYLIST hPlaylist, const BOOL bStopFirst, const CPe_PlayMode enPlayMode)
  500. {
  501.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  502.     CP_HPLAYLISTITEM hItemToPlay = NULL;
  503.     CP_CHECKOBJECT(pPlaylist);
  505.     // Decide on what to play
  506.     switch(enPlayMode)
  507.     {
  508.     case pmCurrentItem:
  509.         if(pPlaylist->m_hCurrent)
  510.         {
  511.             // If the current item is no longer in the list and we are stopping - play the first item
  512.             if(bStopFirst == TRUE || CPLII_DECODEHANDLE(pPlaylist->m_hCurrent)->m_bDestroyOnDeactivate)
  513.             {
  514.                 if(pPlaylist->m_iTrackStackSize > 0)
  515.                 {
  516.                     if(pPlaylist->m_iTrackStackCursor < pPlaylist->m_iTrackStackSize)
  517.                         hItemToPlay = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor];
  518.                     else
  519.                         hItemToPlay = pPlaylist->m_pTrackStack[0];
  520.                 }
  521.             }
  522.             else
  523.                 hItemToPlay = pPlaylist->m_hCurrent;
  524.         }
  525.         else
  526.         {
  527.             if(pPlaylist->m_iTrackStackCursor < pPlaylist->m_iTrackStackSize)
  528.             {
  529.                 hItemToPlay = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor];
  530.             }
  531.             else
  532.             {
  533.                 if(options.shuffle_play)
  534.                     CPL_Stack_Shuffle(globals.m_hPlaylist, FALSE);
  535.                 if(pPlaylist->m_iTrackStackSize > 0)
  536.                     hItemToPlay = pPlaylist->m_pTrackStack[0];
  537.             }
  538.         }
  539.         break;
  541.     case pmNextItem:
  543.         // If the currently playing track is not the one at the head of the stack - play the head of the stack
  544.         if(pPlaylist->m_hCurrent
  545.                 && pPlaylist->m_iTrackStackCursor < pPlaylist->m_iTrackStackSize
  546.                 && pPlaylist->m_hCurrent != pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor])
  547.         {
  548.             hItemToPlay = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor];
  549.         }
  551.         // Play the next item from the track stack
  552.         if(hItemToPlay == NULL)
  553.         {
  554.             if(pPlaylist->m_iTrackStackCursor < pPlaylist->m_iTrackStackSize)
  555.                 pPlaylist->m_iTrackStackCursor++;
  556.             if(pPlaylist->m_iTrackStackCursor < pPlaylist->m_iTrackStackSize)
  557.                 hItemToPlay = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor];
  558.         }
  560.         if(hItemToPlay == NULL && options.repeat_playlist == TRUE)
  561.         {
  562.             if(options.shuffle_play)
  563.                 CPL_Stack_Shuffle(globals.m_hPlaylist, FALSE);
  564.             if(pPlaylist->m_iTrackStackSize > 0)
  565.                 hItemToPlay = pPlaylist->m_pTrackStack[0];
  566.         }
  567.         break;
  569.     case pmPrevItem:
  570.         // Play the prev item in the track stack
  571.         if(pPlaylist->m_iTrackStackCursor > 0)
  572.             hItemToPlay = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor-1];
  573.         else
  574.         {
  575.             if(options.repeat_playlist == TRUE)
  576.             {
  577.                 if(pPlaylist->m_iTrackStackSize > 0)
  578.                     hItemToPlay = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackSize-1];
  579.             }
  580.             else if(pPlaylist->m_iTrackStackSize > 0)
  581.                 hItemToPlay = pPlaylist->m_pTrackStack[0];
  582.         }
  583.         break;
  585.     default:
  586.         CP_FAIL(UnknownPlayMode);
  587.     }
  589.     CPL_SetActiveItem(hPlaylist, hItemToPlay);
  590.     CPL_PlayActiveItem(hPlaylist, bStopFirst);
  591. }
  592. //
  593. //
  594. //
  595. CP_HPLAYLISTITEM CPL_GetFirstItem(CP_HPLAYLIST hPlaylist)
  596. {
  597.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  598.     CP_CHECKOBJECT(pPlaylist);
  600.     return pPlaylist->m_hFirst;
  601. }
  602. //
  603. //
  604. //
  605. CP_HPLAYLISTITEM CPL_GetLastItem(CP_HPLAYLIST hPlaylist)
  606. {
  607.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  608.     CP_CHECKOBJECT(pPlaylist);
  610.     return pPlaylist->m_hLast;
  611. }
  612. //
  613. //
  614. //
  615. CP_HPLAYLISTITEM CPL_GetActiveItem(CP_HPLAYLIST hPlaylist)
  616. {
  617.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  618.     CP_CHECKOBJECT(pPlaylist);
  620.     return pPlaylist->m_hCurrent;
  621. }
  622. //
  623. //
  624. //
  625. CP_HPLAYLISTITEM CPL_FindPlaylistItem(CP_HPLAYLIST hPlaylist, const char* pcPath)
  626. {
  627.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  628.     CP_HPLAYLISTITEM hCursor;
  629.     CP_CHECKOBJECT(pPlaylist);
  631.     for(hCursor = pPlaylist->m_hFirst; hCursor; hCursor = CPLI_Next(hCursor))
  632.     {
  633.         CP_TRACE1("Looked at "%s"", CPLII_DECODEHANDLE(hCursor)->m_pcPath);
  634.         if(stricmp(CPLII_DECODEHANDLE(hCursor)->m_pcPath, pcPath) == 0)
  635.             return hCursor;
  636.     }
  638.     return NULL;
  639. }
  640. //
  641. //
  642. //
  643. void WriteFile_Text(HANDLE hFile, const char* pcLine, const BOOL bAppendCR)
  644. {
  645.     DWORD dwBytesWritten;
  646.     int iLineLen = strlen(pcLine);
  647.     WriteFile(hFile, pcLine, iLineLen, &dwBytesWritten, NULL);
  648.     if(bAppendCR)
  649.         WriteFile(hFile, "rn", 2, &dwBytesWritten, NULL);
  650. }
  651. //
  652. //
  653. //
  654. CPe_PlayListFileType CPL_GetFileType(const char* pcPath)
  655. {
  656.     // Determine format from file extension
  657.     const char* pcExtension = NULL;
  658.     int iCharIDX;
  660.     // Find the extension (the chars after the last dot)
  661.     for(iCharIDX = 0; pcPath[iCharIDX]; iCharIDX++)
  662.     {
  663.         if(pcPath[iCharIDX] == '.')
  664.             pcExtension = pcPath + iCharIDX + 1;
  665.         else if(pcPath[iCharIDX] == '\')
  666.             pcExtension = NULL;
  667.     }
  669.     // No extension - we don't know what format to use!
  670.     if(pcExtension == NULL)
  671.         return pftUnknown;
  673.     if(stricmp(pcExtension, "pls") == 0)
  674.         return pftPLS;
  675.     else if(stricmp(pcExtension, "m3u") == 0)
  676.         return pftM3U;
  678.     return pftUnknown;
  679. }
  680. //
  681. //
  682. //
  683. unsigned int CPL_GetPathVolumeBytes(const char* pcPath)
  684. {
  685.     // We understand volumes in the format of C: or \SYSTEMNAMESHAREPOINT so look for
  686.     // these
  687.     if(pcPath[1] == ':')
  688.         return 3;
  689.     else if(pcPath[0] == '\' && pcPath[1] == '\')
  690.     {
  691.         int iCharIDX;
  692.         int iNumSlashesFound;
  694.         // UNCs format is \SERVERSharePointpath
  696.         // Find the second slash (skipping the double slash at the start)
  697.         iNumSlashesFound = 0;
  698.         for(iCharIDX = 2; pcPath[iCharIDX]; iCharIDX++)
  699.         {
  700.             if(pcPath[iCharIDX] == '\')
  701.                 iNumSlashesFound++;
  703.             // We've found the second slash - build the prefix
  704.             if(iNumSlashesFound == 2)
  705.                 return iCharIDX+1;
  706.         }
  707.     }
  708.     else if(strnicmp(pcPath, CIC_HTTPHEADER, sizeof(CIC_HTTPHEADER)-1) == 0)
  709.         return sizeof(CIC_HTTPHEADER);
  711.     // There is no volume information
  712.     return 0;
  713. }
  714. //
  715. //
  716. //
  717. unsigned int CPL_GetPathDirectoryBytes(const char* pcPath, const unsigned int iVolumeBytes)
  718. {
  719.     unsigned int iCharIDX;
  720.     unsigned int iLastSlashIDX;
  722.     // Find the last slash and trim everything before it
  723.     // - if there is no directory stub then empty this string
  724.     iLastSlashIDX = 0;
  725.     for(iCharIDX = iVolumeBytes; pcPath[iCharIDX]; iCharIDX++)
  726.     {
  727.         if(pcPath[iCharIDX] == '\')
  728.             iLastSlashIDX = iCharIDX + 1;
  729.     }
  731.     return iLastSlashIDX;
  732. }
  733. //
  734. //
  735. //
  736. void CPL_ExportPlaylist(CP_HPLAYLIST hPlaylist, const char* pcOutputName)
  737. {
  738.     HANDLE hOutputFile;
  739.     CPe_PlayListFileType enFileType;
  740.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  741.     const unsigned int iPlaylist_VolumeBytes = CPL_GetPathVolumeBytes(pcOutputName);
  742.     const unsigned int iPlaylist_DirectoryBytes = CPL_GetPathDirectoryBytes(pcOutputName, iPlaylist_VolumeBytes);
  744.     CP_CHECKOBJECT(pPlaylist);
  746.     // Check for known file types
  747.     enFileType = CPL_GetFileType(pcOutputName);
  748.     if(enFileType == pftUnknown)
  749.         return;
  751.     // Open the file
  752.     hOutputFile = CreateFile(pcOutputName, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  753.     if(hOutputFile == INVALID_HANDLE_VALUE)
  754.     {
  755.         MessageBox(windows.wnd_main, "Could not open file", "Error", MB_ICONERROR);
  756.         return;
  757.     }
  759.     // Go through all playlist items - outputting them to the file
  760.     {
  761.         CP_HPLAYLISTITEM hCursor;
  762.         int iFileNumber;
  764.         // If this is a PLS file then write some header info
  765.         if(enFileType == pftPLS)
  766.         {
  767.             int iNumberOfEntries =0;
  768.             char cNumEntriesLine[32];
  770.             WriteFile_Text(hOutputFile, "[PlayList]", TRUE);
  772.             // Count the number of playlist items
  773.             for(hCursor = pPlaylist->m_hFirst; hCursor; hCursor = CPLI_Next(hCursor))
  774.                 iNumberOfEntries++;
  776.             sprintf(cNumEntriesLine, "NumberOfEntries=%d", iNumberOfEntries);
  777.             WriteFile_Text(hOutputFile, cNumEntriesLine, TRUE);
  778.         }
  780.         iFileNumber = 0;
  781.         for(hCursor = pPlaylist->m_hFirst; hCursor; hCursor = CPLI_Next(hCursor), iFileNumber++)
  782.         {
  783.             char cRelPath[MAX_PATH];
  784.             const char* _pcFilename = CPLI_GetPath(hCursor);
  786.             // We prefer relative paths in our playlist files - only works if playlist
  787.             // and target are on the same volume
  788.             if(strnicmp(_pcFilename, pcOutputName, iPlaylist_VolumeBytes) == 0)
  789.             {
  790.                 // - so strip off the directory stubs that the file and playlist may have in common
  791.                 const char* pcLastCommonSplitPoint = _pcFilename;
  792.                 unsigned int iCharIDX;
  794.                 for(iCharIDX = 0; _pcFilename[iCharIDX] && iCharIDX < iPlaylist_DirectoryBytes; iCharIDX++)
  795.                 {
  796.                     if(tolower(_pcFilename[iCharIDX]) != tolower(pcOutputName[iCharIDX]))
  797.                         break;
  799.                     if(_pcFilename[iCharIDX] == '\')
  800.                         pcLastCommonSplitPoint = _pcFilename+iCharIDX+1;
  801.                 }
  803.                 // - add a .. for every slash left in the playlist's path
  804.                 cRelPath[0] = '';
  805.                 for(; iCharIDX < iPlaylist_DirectoryBytes; iCharIDX++)
  806.                 {
  807.                     if(pcOutputName[iCharIDX] == '\')
  808.                         strcat(cRelPath, "..\");
  809.                 }
  810.                 strcat(cRelPath, pcLastCommonSplitPoint);
  811.             }
  812.             else
  813.                 strcpy(cRelPath, _pcFilename);
  815.             // PLS files have the format FileXXX=pathname - we want to write the stuff up to (and including)
  816.             // the equals sign
  817.             if(enFileType == pftPLS)
  818.             {
  819.                 char cPlsFileHeader[32];
  820.                 sprintf(cPlsFileHeader, "File%d=", iFileNumber + 1);
  821.                 WriteFile_Text(hOutputFile, cPlsFileHeader, FALSE);
  822.             }
  824.             // Write the filename
  825.             WriteFile_Text(hOutputFile, cRelPath, TRUE);
  826.         }
  827.     }
  829.     CloseHandle(hOutputFile);
  830. }
  831. //
  832. //
  833. //
  834. void CPL_AddPrefixedFile( CP_HPLAYLIST hPlaylist,
  835.                           const char* pcFilename, const char* pcTitle,
  836.                           const char* pcPlaylistFile,
  837.                           const unsigned int iPlaylist_VolumeBytes,
  838.                           const unsigned int iPlaylist_DirBytes)
  839. {
  840.     const unsigned int iFile_VolumeBytes = CPL_GetPathVolumeBytes(pcFilename);
  842.     // If the file has volume information - add it as it is
  843.     if(iFile_VolumeBytes)
  844.         CPL_AddSingleFile(hPlaylist, pcFilename, pcTitle);
  845.     // If the filename has a leading  then add it prepended by the playlist's volume
  846.     else if(pcFilename[0] == '\')
  847.     {
  848.         char cFullPath[MAX_PATH];
  849.         memcpy(cFullPath, pcPlaylistFile, iPlaylist_VolumeBytes);
  850.         strcpy(cFullPath + iPlaylist_VolumeBytes, pcFilename + 1);
  851.         CPL_AddSingleFile(hPlaylist, cFullPath, pcTitle);
  852.     }
  853.     // Add the filename prepended by the playlist's directory
  854.     else
  855.     {
  856.         char cFullPath[MAX_PATH];
  857.         memcpy(cFullPath, pcPlaylistFile, iPlaylist_DirBytes);
  858.         strcpy(cFullPath + iPlaylist_DirBytes, pcFilename);
  859.         CPL_AddSingleFile(hPlaylist, cFullPath, pcTitle);
  860.     }
  861. }
  862. //
  863. //
  864. //
  865. void CPL_AddFile(CP_HPLAYLIST hPlaylist, const char* pcFilename)
  866. {
  867.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  868.     CPe_PlayListFileType enFileType;
  869.     unsigned int iPlaylist_VolumeBytes;
  870.     unsigned int iPlaylist_DirectoryBytes;
  871.     CP_CHECKOBJECT(pPlaylist);
  873.     // Check for known file types
  874.     enFileType = CPL_GetFileType(pcFilename);
  875.     if(enFileType == pftUnknown)
  876.     {
  877.         // This doesn't seem to be a playlist file - add it as a playlist item
  878.         CPL_AddSingleFile(hPlaylist, pcFilename, NULL);
  879.         return;
  880.     }
  882.     // Get playlist file information
  883.     iPlaylist_VolumeBytes = CPL_GetPathVolumeBytes(pcFilename);
  884.     iPlaylist_DirectoryBytes = CPL_GetPathDirectoryBytes(pcFilename, iPlaylist_VolumeBytes);
  886.     // Load the playlist files
  887.     CPL_cb_LockWindowUpdates(TRUE);
  888.     if(enFileType == pftPLS)
  889.     {
  890.         int iNumFiles, iFileIDX;
  892.         iNumFiles = GetPrivateProfileInt("playlist", "NumberOfEntries", 0, pcFilename);
  893.         for(iFileIDX = 0; iFileIDX < iNumFiles; iFileIDX++)
  894.         {
  895.             DWORD dwNumCharsRead;
  896.             char cPlsFileHeader[32];
  897.             char cBuffer[MAX_PATH];
  898.             char cTitle[1024];
  899.             sprintf(cPlsFileHeader, "File%d", iFileIDX + 1);
  901.             // Get the path - leave room for a drive
  902.             dwNumCharsRead = GetPrivateProfileString("playlist", cPlsFileHeader, NULL, cBuffer, MAX_PATH, pcFilename);
  903.             if(dwNumCharsRead == 0)
  904.                 continue;
  906.             sprintf(cPlsFileHeader, "Title%d", iFileIDX + 1);
  907.             dwNumCharsRead = GetPrivateProfileString("playlist", cPlsFileHeader, NULL, cTitle, 1024, pcFilename);
  908.             if(dwNumCharsRead == 0)
  909.                 CPL_AddPrefixedFile(hPlaylist, cBuffer, NULL, pcFilename, iPlaylist_VolumeBytes, iPlaylist_DirectoryBytes);
  910.             else
  911.                 CPL_AddPrefixedFile(hPlaylist, cBuffer, cTitle, pcFilename, iPlaylist_VolumeBytes, iPlaylist_DirectoryBytes);
  912.         }
  913.     }
  914.     else
  915.     {
  916.         // Open file and load it all into memory
  917.         HANDLE hFile;
  918.         hFile = CreateFile(pcFilename, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  919.         if(hFile != INVALID_HANDLE_VALUE)
  920.         {
  921.             const DWORD dwFileSize = GetFileSize(hFile, NULL);
  923.             // We will only load playlists that are smaller than 256K
  924.             if(dwFileSize < 0x40000)
  925.             {
  926.                 // The plan is to load the entire file into a memblock and then split it into lines
  927.                 // and scan off the whitepace and add the items to the list
  928.                 char *pcPlaylistBuffer = (char*)malloc(dwFileSize+1);
  929.                 DWORD dwBytesRead;
  930.                 unsigned int iLastLineStartIDX, iCharIDX;
  931.                 ReadFile(hFile, pcPlaylistBuffer, dwFileSize, &dwBytesRead, NULL);
  933.                 // Read in the file line by line
  934.                 iLastLineStartIDX = 0;
  935.                 for(iCharIDX = 0; iCharIDX < dwFileSize+1; iCharIDX++)
  936.                 {
  937.                     if( (pcPlaylistBuffer[iCharIDX] == 'r'
  938.                             || pcPlaylistBuffer[iCharIDX] == 'n'
  939.                             || iCharIDX == dwFileSize)
  940.                             && iLastLineStartIDX < iCharIDX)
  941.                     {
  942.                         char cBuffer[512];
  944.                         // Is there a file on this line (strip whitespace from start)
  945.                         if(sscanf(pcPlaylistBuffer + iLastLineStartIDX, " %512[^rn]", cBuffer) == 1)
  946.                         {
  947.                             // Something has been read - ignore lines starting with #
  948.                             if(cBuffer[0] != '#')
  949.                                 CPL_AddPrefixedFile(hPlaylist, cBuffer, NULL, pcFilename, iPlaylist_VolumeBytes, iPlaylist_DirectoryBytes);
  950.                         }
  952.                         // Set the line start for the next line
  953.                         if(pcPlaylistBuffer[iCharIDX + 1] == 'n')
  954.                             iCharIDX++;
  955.                         iLastLineStartIDX = iCharIDX + 1;
  956.                     }
  957.                 }
  959.                 free(pcPlaylistBuffer);
  960.             }
  962.             CloseHandle(hFile);
  963.         }
  965.     }
  967.     if(options.shuffle_play)
  968.         PostThreadMessage(pPlaylist->m_dwWorkerThreadID, CPPLWT_SYNCSHUFFLE, 0, 0);
  970.     CPL_cb_LockWindowUpdates(FALSE);
  971. }
  972. //
  973. //
  974. //
  975. int __cdecl cpl_sort_Path(const void *e1, const void *e2)
  976. {
  977.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  978.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  980.     return stricmp(pElem1->m_pcPath, pElem2->m_pcPath);
  981. }
  982. //
  983. //
  984. //
  985. int __cdecl cpl_sort_Filename(const void *e1, const void *e2)
  986. {
  987.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  988.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  990.     return stricmp(pElem1->m_pcPath, pElem2->m_pcPath);
  991. }
  992. //
  993. //
  994. //
  995. int __cdecl cpl_sort_TrackNum(const void *e1, const void *e2)
  996. {
  997.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  998.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1000.     if(pElem1->m_cTrackNum == pElem2->m_cTrackNum)
  1001.         return cpl_sort_Path(e1, e2);
  1002.     else if((char)pElem1->m_cTrackNum < (char)pElem2->m_cTrackNum)
  1003.         return -1;
  1005.     return 1;
  1006. }
  1007. //
  1008. //
  1009. //
  1010. int __cdecl cpl_sort_Length(const void *e1, const void *e2)
  1011. {
  1012.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1013.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1015.     if(pElem1->m_iTrackLength == pElem2->m_iTrackLength)
  1016.         return 0;
  1017.     else if(pElem1->m_iTrackLength < pElem2->m_iTrackLength)
  1018.         return -1;
  1020.     return 1;
  1021. }
  1022. //
  1023. //
  1024. //
  1025. int __cdecl cpl_sort_TrackStackPos(const void *e1, const void *e2)
  1026. {
  1027.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1028.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1030.     if(pElem1->m_iTrackStackPos == pElem2->m_iTrackStackPos)
  1031.         return 0;
  1032.     if(pElem1->m_iTrackStackPos == CIC_TRACKSTACK_UNSTACKED)
  1033.         return 1;
  1034.     if(pElem2->m_iTrackStackPos == CIC_TRACKSTACK_UNSTACKED)
  1035.         return -1;
  1036.     if(pElem1->m_iTrackStackPos > pElem2->m_iTrackStackPos)
  1037.         return 1;
  1038.     else
  1039.         return -1;
  1040. }
  1041. //
  1042. //
  1043. //
  1044. int __cdecl cpl_sort_TrackName(const void *e1, const void *e2)
  1045. {
  1046.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1047.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1049.     return stricmp(pElem1->m_pcTrackName, pElem2->m_pcTrackName);
  1050. }
  1051. //
  1052. //
  1053. //
  1054. int __cdecl cpl_sort_Album(const void *e1, const void *e2)
  1055. {
  1056.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1057.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1058.     int iStringCompare;
  1060.     if(pElem1->m_pcAlbum == NULL && pElem2->m_pcAlbum == NULL)
  1061.         return cpl_sort_TrackNum(e1, e2);
  1062.     else if(pElem1->m_pcAlbum == NULL)
  1063.         return -1;
  1064.     else if(pElem2->m_pcAlbum == NULL)
  1065.         return 1;
  1067.     // Sort by artist - but fall back to track name
  1068.     iStringCompare = stricmp(pElem1->m_pcAlbum, pElem2->m_pcAlbum);
  1069.     if(iStringCompare != 0)
  1070.         return iStringCompare;
  1072.     return cpl_sort_TrackNum(e1, e2);
  1073. }
  1074. //
  1075. //
  1076. //
  1077. int __cdecl cpl_sort_Artist(const void *e1, const void *e2)
  1078. {
  1079.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1080.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1081.     int iStringCompare;
  1083.     if(pElem1->m_pcArtist == NULL && pElem2->m_pcArtist == NULL)
  1084.         return cpl_sort_Album(e1, e2);
  1085.     else if(pElem1->m_pcArtist == NULL)
  1086.         return -1;
  1087.     else if(pElem2->m_pcArtist == NULL)
  1088.         return 1;
  1090.     // Sort by artist - but fall back to track name
  1091.     iStringCompare = stricmp(pElem1->m_pcArtist, pElem2->m_pcArtist);
  1092.     if(iStringCompare != 0)
  1093.         return iStringCompare;
  1095.     return cpl_sort_Album(e1, e2);
  1096. }
  1097. //
  1098. //
  1099. //
  1100. int __cdecl cpl_sort_Year(const void *e1, const void *e2)
  1101. {
  1102.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1103.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1104.     int iStringCompare;
  1106.     if(pElem1->m_pcYear == NULL && pElem2->m_pcYear == NULL)
  1107.         return cpl_sort_Artist(e1, e2);
  1108.     else if(pElem1->m_pcYear == NULL)
  1109.         return -1;
  1110.     else if(pElem2->m_pcYear == NULL)
  1111.         return 1;
  1113.     // Sort by artist - but fall back to track name
  1114.     iStringCompare = stricmp(pElem1->m_pcYear, pElem2->m_pcYear);
  1115.     if(iStringCompare != 0)
  1116.         return iStringCompare;
  1118.     return cpl_sort_Artist(e1, e2);
  1119. }
  1120. //
  1121. //
  1122. //
  1123. int __cdecl cpl_sort_Genre(const void *e1, const void *e2)
  1124. {
  1125.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1126.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1127.     int iStringCompare;
  1129.     if(CPLI_GetGenre((CP_HPLAYLISTITEM)pElem1) == NULL && CPLI_GetGenre((CP_HPLAYLISTITEM)pElem2) == NULL)
  1130.         return cpl_sort_Artist(e1, e2);
  1131.     else if(CPLI_GetGenre((CP_HPLAYLISTITEM)pElem1) == NULL)
  1132.         return -1;
  1133.     else if(CPLI_GetGenre((CP_HPLAYLISTITEM)pElem2) == NULL)
  1134.         return 1;
  1136.     // Sort by artist - but fall back to track name
  1137.     iStringCompare = stricmp(CPLI_GetGenre((CP_HPLAYLISTITEM)pElem1), CPLI_GetGenre((CP_HPLAYLISTITEM)pElem2));
  1138.     if(iStringCompare != 0)
  1139.         return iStringCompare;
  1141.     return cpl_sort_Artist(e1, e2);
  1142. }
  1143. //
  1144. //
  1145. //
  1146. int __cdecl cpl_sort_Comment(const void *e1, const void *e2)
  1147. {
  1148.     const CPs_PlaylistItem* pElem1 = *(const CPs_PlaylistItem**)e1;
  1149.     const CPs_PlaylistItem* pElem2 = *(const CPs_PlaylistItem**)e2;
  1150.     int iStringCompare;
  1152.     if(pElem1->m_pcComment == NULL && pElem2->m_pcComment == NULL)
  1153.         return cpl_sort_Artist(e1, e2);
  1154.     else if(pElem1->m_pcComment == NULL)
  1155.         return -1;
  1156.     else if(pElem2->m_pcComment == NULL)
  1157.         return 1;
  1159.     // Sort by artist - but fall back to track name
  1160.     iStringCompare = stricmp(pElem1->m_pcComment, pElem2->m_pcComment);
  1161.     if(iStringCompare != 0)
  1162.         return iStringCompare;
  1164.     return cpl_sort_Artist(e1, e2);
  1165. }
  1166. //
  1167. //
  1168. //
  1169. int __cdecl cpl_sort_Random(const void *e1, const void *e2)
  1170. {
  1171.     const unsigned short r1 = rand();
  1172.     const unsigned short r2 = rand();
  1174.     if(r1 < r2)
  1175.         return -1;
  1176.     else if(r1 == r2)
  1177.         return 0;
  1178.     else
  1179.         return 1;
  1180. }
  1181. //
  1182. //
  1183. //
  1184. void CPL_SortList(CP_HPLAYLIST hPlaylist, const CPe_PlayItemSortElement enElement, const BOOL bDesc)
  1185. {
  1186.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1187.     CPs_PlaylistItem** pFlatArray;
  1188.     unsigned int iNumItems;
  1189.     wp_SortFN pfnSort;
  1190.     CP_CHECKOBJECT(pPlaylist);
  1192.     // Skip if list is empty
  1193.     if(pPlaylist->m_hFirst == NULL)
  1194.         return;
  1196.     // Decide sort function
  1197.     {
  1198.         switch(enElement)
  1199.         {
  1200.         case piseTrackStackPos:
  1201.             pfnSort = cpl_sort_TrackStackPos;
  1202.             break;
  1203.         case piseTrackName:
  1204.             pfnSort = cpl_sort_TrackName;
  1205.             break;
  1206.         case piseArtist:
  1207.             pfnSort = cpl_sort_Artist;
  1208.             break;
  1209.         case piseAlbum:
  1210.             pfnSort = cpl_sort_Album;
  1211.             break;
  1212.         case piseYear:
  1213.             pfnSort = cpl_sort_Year;
  1214.             break;
  1215.         case piseTrackNum:
  1216.             pfnSort = cpl_sort_TrackNum;
  1217.             break;
  1218.         case piseGenre:
  1219.             pfnSort = cpl_sort_Genre;
  1220.             break;
  1221.         case piseComment:
  1222.             pfnSort = cpl_sort_Comment;
  1223.             break;
  1224.         case piseFilename:
  1225.             pfnSort = cpl_sort_Filename;
  1226.             break;
  1227.         case pisePath:
  1228.             pfnSort = cpl_sort_Path;
  1229.             break;
  1230.         case piseLength:
  1231.             pfnSort = cpl_sort_Length;
  1232.             break;
  1233.         default:
  1234.             CP_FAIL(UnknownSortOrder);
  1235.         }
  1236.     }
  1238.     // Count items
  1239.     {
  1240.         CP_HPLAYLISTITEM hCursor;
  1241.         iNumItems = 0;
  1242.         for(hCursor = pPlaylist->m_hFirst; hCursor; hCursor = CPLI_Next(hCursor))
  1243.             iNumItems++;
  1244.     }
  1246.     // Build flat array
  1247.     {
  1248.         CP_HPLAYLISTITEM hCursor;
  1249.         int iItemIDX;
  1250.         pFlatArray = (CPs_PlaylistItem**)malloc(sizeof(CPs_PlaylistItem*) * iNumItems);
  1252.         iItemIDX = 0;
  1253.         for(hCursor = pPlaylist->m_hFirst; hCursor; hCursor = CPLI_Next(hCursor), iItemIDX++)
  1254.             pFlatArray[iItemIDX] = CPLII_DECODEHANDLE(hCursor);
  1255.     }
  1257.     // Qsort it
  1258.     qsort(pFlatArray, iNumItems, sizeof(CPs_PlaylistItem*), pfnSort);
  1260.     // Relink list
  1261.     {
  1262.         int iFirstItem, iTermItem, iInc;
  1263.         CP_HPLAYLISTITEM* phCursor_Referrer = &(pPlaylist->m_hFirst);
  1264.         CP_HPLAYLISTITEM hCursor_Prev = NULL;
  1265.         CP_HPLAYLISTITEM hLastAssignment = NULL;
  1266.         int iItemIDX;
  1268.         // Work out how to traverse the flat array
  1269.         if(bDesc == FALSE)
  1270.         {
  1271.             iFirstItem = 0;
  1272.             iTermItem = iNumItems;
  1273.             iInc = 1;
  1274.         }
  1275.         else
  1276.         {
  1277.             iFirstItem = iNumItems-1;
  1278.             iTermItem = -1;
  1279.             iInc = -1;
  1280.         }
  1282.         // Traverse the array
  1283.         for(iItemIDX = iFirstItem; iItemIDX != iTermItem; iItemIDX+=iInc)
  1284.         {
  1285.             *phCursor_Referrer = pFlatArray[iItemIDX];
  1286.             pFlatArray[iItemIDX]->m_hPrev = hCursor_Prev;
  1288.             phCursor_Referrer = &(CPLII_DECODEHANDLE(*phCursor_Referrer)->m_hNext);
  1289.             hCursor_Prev = pFlatArray[iItemIDX];
  1290.             hLastAssignment = hCursor_Prev;
  1291.         }
  1292.         pPlaylist->m_hLast = hLastAssignment;
  1293.         CPLII_DECODEHANDLE(pPlaylist->m_hLast)->m_hNext = NULL;
  1294.     }
  1296.     free(pFlatArray);
  1297.     CPL_cb_SetWindowToReflectList();
  1298. }
  1299. //
  1300. //
  1301. //
  1302. void CPL_InsertItemBefore(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem_Anchor, CP_HPLAYLISTITEM hItem_ToMove)
  1303. {
  1304.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1305.     CPs_PlaylistItem* pAnchor = CPLII_DECODEHANDLE(hItem_Anchor);
  1306.     CP_CHECKOBJECT(pPlaylist);
  1308.     CPL_UnlinkItem(hPlaylist, hItem_ToMove);
  1309.     if(pAnchor->m_hPrev)
  1310.     {
  1311.         CPLII_DECODEHANDLE(pAnchor->m_hPrev)->m_hNext = hItem_ToMove;
  1312.         CPLII_DECODEHANDLE(hItem_ToMove)->m_hPrev = pAnchor->m_hPrev;
  1313.     }
  1314.     else
  1315.     {
  1316.         pPlaylist->m_hFirst = hItem_ToMove;
  1317.         CPLII_DECODEHANDLE(hItem_ToMove)->m_hPrev = NULL;
  1318.     }
  1320.     pAnchor->m_hPrev = hItem_ToMove;
  1321.     CPLII_DECODEHANDLE(hItem_ToMove)->m_hNext = hItem_Anchor;
  1322. }
  1323. //
  1324. //
  1325. //
  1326. void CPL_InsertItemAfter(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem_Anchor, CP_HPLAYLISTITEM hItem_ToMove)
  1327. {
  1328.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1329.     CPs_PlaylistItem* pAnchor = CPLII_DECODEHANDLE(hItem_Anchor);
  1330.     CP_CHECKOBJECT(pPlaylist);
  1332.     CPL_UnlinkItem(hPlaylist, hItem_ToMove);
  1333.     if(pAnchor->m_hNext)
  1334.     {
  1335.         CPLII_DECODEHANDLE(pAnchor->m_hNext)->m_hPrev = hItem_ToMove;
  1336.         CPLII_DECODEHANDLE(hItem_ToMove)->m_hNext = pAnchor->m_hNext;
  1337.     }
  1338.     else
  1339.     {
  1340.         pPlaylist->m_hLast = hItem_ToMove;
  1341.         CPLII_DECODEHANDLE(hItem_ToMove)->m_hNext = NULL;
  1342.     }
  1344.     pAnchor->m_hNext = hItem_ToMove;
  1345.     CPLII_DECODEHANDLE(hItem_ToMove)->m_hPrev = hItem_Anchor;
  1346. }
  1347. //
  1348. //
  1349. //
  1350. void SortLList(CPs_FilenameLLItem* pFirst)
  1351. {
  1352.     char** ppStrings;
  1353.     int iNumStrings;
  1354.     int iStringIDX;
  1355.     CPs_FilenameLLItem* pCursor;
  1357.     if(!pFirst)
  1358.         return;
  1360.     // Count the number of strings in the list
  1361.     iNumStrings = 0;
  1362.     for(pCursor = pFirst; pCursor; pCursor = (CPs_FilenameLLItem*)pCursor->m_pNextItem)
  1363.         iNumStrings++;
  1365.     // Allocate string buffer and assign strings to it
  1366.     ppStrings = (char**)malloc(sizeof(char*) * iNumStrings);
  1367.     iStringIDX = 0;
  1368.     for(pCursor = pFirst; pCursor; pCursor = (CPs_FilenameLLItem*)pCursor->m_pNextItem)
  1369.     {
  1370.         ppStrings[iStringIDX] = pCursor->m_pcFilename;
  1371.         iStringIDX++;
  1372.     }
  1374.     // Sort filelist
  1375.     qsort(ppStrings, iNumStrings, sizeof(char*), exp_CompareStrings);
  1377.     // Assign list to the now sorted string list
  1378.     iStringIDX = 0;
  1379.     for(pCursor = pFirst; pCursor; pCursor = (CPs_FilenameLLItem*)pCursor->m_pNextItem)
  1380.     {
  1381.         pCursor->m_pcFilename = ppStrings[iStringIDX];
  1382.         iStringIDX++;
  1383.     }
  1385.     free(ppStrings);
  1386. }
  1387. //
  1388. //
  1389. //
  1390. void CPL_AddDirectory_Recurse(CP_HPLAYLIST hPlaylist, const char *pDir)
  1391. {
  1392.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1393.     CPs_FilenameLLItem* m_pFirstFile = NULL;
  1394.     CPs_FilenameLLItem* m_pFirstDir = NULL;
  1395.     CPs_FilenameLLItem* pCursor;
  1396.     CPs_FilenameLLItem* pNextItem;
  1397.     char cFullPath[MAX_PATH];
  1398.     char cWildCard[MAX_PATH];
  1399.     const int iDirStrLen = strlen(pDir);
  1400.     WIN32_FIND_DATA finddata;
  1401.     HANDLE hFileFind;
  1402.     CP_CHECKOBJECT(pPlaylist);
  1404.     // Build a full path to the directory
  1405.     strcpy(cFullPath, pDir);
  1406.     if(cFullPath[iDirStrLen-1] == '\' && iDirStrLen > 1)
  1407.         cFullPath[iDirStrLen-1] = '';
  1409.     // Check that this is a correct path
  1410.     if(cFullPath[0] == '' || path_is_directory(cFullPath) == FALSE)
  1411.     {
  1412.         MessageBox(NULL, "Not a valid directory.", cFullPath, MB_ICONERROR);
  1413.         return;
  1414.     }
  1416.     //Scan directory building a list of filenames
  1417.     if(strcmp(cFullPath, "\") == 0)
  1418.         strcpy(cWildCard, "\*.*");
  1419.     else
  1420.     {
  1421.         strcpy(cWildCard, cFullPath);
  1422.         strcat(cWildCard, "\*.*");
  1423.     }
  1425.     strcat(cFullPath, "\");
  1426.     hFileFind = FindFirstFile(cWildCard, &finddata);
  1427.     if(hFileFind == INVALID_HANDLE_VALUE)
  1428.     {
  1429.         MessageBox(NULL, "Could not perform scan", cFullPath, MB_ICONERROR);
  1430.         return;
  1431.     }
  1433.     do
  1434.     {
  1435.         char pcFullPath[MAX_PATH];
  1437.         // Skip dots
  1438.         if(finddata.cFileName[0] == '.')
  1439.             continue;
  1441.         strcpy(pcFullPath, cFullPath);
  1442.         strcat(pcFullPath, finddata.cFileName);
  1444.         // Add to linked list
  1445.         if(finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  1446.         {
  1447.             // Add to dirs list
  1448.             CPs_FilenameLLItem* pNewItem = (CPs_FilenameLLItem*)malloc(sizeof(CPs_FilenameLLItem));
  1449.             pNewItem->m_pNextItem = m_pFirstDir;
  1450.             STR_AllocSetString(&pNewItem->m_pcFilename, pcFullPath, FALSE);
  1451.             m_pFirstDir = pNewItem;
  1452.         }
  1453.         else
  1454.         {
  1455.             // Add to files list
  1456.             CPs_FilenameLLItem* pNewItem = (CPs_FilenameLLItem*)malloc(sizeof(CPs_FilenameLLItem));
  1457.             pNewItem->m_pNextItem = m_pFirstFile;
  1458.             STR_AllocSetString(&pNewItem->m_pcFilename, pcFullPath, FALSE);
  1459.             m_pFirstFile = pNewItem;
  1460.         }
  1462.     } while(FindNextFile(hFileFind, &finddata) != 0);
  1464.     FindClose(hFileFind);
  1466.     SortLList(m_pFirstDir);
  1467.     SortLList(m_pFirstFile);
  1469.     // Add files first - then directories
  1470.     for(pCursor = m_pFirstFile; pCursor; pCursor = (CPs_FilenameLLItem*)pCursor->m_pNextItem)
  1471.         CPL_AddFile(globals.m_hPlaylist, pCursor->m_pcFilename);
  1472.     for(pCursor = m_pFirstDir; pCursor; pCursor = (CPs_FilenameLLItem*)pCursor->m_pNextItem)
  1473.         CPL_AddDirectory_Recurse(hPlaylist, pCursor->m_pcFilename);
  1475.     // Cleanup
  1476.     for(pCursor = m_pFirstFile; pCursor; pCursor = pNextItem)
  1477.     {
  1478.         pNextItem = (CPs_FilenameLLItem*)pCursor->m_pNextItem;
  1479.         free(pCursor->m_pcFilename);
  1480.         free(pCursor);
  1481.     }
  1482.     for(pCursor = m_pFirstDir; pCursor; pCursor = pNextItem)
  1483.     {
  1484.         pNextItem = (CPs_FilenameLLItem*)pCursor->m_pNextItem;
  1485.         free(pCursor->m_pcFilename);
  1486.         free(pCursor);
  1487.     }
  1488. }
  1489. //
  1490. //
  1491. //
  1492. void CPL_AddDroppedFiles(CP_HPLAYLIST hPlaylist, HDROP hDrop)
  1493. {
  1494.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1495.     int iNumFiles, iFileIDX;
  1496.     char** ppFiles;
  1498.     CP_CHECKOBJECT(pPlaylist);
  1500.     // Read all the files into an array of strings
  1501.     iNumFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
  1502.     ppFiles = (char**)malloc(iNumFiles * sizeof(char*));
  1503.     for(iFileIDX = 0; iFileIDX < iNumFiles; iFileIDX++)
  1504.     {
  1505.         const int iBufferSize = DragQueryFile(hDrop, iFileIDX, NULL, 0)+1;
  1506.         ppFiles[iFileIDX] = (char*)malloc(iBufferSize * sizeof(char));
  1507.         DragQueryFile(hDrop, iFileIDX, ppFiles[iFileIDX], iBufferSize);
  1508.     }
  1509.     DragFinish(hDrop);
  1511.     // Sort filelist
  1512.     qsort(ppFiles, iNumFiles, sizeof(char*), exp_CompareStrings);
  1514.     // Add to playlist
  1515.     CLV_BeginBatch(globals.m_hPlaylistViewControl);
  1516.     for(iFileIDX = 0; iFileIDX < iNumFiles; iFileIDX++)
  1517.     {
  1518.         if(path_is_directory(ppFiles[iFileIDX]) == TRUE)
  1519.         {
  1520.             CPL_AddDirectory_Recurse(globals.m_hPlaylist, ppFiles[iFileIDX]);
  1521.             strcpy(options.last_used_directory, ppFiles[iFileIDX]);
  1522.         }
  1523.         else
  1524.             CPL_AddFile(globals.m_hPlaylist, ppFiles[iFileIDX]);
  1525.     }
  1526.     CLV_EndBatch(globals.m_hPlaylistViewControl);
  1528.     // Free string array
  1529.     for(iFileIDX = 0; iFileIDX < iNumFiles; iFileIDX++)
  1530.         free(ppFiles[iFileIDX]);
  1531.     free(ppFiles);
  1533.     // Shuffle playlist
  1534.     if(options.shuffle_play)
  1535.         PostThreadMessage(pPlaylist->m_dwWorkerThreadID, CPPLWT_SYNCSHUFFLE, 0, 0);
  1536. }
  1537. //
  1538. //
  1539. //
  1540. void CPL_Stack_Append(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  1541. {
  1542.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1543.     int iItemNumber;
  1544.     CP_CHECKOBJECT(pPlaylist);
  1546.     // Ensure buffer is big enough
  1547.     if( (pPlaylist->m_iTrackStackSize+1) >= pPlaylist->m_iTrackStackBufferSize)
  1548.     {
  1549.         pPlaylist->m_iTrackStackBufferSize += CPC_TRACKSTACK_BUFFER_QUANTISATION;
  1550.         pPlaylist->m_pTrackStack = realloc(pPlaylist->m_pTrackStack, pPlaylist->m_iTrackStackBufferSize * sizeof(CP_HPLAYLISTITEM));
  1551.     }
  1553.     // Ensure cursor is rational
  1554.     if(pPlaylist->m_iTrackStackCursor > pPlaylist->m_iTrackStackSize)
  1555.         pPlaylist->m_iTrackStackCursor = pPlaylist->m_iTrackStackSize;
  1557.     // Add item
  1558.     pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackSize] = hItem;
  1559.     pPlaylist->m_iTrackStackSize++;
  1561.     // Number item
  1562.     iItemNumber = (pPlaylist->m_iTrackStackSize-1) - pPlaylist->m_iTrackStackCursor;
  1563.     CPLI_SetTrackStackPos(hItem, iItemNumber);
  1564.     CPL_cb_TrackStackChanged();
  1565. }
  1566. //
  1567. //
  1568. //
  1569. void CPL_Stack_Renumber(CP_HPLAYLIST hPlaylist)
  1570. {
  1571.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1572.     unsigned int iStackIDX;
  1573.     CP_CHECKOBJECT(pPlaylist);
  1575.     for(iStackIDX = 0; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1576.         CPLI_SetTrackStackPos(pPlaylist->m_pTrackStack[iStackIDX], iStackIDX - pPlaylist->m_iTrackStackCursor);
  1578.     CPL_cb_TrackStackChanged();
  1579. }
  1580. //
  1581. //
  1582. //
  1583. void CPL_Stack_Remove(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  1584. {
  1585.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1586.     unsigned int iStackIDX;
  1587.     BOOL bFoundItem;
  1588.     CP_CHECKOBJECT(pPlaylist);
  1590.     CPLI_SetTrackStackPos(hItem, CIC_TRACKSTACK_UNSTACKED);
  1592.     // Search stack for item - remove it if we find it and renumber all items from there onwards
  1593.     bFoundItem = FALSE;
  1594.     for(iStackIDX = 0; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1595.     {
  1596.         if(bFoundItem == FALSE && pPlaylist->m_pTrackStack[iStackIDX] == hItem)
  1597.         {
  1598.             pPlaylist->m_iTrackStackSize--;
  1599.             if(iStackIDX < pPlaylist->m_iTrackStackCursor)
  1600.                 pPlaylist->m_iTrackStackCursor--;
  1601.             bFoundItem = TRUE;
  1602.         }
  1604.         if(bFoundItem == TRUE && iStackIDX < pPlaylist->m_iTrackStackSize)
  1605.             pPlaylist->m_pTrackStack[iStackIDX] = pPlaylist->m_pTrackStack[iStackIDX+1];
  1606.     }
  1608.     CPL_Stack_Renumber(hPlaylist);
  1610.     if(bFoundItem == TRUE)
  1611.     {
  1612.         // If the trackstack is now empty - free the buffers
  1613.         if(pPlaylist->m_iTrackStackSize == 0)
  1614.         {
  1615.             pPlaylist->m_iTrackStackBufferSize = 0;
  1616.             free(pPlaylist->m_pTrackStack);
  1617.             pPlaylist->m_pTrackStack = NULL;
  1618.         }
  1620.         CPL_cb_TrackStackChanged();
  1621.     }
  1622. }
  1623. //
  1624. //
  1625. //
  1626. void CPL_Stack_SetCursor(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  1627. {
  1628.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1629.     unsigned int iStackIDX;
  1630.     CP_CHECKOBJECT(pPlaylist);
  1632.     // Search for the item and set the cursor to this item - if it isn't in the stack then
  1633.     // add this item to the end (and move the cursor there)
  1634.     for(iStackIDX = 0; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1635.     {
  1636.         if(pPlaylist->m_pTrackStack[iStackIDX] == hItem)
  1637.         {
  1638.             pPlaylist->m_iTrackStackCursor = iStackIDX;
  1639.             break;
  1640.         }
  1641.     }
  1643.     CPL_Stack_Renumber(hPlaylist);
  1644. }
  1645. //
  1646. //
  1647. //
  1648. void CPL_Stack_Clear(CP_HPLAYLIST hPlaylist)
  1649. {
  1650.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1651.     unsigned int iStackIDX;
  1652.     CP_CHECKOBJECT(pPlaylist);
  1654.     // Mark all items in stack as unstacked
  1655.     for(iStackIDX = 0; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1656.         CPLI_SetTrackStackPos(pPlaylist->m_pTrackStack[iStackIDX], CIC_TRACKSTACK_UNSTACKED);
  1658.     // Clear the stack buffer
  1659.     pPlaylist->m_iTrackStackSize = 0;
  1660.     pPlaylist->m_iTrackStackBufferSize = 0;
  1661.     pPlaylist->m_iTrackStackCursor = 0;
  1662.     free(pPlaylist->m_pTrackStack);
  1663.     pPlaylist->m_pTrackStack = NULL;
  1665.     CPL_cb_TrackStackChanged();
  1666. }
  1667. //
  1668. //
  1669. //
  1670. void CPL_Stack_RestackAll(CP_HPLAYLIST hPlaylist)
  1671. {
  1672.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1673.     CP_HPLAYLISTITEM hCursor;
  1674.     CP_CHECKOBJECT(pPlaylist);
  1676.     pPlaylist->m_iTrackStackSize = 0;
  1677.     pPlaylist->m_iTrackStackCursor = 0;
  1679.     for(hCursor = pPlaylist->m_hFirst; hCursor; hCursor = CPLI_Next(hCursor))
  1680.         CPL_Stack_Append(hPlaylist, hCursor);
  1682.     if(pPlaylist->m_hCurrent)
  1683.         CPL_Stack_SetCursor(hPlaylist, pPlaylist->m_hCurrent);
  1684. }
  1685. //
  1686. //
  1687. //
  1688. CPe_ItemStackState CPL_Stack_GetItemState(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  1689. {
  1690.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1691.     unsigned int iStackIDX;
  1692.     CP_CHECKOBJECT(pPlaylist);
  1694.     // Mark all items in stack as unstacked
  1695.     for(iStackIDX = 0; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1696.     {
  1697.         if(pPlaylist->m_pTrackStack[iStackIDX] == hItem)
  1698.         {
  1699.             if(iStackIDX < pPlaylist->m_iTrackStackCursor)
  1700.                 return issPlayed;
  1701.             else if(iStackIDX == pPlaylist->m_iTrackStackCursor)
  1702.                 return issStacked_Top;
  1703.             else
  1704.                 return issStacked;
  1705.         }
  1706.     }
  1708.     return issUnstacked;
  1709. }
  1710. //
  1711. //
  1712. //
  1713. void CPL_Stack_Shuffle(CP_HPLAYLIST hPlaylist, const BOOL bForceCurrentToHead)
  1714. {
  1715.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1716.     unsigned int iStackIDX;
  1717.     CP_CHECKOBJECT(pPlaylist);
  1719.     if(pPlaylist->m_iTrackStackSize == 0)
  1720.         return;
  1722.     // Qsort stack
  1723.     qsort(pPlaylist->m_pTrackStack, pPlaylist->m_iTrackStackSize, sizeof(CP_HPLAYLISTITEM*), cpl_sort_Random);
  1724.     pPlaylist->m_iTrackStackCursor = 0;
  1726.     if(pPlaylist->m_hCurrent)
  1727.     {
  1728.         // If there is a playing track - ensure that it is at position 0
  1729.         if(bForceCurrentToHead == TRUE)
  1730.         {
  1731.             for(iStackIDX = 0; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1732.             {
  1733.                 if(pPlaylist->m_pTrackStack[iStackIDX] == pPlaylist->m_hCurrent)
  1734.                 {
  1735.                     pPlaylist->m_pTrackStack[iStackIDX] = pPlaylist->m_pTrackStack[0];
  1736.                     pPlaylist->m_pTrackStack[0] = pPlaylist->m_hCurrent;
  1737.                     break;
  1738.                 }
  1739.             }
  1740.         }
  1741.         else
  1742.         {
  1743.             // If the current song is still at the head - swap it with the last song (to prevent a double play)
  1744.             if(pPlaylist->m_pTrackStack[0] == pPlaylist->m_hCurrent)
  1745.             {
  1746.                 pPlaylist->m_pTrackStack[0] = pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackSize-1];
  1747.                 pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackSize-1] = pPlaylist->m_hCurrent;
  1748.             }
  1749.         }
  1750.     }
  1752.     CPL_Stack_Renumber(hPlaylist);
  1753. }
  1754. //
  1755. //
  1756. //
  1757. void CPL_Stack_ClipFromCurrent(CP_HPLAYLIST hPlaylist)
  1758. {
  1759.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1760.     unsigned int iStackIDX;
  1761.     CP_CHECKOBJECT(pPlaylist);
  1763.     if(pPlaylist->m_iTrackStackSize == 0 || pPlaylist->m_iTrackStackCursor >= pPlaylist->m_iTrackStackSize)
  1764.         return;
  1766.     // Mark all items in stack as unstacked
  1767.     for(iStackIDX = pPlaylist->m_iTrackStackCursor+1; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1768.         CPLI_SetTrackStackPos(pPlaylist->m_pTrackStack[iStackIDX], CIC_TRACKSTACK_UNSTACKED);
  1770.     pPlaylist->m_iTrackStackSize = pPlaylist->m_iTrackStackCursor+1;
  1771.     CPL_cb_TrackStackChanged();
  1772. }
  1773. //
  1774. //
  1775. //
  1776. void CPL_Stack_ClipFromItem(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  1777. {
  1778.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1779.     unsigned int iStackIDX;
  1780.     BOOL bItemFound;
  1781.     unsigned int iFoundItemIDX;
  1782.     CP_CHECKOBJECT(pPlaylist);
  1784.     if(pPlaylist->m_iTrackStackSize == 0)
  1785.         return;
  1787.     // Mark items in stack after item as unstacked
  1788.     bItemFound = FALSE;
  1789.     iFoundItemIDX = CPC_INVALIDITEM;
  1790.     for(iStackIDX = pPlaylist->m_iTrackStackCursor; iStackIDX < pPlaylist->m_iTrackStackSize; iStackIDX++)
  1791.     {
  1792.         if(bItemFound == FALSE && pPlaylist->m_pTrackStack[iStackIDX] == hItem)
  1793.         {
  1794.             bItemFound = TRUE;
  1795.             iFoundItemIDX = iStackIDX;
  1796.         }
  1797.         else if(bItemFound)
  1798.             CPLI_SetTrackStackPos(pPlaylist->m_pTrackStack[iStackIDX], CIC_TRACKSTACK_UNSTACKED);
  1799.     }
  1801.     if(bItemFound)
  1802.     {
  1803.         pPlaylist->m_iTrackStackSize = iFoundItemIDX+1;
  1804.         CPL_cb_TrackStackChanged();
  1805.     }
  1806. }
  1807. //
  1808. //
  1809. //
  1810. void CPL_Stack_PlayNext(CP_HPLAYLIST hPlaylist, CP_HPLAYLISTITEM hItem)
  1811. {
  1812.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1813.     unsigned int iStackIDX;
  1815.     CP_CHECKOBJECT(pPlaylist);
  1817.     CPL_Stack_Remove(hPlaylist, hItem);
  1819.     // Rationalise cursor
  1820.     if(pPlaylist->m_iTrackStackCursor >= pPlaylist->m_iTrackStackSize)
  1821.     {
  1822.         CPL_Stack_Append(hPlaylist, hItem);
  1823.         return;
  1824.     }
  1826.     // Simple case
  1827.     if(pPlaylist->m_iTrackStackBufferSize == 0)
  1828.     {
  1829.         CPL_Stack_Append(hPlaylist, hItem);
  1830.         return;
  1831.     }
  1834.     // Ensure buffer is big enough
  1835.     if( (pPlaylist->m_iTrackStackSize+1) >= pPlaylist->m_iTrackStackBufferSize)
  1836.     {
  1837.         pPlaylist->m_iTrackStackBufferSize += CPC_TRACKSTACK_BUFFER_QUANTISATION;
  1838.         pPlaylist->m_pTrackStack = realloc(pPlaylist->m_pTrackStack, pPlaylist->m_iTrackStackBufferSize * sizeof(CP_HPLAYLISTITEM));
  1839.     }
  1841.     // Shunt all items up one
  1842.     for(iStackIDX = pPlaylist->m_iTrackStackSize; iStackIDX > (pPlaylist->m_iTrackStackCursor+1); iStackIDX--)
  1843.     {
  1844.         pPlaylist->m_pTrackStack[iStackIDX] = pPlaylist->m_pTrackStack[iStackIDX-1];
  1845.         CPLI_SetTrackStackPos(pPlaylist->m_pTrackStack[iStackIDX], iStackIDX-pPlaylist->m_iTrackStackCursor);
  1847.     }
  1849.     // Add item
  1850.     pPlaylist->m_pTrackStack[pPlaylist->m_iTrackStackCursor+1] = hItem;
  1851.     CPLI_SetTrackStackPos(pPlaylist->m_pTrackStack[iStackIDX], 1);
  1852.     pPlaylist->m_iTrackStackSize++;
  1853.     CPL_cb_TrackStackChanged();
  1854. }
  1855. //
  1856. //
  1857. //
  1858. DWORD WINAPI CPI_PlaylistWorkerThreadEP(void* pCookie)
  1859. {
  1860.     CPs_PlaylistWorkerThreadInfo* pThreadInfo = (CPs_PlaylistWorkerThreadInfo*)pCookie;
  1861.     MSG msg;
  1862.     CPs_NotifyChunk* pPendingChunk;
  1863. BOOL bRet;
  1864.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE);
  1866.     pPendingChunk = NULL;
  1867.  
  1868.     while((bRet = GetMessage( &msg, NULL, 0, 0 )) != 0)
  1869.     {
  1870. if (bRet == -1)
  1871.     {
  1872.         // handle the error and possibly exit
  1873. return 0;
  1874. }
  1876.         if(msg.message == CPPLWT_TERMINATE)
  1877.         {
  1878.             break;
  1879.         }
  1880.         else if(msg.message == CPPLWT_READTAG)
  1881.         {
  1882.             MSG msgPeek;
  1883.             CP_HPLAYLISTITEM hNewFile = (CP_HPLAYLISTITEM)msg.lParam;
  1885.             if(pThreadInfo->m_dwCurrentBatchID == (DWORD)msg.wParam)
  1886.             {
  1887.                 CPLI_ReadTag(hNewFile);
  1889.                 // If we didn't get a track length from the tag - work it out
  1890.                 if(CPLI_GetTrackLength(hNewFile) == 0
  1891.                         && options.work_out_track_lengths)
  1892.                 {
  1893.                     CPLI_CalculateLength(hNewFile);
  1894.                 }
  1896.                 // Allocate chunk
  1897.                 if(!pPendingChunk)
  1898.                 {
  1899.                     pPendingChunk = (CPs_NotifyChunk*)malloc(sizeof(CPs_NotifyChunk));
  1900.                     pPendingChunk->m_iNumberInChunk = 0;
  1901.                 }
  1903.                 // Add to current chunk
  1904.                 pPendingChunk->m_aryItems[pPendingChunk->m_iNumberInChunk] = hNewFile;
  1905.                 pPendingChunk->m_aryBatchIDs[pPendingChunk->m_iNumberInChunk] = (DWORD)msg.wParam;
  1906.                 pPendingChunk->m_iNumberInChunk++;
  1907.             }
  1908.             else
  1909.                 CPLII_DestroyItem(hNewFile);
  1911.             // Send the current chunk if its full or there are no more pending readtag messages
  1912.             if(pPendingChunk)
  1913.             {
  1914.                 if(pPendingChunk->m_iNumberInChunk == CPC_PLAYLISTWORKER_NOTIFYCHUNKSIZE
  1915.                         || PeekMessage(&msgPeek, NULL, CPPLWT_READTAG, CPPLWT_READTAG, PM_NOREMOVE) == FALSE)
  1916.                 {
  1917.                     PostThreadMessage(pThreadInfo->m_dwHostThreadID, CPPLNM_TAGREAD, (WPARAM)pPendingChunk, 0L);
  1918.                     pPendingChunk = NULL;
  1919.                 }
  1920.             }
  1921.         }
  1922.         else if(msg.message == CPPLWT_SYNCSHUFFLE)
  1923.         {
  1924.             PostThreadMessage(pThreadInfo->m_dwHostThreadID, CPPLNM_SYNCSHUFFLE, 0L, 0L);
  1925.         }
  1926.         else if(msg.message == CPPLWT_SETACTIVE)
  1927.         {
  1928.             CP_HPLAYLISTITEM hFile = (CP_HPLAYLISTITEM)msg.lParam;
  1930.             // Send the current chunk if there is one
  1931.             if(pPendingChunk)
  1932.             {
  1933.                 PostThreadMessage(pThreadInfo->m_dwHostThreadID, CPPLNM_TAGREAD, (WPARAM)pPendingChunk, 0L);
  1934.                 pPendingChunk = NULL;
  1935.             }
  1937.             // Send the setactivate
  1938.             if(pThreadInfo->m_dwCurrentBatchID == (DWORD)msg.wParam)
  1939.                 PostThreadMessage(pThreadInfo->m_dwHostThreadID, CPPLNM_SYNCSETACTIVE, (WPARAM)hFile, 0L);
  1940.         }
  1941.     }
  1943.     // Clean up any pending chunk
  1944.     if(pPendingChunk)
  1945.     {
  1946.         int iChunkItemIDX;
  1948.         for(iChunkItemIDX = 0; iChunkItemIDX < pPendingChunk->m_iNumberInChunk; iChunkItemIDX++)
  1949.             CPLII_DestroyItem(pPendingChunk->m_aryItems[iChunkItemIDX]);
  1950.         free(pPendingChunk);
  1951.     }
  1954.     CP_TRACE0("Playlist worker thread terminating");
  1955.     return 0;
  1956. }
  1957. //
  1958. //
  1959. //
  1960. void CPL_SyncLoadNextFile(CP_HPLAYLIST hPlaylist)
  1961. {
  1962.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1963.     CP_CHECKOBJECT(pPlaylist);
  1965.     pPlaylist->m_bSyncLoadNextFile = TRUE;
  1966. }
  1967. //
  1968. //
  1969. //
  1970. void CPL_SetAutoActivateInitial(CP_HPLAYLIST hPlaylist, const BOOL bAutoActivateInitial)
  1971. {
  1972.     CPs_Playlist* pPlaylist = (CPs_Playlist*)hPlaylist;
  1973.     CP_CHECKOBJECT(pPlaylist);
  1975.     pPlaylist->m_bAutoActivateInitial = TRUE;
  1976. }
  1977. //
  1978. //
  1979. //