示例#1
0
        //

        bool LoadSamplesFromStream(VirtualFileStream stream, SoundType soundType,
                                   out int channels, out int frequency, out float timeLength, out string error)
        {
            channels   = 0;
            frequency  = 0;
            timeLength = 0;
            error      = null;

            switch (soundType)
            {
            case SoundType.OGG:
            {
                VorbisFileReader vorbisFileReader = new VorbisFileReader(stream, false);
                VorbisFile.File  vorbisFile       = new VorbisFile.File();

                if (!vorbisFileReader.OpenVorbisFile(vorbisFile))
                {
                    vorbisFile.Dispose();
                    vorbisFileReader.Dispose();

                    error = "Reading failed";
                    return(false);
                }

                int numSamples = (int)vorbisFile.pcm_total(-1);

                vorbisFile.get_info(-1, out channels, out frequency);
                timeLength = (float)vorbisFile.time_total(-1);

                int size        = numSamples * channels;
                int sizeInBytes = size * 2;
                soundSamples = new byte[sizeInBytes];

                unsafe
                {
                    fixed(byte *pSoundSamples = soundSamples)
                    {
                        int samplePos = 0;

                        while (samplePos < sizeInBytes)
                        {
                            int readBytes = vorbisFile.read((IntPtr)(pSoundSamples + samplePos),
                                                            sizeInBytes - samplePos, 0, 2, 1, IntPtr.Zero);

                            if (readBytes <= 0)
                            {
                                break;
                            }

                            samplePos += readBytes;
                        }
                    }
                }

                vorbisFile.Dispose();
                vorbisFileReader.Dispose();
            }
                return(true);

            case SoundType.WAV:
            {
                int sizeInBytes;
                if (!WavLoader.Load(stream, out channels, out frequency, out soundSamples,
                                    out sizeInBytes, out error))
                {
                    return(false);
                }
                timeLength = (float)(soundSamples.Length / channels / 2) / (float)frequency;
            }
                return(true);
            }

            error = "Unknown file type";
            return(false);
        }
示例#2
0
        unsafe public OpenALSampleSound(VirtualFileStream stream, SoundType soundType, string name, SoundModes mode, out bool initialized)
        {
            initialized = false;

            byte[] samples;
            int    sizeInBytes;
            float  timeLength;

            if (string.Compare(Path.GetExtension(name), ".ogg", true) == 0)
            {
                //ogg

                VorbisFileReader vorbisFileReader = new VorbisFileReader(stream, false);
                VorbisFile.File  vorbisFile       = new VorbisFile.File();

                if (!vorbisFileReader.OpenVorbisFile(vorbisFile))
                {
                    vorbisFile.Dispose();
                    vorbisFileReader.Dispose();

                    Log.Warning("OpenALSoundSystem: Creating sound failed \"{0}\" (Reading failed).", name);
                    return;
                }

                int numSamples = (int)vorbisFile.pcm_total(-1);

                vorbisFile.get_info(-1, out channels, out frequency);
                timeLength = (float)vorbisFile.time_total(-1);

                sizeInBytes = numSamples * channels * 2;
                samples     = new byte[sizeInBytes];

                fixed(byte *pSamples = samples)
                {
                    int samplePos = 0;

                    while (samplePos < sizeInBytes)
                    {
                        int readBytes = vorbisFile.read((IntPtr)(pSamples + samplePos), sizeInBytes - samplePos, 0, 2, 1, IntPtr.Zero);
                        if (readBytes <= 0)
                        {
                            break;
                        }
                        samplePos += readBytes;
                    }
                }

                vorbisFile.Dispose();
                vorbisFileReader.Dispose();
            }
            else if (string.Compare(Path.GetExtension(name), ".wav", true) == 0)
            {
                //wav

                string error;
                if (!WavLoader.Load(stream, out channels, out frequency, out samples, out sizeInBytes, out error))
                {
                    Log.Warning("OpenALSoundSystem: Creating sound failed \"{0}\" ({1}).", name, error);
                    return;
                }

                timeLength = (float)(samples.Length / channels / 2) / (float)frequency;
            }
            else
            {
                Log.Warning("OpenALSoundSystem: Creating sound failed \"{0}\" (Unknown file type).", name);
                return;
            }

            //create buffer

            Al.alGenBuffers(1, out alBuffer);

            int alFormat = (channels == 1) ? Al.AL_FORMAT_MONO16 : Al.AL_FORMAT_STEREO16;

            //bug fix: half volume mono 2D sounds
            //convert to stereo
            if ((mode & SoundModes.Mode3D) == 0 && alFormat == Al.AL_FORMAT_MONO16)
            {
                byte[] stereoSamples = new byte[sizeInBytes * 2];
                for (int n = 0; n < sizeInBytes; n += 2)
                {
                    stereoSamples[n * 2 + 0] = samples[n];
                    stereoSamples[n * 2 + 1] = samples[n + 1];
                    stereoSamples[n * 2 + 2] = samples[n];
                    stereoSamples[n * 2 + 3] = samples[n + 1];
                }
                samples      = stereoSamples;
                alFormat     = Al.AL_FORMAT_STEREO16;
                sizeInBytes *= 2;
            }

            //convert to mono for 3D
            if ((mode & SoundModes.Mode3D) != 0 && channels == 2)
            {
                byte[] oldSamples = samples;
                samples = new byte[oldSamples.Length / 2];
                for (int n = 0; n < samples.Length; n += 2)
                {
                    samples[n + 0] = oldSamples[n * 2 + 0];
                    samples[n + 1] = oldSamples[n * 2 + 1];
                }
                alFormat     = Al.AL_FORMAT_MONO16;
                sizeInBytes /= 2;
            }

            fixed(byte *pSamples = samples)
            Al.alBufferData(alBuffer, alFormat, pSamples, sizeInBytes, frequency);

            if (OpenALSoundWorld.CheckError())
            {
                Log.Warning("OpenALSoundSystem: Creating sound failed \"{0}\".", name);
                return;
            }

            Init(name, mode, timeLength, channels, frequency);
            initialized = true;
        }
