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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
ogg.cpp
资源名称：P2PSource-PeerCast.rar　[点击查看]
上传用户：chn_coc
上传日期：2007-12-20
资源大小：563k
文件大小：11k
源码类别：

P2P编程

开发平台：

Windows_Unix

ogg.cpp：源码内容
  1. // ------------------------------------------------
  2. // File : mp3.cpp
  3. // Date: 28-may-2003
  4. // Author: giles
  5. //
  6. // (c) 2002-3 peercast.org
  7. // ------------------------------------------------
  8. // This program is free software; you can redistribute it and/or modify
  9. // it under the terms of the GNU General Public License as published by
  10. // the Free Software Foundation; either version 2 of the License, or
  11. // (at your option) any later version.
  13. // This program is distributed in the hope that it will be useful,
  14. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. // GNU General Public License for more details.
  17. // ------------------------------------------------
  19. #include "channel.h"
  20. #include "ogg.h"
  23. static int test=0;
  24. // ------------------------------------------
  25. void OGGStream::readHeader(Stream &,Channel *)
  26. {
  27. test = 0;
  28. }
  30. // ------------------------------------------
  31. void OGGStream::readEnd(Stream &,Channel *)
  32. {
  33. }
  35. // ------------------------------------------
  36. int OGGStream::readPacket(Stream &in,Channel *ch)
  37. {
  38. OggPage ogg;
  39. ChanPacket pack;
  41. ogg.read(in);
  43. if (ogg.isBOS())
  44. {
  45. if (!vorbis.needHeader() && !theora.needHeader())
  46. {
  47. ch->headPack.len = 0;
  48. }
  50. if (ogg.detectVorbis())
  51. vorbis.bos(ogg.getSerialNo());
  52. if (ogg.detectTheora())
  53. theora.bos(ogg.getSerialNo());
  54. }
  56. if (ogg.isEOS())
  57. {
  59. if (ogg.getSerialNo() == vorbis.serialNo)
  60. {
  61. LOG_CHANNEL("Vorbis stream: EOS");
  62. vorbis.eos();
  63. }
  64. if (ogg.getSerialNo() == theora.serialNo)
  65. {
  66. LOG_CHANNEL("Theora stream: EOS");
  67. theora.eos();
  68. }
  69. }
  71. if (vorbis.needHeader() || theora.needHeader())
  72. {
  74. if (ogg.getSerialNo() == vorbis.serialNo)
  75. vorbis.readHeader(ch,ogg);
  76. else if (ogg.getSerialNo() == theora.serialNo)
  77. theora.readHeader(ch,ogg);
  78. else
  79. throw StreamException("Bad OGG serial no.");
  82. if (!vorbis.needHeader() && !theora.needHeader())
  83. {
  85. ch->info.bitrate = 0;
  87. if (vorbis.isActive())
  88. ch->info.bitrate += vorbis.bitrate;
  90. if (theora.isActive())
  91. {
  92. ch->info.bitrate += theora.bitrate;
  93. ch->info.contentType = ChanInfo::T_OGM;
  94. }
  97. ch->headPack.type = ChanPacket::T_HEAD;
  98. ch->headPack.pos = ch->streamPos;
  100. ch->startTime = sys->getDTime();
  102. ch->streamPos += ch->headPack.len;
  104. ch->newPacket(ch->headPack);
  105. LOG_CHANNEL("Got %d bytes of headers",ch->headPack.len);
  106. }
  108. }else
  109. {
  112. pack.init(ChanPacket::T_DATA,ogg.data,ogg.headLen+ogg.bodyLen,ch->streamPos);
  113. ch->newPacket(pack);
  115. ch->streamPos+=pack.len;
  117. if (theora.isActive())
  118. {
  119. if (ogg.getSerialNo() == theora.serialNo)
  120. {
  121. ch->sleepUntil(theora.getTime(ogg));
  122. }
  123. }else if (vorbis.isActive())
  124. {
  125. if (ogg.getSerialNo() == vorbis.serialNo)
  126. {
  127. ch->sleepUntil(vorbis.getTime(ogg));
  128. }
  129. }
  131. }
  132. return 0;
  133. }
  135. // -----------------------------------
  136. void OggSubStream::readHeader(Channel *ch,OggPage &ogg)
  137. {
  138. if ((pack.bodyLen + ogg.bodyLen) >= OggPacket::MAX_BODYLEN)
  139. throw StreamException("OGG packet too big");
  141. if (ch->headPack.len+(ogg.bodyLen+ogg.headLen) >= ChanMeta::MAX_DATALEN)
  142. throw StreamException("OGG packet too big for headMeta");
  144. // copy complete packet into head packet
  145. memcpy(&ch->headPack.data[ch->headPack.len],ogg.data,ogg.headLen+ogg.bodyLen);
  146. ch->headPack.len += ogg.headLen+ogg.bodyLen;
  148. // add body to packet
  149. memcpy(&pack.body[pack.bodyLen],&ogg.data[ogg.headLen],ogg.bodyLen);
  150. pack.bodyLen += ogg.bodyLen;
  152. pack.addLacing(ogg);
  154. if (pack.numPackets >= maxHeaders)
  155. procHeaders(ch);
  157. }
  158. // -----------------------------------
  159. void OggVorbisSubStream::procHeaders(Channel *ch)
  160. {
  161. unsigned int packPtr=0;
  163. for(int i=0; i<pack.numPackets; i++)
  164. {
  165. MemoryStream vin(&pack.body[packPtr],pack.packetSizes[i]);
  167. packPtr += pack.packetSizes[i];
  169. char id[8];
  171. vin.read(id,7);
  172. id[7]=0;
  174. switch (id[0])
  175. {
  176. case 1: // ident
  177. LOG_CHANNEL("OGG Vorbis Header: Ident (%d bytes)",vin.len);
  178. readIdent(vin,ch->info);
  179. break;
  180. case 3: // comment
  181. {
  182. LOG_CHANNEL("OGG Vorbis Header: Comment (%d bytes)",vin.len);
  183. ChanInfo newInfo = ch->info;
  184. readComment(vin,newInfo);
  185. ch->updateInfo(newInfo);
  186. }
  187. break;
  188. case 5: // setup
  189. LOG_CHANNEL("OGG Vorbis Header: Setup (%d bytes)",vin.len);
  190. //readSetup(vin);
  191. break;
  192. default:
  193. throw StreamException("Unknown Vorbis packet header type");
  194. break;
  195. }
  196. }
  198. }
  199. // -----------------------------------
  200. double OggTheoraSubStream::getTime(OggPage &ogg)
  201. {
  202.     int64_t iframe=ogg.granPos>>granposShift;
  203.     int64_t pframe=ogg.granPos-(iframe<<granposShift);
  205.     return (iframe+pframe)*frameTime;
  206. }
  207. // -----------------------------------
  208. void OggTheoraSubStream::readInfo(Stream &in, ChanInfo &info)
  209. {
  210. int verMaj = in.readBits(8);
  211. int verMin = in.readBits(8);
  212. int verSub = in.readBits(8);
  214. int encWidth = in.readBits(16) << 4;
  215. int encHeight = in.readBits(16) << 4;
  217. in.readBits(24+24+8+8);
  219. int fpsNum = in.readBits(32);
  220. int fpsDen = in.readBits(32);
  222. float fps = (float)fpsNum/(float)fpsDen;
  223. frameTime = (double)fpsDen/(double)fpsNum;
  225. in.readBits(24+24+8);
  227. bitrate = in.readBits(24) / 1000;
  228. int quality = in.readBits(6);
  230. granposShift = in.readBits(5);
  232. LOG_CHANNEL("OGG Theora Info: %dx%dx%.1ffps %dkbps %dQ %dG",encWidth,encHeight,fps,bitrate,quality,granposShift);
  235. }
  236. // -----------------------------------
  237. void OggTheoraSubStream::procHeaders(Channel *ch)
  238. {
  239. unsigned int packPtr=0;
  241. for(int i=0; i<pack.numPackets; i++)
  242. {
  243. MemoryStream vin(&pack.body[packPtr],pack.packetSizes[i]);
  245. packPtr += pack.packetSizes[i];
  247. unsigned char id[8];
  249. vin.read(id,7);
  250. id[7]=0;
  252. switch (id[0] & 0xff)
  253. {
  254. case 128: // info
  255. LOG_CHANNEL("OGG Theora Header: Info (%d bytes)",vin.len);
  256. readInfo(vin,ch->info);
  257. break;
  258. default:
  259. LOG_CHANNEL("OGG Theora Header: Unknown %d (%d bytes)",id[0] & 0xff,vin.len);
  260. break;
  261. }
  265. }
  267. }
  269. // -----------------------------------
  270. double OggVorbisSubStream::getTime(OggPage &ogg)
  271. {
  272. return (double)ogg.granPos / (double)samplerate;
  274. }
  276. // -----------------------------------
  277. void OggVorbisSubStream::readIdent(Stream &in, ChanInfo &info)
  278. {
  279. int ver = in.readLong();
  280. int chans = in.readChar();
  281. samplerate = in.readLong();
  282. int brMax = in.readLong();
  283. int brNom = in.readLong();
  284. int brLow = in.readLong();
  287. in.readChar(); // skip blocksize 0+1
  289. LOG_CHANNEL("OGG Vorbis Ident: ver=%d, chans=%d, rate=%d, brMax=%d, brNom=%d, brLow=%d",
  290. ver,chans,samplerate,brMax,brNom,brLow);
  293. bitrate = brNom/1000;
  295. char frame = in.readChar(); // framing bit
  296. if (!frame)
  297. throw StreamException("Bad Indent frame");
  299. }
  301.  
  302. // -----------------------------------
  303. void OggVorbisSubStream::readSetup(Stream &in)
  304. {
  305. // skip everything in packet
  306. int cnt=0;
  307. while (!in.eof())
  308. {
  309. cnt++;
  310. in.readChar();
  311. }
  313. LOG_CHANNEL("Read %d bytes of Vorbis Setup",cnt);
  314. }
  315. // -----------------------------------
  316. void OggVorbisSubStream::readComment(Stream &in, ChanInfo &info)
  317. {
  318. int vLen = in.readLong(); // vendor len
  320. in.skip(vLen);
  322. char argBuf[8192];
  324. info.track.clear();
  326. int cLen = in.readLong(); // comment len
  327. for(int i=0; i<cLen; i++)
  328. {
  329. int l = in.readLong();
  330. if (l > sizeof(argBuf))
  331. throw StreamException("Comment string too long");
  332. in.read(argBuf,l);
  333. argBuf[l] = 0;
  334. LOG_CHANNEL("OGG Comment: %s",argBuf);
  336. char *arg;
  337. if ((arg=stristr(argBuf,"ARTIST=")))
  338. {
  339. info.track.artist.set(arg+7,String::T_ASCII);
  340. info.track.artist.convertTo(String::T_UNICODE);
  342. }else if ((arg=stristr(argBuf,"TITLE=")))
  343. {
  344. info.track.title.set(arg+6,String::T_ASCII);
  345. info.track.title.convertTo(String::T_UNICODE);
  347. }else if ((arg=stristr(argBuf,"GENRE=")))
  348. {
  349. info.track.genre.set(arg+6,String::T_ASCII);
  350. info.track.genre.convertTo(String::T_UNICODE);
  352. }else if ((arg=stristr(argBuf,"CONTACT=")))
  353. {
  354. info.track.contact.set(arg+8,String::T_ASCII);
  355. info.track.contact.convertTo(String::T_UNICODE);
  357. }else if ((arg=stristr(argBuf,"ALBUM=")))
  358. {
  359. info.track.album.set(arg+6,String::T_ASCII);
  360. info.track.album.convertTo(String::T_UNICODE);
  361. }
  362. }
  364. char frame = in.readChar(); // framing bit
  365. if (!frame)
  366. throw StreamException("Bad Comment frame");
  368. // updateMeta();
  370. }
  372. // -----------------------------------
  373. bool OggPage::isBOS()
  374. {
  375. return (data[5] & 0x02) != 0;
  376. }
  377. // -----------------------------------
  378. bool OggPage::isEOS()
  379. {
  380. return (data[5] & 0x04) != 0;
  381. }
  382. // -----------------------------------
  383. bool OggPage::isNewPacket()
  384. {
  385. return (data[5] & 0x01) == 0;
  386. }
  387. // -----------------------------------
  388. bool OggPage::isHeader()
  389. {
  390. return ((*(unsigned int *)&data[6]) || (*(unsigned int *)&data[10])) == 0;
  391. }
  392. // -----------------------------------
  393. unsigned int OggPage::getSerialNo()
  394. {
  395. return *(unsigned int *)&data[14];
  396. }
  398. // -----------------------------------
  399. void OggPage::read(Stream &in)
  400. {
  401. // skip until we get OGG capture pattern
  402. bool gotOgg=false;
  403. while (!gotOgg)
  404. {
  405. if (in.readChar() == 'O')
  406. if (in.readChar() == 'g')
  407. if (in.readChar() == 'g')
  408. if (in.readChar() == 'S')
  409. gotOgg = true;
  410. if (!gotOgg)
  411. LOG_CHANNEL("Skipping OGG packet");
  412. }
  416. memcpy(&data[0],"OggS",4);
  418. in.read(&data[4],27-4);
  420. int numSegs = data[26];
  421. bodyLen = 0;
  423. // read segment table
  424. in.read(&data[27],numSegs);
  425. for(int i=0; i<numSegs; i++)
  426. bodyLen += data[27+i];
  428. if (bodyLen >= MAX_BODYLEN)
  429. throw StreamException("OGG body too big");
  431. headLen = 27+numSegs;
  433. if (headLen > MAX_HEADERLEN)
  434. throw StreamException("OGG header too big");
  436. in.read(&data[headLen],bodyLen);
  438. granPos = *(unsigned int *)&data[10];
  439. granPos <<= 32;
  440. granPos |= *(unsigned int *)&data[6];
  443. #if 0
  444. LOG_DEBUG("OGG Packet - page %d, id = %x - %s %s %s - %d:%d - %d segs, %d bytes",
  445. *(unsigned int *)&data[18],
  446. *(unsigned int *)&data[14],
  447. data[5]&0x1?"cont":"new",
  448. data[5]&0x2?"bos":"",
  449. data[5]&0x4?"eos":"",
  450. (unsigned int)(granPos>>32),
  451. (unsigned int)(granPos&0xffffffff),
  452. numSegs,
  453. headLen+bodyLen);
  455. #endif
  457. }
  458. // -----------------------------------
  459. bool OggPage::detectVorbis()
  460. {
  461. return memcmp(&data[headLen+1],"vorbis",6) == 0;
  462. }
  463. // -----------------------------------
  464. bool OggPage::detectTheora()
  465. {
  466. return memcmp(&data[headLen+1],"theora",6) == 0;
  467. }
  469. // -----------------------------------
  470. void OggPacket::addLacing(OggPage &ogg)
  471. {
  473. int numSegs = ogg.data[26];
  474. for(int i=0; i<numSegs; i++)
  475. {
  476. int seg = ogg.data[27+i];
  478. packetSizes[numPackets]+=seg;
  480. if (seg < 255)
  481. {
  482. numPackets++;
  483. if (numPackets >= MAX_PACKETS)
  484. throw StreamException("Too many OGG packets");
  485. packetSizes[numPackets]=0;
  486. }
  487. }
  489. }