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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
CPI_PlaylistItem.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：44k
源码类别：

VC书籍

开发平台：

Visual C++

CPI_PlaylistItem.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_ID3.h"
  17. void CPLI_OGG_SkipOverTab(FILE* pFile);
  18. void CPLI_SetPath(CPs_PlaylistItem* pItem, const char* pcNewPath);
  19. void CPLI_ReadTag_ID3v1(CPs_PlaylistItem* pItem, HANDLE hFile);
  20. void CPLI_ReadTag_ID3v2(CPs_PlaylistItem* pItem, HANDLE hFile);
  21. //void CPLI_ReadTag_OGG(CPs_PlaylistItem* pItem);
  22. void CPLI_WriteTag_ID3v1(CPs_PlaylistItem* pItem, HANDLE hFile);
  23. void CPLI_WriteTag_ID3v2(CPs_PlaylistItem* pItem, HANDLE hFile);
  24. //void CPLI_WriteTag_OGG(CPs_PlaylistItem* pItem, HANDLE hFile);
  25. //void CPLI_CalculateLength_OGG(CPs_PlaylistItem* pItem);
  26. void CPLI_CalculateLength_MP3(CPs_PlaylistItem* pItem);
  27. void CPLI_ShrinkFile(HANDLE hFile, const DWORD dwStartOffset, const unsigned int iNumBytes);
  28. BOOL CPLI_GrowFile(HANDLE hFile, const DWORD dwStartOffset, const unsigned int iNumBytes);
  29. ////////////////////////////////////////////////////////////////////////////////
  30. //
  31. //
  32. //
  33. CP_HPLAYLISTITEM CPLII_CreateItem(const char* pcPath)
  34. {
  35.     CPs_PlaylistItem* pNewItem = (CPs_PlaylistItem*)malloc(sizeof(CPs_PlaylistItem));
  37.     pNewItem->m_pcPath = NULL;
  38.     CPLI_SetPath(pNewItem, pcPath);
  40.     pNewItem->m_cTrackStackPos_AsText[0] = '';
  41.     pNewItem->m_iTrackStackPos = CIC_TRACKSTACK_UNSTACKED;
  42.     pNewItem->m_enTagType = ttUnread;
  43.     pNewItem->m_bID3Tag_SaveRequired = FALSE;
  44.     pNewItem->m_bDestroyOnDeactivate = FALSE;
  45.     pNewItem->m_pcArtist = NULL;
  46.     pNewItem->m_pcAlbum = NULL;
  47.     pNewItem->m_pcTrackName = NULL;
  48.     pNewItem->m_pcComment = NULL;
  49.     pNewItem->m_pcYear = NULL;
  50.     pNewItem->m_cGenre = CIC_INVALIDGENRE;
  51.     pNewItem->m_cTrackNum = CIC_INVALIDTRACKNUM;
  52.     pNewItem->m_pcTrackNum_AsText = NULL;
  53.     pNewItem->m_iTrackLength = 0;
  54.     pNewItem->m_pcTrackLength_AsText = NULL;
  56.     pNewItem->m_iCookie = -1;
  58.     pNewItem->m_hNext = NULL;
  59.     pNewItem->m_hPrev = NULL;
  61.     return pNewItem;
  62. }
  63. //
  64. //
  65. //
  66. void CPLII_RemoveTagInfo(CPs_PlaylistItem* pItem)
  67. {
  68.     if(pItem->m_pcArtist)
  69.     {
  70.         free(pItem->m_pcArtist);
  71.         pItem->m_pcArtist = NULL;
  72.     }
  73.     if(pItem->m_pcAlbum)
  74.     {
  75.         free(pItem->m_pcAlbum);
  76.         pItem->m_pcAlbum = NULL;
  77.     }
  78.     if(pItem->m_pcTrackName)
  79.     {
  80.         free(pItem->m_pcTrackName);
  81.         pItem->m_pcTrackName = NULL;
  82.     }
  83.     if(pItem->m_pcComment)
  84.     {
  85.         free(pItem->m_pcComment);
  86.         pItem->m_pcComment = NULL;
  87.     }
  88.     if(pItem->m_pcYear)
  89.     {
  90.         free(pItem->m_pcYear);
  91.         pItem->m_pcYear = NULL;
  92.     }
  93.     if(pItem->m_pcTrackNum_AsText)
  94.     {
  95.         free(pItem->m_pcTrackNum_AsText);
  96.         pItem->m_pcTrackNum_AsText = NULL;
  97.     }
  98.     if(pItem->m_pcTrackLength_AsText)
  99.     {
  100.         free(pItem->m_pcTrackLength_AsText);
  101.         pItem->m_pcTrackLength_AsText = NULL;
  102.     }
  103.     pItem->m_cGenre = CIC_INVALIDGENRE;
  104.     pItem->m_iTrackLength = 0;
  105.     pItem->m_cTrackNum = CIC_INVALIDTRACKNUM;
  106.     pItem->m_enTagType = ttUnread;
  107.     pItem->m_bID3Tag_SaveRequired = FALSE;
  108. }
  109. //
  110. //
  111. //
  112. void CPLII_DestroyItem(CP_HPLAYLISTITEM hItem)
  113. {
  114.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  115.     CP_CHECKOBJECT(pItem);
  117.     CPLII_RemoveTagInfo(pItem);
  118.     free(pItem->m_pcPath);
  119.     free(pItem);
  120. }
  121. //
  122. //
  123. //
  124. const char* CPLI_GetPath(const CP_HPLAYLISTITEM hItem)
  125. {
  126.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  127.     CP_CHECKOBJECT(pItem);
  129.     return pItem->m_pcPath;
  130. }
  131. //
  132. //
  133. //
  134. const char* CPLI_GetFilename(const CP_HPLAYLISTITEM hItem)
  135. {
  136.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  137.     CP_CHECKOBJECT(pItem);
  139.     return pItem->m_pcFilename;
  140. }
  141. //
  142. //
  143. //
  144. int CPLI_GetTrackStackPos(const CP_HPLAYLISTITEM hItem)
  145. {
  146.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  147.     CP_CHECKOBJECT(pItem);
  149.     return pItem->m_iTrackStackPos;
  150. }
  151. //
  152. //
  153. //
  154. const char* CPLI_GetTrackStackPos_AsText(const CP_HPLAYLISTITEM hItem)
  155. {
  156.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  157.     CP_CHECKOBJECT(pItem);
  159.     return pItem->m_cTrackStackPos_AsText;
  160. }
  161. //
  162. //
  163. //
  164. const char* CPLI_GetArtist(const CP_HPLAYLISTITEM hItem)
  165. {
  166.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  167.     CP_CHECKOBJECT(pItem);
  169.     return pItem->m_pcArtist;
  170. }
  171. //
  172. //
  173. //
  174. const char* CPLI_GetAlbum(const CP_HPLAYLISTITEM hItem)
  175. {
  176.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  177.     CP_CHECKOBJECT(pItem);
  179.     return pItem->m_pcAlbum;
  180. }
  181. //
  182. //
  183. //
  184. const char* CPLI_GetTrackName(const CP_HPLAYLISTITEM hItem)
  185. {
  186.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  187.     CP_CHECKOBJECT(pItem);
  189.     return pItem->m_pcTrackName;
  190. }
  191. //
  192. //
  193. //
  194. const char* CPLI_GetComment(const CP_HPLAYLISTITEM hItem)
  195. {
  196.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  197.     CP_CHECKOBJECT(pItem);
  199.     return pItem->m_pcComment;
  200. }
  201. //
  202. //
  203. //
  204. const char* CPLI_GetYear(const CP_HPLAYLISTITEM hItem)
  205. {
  206.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  207.     CP_CHECKOBJECT(pItem);
  209.     return pItem->m_pcYear;
  210. }
  211. //
  212. //
  213. //
  214. const char* CPLI_GetGenre(const CP_HPLAYLISTITEM hItem)
  215. {
  216.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  217.     CP_CHECKOBJECT(pItem);
  219.     if(pItem->m_cGenre == CIC_INVALIDGENRE)
  220.         return NULL;
  222.     return glb_pcGenres[pItem->m_cGenre];
  223. }
  224. //
  225. //
  226. //
  227. const unsigned char CPLI_GetTrackNum(const CP_HPLAYLISTITEM hItem)
  228. {
  229.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  230.     CP_CHECKOBJECT(pItem);
  232.     return pItem->m_cTrackNum;
  233. }
  234. //
  235. //
  236. //
  237. const char* CPLI_GetTrackNum_AsText(const CP_HPLAYLISTITEM hItem)
  238. {
  239.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  240.     CP_CHECKOBJECT(pItem);
  242.     return pItem->m_pcTrackNum_AsText;
  243. }
  244. //
  245. //
  246. //
  247. const char* CPLI_GetTrackLength_AsText(const CP_HPLAYLISTITEM hItem)
  248. {
  249.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  250.     CP_CHECKOBJECT(pItem);
  252.     return pItem->m_pcTrackLength_AsText;
  253. }
  254. //
  255. //
  256. //
  257. int CPLI_GetTrackLength(const CP_HPLAYLISTITEM hItem)
  258. {
  259.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  260.     CP_CHECKOBJECT(pItem);
  262.     return pItem->m_iTrackLength;
  263. }
  264. //
  265. //
  266. //
  267. void CPLI_SetCookie(CP_HPLAYLISTITEM hItem, const int iCookie)
  268. {
  269.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  270.     CP_CHECKOBJECT(pItem);
  272.     pItem->m_iCookie = iCookie;
  273. }
  274. //
  275. //
  276. //
  277. int CPLI_GetCookie(const CP_HPLAYLISTITEM hItem)
  278. {
  279.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  280.     CP_CHECKOBJECT(pItem);
  282.     return pItem->m_iCookie;
  283. }
  284. //
  285. //
  286. //
  287. CP_HPLAYLISTITEM CPLI_Next(const CP_HPLAYLISTITEM hItem)
  288. {
  289.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  290.     CP_CHECKOBJECT(pItem);
  292.     return pItem->m_hNext;
  293. }
  294. //
  295. //
  296. //
  297. CP_HPLAYLISTITEM CPLI_Prev(const CP_HPLAYLISTITEM hItem)
  298. {
  299.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  300.     CP_CHECKOBJECT(pItem);
  302.     return pItem->m_hPrev;
  303. }
  304. //
  305. //
  306. //
  307. char* DecodeID3String(const char* pcSource, const int iLength)
  308. {
  309.     char* cWorkString = (char*)_alloca(iLength+1);
  310.     char* pDestString;
  311.     char* pcLastWhiteSpace;
  312.     int iCharIDX;
  314.     cWorkString[iLength] = '';
  315.     memcpy(cWorkString, pcSource, iLength);
  317.     // Remove trailing whitespace
  318.     pcLastWhiteSpace = NULL;
  319.     for(iCharIDX = 0; cWorkString[iCharIDX]; iCharIDX++)
  320.     {
  321.         if(cWorkString[iCharIDX] == ' ')
  322.         {
  323.             if(!pcLastWhiteSpace)
  324.                 pcLastWhiteSpace = cWorkString + iCharIDX;
  325.         }
  326.         else
  327.             pcLastWhiteSpace = NULL;
  328.     }
  329.     if(pcLastWhiteSpace)
  330.         *pcLastWhiteSpace = '';
  332.     // Copy string
  333.     STR_AllocSetString(&pDestString, cWorkString, FALSE);
  334.     return pDestString;
  335. }
  336. //
  337. //
  338. //
  339. void CPLI_ReadTag(CP_HPLAYLISTITEM hItem)
  340. {
  341.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  342.     HANDLE hFile;
  344.     CP_CHECKOBJECT(pItem);
  345.     if(pItem->m_enTagType != ttUnread)
  346.         return;
  348.     // - Try to open the file
  349.     hFile = CreateFile(pItem->m_pcPath, GENERIC_READ,
  350.                        FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
  351.                        OPEN_EXISTING, 0, 0);
  353.     // Cannot open - fail silently
  354.     if(hFile == INVALID_HANDLE_VALUE)
  355.         return;
  357.     // Try to read a V2 tag
  358.     if(options.support_id3v2)
  359.         CPLI_ReadTag_ID3v2(pItem, hFile);
  361.     // Failed? - try a V1 tag instead
  362.     if(pItem->m_enTagType == ttUnread)
  363.         CPLI_ReadTag_ID3v1(pItem, hFile);
  365.     CloseHandle(hFile);
  368.     // Update interface
  369.     CPL_cb_OnItemUpdated(hItem);
  370. }
  371. //
  372. //
  373. //
  374. char* CPLI_ID3v2_DecodeString(const BYTE* pSourceText, const int iTagDataSize)
  375. {
  376.     int iStringLength;
  377.     char* pcDestString;
  379.     if(pSourceText[0] == '')
  380.     {
  381.         iStringLength = iTagDataSize-1;
  382.         pcDestString = malloc(iStringLength+1);
  383.         memcpy(pcDestString, pSourceText+1, iStringLength);
  384.         pcDestString[iStringLength] = 0;
  385.     }
  386.     else
  387.     {
  388.         CP_TRACE0("ID3v2 Unknown encoding");
  389.         pcDestString = NULL;
  390.     }
  392.     return pcDestString;
  393. }
  394. //
  395. //
  396. //
  397. void CPLI_DecodeLength(CPs_PlaylistItem* pItem, unsigned int iNewLength)
  398. {
  399.     int iHours, iMins, iSecs;
  401.     // Free existing buffer
  402.     if(pItem->m_pcTrackLength_AsText)
  403.     {
  404.         free(pItem->m_pcTrackLength_AsText);
  405.         pItem->m_pcTrackLength_AsText = NULL;
  406.     }
  408.     pItem->m_iTrackLength = iNewLength;
  409.     iHours = iNewLength/3600;
  410.     iMins = (iNewLength-(iHours*3600)) / 60;
  411.     iSecs = iNewLength - (iHours*3600) - (iMins*60);
  413.     // If length has hours then format as hh:mm:ss otherwise format as mm:ss
  414.     if(iHours > 0)
  415.     {
  416.         pItem->m_pcTrackLength_AsText = (char*)malloc(9);
  417.         sprintf(pItem->m_pcTrackLength_AsText, "%02d:%02d:%02d", iHours, iMins, iSecs);
  418.     }
  419.     else
  420.     {
  421.         pItem->m_pcTrackLength_AsText = (char*)malloc(6);
  422.         sprintf(pItem->m_pcTrackLength_AsText, "%02d:%02d", iMins, iSecs);
  423.     }
  424. }
  425. //
  426. //
  427. //
  428. void CPLI_ReadTag_ID3v2(CPs_PlaylistItem* pItem, HANDLE hFile)
  429. {
  430.     DWORD dwBytesRead;
  431.     int iTagDataToRead;
  432.     CIs_ID3v2Tag ID3v2;
  434.     SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
  435.     ReadFile(hFile, &ID3v2, sizeof(ID3v2), &dwBytesRead, NULL);
  437.     // Not enough file data returned - or the data returned does not look like an ID3
  438.     if(dwBytesRead != sizeof(ID3v2)
  439.             || memcmp(ID3v2.m_cTAG, "ID3", 3) != 0
  440.             || (ID3v2.m_cVersion[0] != 0x03 && ID3v2.m_cVersion[0] != 0x04)) // Major version wrong
  441.     {
  442.         return;
  443.     }
  445.     // Work out the amount of tag left to read
  446.     iTagDataToRead = (ID3v2.m_cSize_Encoded[0] << 21)
  447.                      | (ID3v2.m_cSize_Encoded[1] << 14)
  448.                      | (ID3v2.m_cSize_Encoded[2] << 7)
  449.                      | ID3v2.m_cSize_Encoded[3];
  451.     // Check for a big enough file now (to save endless checking)
  452.     if(GetFileSize(hFile, NULL) < (sizeof(ID3v2) + iTagDataToRead))
  453.         return;
  455.     // Skip over extended header (if there is one)
  456.     if(ID3v2.m_cFlags & ID3v2_FLAG_EXTENDEDHEADER)
  457.     {
  458.         char cExtendedHeaderSize_Encoded[4];
  459.         int iExtendedHeaderSize;
  461.         ReadFile(hFile, cExtendedHeaderSize_Encoded, sizeof(cExtendedHeaderSize_Encoded), &dwBytesRead, NULL);
  463.         iExtendedHeaderSize = (cExtendedHeaderSize_Encoded[0] << 21)
  464.                               | (cExtendedHeaderSize_Encoded[1] << 14)
  465.                               | (cExtendedHeaderSize_Encoded[2] << 7)
  466.                               | cExtendedHeaderSize_Encoded[3];
  468.         SetFilePointer(hFile, iExtendedHeaderSize - sizeof(cExtendedHeaderSize_Encoded), NULL, FILE_CURRENT);
  469.         iTagDataToRead -= iExtendedHeaderSize;
  470.     }
  472.     while(iTagDataToRead > sizeof(CIs_ID3v2Frame))
  473.     {
  474.         CIs_ID3v2Frame ID3v2Frame;
  475.         BYTE* pFrameData;
  476.         int iFrameSize;
  478.         ReadFile(hFile, &ID3v2Frame, sizeof(ID3v2Frame), &dwBytesRead, NULL);
  480.         // Have we encountered padding?
  481.         if(ID3v2Frame.m_cFrameID[0] == '')
  482.             break;
  484.         if(ID3v2.m_cVersion[0] == 0x03)
  485.         {
  486.             iFrameSize = (ID3v2Frame.m_cSize_Encoded[0] << 24)
  487.                          | (ID3v2Frame.m_cSize_Encoded[1] << 16)
  488.                          | (ID3v2Frame.m_cSize_Encoded[2] << 8)
  489.                          | ID3v2Frame.m_cSize_Encoded[3];
  490.         }
  491.         else
  492.         {
  493.             iFrameSize = (ID3v2Frame.m_cSize_Encoded[0] << 21)
  494.                          | (ID3v2Frame.m_cSize_Encoded[1] << 14)
  495.                          | (ID3v2Frame.m_cSize_Encoded[2] << 7)
  496.                          | ID3v2Frame.m_cSize_Encoded[3];
  497.         }
  499.         // Frame size invalid?
  500.         if(iFrameSize > iTagDataToRead)
  501.             return;
  503.         pFrameData = malloc(iFrameSize+1);
  504.         if(!ReadFile(hFile, pFrameData, iFrameSize, &dwBytesRead, NULL)) return;
  505.         pFrameData[iFrameSize] = '';
  507.         // Decode frames
  508.         if(memcmp(ID3v2Frame.m_cFrameID, "TIT2", 4) == 0)
  509.             pItem->m_pcTrackName = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  510.         else if(memcmp(ID3v2Frame.m_cFrameID, "TPE1", 4) == 0)
  511.             pItem->m_pcArtist = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  512.         else if(memcmp(ID3v2Frame.m_cFrameID, "TALB", 4) == 0)
  513.             pItem->m_pcAlbum = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  514.         else if(memcmp(ID3v2Frame.m_cFrameID, "TRCK", 4) == 0)
  515.         {
  516.             pItem->m_pcTrackNum_AsText = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  517.             if(pItem->m_pcTrackNum_AsText)
  518.                 pItem->m_cTrackNum = (unsigned char)atoi(pItem->m_pcTrackNum_AsText);
  519.         }
  520.         else if(memcmp(ID3v2Frame.m_cFrameID, "TYER", 4) == 0)
  521.             pItem->m_pcYear = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  522.         else if(memcmp(ID3v2Frame.m_cFrameID, "TENC", 4) == 0)
  523.             pItem->m_pcComment = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  524.         else if(memcmp(ID3v2Frame.m_cFrameID, "TCON", 4) == 0)
  525.         {
  526.             char* pcGenre = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  527.             if(pcGenre)
  528.             {
  529.                 // Search for this genre among the ID3v1 genres (don't read it if we cannot find it)
  530.                 int iGenreIDX;
  531.                 for(iGenreIDX = 0; iGenreIDX < CIC_NUMGENRES; iGenreIDX++)
  532.                 {
  533.                     if(stricmp(pcGenre, glb_pcGenres[iGenreIDX]) == 0)
  534.                     {
  535.                         pItem->m_cGenre = (unsigned char)iGenreIDX;
  536.                         break;
  537.                     }
  538.                 }
  539.                 free(pcGenre);
  540.             }
  541.         }
  542.         else if(memcmp(ID3v2Frame.m_cFrameID, "TLEN", 4) == 0)
  543.         {
  544.             char* pcLength = CPLI_ID3v2_DecodeString(pFrameData, iFrameSize);
  545.             if(pcLength)
  546.             {
  547.                 CPLI_DecodeLength(pItem, atoi(pcLength)/1000);
  548.                 free(pcLength);
  549.             }
  550.         }
  551. #ifdef _DEBUG
  552.         /*
  553.         else if(ID3v2Frame.m_cFrameID[0] == 'T')
  554.          CP_TRACE2("Text frame %4s "%s"", ID3v2Frame.m_cFrameID, pFrameData+1);
  555.         else
  556.          CP_TRACE1("Any old frame %4s", ID3v2Frame.m_cFrameID);
  557.         */
  558. #endif
  559.         free(pFrameData);
  560.         iTagDataToRead -= iFrameSize + sizeof(ID3v2Frame);
  561.     }
  563.     pItem->m_enTagType = ttID3v2;
  564. }
  565. //
  566. //
  567. //
  568. void CPLI_ReadTag_ID3v1(CPs_PlaylistItem* pItem, HANDLE hFile)
  569. {
  570.     DWORD dwBytesRead;
  571.     CIs_ID3Tag ID3;
  573.     SetFilePointer(hFile, 0-sizeof(ID3), NULL, FILE_END);
  574.     ReadFile(hFile, &ID3, sizeof(ID3), &dwBytesRead, NULL);
  576.     // Not enough file data returned - or the data returned does not look like an ID3
  577.     if(dwBytesRead != sizeof(ID3) || memcmp(ID3.m_cTAG, "TAG", 3) != 0)
  578.         return;
  580.     // Decode the fixed strings into our dynamic strings
  581.     CPLII_RemoveTagInfo(pItem);
  582.     pItem->m_pcTrackName = DecodeID3String(ID3.m_cSong, 30);
  583.     pItem->m_pcArtist = DecodeID3String(ID3.m_cArtist, 30);
  584.     pItem->m_pcAlbum = DecodeID3String(ID3.m_cAlbum, 30);
  585.     pItem->m_pcYear = DecodeID3String(ID3.m_cYear, 4);
  587.     // ID3v1.1 - If the 29th byte of the comment is 0 then the 30th byte is the track num
  588.     // ** Some dodgy implementations of ID3v1.1 just slap a <32 char byte at position 30 and hope
  589.     //    for the best - handle these too <hmph!>
  590.     if(ID3.m_cComment[28] == '' || ID3.m_cComment[29] < 32)
  591.     {
  592.         char cTempString[33];
  594.         pItem->m_pcComment = DecodeID3String(ID3.m_cComment, 28);
  595.         pItem->m_cTrackNum = ID3.m_cComment[29];
  597.         if(pItem->m_cTrackNum != CIC_INVALIDTRACKNUM)
  598.         {
  599.             itoa(pItem->m_cTrackNum, cTempString, 10);
  600.             pItem->m_pcTrackNum_AsText = (char*)malloc(CPC_TRACKNUMASTEXTBUFFERSIZE);
  601.             strncpy(pItem->m_pcTrackNum_AsText, cTempString, CPC_TRACKNUMASTEXTBUFFERSIZE);
  602.         }
  603.     }
  604.     else
  605.     {
  606.         pItem->m_pcComment = DecodeID3String(ID3.m_cComment, 30);
  607.         pItem->m_cTrackNum = CIC_INVALIDTRACKNUM;
  608.     }
  610.     if(ID3.m_cGenre < CIC_NUMGENRES)
  611.         pItem->m_cGenre = ID3.m_cGenre;
  612.     pItem->m_enTagType = ttID3v1;
  613. }
  614. //
  615. //
  616. //
  617. BOOL CPLI_IsTagDirty(CP_HPLAYLISTITEM hItem)
  618. {
  619.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  621.     CP_CHECKOBJECT(pItem);
  622.     return pItem->m_bID3Tag_SaveRequired;
  623. }
  624. //
  625. //
  626. //
  627. void CPLI_WriteTag(CP_HPLAYLISTITEM hItem)
  628. {
  629.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  630.     HANDLE hFile;
  632.     CP_CHECKOBJECT(pItem);
  633.     if(pItem->m_bID3Tag_SaveRequired == FALSE)
  634.         return;
  635. if(stricmp(".ogg", CPLI_GetExtension(hItem)) != 0 && 
  636. stricmp(".mp3", CPLI_GetExtension(hItem)) !=0)
  637. return;
  638.     // Try to open the file
  639.     hFile = CreateFile(pItem->m_pcPath, GENERIC_READ | GENERIC_WRITE,
  640.                        FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
  641.                        OPEN_EXISTING, 0, 0);
  643.     // Cannot open - fail silently
  644.     if(hFile == INVALID_HANDLE_VALUE)
  645.         return;
  647.     pItem->m_bID3Tag_SaveRequired = FALSE;
  649. if (stricmp(".mp3", CPLI_GetExtension(hItem)) ==0)
  650.     {
  651.         CPLI_WriteTag_ID3v1(pItem, hFile);
  652.         if(options.support_id3v2)
  653.             CPLI_WriteTag_ID3v2(pItem, hFile);
  654.     }
  656.     CloseHandle(hFile);
  657. }
  658. //
  659. //
  660. //
  661. void CPLI_WriteTag_ID3v1(CPs_PlaylistItem* pItem, HANDLE hFile)
  662. {
  663.     DWORD dwBytesTransferred;
  664.     CIs_ID3Tag ID3;
  665.     char cTagMagic[3];
  667.     // Build the tag (of ID3v1.1 format)
  668.     memset(&ID3, 32, sizeof(ID3));
  669.     memcpy(ID3.m_cTAG, "TAG", 3);
  670.     if(pItem->m_pcTrackName)
  671.         strncpy(ID3.m_cSong, pItem->m_pcTrackName, 30);
  672.     if(pItem->m_pcArtist)
  673.         strncpy(ID3.m_cArtist, pItem->m_pcArtist, 30);
  674.     if(pItem->m_pcAlbum)
  675.         strncpy(ID3.m_cAlbum, pItem->m_pcAlbum, 30);
  676.     if(pItem->m_pcYear)
  677.         strncpy(ID3.m_cYear, pItem->m_pcYear, 4);
  678.     if(pItem->m_pcComment)
  679. if(strlen(pItem->m_pcComment)>28)
  680. {
  681.         strncpy(ID3.m_cComment, pItem->m_pcComment, 30);
  682. }else
  683. {
  684.         strncpy(ID3.m_cComment, pItem->m_pcComment, 28);
  685.     ID3.m_cComment[28] = '';
  686.     ID3.m_cComment[29] = pItem->m_cTrackNum;
  687. }
  688.     ID3.m_cGenre = pItem->m_cGenre;
  690.     // Set the file pointer to the end of the file (or the start of the tag if there is one already)
  691.     SetFilePointer(hFile, 0-sizeof(ID3), NULL, FILE_END);
  692.     ReadFile(hFile, cTagMagic, sizeof(cTagMagic), &dwBytesTransferred, NULL);
  693.     if(memcmp(cTagMagic, "TAG", 3) == 0)
  694.         SetFilePointer(hFile, 0-sizeof(ID3), NULL, FILE_END);
  695.     else
  696.         SetFilePointer(hFile, 0, NULL, FILE_END);
  698.     WriteFile(hFile, &ID3, sizeof(ID3), &dwBytesTransferred, NULL);
  699. }
  700. //
  701. //
  702. //
  703. void CPLI_ID3v2_WriteSyncSafeInt(char cDest[4], const int iSource)
  704. {
  705.     cDest[0] = (iSource>>21) & 0x7F;
  706.     cDest[1] = (iSource>>14) & 0x7F;
  707.     cDest[2] = (iSource>>7) & 0x7F;
  708.     cDest[3] = iSource & 0x7F;
  709. }
  710. //
  711. //
  712. //
  713. void CPLI_ID3v2_WriteTextFrame(BYTE** ppDest, const char pcTag[4], const char* pcString)
  714. {
  715.     CIs_ID3v2Frame* pFrame = (CIs_ID3v2Frame*)*ppDest;
  716.     BYTE* pFrameData;
  717.     int iFrameDataLength;
  719.     iFrameDataLength = strlen(pcString) + 1; // 1-byte for encoding
  721.     memcpy(pFrame->m_cFrameID, pcTag, sizeof(pcTag));
  722.     CPLI_ID3v2_WriteSyncSafeInt(pFrame->m_cSize_Encoded, iFrameDataLength);
  723.     pFrame->m_cFlags = 0x0;
  725.     // Write frame data
  726.     pFrameData = ((*ppDest) + sizeof(CIs_ID3v2Frame));
  727.     pFrameData[0] = 0x0;
  728.     memcpy(pFrameData + 1, pcString, iFrameDataLength-1);
  730.     *ppDest += iFrameDataLength + sizeof(CIs_ID3v2Frame);
  731. }
  732. //
  733. //
  734. //
  735. void CPLI_WriteTag_ID3v2(CPs_PlaylistItem* pItem, HANDLE hFile)
  736. {
  737.     unsigned int iTagDataLength;
  738.     unsigned int iExistingTagLength;
  739.     DWORD dwBytesTransferred;
  740.     char atiobuffer[33];
  741.     BYTE* pTag;
  742.     BYTE* pTag_Cursor;
  744.     // Work out the size of the data in the tag frames
  745.     iTagDataLength = 0;
  746.     if(pItem->m_pcTrackName)
  747.         iTagDataLength += strlen(pItem->m_pcTrackName) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  748.     if(pItem->m_pcArtist)
  749.         iTagDataLength += strlen(pItem->m_pcArtist) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  750.     if(pItem->m_pcAlbum)
  751.         iTagDataLength += strlen(pItem->m_pcAlbum) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  752.     if(pItem->m_pcYear)
  753.         iTagDataLength += strlen(pItem->m_pcYear) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  754.     if(pItem->m_pcComment)
  755.         iTagDataLength += strlen(pItem->m_pcComment) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  756.     if(pItem->m_cGenre != CIC_INVALIDGENRE)
  757.         iTagDataLength += strlen(glb_pcGenres[pItem->m_cGenre]) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  758.     if(pItem->m_cTrackNum != CIC_INVALIDTRACKNUM)
  759.         iTagDataLength += strlen(itoa(pItem->m_cTrackNum, atiobuffer, 10)) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  760.     if(pItem->m_iTrackLength != 0)
  761.         iTagDataLength += strlen(itoa(pItem->m_iTrackLength*1000, atiobuffer, 10)) + 1 + sizeof(CIs_ID3v2Frame); // 1-byte for encoding and a frame header
  763.     // Add ID3v2 overhead
  764.     iTagDataLength += sizeof(CIs_ID3v2Tag);
  766.     // Quantise tag to the nearest 1K
  767.     iTagDataLength = ((iTagDataLength>>10) + 1) << 10;
  769.     // Is there a tag big enough in the file
  770.     {
  771.         CIs_ID3v2Tag existingtagheader;
  773.         SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
  774.         ReadFile(hFile, &existingtagheader, sizeof(existingtagheader), &dwBytesTransferred, NULL);
  776.         if(memcmp(existingtagheader.m_cTAG, "ID3", 3) == 0)
  777.         {
  778.             iExistingTagLength = (existingtagheader.m_cSize_Encoded[0] << 21)
  779.                                  | (existingtagheader.m_cSize_Encoded[1] << 14)
  780.                                  | (existingtagheader.m_cSize_Encoded[2] << 7)
  781.                                  | existingtagheader.m_cSize_Encoded[3];
  782.             iExistingTagLength += sizeof(CIs_ID3v2Tag); // count the header
  783.             if(iExistingTagLength > iTagDataLength)
  784.                 iTagDataLength = iExistingTagLength;
  785.         }
  786.         else
  787.             iExistingTagLength = 0;
  788.     }
  790.     // Do we need to enlarge the file?
  791.     if(iExistingTagLength < iTagDataLength)
  792.     {
  793.         if(CPLI_GrowFile(hFile, 0, iTagDataLength-iExistingTagLength) == FALSE)
  794.             return;
  795.     }
  797.     // Build tag
  798.     pTag = malloc(iTagDataLength);
  799.     memset(pTag, 0, iTagDataLength); // ** must do this as all padding should be 0x00
  800.     pTag_Cursor = pTag;
  802.     // Header
  803.     {
  804.         CIs_ID3v2Tag* pHeader = (CIs_ID3v2Tag*)pTag_Cursor;
  805.         int iSizeLessHeader = iTagDataLength - sizeof(CIs_ID3v2Tag);
  807.         pHeader->m_cTAG[0] = 'I';
  808.         pHeader->m_cTAG[1] = 'D';
  809.         pHeader->m_cTAG[2] = '3';
  811.         pHeader->m_cVersion[0] = 0x4;
  812.         pHeader->m_cVersion[1] = 0x0;
  814.         pHeader->m_cFlags = 0x0;
  816.         CPLI_ID3v2_WriteSyncSafeInt(pHeader->m_cSize_Encoded, iSizeLessHeader);
  817.         pTag_Cursor += sizeof(CIs_ID3v2Tag);
  818.     }
  820.     // Frames
  821.     if(pItem->m_pcTrackName)
  822.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TIT2", pItem->m_pcTrackName);
  823.     if(pItem->m_pcArtist)
  824.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TPE1", pItem->m_pcArtist);
  825.     if(pItem->m_pcAlbum)
  826.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TALB", pItem->m_pcAlbum);
  827.     if(pItem->m_pcYear)
  828.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TYER", pItem->m_pcYear);
  829.     if(pItem->m_pcComment)
  830.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TENC", pItem->m_pcComment);
  831.     if(pItem->m_cGenre != CIC_INVALIDGENRE)
  832.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TCON", glb_pcGenres[pItem->m_cGenre]);
  833.     if(pItem->m_cTrackNum != CIC_INVALIDTRACKNUM)
  834.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TRCK", itoa(pItem->m_cTrackNum, atiobuffer, 10));
  835.     if(pItem->m_iTrackLength != 0)
  836.         CPLI_ID3v2_WriteTextFrame(&pTag_Cursor, "TLEN", itoa(pItem->m_iTrackLength * 1000, atiobuffer, 10));
  838.     // Output tag
  839.     SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
  840.     WriteFile(hFile, pTag, iTagDataLength, &dwBytesTransferred, NULL);
  841.     CP_ASSERT(dwBytesTransferred == iTagDataLength);
  842. }
  843. //
  844. //
  845. //
  846. CPe_ReadWriteState CPLI_GetReadWriteState(const CP_HPLAYLISTITEM hItem)
  847. {
  848.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  849.     HANDLE hFile;
  850.     CP_CHECKOBJECT(pItem);
  852.     // We will check this every time (and not cache the result) because the
  853.     // file could have been played with outside of CoolPlayer
  855.     // Try to open the file in RW mode
  856.     hFile = CreateFile(pItem->m_pcPath, GENERIC_READ | GENERIC_WRITE,
  857.                        FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
  858.                        OPEN_EXISTING, 0, 0);
  859.     if(hFile != INVALID_HANDLE_VALUE)
  860.     {
  861.         // Only cache
  862.         CloseHandle(hFile);
  863.         return rwsReadWrite;
  864.     }
  866.     // That didn't work - try a RO open
  867.     hFile = CreateFile(pItem->m_pcPath, GENERIC_READ,
  868.                        FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
  869.                        OPEN_EXISTING, 0, 0);
  870.     if(hFile != INVALID_HANDLE_VALUE)
  871.     {
  872.         CloseHandle(hFile);
  873.         return rwsReadOnly;
  874.     }
  876.     return rwsBadFile;
  877. }
  878. //
  879. //
  880. //
  881. void CPLI_SetArtist(CP_HPLAYLISTITEM hItem, const char* pcNewValue)
  882. {
  883.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  884.     CP_CHECKOBJECT(pItem);
  886.     STR_AllocSetString(&pItem->m_pcArtist, pcNewValue, TRUE);
  887.     pItem->m_bID3Tag_SaveRequired = TRUE;
  888.     CPL_cb_OnItemUpdated(hItem);
  889. }
  890. //
  891. //
  892. //
  893. void CPLI_SetAlbum(CP_HPLAYLISTITEM hItem, const char* pcNewValue)
  894. {
  895.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  896.     CP_CHECKOBJECT(pItem);
  898.     STR_AllocSetString(&pItem->m_pcAlbum, pcNewValue, TRUE);
  899.     pItem->m_bID3Tag_SaveRequired = TRUE;
  900.     CPL_cb_OnItemUpdated(hItem);
  901. }
  902. //
  903. //
  904. //
  905. void CPLI_SetTrackName(CP_HPLAYLISTITEM hItem, const char* pcNewValue)
  906. {
  907.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  908.     CP_CHECKOBJECT(pItem);
  910.     STR_AllocSetString(&pItem->m_pcTrackName, pcNewValue, TRUE);
  911.     pItem->m_bID3Tag_SaveRequired = TRUE;
  912.     CPL_cb_OnItemUpdated(hItem);
  913. }
  914. //
  915. //
  916. //
  917. void CPLI_SetYear(CP_HPLAYLISTITEM hItem, const char* pcNewValue)
  918. {
  919.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  920.     CP_CHECKOBJECT(pItem);
  922.     STR_AllocSetString(&pItem->m_pcYear, pcNewValue, TRUE);
  923.     pItem->m_bID3Tag_SaveRequired = TRUE;
  924.     CPL_cb_OnItemUpdated(hItem);
  925. }
  926. //
  927. //
  928. //
  929. void CPLI_SetGenreIDX(CP_HPLAYLISTITEM hItem, const unsigned char iNewValue)
  930. {
  931.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  932.     CP_CHECKOBJECT(pItem);
  934.     pItem->m_cGenre = iNewValue;
  935.     pItem->m_bID3Tag_SaveRequired = TRUE;
  936.     CPL_cb_OnItemUpdated(hItem);
  937. }
  938. //
  939. //
  940. //
  941. void CPLI_SetTrackNum(CP_HPLAYLISTITEM hItem, const unsigned char iNewValue)
  942. {
  943.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  944.     char cTempString[33];
  945.     CP_CHECKOBJECT(pItem);
  947.     pItem->m_cTrackNum = iNewValue;
  948.     if(pItem->m_cTrackNum != CIC_INVALIDTRACKNUM)
  949.     {
  950.         if(pItem->m_pcTrackNum_AsText)
  951.             free(pItem->m_pcTrackNum_AsText);
  953.         pItem->m_pcTrackNum_AsText = (char*)malloc(CPC_TRACKNUMASTEXTBUFFERSIZE);
  954.         itoa(pItem->m_cTrackNum, cTempString, 10);
  955.         strncpy(pItem->m_pcTrackNum_AsText, cTempString, CPC_TRACKNUMASTEXTBUFFERSIZE);
  956.     }
  957.     else
  958.     {
  959.         if(pItem->m_pcTrackNum_AsText)
  960.         {
  961.             free(pItem->m_pcTrackNum_AsText);
  962.             pItem->m_pcTrackNum_AsText = NULL;
  963.         }
  964.     }
  965.     pItem->m_bID3Tag_SaveRequired = TRUE;
  966.     CPL_cb_OnItemUpdated(hItem);
  967. }
  968. //
  969. //
  970. //
  971. void CPLI_SetTrackNum_AsText(CP_HPLAYLISTITEM hItem, const char* pcNewValue)
  972. {
  973.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  974.     CP_CHECKOBJECT(pItem);
  976.     if(pcNewValue[0] == '')
  977.         pItem->m_cTrackNum = CIC_INVALIDTRACKNUM;
  978.     else
  979.         pItem->m_cTrackNum = (unsigned char)atoi(pcNewValue);
  981.     if(pItem->m_pcTrackNum_AsText)
  982.         free(pItem->m_pcTrackNum_AsText);
  984.     pItem->m_pcTrackNum_AsText = (char*)malloc(CPC_TRACKNUMASTEXTBUFFERSIZE);
  985.     strncpy(pItem->m_pcTrackNum_AsText, pcNewValue, CPC_TRACKNUMASTEXTBUFFERSIZE);
  986.     pItem->m_bID3Tag_SaveRequired = TRUE;
  987.     CPL_cb_OnItemUpdated(hItem);
  988. }
  989. //
  990. //
  991. //
  992. void CPLI_SetComment(CP_HPLAYLISTITEM hItem, const char* pcNewValue)
  993. {
  994.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  995.     CP_CHECKOBJECT(pItem);
  997.     STR_AllocSetString(&pItem->m_pcComment, pcNewValue, TRUE);
  998.     pItem->m_bID3Tag_SaveRequired = TRUE;
  999.     CPL_cb_OnItemUpdated(hItem);
  1000. }
  1001. //
  1002. //
  1003. //
  1004. void CPLI_SetTrackStackPos(CP_HPLAYLISTITEM hItem, const int iNewPos)
  1005. {
  1006.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  1007.     CP_CHECKOBJECT(pItem);
  1009.     pItem->m_iTrackStackPos = iNewPos;
  1010.     if(iNewPos == 0)
  1011.     {
  1012.         pItem->m_cTrackStackPos_AsText[0] = '>';
  1013.         pItem->m_cTrackStackPos_AsText[1] = '>';
  1014.         pItem->m_cTrackStackPos_AsText[2] = '>';
  1015.         pItem->m_cTrackStackPos_AsText[3] = '';
  1016.     }
  1017.     else if(iNewPos == CIC_TRACKSTACK_UNSTACKED)
  1018.     {
  1019.         pItem->m_cTrackStackPos_AsText[0] = '';
  1020.     }
  1021.     else
  1022.     {
  1023.         _snprintf(pItem->m_cTrackStackPos_AsText, sizeof(pItem->m_cTrackStackPos_AsText), "%d", iNewPos);
  1024.     }
  1025. }
  1026. //
  1027. //
  1028. //
  1029. void CPLI_CalculateLength(CP_HPLAYLISTITEM hItem)
  1030. {
  1031.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  1032.     const char* pcExtension;
  1034.     CP_CHECKOBJECT(pItem);
  1036.     pcExtension = CPLI_GetExtension(hItem);
  1038.     if(stricmp(pcExtension, ".mp3") == 0
  1039.             || stricmp(pcExtension, ".mp2") == 0)
  1040.     {
  1041.         CPLI_CalculateLength_MP3(pItem);
  1042.     }
  1044. //    pItem->m_bID3Tag_SaveRequired = TRUE;
  1045.     CPL_cb_OnItemUpdated(hItem);
  1046. }
  1047. //
  1048. //
  1049. //
  1051. //
  1052. //
  1053. //
  1055. //
  1056. //
  1057. //
  1058. void CPLI_CalculateLength_MP3(CPs_PlaylistItem* pItem)
  1059. {
  1060.     BYTE pbBuffer[0x8000];
  1061.     unsigned int iBufferCursor;
  1062.     DWORD dwBufferSize;
  1063.     HANDLE hFile;
  1064.     BOOL bFoundFrameHeader;
  1065.     int iBitRate;
  1066.     DWORD dwFileSize;
  1067.     int iMPEG_version;
  1068.     int iLayer;
  1069.     BOOL bMono;
  1070.     unsigned int iVBRHeader;
  1072.     // - Try to open the file
  1073.     hFile = CreateFile(pItem->m_pcPath, GENERIC_READ,
  1074.                        FILE_SHARE_READ, 0,
  1075.                        OPEN_EXISTING, 0, 0);
  1076.     dwFileSize = GetFileSize(hFile, NULL);
  1078.     // Cannot open - fail silently
  1079.     if(hFile == INVALID_HANDLE_VALUE)
  1080.         return;
  1082.     // Read the first 64K of the file (that should contain the first frame header!)
  1083.     ReadFile(hFile, pbBuffer, sizeof(pbBuffer), &dwBufferSize, NULL);
  1084.     CloseHandle(hFile);
  1086.     iBufferCursor = 0;
  1088.     // Skip over a any ID3v2 tag
  1089.     {
  1090.         CIs_ID3v2Tag* pHeader = (CIs_ID3v2Tag*)(pbBuffer + iBufferCursor);
  1092.         if(memcmp(pHeader->m_cTAG, "ID3", 3) == 0)
  1093.         {
  1094.             iBufferCursor += (pHeader->m_cSize_Encoded[0] << 21)
  1095.                              | (pHeader->m_cSize_Encoded[1] << 14)
  1096.                              | (pHeader->m_cSize_Encoded[2] << 7)
  1097.                              | pHeader->m_cSize_Encoded[3];
  1098.             iBufferCursor += sizeof(CIs_ID3v2Tag); // count the header
  1099.         }
  1100.     }
  1102.     // Seek to the start of the first frame
  1103.     bFoundFrameHeader = FALSE;
  1104.     while(iBufferCursor < (dwBufferSize-4))
  1105.     {
  1106.         if(pbBuffer[iBufferCursor] == 0xFF
  1107.                 && (pbBuffer[iBufferCursor+1] & 0xE0) == 0xE0)
  1108.         {
  1109.             bFoundFrameHeader = TRUE;
  1110.             break;
  1111.         }
  1112.         iBufferCursor++;
  1113.     }
  1114.     if(bFoundFrameHeader == FALSE)
  1115.         return;
  1117.     // Work out MPEG version
  1118.     if( ((pbBuffer[iBufferCursor+1] >> 3) & 0x3) == 0x3)
  1119.         iMPEG_version = 1;
  1120.     else
  1121.         iMPEG_version = 2;
  1123.     // Work out layer
  1124.     iLayer = 0x4 - ( (pbBuffer[iBufferCursor+1] >> 1) & 0x3);
  1125.     if(iLayer == 0)
  1126.         return;
  1128.     // Work out stereo
  1129.     if( (pbBuffer[iBufferCursor+3]>>6) == 0x3)
  1130.         bMono = TRUE;
  1131.     else
  1132.         bMono = FALSE;
  1134.     // Work out the VBR header should be
  1135.     if(iMPEG_version == 1)
  1136.         iVBRHeader = (iBufferCursor+4) + (bMono ? 17 : 32);
  1137.     else
  1138.         iVBRHeader = (iBufferCursor+4) + (bMono ? 9 : 17);
  1141.     // Is this a VBR file
  1142.     if( (iBufferCursor+iVBRHeader+12) < dwBufferSize
  1143.             && pbBuffer[iVBRHeader]=='X'
  1144.             && pbBuffer[iVBRHeader+1]=='i'
  1145.             && pbBuffer[iVBRHeader+2]=='n'
  1146.             && pbBuffer[iVBRHeader+3]=='g')
  1147.     {
  1148.         int iNumberOfFrames;
  1149.         int iFreq;
  1150.         int iDetailedVersion;
  1151.         const int aryFrequencies[3][3] = {
  1152.                                              {44100, 48000, 32000}, //MPEG 1
  1153.                                              {22050, 24000, 16000}, //MPEG 2
  1154.                                              {32000, 16000,  8000}  //MPEG 2.5
  1155.                                          };
  1157.         if( ((pbBuffer[iBufferCursor+1] >> 3) & 0x3) == 0x3)
  1158.             iDetailedVersion = 1;
  1159.         else if( ((pbBuffer[iBufferCursor+1] >> 3) & 0x3) == 0x2)
  1160.             iDetailedVersion = 2;
  1161.         else
  1162.             iDetailedVersion = 3;
  1164.         // Get the number of frames from the Xing header
  1165.         iNumberOfFrames = (pbBuffer[iVBRHeader+8] << 24)
  1166.                           | (pbBuffer[iVBRHeader+9] << 16)
  1167.                           | (pbBuffer[iVBRHeader+10] << 8)
  1168.                           | pbBuffer[iVBRHeader+11];
  1170.         if( ((pbBuffer[iBufferCursor+2]>>2) & 0x3) == 0x3)
  1171.             return;
  1172.         iFreq = aryFrequencies[iDetailedVersion-1][(pbBuffer[iBufferCursor+2]>>2) & 0x3];
  1174.         CPLI_DecodeLength(pItem, (8 * iNumberOfFrames * 144)/iFreq);
  1175.     }
  1176.     // Work out the bit rate for a CBR file
  1177.     else
  1178.     {
  1179.         const int aryBitRates[2][3][16] = {
  1180.                                               {         //MPEG 2 & 2.5
  1181.                                                   {0, 32, 48, 56, 64, 80, 96,112,128,144,160,176,192,224,256,0}, //Layer I
  1182.                                                   {0,  8, 16, 24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160,0}, //Layer II
  1183.                                                   {0,  8, 16, 24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160,0}  //Layer III
  1184.                                               },{       //MPEG 1
  1185.                                                   {0, 32, 64, 96,128,160,192,224,256,288,320,352,384,416,448,0}, //Layer I
  1186.                                                   {0, 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384,0}, //Layer II
  1187.                                                   {0, 32, 40, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,0}  //Layer III
  1188.                                               }
  1189.                                           };
  1191.         iBitRate = aryBitRates[2-iMPEG_version][iLayer-1][pbBuffer[iBufferCursor+2]>>4];
  1192.         if(iBitRate)
  1193.             CPLI_DecodeLength(pItem, (dwFileSize*8)/(iBitRate*1000) );
  1194.     }
  1195. }
  1196. //
  1197. //
  1198. //
  1199. BOOL CPLI_RenameTrack(CP_HPLAYLISTITEM hItem, const CPe_FilenameFormat enFormat)
  1200. {
  1201.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  1202.     char cPath[MAX_PATH];
  1203.     char cNewPath[MAX_PATH];
  1204.     BOOL bMoved;
  1205.     const char* pcExtension;
  1207.     CP_CHECKOBJECT(pItem);
  1209.     strncpy(cPath, pItem->m_pcPath, MAX_PATH);
  1211.     // Remove the filename from the path
  1212.     {
  1213.         int iLastSlashIDX, iCharIDX;
  1214.         iLastSlashIDX = CPC_INVALIDCHAR;
  1216.         for(iCharIDX = 0; cPath[iCharIDX]; iCharIDX++)
  1217.         {
  1218.             if(cPath[iCharIDX] == '\')
  1219.                 iLastSlashIDX = iCharIDX;
  1220.         }
  1222.         if(iLastSlashIDX != CPC_INVALIDCHAR)
  1223.             cPath[iLastSlashIDX] = '';
  1224.     }
  1226.     pcExtension = CPLI_GetExtension(hItem);
  1228.     // Apply the name format
  1229.     {
  1230.         char cNewFilename[MAX_PATH];
  1231.         const char* pcTitle;
  1232.         const char* pcArtist;
  1233.         const char* pcAlbum;
  1235.         if(pItem->m_pcTrackName)
  1236.             pcTitle = pItem->m_pcTrackName;
  1237.         else
  1238.             pcTitle = "<title>";
  1239.         if(pItem->m_pcArtist)
  1240.             pcArtist = pItem->m_pcArtist;
  1241.         else
  1242.             pcArtist = "<title>";
  1243.         if(pItem->m_pcAlbum)
  1244.             pcAlbum = pItem->m_pcAlbum;
  1245.         else
  1246.             pcAlbum = "<album>";
  1249.         switch(enFormat)
  1250.         {
  1251.         case rwsArtistAlbumNumberTitle:
  1252.             sprintf(cNewFilename, "%s - %s - %02d - %s%s", pcArtist, pcAlbum, (int)pItem->m_cTrackNum, pcTitle, pcExtension);
  1253.             break;
  1254.         case rwsArtistNumberTitle:
  1255.             sprintf(cNewFilename, "%s - %02d - %s%s", pcArtist, (int)pItem->m_cTrackNum, pcTitle, pcExtension);
  1256.             break;
  1257.         case rwsAlbumNumberTitle:
  1258.             sprintf(cNewFilename, "%s - %02d - %s%s", pcAlbum, (int)pItem->m_cTrackNum, pcTitle, pcExtension);
  1259.             break;
  1260.         case rwsAlbumNumber:
  1261.             sprintf(cNewFilename, "%s - %02d%s", pcAlbum, (int)pItem->m_cTrackNum, pcExtension);
  1262.             break;
  1263.         case rwsNumberTitle:
  1264.             sprintf(cNewFilename, "%02d - %s%s", (int)pItem->m_cTrackNum, pcTitle, pcExtension);
  1265.             break;
  1266.         case rwsTitle:
  1267.             sprintf(cNewFilename, "%s%s", pcTitle, pcExtension);
  1268.             break;
  1269.         default:
  1270.             CP_FAIL("Unknown rename format");
  1271.         }
  1273.         // Replace illegal chars with _
  1274.         {
  1275.             int iCharIDX;
  1277.             for(iCharIDX = 0; cNewFilename[iCharIDX]; iCharIDX++)
  1278.             {
  1279.                 if(cNewFilename[iCharIDX] == '\'
  1280.                         || cNewFilename[iCharIDX] == '/'
  1281.                         || cNewFilename[iCharIDX] == ':'
  1282.                         || cNewFilename[iCharIDX] == '"')
  1283.                 {
  1284.                     cNewFilename[iCharIDX] = '_';
  1285.                 }
  1286.             }
  1287.         }
  1289.         sprintf(cNewPath, "%s\%s", cPath, cNewFilename);
  1290.     }
  1292.     CP_TRACE2("Rename "%s" to "%s"", pItem->m_pcPath, cNewPath);
  1293.     bMoved = MoveFile(pItem->m_pcPath, cNewPath);
  1294.     if(bMoved)
  1295.     {
  1296.         CPLI_SetPath(pItem, cNewPath);
  1298.         // Update interface
  1299.         CPL_cb_OnItemUpdated(hItem);
  1300.     }
  1302.     return bMoved;
  1303. }
  1304. //
  1305. //
  1306. //
  1307. void CPLI_SetPath(CPs_PlaylistItem* pItem, const char* pcPath)
  1308. {
  1309.     int iCharIDX, iLastSlashIDX;
  1310.     char cFullPath[MAX_PATH];
  1312.     if(pItem->m_pcPath)
  1313.         free(pItem->m_pcPath);
  1316.     // Store the full path to the file if this isn't a stream
  1317.     if(strnicmp(CIC_HTTPHEADER, pcPath, 5) != 0
  1318.             && strnicmp("https:", pcPath, 6) != 0
  1319.             && strnicmp("ftp:", pcPath, 4) != 0)
  1320.     {
  1321.         _fullpath(cFullPath, pcPath, MAX_PATH);
  1322.         STR_AllocSetString(&pItem->m_pcPath, cFullPath, FALSE);
  1323.     }
  1324.     else
  1325.         STR_AllocSetString(&pItem->m_pcPath, pcPath, FALSE);
  1327.     // Get the filename (the string following the last slash)
  1328.     iLastSlashIDX = 0;
  1329.     for(iCharIDX = 0; pItem->m_pcPath[iCharIDX]; iCharIDX++)
  1330.     {
  1331.         if(pItem->m_pcPath[iCharIDX] == '\')
  1332.             iLastSlashIDX = iCharIDX;
  1333.     }
  1334.     pItem->m_pcFilename = pItem->m_pcPath + iLastSlashIDX + 1;
  1335. }
  1336. //
  1337. //
  1338. //
  1339. const char* CPLI_GetExtension(const CP_HPLAYLISTITEM hItem)
  1340. {
  1341.     CPs_PlaylistItem* pItem = (CPs_PlaylistItem*)hItem;
  1342.     int iCharIDX;
  1343.     const char* pcLastDot;
  1345.     CP_CHECKOBJECT(pItem);
  1347.     pcLastDot = NULL;
  1348.     for(iCharIDX = 0; pItem->m_pcPath[iCharIDX]; iCharIDX++)
  1349.     {
  1350.         if(pItem->m_pcPath[iCharIDX] == '.')
  1351.             pcLastDot = pItem->m_pcPath + iCharIDX;
  1352.         // If there is a directory name with a dot in it we don't want that!
  1353.         else if(pItem->m_pcPath[iCharIDX] == '\')
  1354.             pcLastDot = NULL;
  1355.     }
  1357.     // Ensure the string is valid
  1358.     if(!pcLastDot)
  1359.         pcLastDot = "";
  1361.     return pcLastDot;
  1362. }
  1363. //
  1364. //
  1365. //
  1366. /*
  1367. void CPLI_OGG_SkipOverTab(FILE* pFile)
  1368. {
  1369.     CIs_ID3v2Tag tag;
  1370.     int iStreamStart = 0;
  1372.     memset(&tag, 0, sizeof(tag));
  1373.     fread(&tag, sizeof(tag), 1, pFile);
  1375.     if(memcmp(tag.m_cTAG, "ID3", 3) == 0)
  1376.     {
  1377.         iStreamStart = sizeof(CIs_ID3v2Tag);
  1378.         iStreamStart += (tag.m_cSize_Encoded[0] << 21)
  1379.                         | (tag.m_cSize_Encoded[1] << 14)
  1380.                         | (tag.m_cSize_Encoded[2] << 7)
  1381.                         | tag.m_cSize_Encoded[3];
  1382.     }
  1384.     fseek(pFile, iStreamStart, SEEK_SET);
  1385. }*/
  1386. //
  1387. //
  1388. //
  1389. /*void CPLI_OGG_DecodeString(char** ppcString, const char* pcNewValue)
  1390. {
  1391.     int iStringLength;
  1393.     if(*ppcString)
  1394.         free(*ppcString);
  1396.     iStringLength = strlen(pcNewValue);
  1397.     *ppcString = malloc(iStringLength + 1);
  1398.     memcpy(*ppcString, pcNewValue, iStringLength+1);
  1399. }*/
  1401. //
  1402. //
  1403. //
  1404. void CPLI_ShrinkFile(HANDLE hFile, const DWORD dwStartOffset, const unsigned int iNumBytes)
  1405. {
  1406.     BYTE pBuffer[0x10000];
  1407.     DWORD dwLength;
  1408.     DWORD dwBytesTransferred;
  1409.     DWORD dwCursor;
  1411.     CP_TRACE1("Shrunking file by %d bytes", iNumBytes);
  1413.     dwLength = GetFileSize(hFile, NULL);
  1414.     CP_ASSERT( (dwStartOffset+iNumBytes) < dwLength);
  1415.     dwCursor = dwStartOffset;
  1416.     while((dwCursor+iNumBytes) < dwLength)
  1417.     {
  1418.         unsigned int iChunkSize;
  1420.         iChunkSize = 0x10000;
  1421.         if(iChunkSize > dwLength-(dwCursor+iNumBytes) )
  1422.             iChunkSize = dwLength-(dwCursor+iNumBytes);
  1424.         SetFilePointer(hFile, dwCursor + iNumBytes, NULL, FILE_BEGIN);
  1425.         ReadFile(hFile, pBuffer, iChunkSize, &dwBytesTransferred, NULL);
  1426.         CP_ASSERT(dwBytesTransferred == iChunkSize);
  1428.         SetFilePointer(hFile, dwCursor, NULL, FILE_BEGIN);
  1429.         WriteFile(hFile, pBuffer, iChunkSize, &dwBytesTransferred, NULL);
  1431.         dwCursor += iChunkSize;
  1432.     }
  1434.     SetFilePointer(hFile, dwLength - iNumBytes, NULL, FILE_BEGIN);
  1435.     SetEndOfFile(hFile);
  1436. }
  1437. //
  1438. //
  1439. //
  1440. BOOL CPLI_GrowFile(HANDLE hFile, const DWORD dwStartOffset, const unsigned int iNumBytes)
  1441. {
  1442.     DWORD dwFileSize;
  1443.     unsigned int iFileCursor;
  1444.     DWORD dwBytesTransferred;
  1445.     BYTE* pbReadBlock[0x10000];
  1447.     dwFileSize = GetFileSize(hFile, NULL);
  1448.     CP_TRACE1("Enlarging file by %d bytes", iNumBytes);
  1450.     // Try to write extra data to end of file - if we fail then clip the file and return
  1451.     // (so that we don't corrupt the file in short of space situations)
  1452.     {
  1453.         BYTE* pbExtra;
  1455.         pbExtra = (BYTE*)malloc(iNumBytes);
  1456.         memset(pbExtra, 0, iNumBytes);
  1457.         SetFilePointer(hFile, dwFileSize + iNumBytes, NULL, FILE_BEGIN);
  1458.         WriteFile(hFile, pbExtra, iNumBytes, &dwBytesTransferred, NULL);
  1459.         if(dwBytesTransferred != iNumBytes)
  1460.         {
  1461.             // Failed - clip file again and abort tag write
  1462.             SetFilePointer(hFile, dwFileSize, NULL, FILE_BEGIN);
  1463.             SetEndOfFile(hFile);
  1464.             return FALSE;
  1465.         }
  1466.     }
  1468.     // Enlarge tag
  1469.     iFileCursor = dwFileSize;
  1470.     while(iFileCursor > dwStartOffset)
  1471.     {
  1472.         unsigned int iBlockSize;
  1474.         iBlockSize = 0x10000;
  1475.         if( (iFileCursor - dwStartOffset) < iBlockSize)
  1476.             iBlockSize = iFileCursor - dwStartOffset;
  1478.         // Read a chunk
  1479.         SetFilePointer(hFile, iFileCursor - iBlockSize, NULL, FILE_BEGIN);
  1480.         ReadFile(hFile, pbReadBlock, iBlockSize, &dwBytesTransferred, NULL);
  1481.         CP_ASSERT(dwBytesTransferred == iBlockSize);
  1483.         // Write chunk at offsetted position
  1484.         SetFilePointer(hFile, iFileCursor - iBlockSize + iNumBytes, NULL, FILE_BEGIN);
  1485.         WriteFile(hFile, pbReadBlock, iBlockSize, &dwBytesTransferred, NULL);
  1486.         CP_ASSERT(dwBytesTransferred == iBlockSize);
  1488.         iFileCursor -= iBlockSize;
  1489.     }
  1491.     return TRUE;
  1492. }
  1493. //
  1494. //
  1495. //