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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
ZZLFileWriter.cpp
资源名称：p2p_vod.rar　[点击查看]
上传用户：liguizhu
上传日期：2015-11-01
资源大小：2422k
文件大小：19k
源码类别：

P2P编程

开发平台：

Visual C++

ZZLFileWriter.cpp：源码内容
  1. /*
  2. *  Openmysee
  3. *
  4. *  This program is free software; you can redistribute it and/or modify
  5. *  it under the terms of the GNU General Public License as published by
  6. *  the Free Software Foundation; either version 2 of the License, or
  7. *  (at your option) any later version.
  8. *
  9. *  This program is distributed in the hope that it will be useful,
  10. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. *  GNU General Public License for more details.
  13. *
  14. *  You should have received a copy of the GNU General Public License
  15. *  along with this program; if not, write to the Free Software
  16. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17. *
  18. */
  19. #include "stdafx.h"
  20. #include "zzlfilewriter.h"
  21. #include "md5.h"
  23. ZZLFileWriter::ZZLFileWriter(void) : FILE_VERSION(1.0f),mbIsSingleAudio(FALSE)
  24. {
  25. zzlHandle = INVALID_HANDLE_VALUE;
  26. blockCount = 0;
  27. dataOffset = 0;
  28. startTime = endTime = 0;
  30. dataHandle = keySampleHandle = configHandle = INVALID_HANDLE_VALUE;
  31. firstSampleTime = firstKeySampleTime = 0;
  32. newBlockSize = 0;
  33. sampleBuffer = NULL;
  34. sampleBufferSize = 0;
  35. dataFileCount = 0;
  36. audioDataSize = videoDataSize = 0;
  37. audioStartTime = audioEndTime = videoStartTime = videoEndTime = 0;
  39. mLLMaxAudioTime = 0;
  40. mLLMaxVideoTime = 0;
  42. InitializeCriticalSection(&zzlfile_cs);
  43. }
  45. ZZLFileWriter::~ZZLFileWriter(void)
  46. {
  47. CloseHandle(zzlHandle);
  48. CloseHandle(dataHandle);
  49. CloseHandle(keySampleHandle);
  50. CloseHandle(configHandle);
  51. zzlHandle= dataHandle = keySampleHandle = configHandle = INVALID_HANDLE_VALUE;
  52. SAFE_ARRAYDELETE(sampleBuffer);
  53. DeleteCriticalSection(&zzlfile_cs);
  54. }
  56. bool ZZLFileWriter::Init(string path, string name) {
  57. if(path.empty() || name.empty())
  58. return false;
  59. if(!chnlName.empty())
  60. return true;
  62. //补路径后的斜杠
  63. string::const_iterator litSavePath = path.end();
  64. --litSavePath;
  65. if ('\' != static_cast<BYTE>(*litSavePath))
  66. {
  67. path += "\"; 
  68. }
  70. savePath = path+name; // 再加一层目录，名字就是节目名
  71. chnlName = name;
  73. // calculate md5 hashcode of channel name
  74. char* md5Str = NULL;
  75. MD5 md5(reinterpret_cast<const unsigned char*>(chnlName.data()), chnlName.size());
  76. md5Str = md5.hex_digest();
  77. assert(md5Str);
  79. // 删除旧的临时文件
  80. if(!RemoveOldTmpFile(savePath)) {
  81. return false; // 不能删除旧的节目数据，此次压缩取消
  82. }
  84. for(;;) {
  85. string bufferFileName = savePath+"\"+name+".zzl";
  86. // 创建zzl文件
  87. if((zzlHandle = CreateFile(bufferFileName.data(), 
  88. GENERIC_WRITE | GENERIC_READ, 
  89. FILE_SHARE_READ, 
  90. NULL, 
  91. CREATE_ALWAYS, 
  92. FILE_ATTRIBUTE_NORMAL, 
  93. NULL)) == INVALID_HANDLE_VALUE)
  94. {
  95. int err = GetLastError();
  96. if(err == ERROR_PATH_NOT_FOUND) { 
  97. // 创建文件失败,因为有不存在的中间目录,需要首先创建中间目录
  98. int index = 0;
  99. string temp;
  100. do {
  101. int offset = bufferFileName.find_first_of('\', index);
  102. if(offset == -1)
  103. break;
  104. temp = bufferFileName.substr(0, offset);
  105. index = offset+1;
  106. if(!CreateDirectory(temp.data(), NULL)) {
  107. int ret = GetLastError();
  108. if(ret == ERROR_ALREADY_EXISTS || ret == ERROR_ACCESS_DENIED)
  109. continue;
  110. break;
  111. }
  112. }
  113. while(1);
  114. // Create Again
  115. continue;
  116. }
  117. else
  118. return false;
  119. }
  120. break; // succeeded
  121. }
  123. DWORD writenBytes = 0;
  125. // 1. write ZZLD
  126. char fcc[5];
  127. strcpy(fcc, "ZZLD");
  128. if(INVALID_SET_FILE_POINTER == SetFilePointer(zzlHandle, 0, 0, FILE_BEGIN))
  129. return false;
  130. if(!WriteFile(zzlHandle, fcc, 4, &writenBytes, NULL))
  131. return false;
  132. if(writenBytes != 4)
  133. return false;
  135. // 2. write file version
  136. float version = FILE_VERSION;
  137. if(!WriteFile(zzlHandle, &version, sizeof(version), &writenBytes, NULL))
  138. return false;
  139. if(writenBytes != sizeof(version))
  140. return false;
  142. savePath = savePath + "\" + md5Str;
  144. if(!CreateDirectory(savePath.data(), NULL)) {
  145. int ret = GetLastError();
  146. if(ret != ERROR_ALREADY_EXISTS && ret != ERROR_ACCESS_DENIED)
  147. {
  148. return false;
  149. }
  150. }
  152. keySampleHandle = CreateFile((savePath+"\keysample").data(), 
  153. GENERIC_WRITE | GENERIC_READ, 
  154. FILE_SHARE_READ, 
  155. NULL, 
  156. CREATE_ALWAYS, 
  157. FILE_ATTRIBUTE_NORMAL, 
  158. NULL);
  161. if(keySampleHandle == INVALID_HANDLE_VALUE)
  162. return false;
  164. configHandle = CreateFile((savePath+"\config").data(), 
  165. GENERIC_WRITE | GENERIC_READ, 
  166. FILE_SHARE_READ, 
  167. NULL, 
  168. CREATE_ALWAYS, 
  169. FILE_ATTRIBUTE_NORMAL, 
  170. NULL);
  171. if(configHandle == INVALID_HANDLE_VALUE)
  172. return false;
  174. char temp[16];
  175. itoa(dataFileCount, temp, 10);
  176. dataHandle = CreateFile((savePath+"\"+temp).data(), 
  177. GENERIC_WRITE | GENERIC_READ, 
  178. FILE_SHARE_READ, 
  179. NULL, 
  180. CREATE_ALWAYS, 
  181. FILE_ATTRIBUTE_NORMAL, 
  182. NULL);
  183. if(dataHandle == INVALID_HANDLE_VALUE)
  184. return false;
  186. mLLMaxAudioTime = 0;
  187. mLLMaxVideoTime = 0;
  189. // 写入节目开始的标志Sample
  190. SampleHeader header;
  191. memset(&header, 0, sizeof(SampleHeader));
  192. header.size = sizeof(SampleHeader);
  193. header.length = 0xffffffff;
  194. header.start = 0xffffffffffffffff;
  195. header.bSyncPoint = 1;
  196. if(!PutSample(header, NULL))
  197. return false;
  199. return true;
  200. }
  202. bool ZZLFileWriter::SetMediaType(const TVMEDIATYPESECTION& audioType, BYTE* audioData, const TVMEDIATYPESECTION& videoType, BYTE* videoData) {
  203. if(zzlHandle == INVALID_HANDLE_VALUE)
  204. return false;
  205. assert(audioData || videoData);
  206. DWORD writenBytes = 0;
  208. char temp[1024];
  209. memset(temp, 0, sizeof(temp));
  211. char* pTemp = temp;
  212. // write media type
  213. memcpy(pTemp, &videoType, sizeof(videoType));
  214. pTemp += sizeof(videoType);
  215. if(videoData)
  216. memcpy(pTemp, videoData, videoType.cbFormat);
  217. pTemp += videoType.cbFormat;
  218. memcpy(pTemp, &audioType, sizeof(audioType));
  219. pTemp += sizeof(audioType);
  220. if(audioData)
  221. memcpy(pTemp, audioData, audioType.cbFormat);
  222. pTemp += audioType.cbFormat;
  223. // write start & end Time
  224. memcpy(pTemp, &startTime, sizeof(startTime));
  225. pTemp += sizeof(startTime);
  226. memcpy(pTemp, &endTime, sizeof(endTime));
  227. pTemp += sizeof(endTime);
  229. if(INVALID_SET_FILE_POINTER == SetFilePointer(zzlHandle, 4+sizeof(float), 0, FILE_BEGIN))
  230. return false;
  231. if(!WriteFile(zzlHandle, temp, pTemp-temp, &writenBytes, NULL))
  232. return false;
  233. if(writenBytes != pTemp-temp)
  234. return false;
  236. dataOffset = 4 + sizeof(float) + pTemp-temp;
  238. // calculate md5 hashcode of channel name
  239. char* md5Str = NULL;
  240. MD5 md5(reinterpret_cast<const unsigned char*>(chnlName.data()), chnlName.size());
  241. md5Str = md5.hex_digest();
  242. assert(md5Str);
  244. char cfgStr[1024];
  245. memset(cfgStr, 0, sizeof(cfgStr));
  246. // write config data
  247. // 注意：此处给BitRate所留的空间是“BitRate=000000000”
  248. sprintf(cfgStr, "BitRate=000000000nBlockSize=%dnChannelName=%snResourceHash=%snDataLength=%dnData=", 
  249. BLOCK_SIZE, chnlName.data(), md5Str, 
  250. sizeof(audioType) + audioType.cbFormat + sizeof(videoType) + videoType.cbFormat);
  251. delete [] md5Str;
  253. int totalLen = strlen(cfgStr);
  254. // write media type
  255. memcpy(cfgStr+totalLen, temp, sizeof(videoType)+videoType.cbFormat+sizeof(audioType)+audioType.cbFormat);
  256. totalLen += sizeof(videoType)+videoType.cbFormat+sizeof(audioType)+audioType.cbFormat;
  258. if(INVALID_SET_FILE_POINTER == SetFilePointer(configHandle, 0, 0, FILE_BEGIN))
  259. return false;
  260. if(!WriteFile(configHandle, cfgStr, totalLen, &writenBytes, NULL))
  261. return false;
  262. if(writenBytes != totalLen)
  263. return false;
  265. return true;
  266. }
  268. /*
  269.  * block content
  270.  *  |offset of first keysample(int32)|offset of first sample(int32)|list of samples|last uncomplete sample|
  271.  *  |sample data| = |header(SampleHeader)|data(...)|
  272.  */
  273. bool ZZLFileWriter::SaveSample(UINT dataOff, const UINT allSize) {
  274. // at the start of new block, write the offset of next sample
  275. if(newBlockSize == 0) {
  276. // 在开头的4个字节写入first keysample offset
  277. *(UINT*)newBlock = 0; // 默认值是0
  278. // 在此后的4个字节写入first sample offset
  279. *((UINT*)newBlock+1) = sizeof(int)*2; // 如果开始保存新的Sample，则first sample offset = 8
  280. if(dataOff > 0)
  281. *((UINT*)newBlock+1) += allSize-dataOff;// 如果保存前一个sample剩下的部分，则要加上其剩下的长度
  282. if(*((UINT*)newBlock+1) >= BLOCK_SIZE) // 如果此sample剩下的部分长度超过当前Block，则用UINT_MAX表示
  283. *((UINT*)newBlock+1) = UINT_MAX;
  285. newBlockSize += sizeof(int)*2;
  286. }
  288. if( *(UINT*)(newBlock) == 0 && // 当前Block尚未记录FirstKeySampleOffset
  289. dataOff == 0 && // 一个新的Sample
  290. firstKeySampleTime && // KeySample的时间
  291. newBlockSize+sizeof(SampleHeader) < BLOCK_SIZE) // SampleHeader刚好保存在当前Block中
  292. {
  293. // 在开头的4个字节记录FirstKeySampleOffset, sizeof(UINT)*2是start在SampleHeader中的位置
  294. *(UINT*)(newBlock) = newBlockSize+sizeof(UINT)*2;
  295. }
  297. // 比较剩余数据与剩余空间
  298. if(allSize-dataOff >= BLOCK_SIZE-newBlockSize) {
  299. // 剩余数据超过剩余空间，则填满并保存当前Block，并继续存储剩下的数据
  300. memcpy(newBlock+newBlockSize, sampleBuffer+dataOff, BLOCK_SIZE-newBlockSize);
  301. dataOff += BLOCK_SIZE-newBlockSize;
  303. newBlockSize = 0; // 开始新的Block
  304. // 保存旧的Block
  305. if(!SaveBlock(newBlock, BLOCK_SIZE))
  306. return false;
  308. // 继续保存剩余的数据
  309. if(allSize-dataOff > 0)
  310. return SaveSample(dataOff, allSize);
  311. }
  312. else {
  313. // 剩余数据小于剩余空间，复制并等待下一个Sample
  314. memcpy(newBlock+newBlockSize, sampleBuffer+dataOff, allSize-dataOff);
  315. newBlockSize += allSize-dataOff;
  316. }
  317. return true;
  318. }
  320. bool ZZLFileWriter::PutSample(const SampleHeader& header, BYTE* pData) {
  321. if(header.size > 1024*1024)
  322. return false;
  323. bool ret = true;
  324. EnterCriticalSection(&zzlfile_cs);
  326. char tmpStr[96];
  327. _i64toa(header.start, tmpStr, 10);
  328. _i64toa(header.length+header.start, tmpStr+32, 10);
  329. DbgLog((LOG_TRACE, 5, TEXT("start: %s end: %s"), tmpStr, tmpStr+32));
  331. // record first sample time
  332. if(firstSampleTime == 0)
  333. firstSampleTime = (time_t)(header.start/10000000);
  334. // record first keysample time
  336. //区分单音频和视频的情况
  337. if (firstKeySampleTime == 0 && TRUE == mbIsSingleAudio && header.start != 0xffffffffffffffff/*非节目起始标志Sample*/)
  338. {
  339. firstKeySampleTime = (time_t)(header.start/10000000);
  340. }
  341. else if(firstKeySampleTime == 0 && header.bSyncPoint && header.start != 0xffffffffffffffff/*非节目起始标志Sample*/) 
  342. {
  343. firstKeySampleTime = (time_t)(header.start/10000000);
  344. }
  346. if(header.size > sampleBufferSize) {
  347. SAFE_ARRAYDELETE(sampleBuffer);
  348. sampleBuffer = new BYTE[header.size];
  349. sampleBufferSize = header.size;
  350. }
  352. // copy sample header into sample buffer
  353. memcpy(sampleBuffer, &header, sizeof(SampleHeader));
  355. // copy sample data into sample buffer;
  356. if(header.size-sizeof(SampleHeader)) {
  357. assert(pData);
  358. memcpy(sampleBuffer+sizeof(SampleHeader), pData, header.size-sizeof(SampleHeader));
  359. }
  361. #ifndef GENERATE_SMALL_ZZL
  362. if(header.start > 0 && header.start != 0xffffffffffffffff/*非节目起始标志Sample*/) {
  363. if(header.bAudioSample) {
  366. //检查音频时间是否回滚
  367. if (header.start > mLLMaxAudioTime)
  368. {
  369. mLLMaxAudioTime = header.start;
  370. }
  371. else
  372. {
  373. //char lstr[1024];
  374. //sprintf(lstr, "这段音频的数据应该已经播放过了，不能进行直播%I64D",header.start);
  376. MessageBox(NULL,"这段音频的数据应该已经播放过了，不能进行直播", "错误", MB_OK|MB_ICONSTOP);
  377. return FALSE;
  378. }
  380. // calculate total size of audio samples
  381. audioDataSize += header.size;
  382. // set start&end time of audio samples
  383. if(header.start > audioEndTime || header.start < audioStartTime) {
  384. if(audioStartTime == 0 || header.start < audioStartTime) {
  385. audioStartTime = header.start;
  386. }
  387. if(header.start+header.length > audioEndTime)
  388. audioEndTime = header.start+header.length;
  389. }
  390. assert(audioStartTime <= header.start);
  391. }
  392. else {
  394. //检查视频时间是否回滚
  395. if (header.start > mLLMaxVideoTime)
  396. {
  397. mLLMaxVideoTime = header.start;
  398. }
  399. else
  400. {
  401. MessageBox(NULL,"这段视频的数据应该已经播放过了，不能进行直播", "错误", MB_OK|MB_ICONSTOP);
  402. return FALSE;
  403. }
  405. // calculate total size of video samples
  406. videoDataSize += header.size;
  407. // set start&end time of video samples
  408. if(header.start > videoEndTime || header.start < videoStartTime) {
  409. if(videoStartTime == 0 || header.start < videoStartTime) {
  410. videoStartTime = header.start;
  411. }
  412. if(header.start+header.length > videoEndTime)
  413. videoEndTime = header.start+header.length;
  414. }
  415. assert(videoStartTime <= header.start);
  417. // 检查video sample和audio sample是否时间相差过多，相差过多的节目不适合进行直播！
  419. if(videoEndTime > 0 && audioEndTime > 0)
  420. {
  421. if(videoEndTime > audioEndTime+10*10000000
  422. || audioEndTime > videoEndTime+10*10000000)
  423. {
  424. ::MessageBox(NULL,
  425. "现在视频和音频已经不同步，相差超过10s，这样压缩出来的节目是不能进行直播的！",
  426. "错误", MB_OK|MB_ICONSTOP);
  427. ret = false;
  428. }
  429. }
  431. }
  432. }
  434. #endif
  436. if(ret)
  437. ret = SaveSample(0, header.size);
  439. LeaveCriticalSection(&zzlfile_cs);
  441. return ret;
  442. }
  444. bool ZZLFileWriter::SaveBlock(const PBYTE data, const UINT size) {
  445. if(zzlHandle == INVALID_HANDLE_VALUE)
  446. return false;
  447. DWORD writenBytes = 0;
  448. if(INVALID_SET_FILE_POINTER == SetFilePointer(zzlHandle, dataOffset + blockCount*BLOCK_SIZE, 0, FILE_BEGIN))
  449. return false;
  450. if(!WriteFile(zzlHandle, data, size, &writenBytes, NULL))
  451. return false;
  452. if(writenBytes != size)
  453. return false;
  455. // write min&max keySample to zzl file
  456. if(firstSampleTime > 0) {
  457. if(firstSampleTime > endTime || firstSampleTime < startTime) {
  458. if(startTime == 0 || firstSampleTime < startTime) {
  459. startTime = firstSampleTime;
  460. }
  461. if(firstSampleTime > endTime)
  462. endTime = firstSampleTime;
  463. if(INVALID_SET_FILE_POINTER == SetFilePointer(zzlHandle, dataOffset-sizeof(startTime)-sizeof(endTime), 0, FILE_BEGIN))
  464. return false;
  465. // write start & end Time
  466. if(!WriteFile(zzlHandle, &startTime, sizeof(startTime), &writenBytes, NULL))
  467. return false;
  468. if(writenBytes != sizeof(startTime))
  469. return false;
  470. if(!WriteFile(zzlHandle, &endTime, sizeof(endTime), &writenBytes, NULL))
  471. return false;
  472. if(writenBytes != sizeof(endTime))
  473. return false;
  474. }
  475. assert(startTime <= firstSampleTime);
  476. }
  478. if(firstKeySampleTime > 0) {
  479. // write keysample to keysample file
  480. if(INVALID_SET_FILE_POINTER == SetFilePointer(keySampleHandle, 0, 0, FILE_END)) // seek to end of file
  481. return false;
  482. // write blockID
  483. if(!WriteFile(keySampleHandle, &blockCount, sizeof(blockCount), &writenBytes, NULL))
  484. return false;
  485. if(writenBytes != sizeof(blockCount))
  486. return false;
  487. // write keysample
  488. if(!WriteFile(keySampleHandle, &firstKeySampleTime, sizeof(firstKeySampleTime), &writenBytes, NULL))
  489. return false;
  490. if(writenBytes != sizeof(firstKeySampleTime))
  491. return false;
  492. }
  494. // write block data to data file
  495. if(blockCount/BLOCK_OF_DATA_FILE > dataFileCount) {
  496. dataFileCount = blockCount/BLOCK_OF_DATA_FILE;
  497. CloseHandle(dataHandle);
  498. char temp[16];
  499. itoa(dataFileCount, temp, 10);
  500. dataHandle = CreateFile((savePath+"\"+temp).data(), 
  501. GENERIC_WRITE | GENERIC_READ, 
  502. FILE_SHARE_READ, 
  503. NULL, 
  504. CREATE_ALWAYS, 
  505. FILE_ATTRIBUTE_NORMAL, 
  506. NULL);
  507. if(dataHandle == INVALID_HANDLE_VALUE)
  508. return false;
  509. }
  510. if(INVALID_SET_FILE_POINTER == SetFilePointer(dataHandle, (blockCount%BLOCK_OF_DATA_FILE)*BLOCK_SIZE, 0, FILE_BEGIN))
  511. return false;
  512. if(!WriteFile(dataHandle, data, size, &writenBytes, NULL))
  513. return false;
  514. if(writenBytes != size)
  515. return false;
  517. firstKeySampleTime = 0;
  518. firstSampleTime = 0;
  519. blockCount++;
  521. // 将最新的码率统计写入配置文件
  522. if(!SaveBitRate())
  523. return false;
  524. return true;
  525. }
  527. double ZZLFileWriter::GetBitRate() {
  528. // 根据起始Sample和最近一个Sample的时间戳以及数据的大小，分别计算视频音频的码率，然后加起来就是总的码率
  529. double bitRate = 0.0f;
  530. if(videoEndTime-videoStartTime > 0)
  531. bitRate += ((double)videoDataSize)/1024/((videoEndTime-videoStartTime)/10000000);
  532. if(audioEndTime-audioStartTime > 0)
  533. bitRate += ((double)audioDataSize)/1024/((audioEndTime-audioStartTime)/10000000);
  534. return bitRate;
  535. }
  537. //设置是否是单音频
  538. void ZZLFileWriter::SetIsSingleAudio(BOOL abAudio)
  539. {
  540. mbIsSingleAudio = abAudio;
  541. }
  543. bool ZZLFileWriter::SaveBitRate() {
  544. if(configHandle == INVALID_HANDLE_VALUE)
  545. return false;
  547. DWORD writenBytes = 0;
  548. char temp[64];
  549. if(INVALID_SET_FILE_POINTER == SetFilePointer(configHandle, 0, 0, FILE_BEGIN))
  550. return false;
  551. sprintf(temp, "BitRate=%.4f", GetBitRate());
  553. // 注意：配置文件中所留的空间是“BitRate=000000000”，所以要防止超过这个长度
  554. temp[strlen("BitRate=000000000")-1] = 0;
  556. // 检查一下，某些情况下，最后码率是0，很奇怪
  557. if(blockCount > 20) {
  558. assert(strcmp(temp, "BitRate=000000000") != 0);
  559. }
  561. if(!WriteFile(configHandle, temp, strlen(temp), &writenBytes, NULL))
  562. return false;
  563. if(writenBytes != strlen(temp))
  564. return false;
  565. return true;
  566. }
  568. bool ZZLFileWriter::RemoveOldTmpFile(string path) {
  569. WIN32_FIND_DATA fileData;
  570. string match = path;
  571. match.append("\*");
  572. HANDLE hFind = FindFirstFile(match.data(), &fileData);
  573. if(hFind == INVALID_HANDLE_VALUE)
  574. return true;
  575. bool firstDeleteFile = true;
  576. while(1) {
  577. bool shouldDelete = false;
  578. if(stricmp(fileData.cFileName, "config") == 0) // 配置文件
  579. shouldDelete = true;
  580. else if(stricmp(fileData.cFileName, "keysample") == 0) // 关键帧文件
  581. shouldDelete = true;
  582. else if(stricmp(fileData.cFileName, (chnlName+".zzl").data()) == 0) // zzl文件
  583. shouldDelete = true;
  584. else {
  585. // 如果是纯数字，说明是数据文件
  586.  int itemp  = atoi(fileData.cFileName);
  587.  char stemp[64];
  588.  itoa(itemp, stemp, 10);
  589.  if(itemp >= 0 && stricmp(fileData.cFileName, stemp) == 0)
  590.  shouldDelete = true;
  591. }
  593. if(shouldDelete) {
  594. if(firstDeleteFile) {
  595. firstDeleteFile = false;
  596. TCHAR temp[1024];
  597. //sprintf(temp, "名字是 %s 的节目已经存在于目录 %s ，请问要删除旧的节目数据吗？(可能是被遗忘的有用数据)", chnlName.data(), path.data());
  598. //int answer = MessageBox(NULL, temp, "警告", MB_YESNO|MB_ICONQUESTION);
  599. int answer = IDYES;
  600. if(answer != IDNO) {
  601. //MessageBox(NULL, "你选择删除旧的节目数据，新的节目开始压缩！", "通知", MB_OK|MB_ICONINFORMATION);
  602. TraceLog1("现在覆盖旧的节目数据，新的节目开始压缩！n");
  603. }
  604. else {
  605. sprintf(temp, "你选择保存旧的节目数据，此次压缩将被取消，请在转移目录 %s 下的数据之后，重新开始压缩。", path.data());
  606. MessageBox(NULL, temp, "通知", MB_OK|MB_ICONINFORMATION);
  607. return false;
  608. }
  609. }
  610. string temp = path+"\";
  611. temp.append(fileData.cFileName);
  612. DeleteFile(temp.data());
  613. }
  615. if(!FindNextFile(hFind, &fileData)) {
  616. if(GetLastError() == ERROR_NO_MORE_FILES)
  617. break;
  618. else {
  619. assert(0);
  620. return true; 
  621. }
  622. }
  623. }
  624. FindClose(hFind);
  625. return true;
  626. }