示例#3
0
		unsafe public OpenALSampleSound( VirtualFileStream stream, SoundType soundType, string name,
			SoundMode mode, out bool initialized )
		{
			initialized = false;

			byte[] samples;
			int sizeInBytes;
			float timeLength;

			if( string.Compare( Path.GetExtension( name ), ".ogg", true ) == 0 )
			{
				//ogg

				VorbisFileReader vorbisFileReader = new VorbisFileReader( stream, false );
				VorbisFile.File vorbisFile = new VorbisFile.File();

				if( !vorbisFileReader.OpenVorbisFile( vorbisFile ) )
				{
					vorbisFile.Dispose();
					vorbisFileReader.Dispose();

					Log.Warning( "OpenALSoundSystem: Creating sound failed \"{0}\" (Reading failed).",
						name );
					return;
				}

				int numSamples = (int)vorbisFile.pcm_total( -1 );

				vorbisFile.get_info( -1, out channels, out frequency );
				timeLength = (float)vorbisFile.time_total( -1 );

				sizeInBytes = numSamples * channels * 2;
				samples = new byte[ sizeInBytes ];

				fixed( byte* pSamples = samples )
				{
					int samplePos = 0;
					while( samplePos < sizeInBytes )
					{
						int readBytes = vorbisFile.read( (IntPtr)( pSamples + samplePos ),
							sizeInBytes - samplePos, 0, 2, 1, IntPtr.Zero );
						if( readBytes <= 0 )
							break;
						samplePos += readBytes;
					}
				}

				vorbisFile.Dispose();
				vorbisFileReader.Dispose();
			}
			else if( string.Compare( Path.GetExtension( name ), ".wav", true ) == 0 )
			{
				//wav

				string error;
				if( !WavLoader.Load( stream, out channels,
					out frequency, out samples, out sizeInBytes, out error ) )
				{
					Log.Warning( "OpenALSoundSystem: Creating sound failed \"{0}\" ({1}).",
						name, error );
					return;
				}

				timeLength = (float)( samples.Length / channels / 2 ) / (float)frequency;
			}
			else
			{
				Log.Warning( "OpenALSoundSystem: Creating sound failed \"{0}\" (Unknown file type).",
					name );
				return;
			}

			//create buffer

			Al.alGenBuffers( 1, out alBuffer );

			int alFormat = ( channels == 1 ) ? Al.AL_FORMAT_MONO16 : Al.AL_FORMAT_STEREO16;

			//bug fix: half volume mono 2D sounds
			//convert to stereo
			if( ( mode & SoundMode.Mode3D ) == 0 && alFormat == Al.AL_FORMAT_MONO16 )
			{
				byte[] stereoSamples = new byte[ sizeInBytes * 2 ];
				for( int n = 0; n < sizeInBytes; n += 2 )
				{
					stereoSamples[ n * 2 + 0 ] = samples[ n ];
					stereoSamples[ n * 2 + 1 ] = samples[ n + 1 ];
					stereoSamples[ n * 2 + 2 ] = samples[ n ];
					stereoSamples[ n * 2 + 3 ] = samples[ n + 1 ];
				}
				samples = stereoSamples;
				alFormat = Al.AL_FORMAT_STEREO16;
				sizeInBytes *= 2;
			}

			//convert to mono for 3D
			if( ( mode & SoundMode.Mode3D ) != 0 && channels == 2 )
			{
				byte[] oldSamples = samples;
				samples = new byte[ oldSamples.Length / 2 ];
				for( int n = 0; n < samples.Length; n += 2 )
				{
					samples[ n + 0 ] = oldSamples[ n * 2 + 0 ];
					samples[ n + 1 ] = oldSamples[ n * 2 + 1 ];
				}
				alFormat = Al.AL_FORMAT_MONO16;
				sizeInBytes /= 2;
			}

			fixed( byte* pSamples = samples )
			{
				Al.alBufferData( alBuffer, alFormat, pSamples, sizeInBytes, frequency );
			}

			if( OpenALSoundWorld.CheckError() )
			{
				Log.Warning( "OpenALSoundSystem: Creating sound failed \"{0}\".", name );
				return;
			}

			Init( name, mode, timeLength, channels, frequency );
			initialized = true;
		}
