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

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

P2P编程

开发平台：

Visual C++

LiveResource.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 ".liveresource.h"
  21. #include "Communicator.h"
  22. #include "BufferMgr.h"
  24. namespace NPLayer1 {
  26. LiveResource::LiveResource(Communicator*c ) : 
  27. BaseResource(c), A_currBlock(NULL), V_currBlock(NULL), tmpBlockData(NULL)
  28. {
  29. }
  31. LiveResource::~LiveResource(void) {
  32. Uninit(false);
  33. }
  35. // 第一次开始下载的初始化
  36. P2P_RETURN_TYPE LiveResource::Init(
  37. string resname, // 资源名
  38. string hashcode, // 资源的Hash码
  39. string strSPList, // SuperPeer列表的IP地址
  40. float bitRate) // 频道的码率
  41. {
  42. CriticalSection::Owner lock(dataLocker);
  43. try {
  44. // 不能重复初始化
  45. if(bInited)
  46. throw PRT_DUP_INIT;
  48. this->resname = resname;
  49. this->hashcode = hashcode;
  50. bufferMgr = &comm->g_bufferMgr;
  52. // 直播资源未知大小,需要的磁盘空间是小于缓冲文件大小的某个固定值
  53. // DEFAULT_SPACE必须保证整除BLOCK_SIZE
  54. blockMapSize = DEFAULT_SPACE/BLOCK_SIZE;
  56. // 初始化数组
  57. blockMapArray = new UINT[blockMapSize];
  58. blockIDArray = new UINT[blockMapSize];
  59. if(!blockMapArray || !blockIDArray)
  60. throw PRT_ALLOC;
  62. // 初始化数组所有成员为UINT_MAX
  63. fill(blockMapArray, blockMapArray+blockMapSize, UINT_MAX);
  64. fill(blockIDArray, blockIDArray+blockMapSize, UINT_MAX);
  66. P2P_RETURN_TYPE ret = ParseSPList(strSPList);
  67. if(ret != PRT_OK)
  68. throw ret;
  70. ret = InitBroadcastMember(bitRate);
  71. if(ret < PRT_OK)
  72. throw ret;
  73. }
  74. catch (P2P_RETURN_TYPE ret) {
  75. comm->logFile.StatusOut("Init Res Error!");
  76. Uninit(true);
  77. return ret;
  78. }
  80. bInited = TRUE;
  81. return PRT_OK;
  82. }
  84. void LiveResource::Uninit(bool force) {
  85. CriticalSection::Owner lock(dataLocker);
  86. if(bInited || force) {
  87. delete [] A_currBlock;
  88. delete [] V_currBlock;
  89. delete [] tmpBlockData;
  90. A_currBlock = V_currBlock = NULL;
  91. tmpBlockData = NULL;
  93. if(blockMapArray) {
  94. for(UINT i = 0; i < blockMapSize; ++i) {
  95. if(blockMapArray[i] != UINT_MAX)
  96. comm->g_bufferMgr.EraseIndex(blockMapArray[i]);
  97. }
  98. }
  100. UninitEx();
  101. bInited = FALSE;
  102. }
  103. }
  105. P2P_RETURN_TYPE LiveResource::InitBroadcastMember(float bitRate) {
  106. this->bitRate = bitRate; // 码率
  107. memset(&spUpdate, 0, sizeof(SPUpdate));
  109. // 当前视频/音频块的数据
  110. if(!A_currBlock)
  111. A_currBlock = new BYTE[BLOCK_SIZE];
  112. if(!V_currBlock)
  113. V_currBlock = new BYTE[BLOCK_SIZE];
  114. if(!tmpBlockData)
  115. tmpBlockData = new BYTE[BLOCK_SIZE];
  116. if(!A_currBlock || !V_currBlock || !tmpBlockData)
  117. return PRT_ALLOC;
  118. A_currBlockID = V_currBlockID = UINT_MAX;
  119. A_leftDataInCurrBlock = V_leftDataInCurrBlock = 0;
  120. A_lastSampleTime = V_lastSampleTime = 0;
  121. A_last_OriginTime = V_last_OriginTime = 0;
  122. A_lastGetSampleFailedTime = V_lastGetSampleFailedTime = 0;
  123. programStartTime = 0;
  124. programState = PS_BOTH_BEGINS;
  125. totalBufferCount = 0;
  126. totalBufferTime  = 0;
  128. mediaArray.Clear();
  129. V_sentArray.Clear();
  130. A_sentArray.Clear();
  132. // 至少缓冲10块才能开始播放
  133. blocks4Play = max(static_cast<UINT>(TIME_FOR_PLAY*bitRate*1024/BLOCK_SIZE), 10);
  135. comm->logFile.StatusOut("blocks4play = %d. ", blocks4Play);
  137. return PRT_OK;
  138. }
  140. P2P_RETURN_TYPE LiveResource::LoadSample(
  141. SampleHeader& header, // Sample头
  142. PBYTE& sampleData, // Sample数据
  143. UINT sampleOff, // 已经读取的长度
  144. const UINT maxSize, // Sample最大长度
  145. const bool isAudio, // 视频还是音频
  146. bool& bMediaTypeSample // 是否媒体类型的特殊Sample
  147. )
  148. {
  149. UINT& currBlockID = isAudio ? A_currBlockID : V_currBlockID;
  150. BYTE *currBlock = isAudio ? A_currBlock : V_currBlock;
  151. UINT& leftDataInCurrBlock = isAudio ? A_leftDataInCurrBlock : V_leftDataInCurrBlock;
  152. MediaArray& sentArray = isAudio ? A_sentArray: V_sentArray;
  154. bMediaTypeSample = false;
  156. // 尚未设置开始播放的位置
  157. if(currBlockID == UINT_MAX)
  158. return PRT_PROGRAM_SYNC;
  160. while(0 == leftDataInCurrBlock) { // not data in current block, load next
  161. // 读取当前块数据
  162. UINT bSize = 0;
  163. P2P_RETURN_TYPE ret = GetBlock(currBlockID, bSize, currBlock);
  164. if(ret < PRT_OK)
  165. return ret;
  166. assert(bSize <= BLOCK_SIZE);
  168. // 如果此块的媒体类型还没有提交给上层，那么首先返回媒体类型
  169. if(!sentArray.FindBlock(currBlockID)) {
  170. MediaInterval mInterval;
  171. if(!mediaArray.GetInterval(currBlockID, mInterval)) {
  172. // 还没有下载到当前块的媒体类型
  173. return PRT_PROGRAM_SYNC;
  174. }
  176. comm->logFile.StatusOut("Post %s Media Type[%d, %d)) @ %d.", 
  177. isAudio?"Audio":"Video", mInterval.start, mInterval.start+mInterval.size, currBlockID);
  179. // 在sample中填入媒体类型数据
  180. header.start = header.length = 0;
  181. header.bSyncPoint = 1;
  182. header.bAudioSample = isAudio;
  183. if(isAudio) {
  184. memcpy(sampleData, &mInterval.audioType, sizeof(mInterval.audioType));
  185. memcpy(sampleData+sizeof(mInterval.audioType), mInterval.audioData, mInterval.audioType.cbFormat);
  186. header.size = sizeof(mInterval.audioType) + mInterval.audioType.cbFormat;
  187. }
  188. else {
  189. memcpy(sampleData, &mInterval.videoType, sizeof(mInterval.videoType));
  190. memcpy(sampleData+sizeof(mInterval.videoType), mInterval.videoData, mInterval.videoType.cbFormat);
  191. header.size = sizeof(mInterval.videoType) + mInterval.videoType.cbFormat;
  192. }
  193. assert(header.size >= sizeof(MediaType));
  195. if(!sentArray.AddInterval(mInterval))
  196. assert(0);
  198. // video or audio stopped
  199. if(isAudio && mInterval.audioType.cbFormat == 0)
  200. A_currBlockID = UINT_MAX;
  201. if(!isAudio && mInterval.videoType.cbFormat == 0)
  202. V_currBlockID = UINT_MAX;
  204. bMediaTypeSample = true;
  205. return PRT_OK;
  206. }
  208. currBlockID++;
  210. // 此Block从完整的Sample开始, 或许是新的节目开始了，确认一下
  211. if(IsFirstBlockOfNewProgram(currBlock)) {
  212. // 获取此块对应的编码格式，如果暂时没有，则返回同步中的消息
  213. MediaInterval mInterval;
  214. if(!mediaArray.GetInterval(currBlockID-1, mInterval)) {
  215. currBlockID--;
  216. assert(0);
  217. return PRT_PROGRAM_SYNC;
  218. }
  220. comm->logFile.StatusOut("New Program %d!", currBlockID-1);
  221.             /*
  222.             if(!mInterval.audioType.bThisPinOnly && !mInterval.videoType.bThisPinOnly) {
  223. // 有音频和视频，准备同步过程
  224. if(programState == PS_BOTH_BEGINS)
  225. programState = (isAudio?PS_AUDIO_BEGINS:PS_VIDEO_BEGINS); // 进入同步阶段
  226. else if(isAudio) {
  227. if(programState == PS_VIDEO_BEGINS)
  228. programState = PS_BOTH_BEGINS; // 发现视频已经在等待音频了，那么同步结束，开始播放
  229. else
  230. assert(0); // 音频正在同步中，不可能又读取了新的Block
  231. }
  232. else {
  233. if(programState == PS_AUDIO_BEGINS) // 发现音频已经在等待视频了，那么同步结束，开始播放
  234. programState = PS_BOTH_BEGINS;
  235. else
  236. assert(0); // 视频正在同步中，不可能有读取了新的Block
  237. }
  238. }
  239. if(programState == PS_BOTH_BEGINS) {
  240. // 同步结束，选择节目开始时间
  241. if(mInterval.videoType.bThisPinOnly) {
  242. programStartTime = V_lastSampleTime+TIME_BETWEEN_PROGRAM; // 单路视频
  243. }
  244. // 有视频/音频两路的情况下,选择音频作为新节目开始的时间.
  245. comm->logFile.StatusOut("Program Start Old %I64d.", programStartTime);
  246. programStartTime = A_lastSampleTime+TIME_BETWEEN_PROGRAM;
  247. comm->logFile.StatusOut("Program Start New %I64d.", programStartTime);
  248. }
  249.             */
  251. // 移动到第一个真正的Sample（非节目开头的标志Sample）的位置
  252. sampleOff = 0;
  253. leftDataInCurrBlock = BLOCK_SIZE-sizeof(UINT)*2-sizeof(SampleHeader);
  254. break;
  255. }
  257. // 第4~8个字节是first sample offset
  258. UINT sampleOffset = *((UINT*)currBlock+1);
  259. if(sampleOffset != UINT_MAX && (sampleOffset < sizeof(UINT)*2 || sampleOffset > BLOCK_SIZE)) {
  260. assert(0);
  262. // 删除这个错误的Block，并且跳过这个Block
  263. DelBlock(currBlockID-1);
  264. leftDataInCurrBlock = 0;
  265. sampleOff = 0;
  266. continue; // 错误的SampleOffset，抛弃当前块
  267. }
  269. // TODO: 由于CaptureServer的一个BUG，这里作一个修正，随着所有CaptureServer的更新，这里可以去除。 2005.04.18
  270. if(sampleOffset == BLOCK_SIZE)
  271. sampleOffset = UINT_MAX;
  273. if(sampleOff == 0) { // 开始读取新的Sample
  274. if(sampleOffset == UINT_MAX)
  275. continue; // 新的Sample不在当前Block中，继续寻找下一个
  276. else 
  277. leftDataInCurrBlock = BLOCK_SIZE-sampleOffset; // 新的Sample位置
  278. }
  279. else { // 继续读取剩余的数据
  280. leftDataInCurrBlock = BLOCK_SIZE-sizeof(UINT)*2; 
  281. if(!(sampleOffset==UINT_MAX || sampleOff < sizeof(SampleHeader) || sampleOffset == sizeof(UINT)*2+header.size-sampleOff)) {
  282. char* temp = NULL;
  283. MD5 md5(reinterpret_cast<BYTE*>(currBlock), BLOCK_SIZE);
  284. temp = md5.hex_digest();
  285. comm->logFile.StatusOut("Bad Block %d(%s).", currBlockID-1, temp);
  286. delete [] temp;
  288. assert(0);
  289. // 删除这个错误的Block，并且跳过这个Block
  290. DelBlock(currBlockID-1);
  291. leftDataInCurrBlock = 0;
  292. sampleOff = 0;
  293. continue;
  294. }
  295. }
  296. assert(leftDataInCurrBlock <= BLOCK_SIZE);
  297. break;
  298. }
  300. if(programState != PS_BOTH_BEGINS) { // 正在同步,应该可以投出类型数据
  301. if(!isAudio) {
  302. if(programState == PS_VIDEO_BEGINS)
  303. return PRT_PROGRAM_SYNC; // 视频正在等待同步，暂时不返回数据
  304. //else
  305. // 音频正在同步，不影响视频，所以继续
  306. }
  307. else {
  308. if(programState == PS_AUDIO_BEGINS)
  309. return PRT_PROGRAM_SYNC; // 音频正在等待同步，暂时不返回数据
  310. //else
  311. // 视频正在同步，不影响音频，所以继续
  312. }
  313. }
  315. BYTE* startOff = currBlock+(BLOCK_SIZE - leftDataInCurrBlock);
  317. // 尝试读取SampleHeader，直到读取了sizeof(SampleHeader)个字节，即dataOff == sizeof(SampleHeader)
  318. if(sampleOff < sizeof(SampleHeader)) {
  319. if(leftDataInCurrBlock < sizeof(SampleHeader)-sampleOff) {
  320. // 数据仍然不足sizeof(SampleHeader)，继续读取下一个块
  321. memcpy((BYTE*)&header + sampleOff, startOff, leftDataInCurrBlock);
  322. sampleOff += leftDataInCurrBlock;
  323. leftDataInCurrBlock = 0;
  324. return LoadSample(header, sampleData, sampleOff, maxSize, isAudio, bMediaTypeSample);
  325. }
  326. else {
  327. // 数据已经足够，读取完整的sample header
  328. memcpy((BYTE*)&header + sampleOff, startOff, sizeof(SampleHeader)-sampleOff);
  329. assert(header.size >= sizeof(SampleHeader) && header.size <= maxSize);
  330. if(header.size < sizeof(SampleHeader) || header.size > maxSize) {
  331. // 错误的Header，抛弃当前块，重新读取新的Sample
  332. sampleOff = 0;
  333. leftDataInCurrBlock = 0;
  334. return LoadSample(header, sampleData, sampleOff, maxSize, isAudio, bMediaTypeSample);
  335. }
  336. leftDataInCurrBlock -= (sizeof(SampleHeader)-sampleOff);
  337. sampleOff = sizeof(SampleHeader);
  338. }
  339. }
  341. startOff = currBlock+(BLOCK_SIZE - leftDataInCurrBlock);
  342. // 读取SampleHeader之外的数据
  343. if(sampleOff >= sizeof(SampleHeader)) {
  344. if(leftDataInCurrBlock < header.size-sampleOff) {
  345. // 当前块中剩下的数据不足，继续读取下一块
  346. if(sampleData)
  347. memcpy(sampleData+sampleOff-sizeof(SampleHeader), startOff, leftDataInCurrBlock);
  348. sampleOff += leftDataInCurrBlock;
  349. leftDataInCurrBlock = 0;
  350. return LoadSample(header, sampleData, sampleOff, maxSize, isAudio, bMediaTypeSample);
  351. }
  352. else {
  353. // 读取到完整的Sample
  354. if(sampleData)
  355. memcpy(sampleData+sampleOff-sizeof(SampleHeader), startOff, header.size-sampleOff);
  356. leftDataInCurrBlock -= (header.size-sampleOff);
  357. }
  358. }
  360. assert(leftDataInCurrBlock <= BLOCK_SIZE);
  361. return PRT_OK;
  362. }
  364. P2P_RETURN_TYPE LiveResource::GetData(
  365.   SampleHeader& header, // out, 数据头
  366.   PBYTE& pData, // out, 存储数据的缓冲区
  367.   const UINT maxSize, // in, 缓冲区的长度
  368.   const bool bAudio, // in, 获取音频还是视频
  369.   const bool bKeySample // in, 是否寻找关键帧
  370.   )
  371. {
  372. if(!bInited) // not started
  373. return PRT_NOT_INIT;
  374. CriticalSection::Owner lock(dataLocker);
  376. bool bMediaTypeSample = false;
  378. for(;;) {
  379. for(;;) {
  380. P2P_RETURN_TYPE ret = LoadSample(header, pData, 0, maxSize, bAudio, bMediaTypeSample);
  381. if(ret < PRT_OK) {
  382. if(bAudio)
  383. A_lastGetSampleFailedTime = timeGetTime(); // 记录GetSample失败的时间
  384. else
  385. V_lastGetSampleFailedTime = timeGetTime(); // 记录GetSample失败的时间
  386. comm->logFile.StatusOut("GetData failed. %d", ret);
  387. return ret;
  388. }
  389. // 如果是目标类型，则完成寻找
  390. if(bAudio == header.bAudioSample)
  391. break;
  392. }
  394. // 是否正在寻找视频的关键Sample，如果是，当前Sample是目标Sample吗？
  395. if(!bKeySample || (!bAudio && header.bSyncPoint))
  396. break;
  397. }
  399. if(bAudio)
  400. A_lastGetSampleFailedTime = 0; // GetSample成功了
  401. else
  402. V_lastGetSampleFailedTime = 0; // GetSample成功了
  405. if(!bMediaTypeSample) {
  406. A_last_OriginTime = header.start+header.length;
  408. // 加上节目开始的时间
  409. header.start += programStartTime;
  411. //assert(header.start+1*10000000 >= (isAudio?A_lastSampleTime:V_lastSampleTime));
  412. //assert(header.bDiscontinuity == 0);
  413. header.bDiscontinuity = 0;
  415. // 记录最近一个Sample的时间
  416. if(bAudio)
  417. A_lastSampleTime = header.start;
  418. else
  419. V_lastSampleTime = header.start;
  421. comm->logFile.StatusOut("%s Sample Time %I64d(%I64d) at Block %d", bAudio?"Audio":"Video", header.start, 
  422. header.start - programStartTime, bAudio?A_currBlockID-1:V_currBlockID-1);
  423. }
  424. return PRT_OK;
  425. }
  427. // 存储Block，在存储之前检查此Block及其后面的一个Block是否正确
  428. P2P_RETURN_TYPE LiveResource::PutBlock(UINT blockID, UINT blockSize, PBYTE data) {
  429. if(!bInited) // not started
  430. return PRT_NOT_INIT;
  431. CriticalSection::Owner lock(dataLocker);
  432.     assert(mediaArray.FindBlock(blockID));
  433. P2P_RETURN_TYPE ret = PRT_OK;
  434. UINT unfinishedSize = 0;
  435. UINT tmpSize = 0;
  436. // 1. 读取blockID-1的数据，以便检查blockID块的数据是否正确
  437. ret = GetBlock(blockID-1, tmpSize, tmpBlockData);
  438. if(ret != PRT_OK && ret != PRT_BLOCK_NOTFOUND) {// 如果找到或者没找到此块都是正常的，但是其他返回值就不正常了
  439. assert(0);
  440. return ret;
  441. }
  442. if(ret != PRT_BLOCK_NOTFOUND) {
  443. // 2. 获取blockID-1块最后一个Sample，在blockID中的剩余长度
  444. if(!GetUnfinishedSampleSize(tmpBlockData, unfinishedSize)) {
  445. DelBlock(blockID-1); // 删除错误的blockID-1块
  446. }
  447. else if(unfinishedSize != UINT_MAX) {
  448. // 3. 根据剩余长度检查blockID块数据是否正确
  449. UINT sampleOffset = *((UINT*)data + 1);
  450. // TODO: 由于CaptureServer的一个BUG，这里作一个修正，随着所有CaptureServer的更新，这里可以去除。 2005.04.18
  451. if(sampleOffset == BLOCK_SIZE)
  452. sampleOffset = UINT_MAX;
  454. if(sampleOffset != unfinishedSize+sizeof(UINT)*2) {
  455. if(sampleOffset == UINT_MAX && unfinishedSize > BLOCK_SIZE) {
  456. ; // blockID块被完全跨越，数据应该是正确的
  457. }
  458. else if(!IsFirstBlockOfNewProgram(data)) {
  459. assert(0);
  460. return PRT_BAD_BLOCK; // 不是新节目，blockID块数据错误，直接错误
  461. }
  462. }
  463. }
  465. // 4. 读取blockID+1块
  466. ret = GetBlock(blockID+1, tmpSize, tmpBlockData);
  467. if(ret != PRT_OK && ret != PRT_BLOCK_NOTFOUND)// 如果找到或者没找到此块都是正常的，但是其他返回值就不正常了
  468. return ret;
  469. if(ret != PRT_BLOCK_NOTFOUND) {
  470. // 5. 获取blockID块最后一个Sample，在blockID+1中的剩余长度
  471. if(!GetUnfinishedSampleSize(data, unfinishedSize))
  472. return PRT_OK; // blockID块数据错误，直接返回
  473. else if(unfinishedSize != UINT_MAX) {
  474. // 6. 根据剩余长度检查blockID+1块数据是否正确
  475. UINT sampleOffset = *((UINT*)tmpBlockData + 1);
  476. // TODO: 由于CaptureServer的一个BUG，这里作一个修正，随着所有CaptureServer的更新，这里可以去除。 2005.04.18
  477. if(sampleOffset == BLOCK_SIZE)
  478. sampleOffset = UINT_MAX;
  480. if(sampleOffset != unfinishedSize+sizeof(UINT)*2) {
  481. if(sampleOffset == UINT_MAX && unfinishedSize > BLOCK_SIZE) {
  482. ; // blockID+1块被完全跨越，数据应该是正确的
  483. }
  484. else if(!IsFirstBlockOfNewProgram(tmpBlockData)) {
  485. assert(0);
  486. DelBlock(blockID+1); // 删除错误的blockID+1块, 没有记录此块来自哪个NP
  487. }
  488. }
  489. }
  490. }
  491. }
  494. // 数据正确，存储此Block
  495. return BaseResource::PutBlock(blockID, blockSize, data);
  496. }
  498. // 获取此Block末尾一个Sample被截断后，在下一个Block所残留的长度，返回值表示此Block是否数据正确
  499. bool LiveResource::GetUnfinishedSampleSize(PBYTE& blockData, UINT& unfinishedSize) {
  500. UINT sampleOffset = *((UINT*)blockData + 1);
  501. if(sampleOffset == UINT_MAX) {
  502. unfinishedSize = UINT_MAX;
  503. return true; // 没法检查，因为sample跨越了整个block，放过这种情况吧
  504. }
  505. else if(sampleOffset < sizeof(UINT)*2 || sampleOffset > BLOCK_SIZE) {
  506. assert(0);
  507. return false; // 数据错误
  508. }
  510. SampleHeader* header = (SampleHeader*)(blockData+sampleOffset);
  511. while(1) {
  512. if(sampleOffset+sizeof(UINT) > BLOCK_SIZE) {
  513. // SampleHeader中的Size尚未读全，没法确定残留的长度，放过这种情况
  514. unfinishedSize = UINT_MAX;
  515. return true;
  516. }
  517. else if(sampleOffset + header->size >= BLOCK_SIZE) {
  518. unfinishedSize = sampleOffset + header->size - BLOCK_SIZE; // 这就是残留的长度
  519. if(unfinishedSize > 1000000)
  520. assert(0);
  521. return true;
  522. }
  523. sampleOffset += header->size;
  524. header = (SampleHeader*)(blockData+sampleOffset);
  525. }
  526. assert(0);
  527. return false;
  528. }
  530. // 检查此Block是否新节目的第一块
  531. bool LiveResource::IsFirstBlockOfNewProgram(PBYTE& blockData) {
  532. UINT sampleOffset = *((UINT*)blockData + 1);
  533. if(sampleOffset == sizeof(UINT)*2) {
  534. SampleHeader* header = (SampleHeader*)(blockData+sizeof(UINT)*2);
  535. // 新节目的第一个Sample格式特殊，具体值如下判断
  536. if(header->length == 0xffffffff && header->start == 0xffffffffffffffff && header->size == sizeof(SampleHeader))
  537. return true;
  538. }
  539. return false;
  540. }
  542. UINT16 LiveResource::GetBufferCount() {
  543. if(totalBufferCount >= 0xffff)
  544. return 0xffff;
  545. return static_cast<UINT16>(totalBufferCount);
  546. }
  548. UINT16 LiveResource::GetBufferTime() {
  549. if(totalBufferTime/1000 >= 0xffff)
  550. return 0xffff;
  551. return static_cast<UINT16>(totalBufferTime/1000);
  552. }
  554. UINT16 LiveResource::GetBufferingTime() {
  555. // 如果正在缓冲的过程中，那么把到目前为止的时间也要计算上
  556. DWORD lastGetSampleFailedTime = A_lastGetSampleFailedTime;
  557. if(lastGetSampleFailedTime == 0)
  558. lastGetSampleFailedTime = V_lastGetSampleFailedTime;
  559. if(lastGetSampleFailedTime != 0) {
  560. UINT bufTime = timeGetTime()-lastGetSampleFailedTime;
  561. if(bufTime/1000 >= 0xffff)
  562. return 0xffff;
  563. return static_cast<UINT16>(bufTime/1000);
  564. }
  565. return 0;
  566. }
  568. void LiveResource::SetSPUpdate(const SPUpdate& update, BYTE sum) {
  569. #ifdef _DEBUG
  570. // TODO: 测试使用，正式版本一定要去掉
  571. //spUpdate.minBlockID = spUpdate.maxBlockID = 0;
  572. #endif
  573. // 是否尚未收到过SPUpdate
  574. bool bNoFirstSPUpdate = (spUpdate.minBlockID == 0 && spUpdate.maxBlockID == 0);
  575. spUpdate = update;
  576. spUpdateSum = sum;
  578. // 是否需要重新设置播放位置
  579. bool bNeedResetPlayingBlock = bNoFirstSPUpdate;
  581. // 如果播放位置比SP拥有的最小Block还小，就自动调整播放位置
  582. if(GetPlayingBlock() < spUpdate.minBlockID)
  583. bNeedResetPlayingBlock = true;
  585. // 从TIME_BEGIN_PLAY秒钟前的位置开始下载播放
  586. if(bNeedResetPlayingBlock) {
  587. const float SECPERBLOCK = bitRate*1024/BLOCK_SIZE; // 每块包含的大致时间长度
  588. const UINT BLOCK_BEFORE = static_cast<UINT>(TIME_BEGIN_PLAY*SECPERBLOCK); // 提前的块数
  589. if(spUpdate.maxBlockID >= spUpdate.minBlockID+BLOCK_BEFORE)
  590. SetPlayingBlock(spUpdate.maxBlockID-BLOCK_BEFORE);
  591. else
  592. SetPlayingBlock(spUpdate.minBlockID);
  593. }
  594. }
  596. BOOL LiveResource::SeekToTime(LONGLONG& targetTime) {
  597. comm->logFile.StatusOut("Begin Seeking......to %ds %dms", targetTime/10000000, targetTime/10000);
  598. if(!bInited)
  599. return FALSE;
  601. if(targetTime == 0) // reset to begin. do nothing.
  602. return TRUE;
  604. if((spUpdate.maxKeySample > spUpdate.minKeySample) && 
  605. (targetTime >= spUpdate.minKeySample) && (targetTime <= spUpdate.maxKeySample) && 
  606. spUpdate.maxBlockID > spUpdate.minBlockID) 
  607. {
  608. double temp = ((double)(targetTime-spUpdate.minKeySample))/(spUpdate.maxKeySample-spUpdate.minKeySample);
  609. UINT targetBlockID = static_cast<UINT>(temp*(spUpdate.maxBlockID-spUpdate.minBlockID))+spUpdate.minBlockID;
  611. SetPlayingBlock(targetBlockID);
  612. }
  613. else {
  614. comm->logFile.StatusOut("Bad seeking position!");
  615. return FALSE;
  616. }
  617. return TRUE;
  618. }
  620. // 添加一个区间对应的媒体类型
  621. void LiveResource::AddMediaInterval(const MediaInterval& mi) {
  622. comm->logFile.StatusOut("Got MediaType of [%d, %d).", mi.start, mi.start+mi.size);
  623.     // 是否发生了直播改变编码格式
  624.     bool bLiveChangeMediaData = false;
  625.     if(!mediaArray.AddInterval(mi, &bLiveChangeMediaData)) {
  626. assert(0);
  627.         return;
  628.     }
  629.     if(bLiveChangeMediaData) {
  630.         // 清除NP连接发送媒体类型区间的记录
  631.         comm->p2pMgr.ClearSentMediaArray();
  633.         // 记录不再向上层提交的媒体类型
  634.         MediaInterval temp;
  635.         if(A_sentArray.FindBlock(A_currBlockID)) {
  636.             if(mediaArray.GetInterval(A_currBlockID, temp)) {
  637.                 A_sentArray.Clear();
  638.                 A_sentArray.AddInterval(temp);
  639.             }
  640.         }
  641.         if(V_sentArray.FindBlock(V_currBlockID)) {
  642.             if(mediaArray.GetInterval(V_currBlockID, temp)) {
  643.                 V_sentArray.Clear();
  644.                 V_sentArray.AddInterval(temp);
  645.             }
  646.         }
  647.     }
  648. }
  650. // 获取一个Block所在区间的媒体类型
  651. bool LiveResource::GetMediaInterval(const UINT blockID, MediaInterval& mi) {
  652. return mediaArray.GetInterval(blockID, mi);
  653. }
  655. BOOL LiveResource::SetPlayingBlock(UINT blockID) {
  656. if(blockID == UINT_MAX)
  657. return FALSE;
  659. CriticalSection::Owner lock(dataLocker);
  660. // 设置开始播放的位置
  661. A_currBlockID = V_currBlockID = blockID;
  662. A_leftDataInCurrBlock = V_leftDataInCurrBlock = 0;
  664. comm->logFile.StatusOut("SetPlayingBlock %d. spupdate.maxblockID %d", blockID, spUpdate.maxBlockID);
  665. return TRUE;
  666. }
  668. // 对于直播, 取得视频音频中比较大(小)的那个BlockID, 当然,如果是单音频或者单视频的,就取得相应的BlockID
  669. UINT LiveResource::GetPlayingBlock(bool max) {
  670. if(V_currBlockID == UINT_MAX)
  671. return A_currBlockID;
  672. if(A_currBlockID == UINT_MAX)
  673. return V_currBlockID;
  675. if(max)
  676. return max(V_currBlockID, A_currBlockID);
  677. return min(V_currBlockID, A_currBlockID);
  678. };
  680. int LiveResource::GetBufferPercent() {
  681. // 要保证blocks4Play不等于0，否则此处一定返回100
  682. if(blocks4Play == 0)
  683. return 100;
  684. UINT nextBlock = GetPlayingBlock();
  685. return min(100, allIntervals.GetCountInInterval(nextBlock, blocks4Play)*100/blocks4Play);
  686. }
  688. bool LiveResource::EnlargeBuffer() {
  689. totalBufferCount++;
  691. DWORD lastGetSampleFailedTime = A_lastGetSampleFailedTime;
  692. if(lastGetSampleFailedTime == 0)
  693. lastGetSampleFailedTime = V_lastGetSampleFailedTime;
  694. if(lastGetSampleFailedTime != 0)
  695. totalBufferTime += (timeGetTime() - lastGetSampleFailedTime);
  697. if(blocks4Play >= static_cast<UINT>(180*bitRate*1024/BLOCK_SIZE)) {
  698. comm->logFile.StatusOut("Delay more than 3 minutes, do not add.");
  699. return false;
  700. }
  701. comm->logFile.StatusOut("live Pause! Add 50%% time for buffer.");
  702. blocks4Play = static_cast<UINT>(blocks4Play*1.5f);
  703. return true;
  704. }
  706. void LiveResource::PrintStatus() {
  707. comm->logFile.StatusOut("CurrBlock: A%d/V%d, Continued: %d/%d. BlockRange: %d/%d, SPUpdate: %d/%d, ntBuffer Percent: %d%%. BufferCount: %d, BufferTime: %ds, curr Buffer: %ds.", 
  708. A_currBlockID, V_currBlockID, 
  709. allIntervals.GetContinousCount(GetPlayingBlock()), 
  710. allIntervals.GetCountInInterval(GetPlayingBlock(), UINT_MAX), 
  711. GetMinBlockID(), GetMaxBlockID(), 
  712. spUpdate.minBlockID, spUpdate.maxBlockID, 
  713. GetBufferPercent(), GetBufferCount(), 
  714. GetBufferTime(), GetBufferingTime());
  715. }
  717. void LiveResource::SetDefaultCP() {
  718. // 直播的默认CP地址就是和SP相同的IP
  719. if(spIPList) {
  720. PeerInfoWithAddr nAddr;
  721. nAddr.outerIP.sin_addr.s_addr = spIPList[0].sin_addr.s_addr;
  722. nAddr.subnetIP.sin_addr.s_addr = 0xffffffff;
  723. nAddr.subnetIP.sin_port = htons(CP4NP_PORT);
  724. nAddr.isCachePeer = true;
  725. nAddr.layer = 0;
  727. comm->p2pMgr.AddPeerInfo(nAddr);
  729. comm->logFile.StatusOut("Choose Default CP %s.", comm->p2pMgr.FormatIPAddress(nAddr));
  730. }
  731. };
  733. // 获取节目名字
  734. string LiveResource::GetProgramName() {
  735. MediaInterval mInterval;
  736. if(!mediaArray.GetInterval(GetPlayingBlock(), mInterval))
  737. return "";
  738. if(!mInterval.pname || !mInterval.pnamesize)
  739. return "";
  740. string temp = mInterval.pname;
  741. return temp;
  742. }
  744. // 获取节目时间长度
  745. UINT32 LiveResource::GetProgramTimeInSeconds() {
  746. MediaInterval mInterval;
  747. if(!mediaArray.GetInterval(GetPlayingBlock(), mInterval))
  748. return 0;
  749. return mInterval.progtime;
  750. }
  752. // 获取频道名字
  753. string LiveResource::GetChannelName() {
  754. MediaInterval mInterval;
  755. if(!mediaArray.GetInterval(GetPlayingBlock(), mInterval))
  756. return "";
  757. if(!mInterval.cname || !mInterval.cnamesize)
  758. return "";
  759. string temp = mInterval.cname;
  760. return temp;
  761. }
  762. }