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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llaudiodecodemgr.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：16k
源码类别：

游戏引擎

开发平台：

C++ Builder

llaudiodecodemgr.cpp：源码内容
  1. /** 
  2.  * @file llaudiodecodemgr.cpp
  3.  *
  4.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2003-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  32. #include "linden_common.h"
  34. #include "llaudiodecodemgr.h"
  36. #include "llaudioengine.h"
  37. #include "lllfsthread.h"
  38. #include "llvfile.h"
  39. #include "llstring.h"
  40. #include "lldir.h"
  41. #include "llendianswizzle.h"
  42. #include "llassetstorage.h"
  43. #include "llrefcount.h"
  45. #include "llvorbisencode.h"
  47. #include "vorbis/codec.h"
  48. #include "vorbis/vorbisfile.h"
  50. extern LLAudioEngine *gAudiop;
  52. LLAudioDecodeMgr *gAudioDecodeMgrp = NULL;
  54. static const S32 WAV_HEADER_SIZE = 44;
  57. //////////////////////////////////////////////////////////////////////////////
  60. class LLVorbisDecodeState : public LLRefCount
  61. {
  62. public:
  63. class WriteResponder : public LLLFSThread::Responder
  64. {
  65. public:
  66. WriteResponder(LLVorbisDecodeState* decoder) : mDecoder(decoder) {}
  67. ~WriteResponder() {}
  68. void completed(S32 bytes)
  69. {
  70. mDecoder->ioComplete(bytes);
  71. }
  72. LLPointer<LLVorbisDecodeState> mDecoder;
  73. };
  75. LLVorbisDecodeState(const LLUUID &uuid, const std::string &out_filename);
  77. BOOL initDecode();
  78. BOOL decodeSection(); // Return TRUE if done.
  79. BOOL finishDecode();
  81. void flushBadFile();
  83. void ioComplete(S32 bytes) { mBytesRead = bytes; }
  84. BOOL isValid() const { return mValid; }
  85. BOOL isDone() const { return mDone; }
  86. const LLUUID &getUUID() const { return mUUID; }
  88. protected:
  89. virtual ~LLVorbisDecodeState();
  91. BOOL mValid;
  92. BOOL mDone;
  93. LLAtomicS32 mBytesRead;
  94. LLUUID mUUID;
  96. std::vector<U8> mWAVBuffer;
  97. #if !defined(USE_WAV_VFILE)
  98. std::string mOutFilename;
  99. LLLFSThread::handle_t mFileHandle;
  100. #endif
  102. LLVFile *mInFilep;
  103. OggVorbis_File mVF;
  104. S32 mCurrentSection;
  105. };
  107. size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
  108. {
  109. LLVFile *file = (LLVFile *)datasource;
  111. if (file->read((U8*)ptr, (S32)(size * nmemb))) /*Flawfinder: ignore*/
  112. {
  113. S32 read = file->getLastBytesRead();
  114. return  read / size; /*Flawfinder: ignore*/
  115. }
  116. else
  117. {
  118. return 0;
  119. }
  120. }
  122. int vfs_seek(void *datasource, ogg_int64_t offset, int whence)
  123. {
  124. LLVFile *file = (LLVFile *)datasource;
  126. // vfs has 31-bit files
  127. if (offset > S32_MAX)
  128. {
  129. return -1;
  130. }
  132. S32 origin;
  133. switch (whence) {
  134. case SEEK_SET:
  135. origin = 0;
  136. break;
  137. case SEEK_END:
  138. origin = file->getSize();
  139. break;
  140. case SEEK_CUR:
  141. origin = -1;
  142. break;
  143. default:
  144. llerrs << "Invalid whence argument to vfs_seek" << llendl;
  145. return -1;
  146. }
  148. if (file->seek((S32)offset, origin))
  149. {
  150. return 0;
  151. }
  152. else
  153. {
  154. return -1;
  155. }
  156. }
  158. int vfs_close (void *datasource)
  159. {
  160. LLVFile *file = (LLVFile *)datasource;
  161. delete file;
  162. return 0;
  163. }
  165. long vfs_tell (void *datasource)
  166. {
  167. LLVFile *file = (LLVFile *)datasource;
  168. return file->tell();
  169. }
  171. LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &out_filename)
  172. {
  173. mDone = FALSE;
  174. mValid = FALSE;
  175. mBytesRead = -1;
  176. mUUID = uuid;
  177. mInFilep = NULL;
  178. mCurrentSection = 0;
  179. #if !defined(USE_WAV_VFILE)
  180. mOutFilename = out_filename;
  181. mFileHandle = LLLFSThread::nullHandle();
  182. #endif
  183. // No default value for mVF, it's an ogg structure?
  184. // Hey, let's zero it anyway, for predictability.
  185. memset(&mVF, 0, sizeof(mVF));
  186. }
  188. LLVorbisDecodeState::~LLVorbisDecodeState()
  189. {
  190. if (!mDone)
  191. {
  192. delete mInFilep;
  193. mInFilep = NULL;
  194. }
  195. }
  198. BOOL LLVorbisDecodeState::initDecode()
  199. {
  200. ov_callbacks vfs_callbacks;
  201. vfs_callbacks.read_func = vfs_read;
  202. vfs_callbacks.seek_func = vfs_seek;
  203. vfs_callbacks.close_func = vfs_close;
  204. vfs_callbacks.tell_func = vfs_tell;
  206. //llinfos << "Initing decode from vfile: " << mUUID << llendl;
  208. mInFilep = new LLVFile(gVFS, mUUID, LLAssetType::AT_SOUND);
  209. if (!mInFilep || !mInFilep->getSize())
  210. {
  211. llwarns << "unable to open vorbis source vfile for reading" << llendl;
  212. delete mInFilep;
  213. mInFilep = NULL;
  214. return FALSE;
  215. }
  217. int r = ov_open_callbacks(mInFilep, &mVF, NULL, 0, vfs_callbacks);
  218. if(r < 0) 
  219. {
  220. llwarns << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << mUUID << llendl;
  221. return(FALSE);
  222. }
  224. S32 sample_count = ov_pcm_total(&mVF, -1);
  225. size_t size_guess = (size_t)sample_count;
  226. vorbis_info* vi = ov_info(&mVF, -1);
  227. size_guess *= vi->channels;
  228. size_guess *= 2;
  229. size_guess += 2048;
  231. bool abort_decode = false;
  233. if( vi->channels < 1 || vi->channels > LLVORBIS_CLIP_MAX_CHANNELS )
  234. {
  235. abort_decode = true;
  236. llwarns << "Bad channel count: " << vi->channels << llendl;
  237. }
  239. if( (size_t)sample_count > LLVORBIS_CLIP_REJECT_SAMPLES )
  240. {
  241. abort_decode = true;
  242. llwarns << "Illegal sample count: " << sample_count << llendl;
  243. }
  245. if( size_guess > LLVORBIS_CLIP_REJECT_SIZE )
  246. {
  247. abort_decode = true;
  248. llwarns << "Illegal sample size: " << size_guess << llendl;
  249. }
  251. if( abort_decode )
  252. {
  253. llwarns << "Canceling initDecode. Bad asset: " << mUUID << llendl;
  254. llwarns << "Bad asset encoded by: " << ov_comment(&mVF,-1)->vendor << llendl;
  255. delete mInFilep;
  256. mInFilep = NULL;
  257. return FALSE;
  258. }
  260. mWAVBuffer.reserve(size_guess);
  261. mWAVBuffer.resize(WAV_HEADER_SIZE);
  263. {
  264. // write the .wav format header
  265. //"RIFF"
  266. mWAVBuffer[0] = 0x52;
  267. mWAVBuffer[1] = 0x49;
  268. mWAVBuffer[2] = 0x46;
  269. mWAVBuffer[3] = 0x46;
  271. // length = datalen + 36 (to be filled in later)
  272. mWAVBuffer[4] = 0x00;
  273. mWAVBuffer[5] = 0x00;
  274. mWAVBuffer[6] = 0x00;
  275. mWAVBuffer[7] = 0x00;
  277. //"WAVE"
  278. mWAVBuffer[8] = 0x57;
  279. mWAVBuffer[9] = 0x41;
  280. mWAVBuffer[10] = 0x56;
  281. mWAVBuffer[11] = 0x45;
  283. // "fmt "
  284. mWAVBuffer[12] = 0x66;
  285. mWAVBuffer[13] = 0x6D;
  286. mWAVBuffer[14] = 0x74;
  287. mWAVBuffer[15] = 0x20;
  289. // chunk size = 16
  290. mWAVBuffer[16] = 0x10;
  291. mWAVBuffer[17] = 0x00;
  292. mWAVBuffer[18] = 0x00;
  293. mWAVBuffer[19] = 0x00;
  295. // format (1 = PCM)
  296. mWAVBuffer[20] = 0x01;
  297. mWAVBuffer[21] = 0x00;
  299. // number of channels
  300. mWAVBuffer[22] = 0x01;
  301. mWAVBuffer[23] = 0x00;
  303. // samples per second
  304. mWAVBuffer[24] = 0x44;
  305. mWAVBuffer[25] = 0xAC;
  306. mWAVBuffer[26] = 0x00;
  307. mWAVBuffer[27] = 0x00;
  309. // average bytes per second
  310. mWAVBuffer[28] = 0x88;
  311. mWAVBuffer[29] = 0x58;
  312. mWAVBuffer[30] = 0x01;
  313. mWAVBuffer[31] = 0x00;
  315. // bytes to output at a single time
  316. mWAVBuffer[32] = 0x02;
  317. mWAVBuffer[33] = 0x00;
  318.  
  319. // 16 bits per sample
  320. mWAVBuffer[34] = 0x10;
  321. mWAVBuffer[35] = 0x00;
  323. // "data"
  324. mWAVBuffer[36] = 0x64;
  325. mWAVBuffer[37] = 0x61;
  326. mWAVBuffer[38] = 0x74;
  327. mWAVBuffer[39] = 0x61;
  329. // these are the length of the data chunk, to be filled in later
  330. mWAVBuffer[40] = 0x00;
  331. mWAVBuffer[41] = 0x00;
  332. mWAVBuffer[42] = 0x00;
  333. mWAVBuffer[43] = 0x00;
  334. }
  336. //{
  337. //char **ptr=ov_comment(&mVF,-1)->user_comments;
  338. // vorbis_info *vi=ov_info(&vf,-1);
  339. //while(*ptr){
  340. // fprintf(stderr,"%sn",*ptr);
  341. // ++ptr;
  342. //}
  343. //    fprintf(stderr,"nBitstream is %d channel, %ldHzn",vi->channels,vi->rate);
  344. //    fprintf(stderr,"nDecoded length: %ld samplesn", (long)ov_pcm_total(&vf,-1));
  345. //    fprintf(stderr,"Encoded by: %snn",ov_comment(&vf,-1)->vendor);
  346. //}
  347. return TRUE;
  348. }
  350. BOOL LLVorbisDecodeState::decodeSection()
  351. {
  352. if (!mInFilep)
  353. {
  354. llwarns << "No VFS file to decode in vorbis!" << llendl;
  355. return TRUE;
  356. }
  357. if (mDone)
  358. {
  359. //  llwarns << "Already done with decode, aborting!" << llendl;
  360. return TRUE;
  361. }
  362. char pcmout[4096]; /*Flawfinder: ignore*/
  364. BOOL eof = FALSE;
  365. long ret=ov_read(&mVF, pcmout, sizeof(pcmout), 0, 2, 1, &mCurrentSection);
  366. if (ret == 0)
  367. {
  368. /* EOF */
  369. eof = TRUE;
  370. mDone = TRUE;
  371. mValid = TRUE;
  372. // llinfos << "Vorbis EOF" << llendl;
  373. }
  374. else if (ret < 0)
  375. {
  376. /* error in the stream.  Not a problem, just reporting it in
  377.    case we (the app) cares.  In this case, we don't. */
  379. llwarns << "BAD vorbis decode in decodeSection." << llendl;
  381. mValid = FALSE;
  382. mDone = TRUE;
  383. // We're done, return TRUE.
  384. return TRUE;
  385. }
  386. else
  387. {
  388. // llinfos << "Vorbis read " << ret << "bytes" << llendl;
  389. /* we don't bother dealing with sample rate changes, etc, but.
  390.    you'll have to*/
  391. std::copy(pcmout, pcmout+ret, std::back_inserter(mWAVBuffer));
  392. }
  393. return eof;
  394. }
  396. BOOL LLVorbisDecodeState::finishDecode()
  397. {
  398. if (!isValid())
  399. {
  400. llwarns << "Bogus vorbis decode state for " << getUUID() << ", aborting!" << llendl;
  401. return TRUE; // We've finished
  402. }
  404. #if !defined(USE_WAV_VFILE)
  405. if (mFileHandle == LLLFSThread::nullHandle())
  406. #endif
  407. {
  408. ov_clear(&mVF);
  409.   
  410. // write "data" chunk length, in little-endian format
  411. S32 data_length = mWAVBuffer.size() - WAV_HEADER_SIZE;
  412. mWAVBuffer[40] = (data_length) & 0x000000FF;
  413. mWAVBuffer[41] = (data_length >> 8) & 0x000000FF;
  414. mWAVBuffer[42] = (data_length >> 16) & 0x000000FF;
  415. mWAVBuffer[43] = (data_length >> 24) & 0x000000FF;
  416. // write overall "RIFF" length, in little-endian format
  417. data_length += 36;
  418. mWAVBuffer[4] = (data_length) & 0x000000FF;
  419. mWAVBuffer[5] = (data_length >> 8) & 0x000000FF;
  420. mWAVBuffer[6] = (data_length >> 16) & 0x000000FF;
  421. mWAVBuffer[7] = (data_length >> 24) & 0x000000FF;
  423. //
  424. // FUDGECAKES!!! Vorbis encode/decode messes up loop point transitions (pop)
  425. // do a cheap-and-cheesy crossfade 
  426. //
  427. {
  428. S16 *samplep;
  429. S32 i;
  430. S32 fade_length;
  431. char pcmout[4096]; /*Flawfinder: ignore*/ 
  433. fade_length = llmin((S32)128,(S32)(data_length-36)/8);
  434. if((S32)mWAVBuffer.size() >= (WAV_HEADER_SIZE + 2* fade_length))
  435. {
  436. memcpy(pcmout, &mWAVBuffer[WAV_HEADER_SIZE], (2 * fade_length)); /*Flawfinder: ignore*/
  437. }
  438. llendianswizzle(&pcmout, 2, fade_length);
  440. samplep = (S16 *)pcmout;
  441. for (i = 0 ;i < fade_length; i++)
  442. {
  443. *samplep = llfloor((F32)*samplep * ((F32)i/(F32)fade_length));
  444. samplep++;
  445. }
  447. llendianswizzle(&pcmout, 2, fade_length);
  448. if((WAV_HEADER_SIZE+(2 * fade_length)) < (S32)mWAVBuffer.size())
  449. {
  450. memcpy(&mWAVBuffer[WAV_HEADER_SIZE], pcmout, (2 * fade_length)); /*Flawfinder: ignore*/
  451. }
  452. S32 near_end = mWAVBuffer.size() - (2 * fade_length);
  453. if ((S32)mWAVBuffer.size() >= ( near_end + 2* fade_length))
  454. {
  455. memcpy(pcmout, &mWAVBuffer[near_end], (2 * fade_length)); /*Flawfinder: ignore*/
  456. }
  457. llendianswizzle(&pcmout, 2, fade_length);
  459. samplep = (S16 *)pcmout;
  460. for (i = fade_length-1 ; i >=  0; i--)
  461. {
  462. *samplep = llfloor((F32)*samplep * ((F32)i/(F32)fade_length));
  463. samplep++;
  464. }
  466. llendianswizzle(&pcmout, 2, fade_length);
  467. if (near_end + (2 * fade_length) < (S32)mWAVBuffer.size())
  468. {
  469. memcpy(&mWAVBuffer[near_end], pcmout, (2 * fade_length));/*Flawfinder: ignore*/
  470. }
  471. }
  473. if (36 == data_length)
  474. {
  475. llwarns << "BAD Vorbis decode in finishDecode!" << llendl;
  476. mValid = FALSE;
  477. return TRUE; // we've finished
  478. }
  479. #if !defined(USE_WAV_VFILE)
  480. mBytesRead = -1;
  481. mFileHandle = LLLFSThread::sLocal->write(mOutFilename, &mWAVBuffer[0], 0, mWAVBuffer.size(),
  482.  new WriteResponder(this));
  483. #endif
  484. }
  486. if (mFileHandle != LLLFSThread::nullHandle())
  487. {
  488. if (mBytesRead >= 0)
  489. {
  490. if (mBytesRead == 0)
  491. {
  492. llwarns << "Unable to write file in LLVorbisDecodeState::finishDecode" << llendl;
  493. mValid = FALSE;
  494. return TRUE; // we've finished
  495. }
  496. }
  497. else
  498. {
  499. return FALSE; // not done
  500. }
  501. }
  503. mDone = TRUE;
  505. #if defined(USE_WAV_VFILE)
  506. // write the data.
  507. LLVFile output(gVFS, mUUID, LLAssetType::AT_SOUND_WAV);
  508. output.write(&mWAVBuffer[0], mWAVBuffer.size());
  509. #endif
  510. //llinfos << "Finished decode for " << getUUID() << llendl;
  512. return TRUE;
  513. }
  515. void LLVorbisDecodeState::flushBadFile()
  516. {
  517. if (mInFilep)
  518. {
  519. llwarns << "Flushing bad vorbis file from VFS for " << mUUID << llendl;
  520. mInFilep->remove();
  521. }
  522. }
  524. //////////////////////////////////////////////////////////////////////////////
  526. class LLAudioDecodeMgr::Impl
  527. {
  528. friend class LLAudioDecodeMgr;
  529. public:
  530. Impl() {};
  531. ~Impl() {};
  533. void processQueue(const F32 num_secs = 0.005);
  535. protected:
  536. LLLinkedQueue<LLUUID> mDecodeQueue;
  537. LLPointer<LLVorbisDecodeState> mCurrentDecodep;
  538. };
  541. void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
  542. {
  543. LLUUID uuid;
  545. LLTimer decode_timer;
  547. BOOL done = FALSE;
  548. while (!done)
  549. {
  550. if (mCurrentDecodep)
  551. {
  552. BOOL res;
  554. // Decode in a loop until we're done or have run out of time.
  555. while(!(res = mCurrentDecodep->decodeSection()) && (decode_timer.getElapsedTimeF32() < num_secs))
  556. {
  557. // decodeSection does all of the work above
  558. }
  560. if (mCurrentDecodep->isDone() && !mCurrentDecodep->isValid())
  561. {
  562. // We had an error when decoding, abort.
  563. llwarns << mCurrentDecodep->getUUID() << " has invalid vorbis data, aborting decode" << llendl;
  564. mCurrentDecodep->flushBadFile();
  565. LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
  566. adp->setHasValidData(FALSE);
  567. mCurrentDecodep = NULL;
  568. done = TRUE;
  569. }
  571. if (!res)
  572. {
  573. // We've used up out time slice, bail...
  574. done = TRUE;
  575. }
  576. else if (mCurrentDecodep)
  577. {
  578. if (mCurrentDecodep->finishDecode())
  579. {
  580. // We finished!
  581. if (mCurrentDecodep->isValid() && mCurrentDecodep->isDone())
  582. {
  583. LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
  584. adp->setHasDecodedData(TRUE);
  585. adp->setHasValidData(TRUE);
  587. // At this point, we could see if anyone needs this sound immediately, but
  588. // I'm not sure that there's a reason to - we need to poll all of the playing
  589. // sounds anyway.
  590. //llinfos << "Finished the vorbis decode, now what?" << llendl;
  591. }
  592. else
  593. {
  594. llinfos << "Vorbis decode failed!!!" << llendl;
  595. }
  596. mCurrentDecodep = NULL;
  597. }
  598. done = TRUE; // done for now
  599. }
  600. }
  602. if (!done)
  603. {
  604. if (!mDecodeQueue.getLength())
  605. {
  606. // Nothing else on the queue.
  607. done = TRUE;
  608. }
  609. else
  610. {
  611. LLUUID uuid;
  612. mDecodeQueue.pop(uuid);
  613. if (gAudiop->hasDecodedFile(uuid))
  614. {
  615. // This file has already been decoded, don't decode it again.
  616. continue;
  617. }
  619. lldebugs << "Decoding " << uuid << " from audio queue!" << llendl;
  621. std::string uuid_str;
  622. std::string d_path;
  624. LLTimer timer;
  625. timer.reset();
  627. uuid.toString(uuid_str);
  628. d_path = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str) + ".dsf";
  630. mCurrentDecodep = new LLVorbisDecodeState(uuid, d_path);
  631. if (!mCurrentDecodep->initDecode())
  632. {
  633. mCurrentDecodep = NULL;
  634. }
  635. }
  636. }
  637. }
  638. }
  640. //////////////////////////////////////////////////////////////////////////////
  642. LLAudioDecodeMgr::LLAudioDecodeMgr()
  643. {
  644. mImpl = new Impl;
  645. }
  647. LLAudioDecodeMgr::~LLAudioDecodeMgr()
  648. {
  649. delete mImpl;
  650. }
  652. void LLAudioDecodeMgr::processQueue(const F32 num_secs)
  653. {
  654. mImpl->processQueue(num_secs);
  655. }
  657. BOOL LLAudioDecodeMgr::addDecodeRequest(const LLUUID &uuid)
  658. {
  659. if (gAudiop->hasDecodedFile(uuid))
  660. {
  661. // Already have a decoded version, don't need to decode it.
  662. return TRUE;
  663. }
  665. if (gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
  666. {
  667. // Just put it on the decode queue.
  668. mImpl->mDecodeQueue.push(uuid);
  669. return TRUE;
  670. }
  672. return FALSE;
  673. }