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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
alapp.cpp
资源名称：Engine_v0.2.tar.gz　[点击查看]
上传用户：qccn516
上传日期：2013-05-02
资源大小：3382k
文件大小：14k
源码类别：

游戏引擎

开发平台：

Visual C++

alapp.cpp：源码内容
  1. /* ALApp
  2.  *
  3.  * Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <vorbis/vorbisfile.h>
  23. #include <mad.h>
  24. #include "alapp.h"
  26. #ifdef _WIN32
  27. #pragma comment (lib,"openal32.lib")
  28. #pragma comment (lib,"ogg.lib")
  29. #pragma comment (lib,"vorbis.lib")
  30. #pragma comment (lib,"vorbisfile.lib")
  31. #pragma comment (lib,"libmad.lib")
  32. #endif
  34. /*****************************************************************************/
  35. /*                                                                           */
  36. /*                                                                           */
  37. /*                                                                           */
  38. /*****************************************************************************/
  40. class SoundFileOgg : public SoundFile {
  41. public:
  42. SoundFileOgg(const char *name);
  43. virtual ~SoundFileOgg();
  45. virtual int size();
  46. virtual int read(char *buf,int size = -1);
  47. virtual void seek(double time);
  49. protected:
  50. FILE *file;
  51. OggVorbis_File vf;
  52. vorbis_info *vi;
  53. };
  55. SoundFileOgg::SoundFileOgg(const char *name) {
  56. file = fopen(name,"rb");
  57. if(!file) {
  58. fprintf(stderr,"SoundFileOgg::SoundFileOgg(): error open "%s" filen",name);
  59. return;
  60. }
  61. if(ov_open(file,&vf,NULL,0) < 0) {
  62. fprintf(stderr,"SoundFileOgg::SoundFileOgg(): "%s" is not ogg bitstreamn",name);
  63. fclose(file);
  64. file = NULL;
  65. return;
  66. }
  67. vi = ov_info(&vf,-1);
  68. channels = vi->channels;
  69. freq = vi->rate;
  70. }
  72. SoundFileOgg::~SoundFileOgg() {
  73. if(file) {
  74. ov_clear(&vf);
  75. fclose(file);
  76. }
  77. }
  79. /*
  80.  */
  81. int SoundFileOgg::size() {
  82. if(!file) return 0;
  83. return (int)(ov_time_total(&vf,-1) + 0.5) * channels * freq * 2;
  84. }
  86. int SoundFileOgg::read(char *buffer,int size) {
  87. if(!file) return 0;
  88. int current_section;
  89. if(size < 0) size = this->size();
  90. int read = 0;
  91. while(read < size) {
  92. int ret = ov_read(&vf,buffer + read,size - read,0,2,1,&current_section);
  93. if(ret <= 0) break;
  94. read += ret;
  95. }
  96. return read;
  97. }
  99. void SoundFileOgg::seek(double time) {
  100. if(!file) return;
  101. ov_time_seek(&vf,time);
  102. }
  104. /*****************************************************************************/
  105. /*                                                                           */
  106. /*                                                                           */
  107. /*                                                                           */
  108. /*****************************************************************************/
  110. class SoundFileMp3 : public SoundFile {
  111. public:
  112. SoundFileMp3(const char *name);
  113. virtual ~SoundFileMp3();
  115. virtual int size();
  116. virtual int read(char *buf,int size = -1);
  117. virtual void seek(double time);
  119. protected:
  120. int read_frame();
  121. inline int scale(mad_fixed_t sample);
  123. enum {
  124. BUFFER_SIZE = 4096,
  125. };
  127. FILE *file;
  128. int file_size;
  129. unsigned char buffer[BUFFER_SIZE];
  130. int buffer_length;
  131. struct mad_synth synth;
  132. struct mad_stream stream;
  133. struct mad_frame frame;
  134. int bitrate;
  135. };
  137. SoundFileMp3::SoundFileMp3(const char *name) {
  138. file = fopen(name,"rb");
  139. if(!file) {
  140. fprintf(stderr,"SoundFileMp3::SoundFileMp3(): error open "%s" filen",name);
  141. return;
  142. }
  143. fseek(file,0,SEEK_END);
  144. file_size = ftell(file);
  145. fseek(file,0,SEEK_SET);
  146. buffer_length = 0;
  147. mad_synth_init(&synth);
  148. mad_stream_init(&stream);
  149. mad_frame_init(&frame);
  150. if(read_frame() == 0) {
  151. fprintf(stderr,"SoundFileMp3::SoundFileMp3(): can`t find framen",name);
  152. fclose(file);
  153. file = NULL;
  154. mad_synth_finish(&synth);
  155. mad_stream_finish(&stream);
  156. mad_frame_finish(&frame);
  157. return;
  158. }
  159. channels = (frame.header.mode == MAD_MODE_SINGLE_CHANNEL) ? 1 : 2;
  160. freq = frame.header.samplerate;
  161. bitrate = frame.header.bitrate;
  162. }
  164. SoundFileMp3::~SoundFileMp3() {
  165. if(file) {
  166. fclose(file);
  167. mad_synth_finish(&synth);
  168. mad_stream_finish(&stream);
  169. mad_frame_finish(&frame);
  170. }
  171. }
  173. /*
  174.  */
  175. int SoundFileMp3::read_frame() {
  176. while(1) {
  177. int ret = fread(&buffer[buffer_length],1,BUFFER_SIZE - buffer_length,file);
  178. if(ret <= 0) break;
  179. buffer_length += ret;
  180. while(1) {
  181. mad_stream_buffer(&stream,buffer,buffer_length);
  182. ret = mad_frame_decode(&frame,&stream);
  183. if(stream.next_frame) {
  184. int length = buffer + buffer_length - (unsigned char*)stream.next_frame;
  185. memmove(buffer,stream.next_frame,length);
  186. buffer_length = length;
  187. }
  188. if(ret == 0) return 1;
  189. if(stream.error == MAD_ERROR_BUFLEN) break;
  190. }
  191. }
  192. return 0;
  193. }
  195. /*
  196.  */
  197. inline int SoundFileMp3::scale(mad_fixed_t sample) {
  198. sample += (1 << (MAD_F_FRACBITS - 16));
  199. if(sample >= MAD_F_ONE) sample = MAD_F_ONE - 1;
  200. else if(sample < -MAD_F_ONE) sample = -MAD_F_ONE;
  201. return sample >> (MAD_F_FRACBITS + 1 - 16);
  202. }
  204. /*
  205.  */
  206. int SoundFileMp3::size() {
  207. if(!file) return 0;
  208. return file_size * 8 / bitrate * channels * freq * 2;
  209. }
  211. int SoundFileMp3::read(char *buffer,int size) {
  212. if(!file) return 0;
  213. if(size < 0) size = this->size();
  214. int read = 0;
  215. while(read < size) {
  216. mad_synth_frame(&synth,&frame);
  217. struct mad_pcm *pcm = &synth.pcm;
  218. mad_fixed_t *left = pcm->samples[0];
  219. mad_fixed_t *right = pcm->samples[1];
  220. unsigned short *data = (unsigned short*)(buffer + read);
  221. for(unsigned int length = pcm->length; length > 0; length--) {
  222. *data++ = scale(*left++);
  223. if(channels == 2) *data++ = scale(*right++);
  224. }
  225. read += pcm->length * channels * 2;
  226. if(!read_frame()) return read;
  227. }
  228. return read;
  229. }
  231. void SoundFileMp3::seek(double time) {
  232. if(!file) return;
  233. fseek(file,(unsigned int)((double)bitrate / 8.0 * time),SEEK_SET);
  234. read_frame();
  235. }
  237. /*****************************************************************************/
  238. /*                                                                           */
  239. /*                                                                           */
  240. /*                                                                           */
  241. /*****************************************************************************/
  243. class SoundFileWav : public SoundFile {
  244. public:
  245. SoundFileWav(const char *name);
  246. virtual ~SoundFileWav();
  248. virtual int size();
  249. virtual int read(char *buf,int size = -1);
  250. virtual void seek(double time);
  252. protected:
  253. enum {
  254. RIFF = 0x46464952,
  255. WAVE = 0x45564157,
  256. FMT = 0x20746D66,
  257. DATA = 0x61746164,
  258. };
  260. struct Fmt {
  261. unsigned short encoding;
  262. unsigned short channels;
  263. unsigned int frequency;
  264. unsigned int byterate;
  265. unsigned short blockalign;
  266. unsigned short bitspersample;
  267. };
  269. FILE *file;
  270. Fmt fmt;
  271. unsigned int data_offset;
  272. unsigned int data_length;
  273. };
  275. SoundFileWav::SoundFileWav(const char *name) {
  276. memset(&fmt,0,sizeof(Fmt));
  277. file = fopen(name,"rb");
  278. if(!file) {
  279. fprintf(stderr,"SoundFileWav::SoundFileWav(): error open "%s" filen",name);
  280. return;
  281. }
  282. unsigned int magic;
  283. unsigned int length;
  284. fread(&magic,sizeof(unsigned int),1,file);
  285. fread(&length,sizeof(unsigned int),1,file);
  286. if(magic != RIFF) {
  287. fprintf(stderr,"SoundFileWav::SoundFileWav(): wrong main chunkn");
  288. fclose(file);
  289. file = NULL;
  290. return;
  291. }
  292. fread(&magic,sizeof(unsigned int),1,file);
  293. if(magic != WAVE) {
  294. fprintf(stderr,"SoundFileWav::SoundFileWav(): unknown file typen");
  295. fclose(file);
  296. file = NULL;
  297. return;
  298. }
  299. while(1) {
  300. if(fread(&magic,sizeof(unsigned int),1,file) != 1) break;
  301. if(fread(&length,sizeof(unsigned int),1,file) != 1) break;
  302. if(magic == FMT) {
  303. fread(&fmt,sizeof(Fmt),1,file);
  304. if(fmt.encoding != 1) {
  305. fprintf(stderr,"SoundFileWav::SoundFileWav(): can`t open compressed waveform datan");
  306. fclose(file);
  307. file = NULL;
  308. return;
  309. }
  310. if(fmt.bitspersample != 16) {
  311. fprintf(stderr,"SoundFileWav::SoundFileWav(): can`t open %d bit per sample formatn",fmt.bitspersample);
  312. fclose(file);
  313. file = NULL;
  314. return;
  315. }
  316. channels = fmt.channels;
  317. freq = fmt.frequency;
  318. } else if(magic == DATA) {
  319. data_offset = ftell(file);
  320. data_length = length;
  321. break;
  322. } else {
  323. fseek(file,length,SEEK_CUR);
  324. }
  325. }
  326. if(channels == 0 || freq == 0 || data_offset == 0 || data_length == 0) {
  327. fprintf(stderr,"SoundFileWav::SoundFileWav(): can`t find FMT or DATA blockn");
  328. fclose(file);
  329. file = NULL;
  330. }
  331. }
  333. SoundFileWav::~SoundFileWav() {
  334. if(file) fclose(file);
  335. }
  337. /*
  338.  */
  339. int SoundFileWav::size() {
  340. if(!file) return 0;
  341. return data_length;
  342. }
  344. int SoundFileWav::read(char *buffer,int size) {
  345. if(!file) return 0;
  346. int left = data_length - ftell(file) + data_offset;
  347. if(size < 0 || left < size) size = left;
  348. fread(buffer,sizeof(char),size,file);
  349. return size;
  350. }
  352. void SoundFileWav::seek(double time) {
  353. if(!file) return;
  354. fseek(file,data_offset + (int)(time * fmt.channels * fmt.frequency),SEEK_SET);
  355. }
  357. /*****************************************************************************/
  358. /*                                                                           */
  359. /*                                                                           */
  360. /*                                                                           */
  361. /*****************************************************************************/
  363. SoundFile *SoundFile::load(const char *name) {
  364. if(strstr(name,".ogg")) return new SoundFileOgg(name);
  365. if(strstr(name,".mp3")) return new SoundFileMp3(name);
  366. if(strstr(name,".wav")) return new SoundFileWav(name);
  367. fprintf(stderr,""%s" is not supportedn",name);
  368. return NULL;
  369. }
  371. /*****************************************************************************/
  372. /*                                                                           */
  373. /*                                                                           */
  374. /*                                                                           */
  375. /*****************************************************************************/
  377. Sound::Sound(const char *name,int flag) : flag(flag) {
  378. file = SoundFile::load(name);
  379. if(!file) return;
  380. format = file->channels == 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16;
  381. if(file->size() < BUFFER_SIZE * 2) this->flag &= ~STREAM;
  382. if(this->flag & STREAM) {
  383. buffer = new char[BUFFER_SIZE * 2];
  384. alGenBuffers(2,buffers);
  385. alGenSources(1,&source);
  386. current_buffer = 0;
  387. } else {
  388. buffer = new char[file->size()];
  389. int size = file->read(buffer);
  390. alGenBuffers(1,buffers);
  391. alBufferData(buffers[0],format,buffer,size,file->freq);
  392. alGenSources(1,&source);
  393. alSourcei(source,AL_BUFFER,buffers[0]);
  394. alSourcei(source,AL_LOOPING,flag & LOOP ? AL_TRUE : AL_FALSE);
  395. delete buffer;
  396. }
  397. }
  399. Sound::~Sound() {
  400. if(!file) return;
  401. delete file;
  402. if(flag & STREAM) delete buffer;
  403. alDeleteSources(1,&source);
  404. if(flag & STREAM) alDeleteBuffers(2,buffers);
  405. else alDeleteBuffers(1,buffers);
  406. }
  408. /*
  409.  */
  410. void Sound::play() {
  411. if(!file) return;
  412. ALint state;
  413. alGetSourcei(source,AL_SOURCE_STATE,&state);
  414. if(state == AL_PLAYING) return;
  415. if(state != AL_PAUSED && flag & STREAM) {
  416. file->read(buffer,BUFFER_SIZE);
  417. alBufferData(buffers[0],format,buffer,BUFFER_SIZE,file->freq);
  418. file->read(buffer,BUFFER_SIZE);
  419. alBufferData(buffers[1],format,buffer,BUFFER_SIZE,file->freq);
  420. alSourceQueueBuffers(source,2,buffers);
  421. ALApp::addStream(this);
  422. }
  423. alSourcePlay(source);
  424. }
  426. /*
  427.  */
  428. void Sound::pause() {
  429. if(!file) return;
  430. alSourcePause(source);
  431. }
  433. /*
  434.  */
  435. void Sound::stop() {
  436. if(!file) return;
  437. alSourceStop(source);
  438. file->seek(0.0);
  439. if(flag & STREAM) {
  440. ALint queued;
  441. alGetSourcei(source,AL_BUFFERS_QUEUED,&queued);
  442. if(queued > 0) alSourceUnqueueBuffers(source,2,buffers);
  443. ALApp::removeStream(this);
  444. current_buffer = 0;
  445. }
  446. }
  448. /*
  449.  */
  450. void Sound::update() {
  451. if(!file) return;
  452. if(flag & STREAM) {
  453. ALint processed;
  454. alGetSourcei(source,AL_BUFFERS_PROCESSED,&processed);
  455. if(processed == 1) {
  456. alSourceUnqueueBuffers(source,1,&buffers[current_buffer]);
  457. int size = file->read(buffer,BUFFER_SIZE);
  458. if(size > 0 || (size == 0 && flag & LOOP)) {
  459. alBufferData(buffers[current_buffer],format,buffer,size,file->freq);
  460. alSourceQueueBuffers(source,1,&buffers[current_buffer]);
  461. if(size != BUFFER_SIZE && flag & LOOP) file->seek(0.0);
  462. } else {
  463. int queued;
  464. alGetSourcei(source,AL_BUFFERS_QUEUED,&queued);
  465. if(queued == 0) file->seek(0.0);
  466. }
  467. current_buffer = 1 - current_buffer;
  468. } else if(processed == 2) {
  469. alSourceUnqueueBuffers(source,2,buffers);
  470. current_buffer = 0;
  471. play();
  472. }
  473. }
  474. }
  476. /*****************************************************************************/
  477. /*                                                                           */
  478. /*                                                                           */
  479. /*                                                                           */
  480. /*****************************************************************************/
  482. std::vector<Sound*> ALApp::streams;
  484. ALApp::ALApp() {
  485. device = alcOpenDevice(NULL);
  486. if(!device) {
  487. fprintf(stderr,"ALApp::ALApp(): invalid devicen");
  488. return;
  489. }
  490. context = alcCreateContext(device,NULL);
  491. if(!context) {
  492. fprintf(stderr,"ALApp::ALApp(): invalid contextn");
  493. return;
  494. }
  495. alcMakeContextCurrent(context);
  496. }
  498. ALApp::~ALApp() {
  499. alcDestroyContext(context);
  500. alcCloseDevice(device);
  501. }
  503. /*
  504.  */
  505. void ALApp::error() {
  506. ALenum error;
  507. while((error = alGetError()) != AL_NO_ERROR) {
  508. fprintf(stderr,"ALApp::error(): 0x%04Xn",error);
  509. }
  510. }
  512. /*
  513.  */
  514. void ALApp::update() {
  515. for(int i = 0; i < (int)streams.size(); i++) streams[i]->update();
  516. }
  518. /*
  519.  */
  520. void ALApp::addStream(Sound *s) {
  521. int i = 0;
  522. for(i = 0; i < (int)streams.size(); i++) if(streams[i] == s) break;
  523. if(i == (int)streams.size()) streams.push_back(s);
  524. }
  526. /*
  527.  */
  528. void ALApp::removeStream(Sound *s) {
  529. if((int)streams.size() == 0) return;
  530. int i = 0;
  531. for(i = 0; i < (int)streams.size(); i++) if(streams[i] == s) break;
  532. if(i == (int)streams.size()) streams.erase(streams.begin() + i);
  533. }