示例#4
0
		//

		bool LoadSamplesFromStream( VirtualFileStream stream, SoundType soundType,
			out int channels, out int frequency, out float timeLength, out string error )
		{
			channels = 0;
			frequency = 0;
			timeLength = 0;
			error = null;

			switch( soundType )
			{
			case SoundType.OGG:
				{
					VorbisFileReader vorbisFileReader = new VorbisFileReader( stream, false );
					VorbisFile.File vorbisFile = new VorbisFile.File();

					if( !vorbisFileReader.OpenVorbisFile( vorbisFile ) )
					{
						vorbisFile.Dispose();
						vorbisFileReader.Dispose();

						error = "Reading failed";
						return false;
					}

					int numSamples = (int)vorbisFile.pcm_total( -1 );

					vorbisFile.get_info( -1, out channels, out frequency );
					timeLength = (float)vorbisFile.time_total( -1 );

					int size = numSamples * channels;
					int sizeInBytes = size * 2;
					soundSamples = new byte[ sizeInBytes ];

					unsafe
					{
						fixed( byte* pSoundSamples = soundSamples )
						{
							int samplePos = 0;
							while( samplePos < sizeInBytes )
							{
								int readBytes = vorbisFile.read( (IntPtr)( pSoundSamples + samplePos ),
									sizeInBytes - samplePos, 0, 2, 1, IntPtr.Zero );

								if( readBytes <= 0 )
									break;

								samplePos += readBytes;
							}
						}
					}

					vorbisFile.Dispose();
					vorbisFileReader.Dispose();
				}
				return true;

			case SoundType.WAV:
				{
					int sizeInBytes;
					if( !WavLoader.Load( stream, out channels, out frequency, out soundSamples,
						out sizeInBytes, out error ) )
					{
						return false;
					}
					timeLength = (float)( soundSamples.Length / channels / 2 ) / (float)frequency;
				}
				return true;

			}

			error = "Unknown file type";
			return false;
		}