spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

Method InitAudioStream()
    
        Local result:Int
        Local nChannels:Short       = 1     ; If STREAM_FORMAT = MM_STEREO8 Or STREAM_FORMAT = MM_STEREO16 Then nChannels = 2
        Local wBitsPerSample:Short  = 16    ; If STREAM_FORMAT = MM_MONO8 Or STREAM_FORMAT = MM_STEREO8 Then wBitsPerSample = 8     

        ' CREATE THE WAVE FORMAT STRUCTURE    
        wfx.wFormatTag      = WAVE_FORMAT_PCM
        wfx.nChannels       = nChannels
        wfx.nSamplesPerSec  = SAMPLE_RATE   'nSamplesPerSec
        wfx.wBitsPerSample  = wBitsPerSample
        wfx.nBlockAlign     = (wBitsPerSample / 8 * nChannels)
        wfx.nAvgBytesPerSec = (SAMPLE_RATE * wfx.nBlockAlign)   '(nSamplesPerSec * wfx.nBlockAlign)
    
        ' CREATE THE SECONDARY BUFFER STRUCTURE
        dsbd.dwSize         = SizeOf(dsbd)
        dsbd.dwFlags        = DSBCAPS_CTRLVOLUME|DSBCAPS_CTRLFREQUENCY|DSBCAPS_CTRLPAN|DSBCAPS_STATIC|DSBCAPS_LOCDEFER|DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_GLOBALFOCUS
        dsbd.dwBufferBytes  = STREAM_BUFFER_SIZE
        dsbd.lpwfxFormat    = wfx
    
        ' CREATE THE SECONDARY BUFFER INTERFACE
        Result = TAudioDevice.dsi.CreateSoundBuffer(dsbd,Varptr(pDSB),Null)
        PrintDSoundError(result,"CreateSoundBuffer")
   
    EndMethod

Quellcode

ype TMaxModAudioDriver Extends TAudioDriver


    Method CreateSound:TSound( sample:TAudioSample,loop_flag:Int )

        Local channels:Int,bits:Int,format:Int,length:Int,result:Int
        
        Select sample.format
?BigEndian
            Case SF_MONO16LE    ; sample=sample.Convert(SF_MONO16BE)
            Case SF_STEREO16LE  ; sample=sample.Convert(SF_STEREO16BE)
?LittleEndian
            Case SF_MONO16BE    ; sample=sample.Convert(SF_MONO16LE)
            Case SF_STEREO16BE  ; sample=sample.Convert(SF_STEREO16LE)
?
        End Select
        
        length=sample.length
        Select sample.format
            Case SF_MONO8                       ; channels = 1 ; bits=8  ; 
            Case SF_STEREO8                     ; channels = 2 ; bits=8  ; length:*2
            Case SF_MONO16LE, SF_MONO16BE       ; channels = 1 ; bits=16 ; length:*2
            Case SF_STEREO16LE, SF_STEREO16BE   ; channels = 2 ; bits=16 ; length:*4
        EndSelect
            
        Local snd:TMaxModAudioSound = New TMaxModAudioSound
    
        snd.SAMPLERATE = sample.hertz
    
        ' CREATE THE WAVE FORMAT STRUCTURE    
        snd.wfx.wFormatTag              = WAVE_FORMAT_PCM
        snd.wfx.nChannels               = Channels
        snd.wfx.nSamplesPerSec          = sample.hertz
        snd.wfx.wBitsPerSample          = bits
        snd.wfx.nBlockAlign             = bits / 8 * Channels
        snd.wfx.nAvgBytesPerSec         = sample.hertz * snd.wfx.nBlockAlign
    
        ' CREATE THE SECONDARY BUFFER STRUCTURE
        snd.dsbd.dwSize         = SizeOf(snd.dsbd)
        snd.dsbd.dwFlags        = DSBCAPS_CTRLVOLUME|DSBCAPS_CTRLFREQUENCY|DSBCAPS_CTRLPAN|DSBCAPS_STATIC|DSBCAPS_LOCDEFER|DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_GLOBALFOCUS
        snd.dsbd.dwBufferBytes  = length
        snd.dsbd.dwReserved     = Null
        snd.dsbd.lpwfxFormat    = snd.wfx
    
        ' CREATE THE SECONDARY BUFFER INTERFACE
        Result = TAudioDevice.dsi.CreateSoundBuffer(snd.dsbd,Varptr(snd.pDSB),Null) ; PrintDSoundError(result,"CreateSoundBuffer")

        Local lpvWrite:Int, dwLength:Int, lpvWrite1:Int, dwLength1:Int
        If snd.pDSB.Lock(0,length,Varptr(lpvWrite),Varptr(dwLength),Varptr(lpvWrite1),Varptr(dwLength1),0) = DS_OK 
            MemCopy(Byte Ptr(lpvWrite), Varptr(Sample.Samples[0]), length)
        EndIf

        Return snd
        
    End Method
    
    Method AllocChannel:TChannel()
        Local Channel:TMaxModAudioChannel = New TMaxModAudioChannel
        Return Channel
    End Method
    
End Type










Type TAudioDevice

    Global dsi              :IDirectSound8      = Null
    Global DSBPrimary       :IDirectSoundBuffer = Null
    Global PrimaryDSBDesc   :DSBUFFERDESC       = New DSBUFFERDESC
    
    Function Init()
    
        PrimaryDSBDesc.dwSize   = SizeOf(PrimaryDSBDesc)
        PrimaryDSBDesc.dwFlags  = DSBCAPS_PRIMARYBUFFER

        Local Result:Int = DirectSoundCreate8( Null, Varptr(dsi), Null )        ; PrintDSoundError(result,"DirectSoundCreate8")
        Result = dsi.SetCooperativeLevel( GetActiveWindow(), DSSCL_PRIORITY )   ; PrintDSoundError(result,"SetCooperativeLevel")
        Result = dsi.CreateSoundBuffer(PrimaryDSBDesc, Varptr(DSBPrimary),Null) ; PrintDSoundError(result,"CreateSoundBuffer")
        
    EndFunction

    Function Release_()
        dsi         = Null
        DSBPrimary  = Null
        GCCollect()
    EndFunction

EndType

C-/C++-Quelltext

#pragma once

#include <windows.h>
#include <dsound.h>

#pragma comment (lib, "dsound.lib")

namespace core
{
    class buffer_manager;
    class sounds;

    class directsound
    {
    private:
        directsound  (void);
        ~directsound (void);

    public:
        inline static directsound &getInst (void)
        {
            static directsound inst;
            return inst;
        }

        friend class buffer_manager;
        friend class sounds;

        int init (::HWND__* hWnd);
        void shutdown (void);

    private:
        ::IDirectSound8*            direct_sound;
        ::IDirectSoundBuffer*       primary_buffer;
    };
}

C-/C++-Quelltext

#include "directsound.h"

namespace core
{
    directsound::directsound (void) : direct_sound(NULL), primary_buffer(NULL)
    {
    }
    directsound::~directsound (void)
    {
        shutdown ();
    }

    int directsound::init (::HWND__* hWnd)
    {
        ::WAVEFORMATEX waveformat;
        ::DSBUFFERDESC desc;
        ::ZeroMemory (&desc, sizeof(::DSBUFFERDESC));

        if(::DirectSoundCreate8 (NULL, &direct_sound, NULL) != DS_OK)
        {
            ::MessageBoxW (NULL, L"Direct Sound Objekt konnte nicht erstellt werden!", L"Error", MB_ICONERROR);
            return 0;
        }

        if(direct_sound->SetCooperativeLevel (hWnd, DSSCL_EXCLUSIVE) != DS_OK)
        {
            ::MessageBoxW (NULL, L"Direct Sound Kooperations Level konnte nicht gesetzt werden!", L"Error", MB_ICONERROR);
            return 0;
        }

        desc.dwSize     = sizeof(::DSBUFFERDESC);
        desc.dwFlags    = DSBCAPS_PRIMARYBUFFER;

        if(direct_sound->CreateSoundBuffer (&desc, &primary_buffer, NULL) != DS_OK)
        {
            ::MessageBoxW (NULL, L"Primärer Soundpuffer konnte nicht erstellt werden!", L"Error", MB_ICONERROR);
            return 0;
        }

        waveformat.wFormatTag       = WAVE_FORMAT_PCM;
        waveformat.nChannels        = 2;
        waveformat.nSamplesPerSec   = 44100;
        waveformat.wBitsPerSample   = 16;
        waveformat.nBlockAlign      = waveformat.nChannels * waveformat.wBitsPerSample / 8;
        waveformat.nAvgBytesPerSec  = waveformat.nSamplesPerSec * waveformat.nBlockAlign;
        waveformat.cbSize           = 0;

        if (primary_buffer->SetFormat (&waveformat) != DS_OK)
        {
            ::MessageBoxW (NULL, L"Sound Format konnte nicht gesetzt werden!", L"Error", MB_ICONERROR);
            return 0;
        }

        return 1;
    }

    void directsound::shutdown (void)
    {
        if(primary_buffer != NULL) 
        {
            primary_buffer->Release();
            primary_buffer = NULL;
        }

        if(direct_sound != NULL)
        {
            direct_sound->Release();
            direct_sound = NULL;
        }
    }
}

C-/C++-Quelltext

        ::IDirectSoundBuffer* buffer_;
        ::ZeroMemory (&buffer, sizeof (::IDirectSoundBuffer*));

        ::WAVEFORMATEX wave_format;
        ::DSBUFFERDESC buffer_desc;
        ::HMMIO__*     wave_file;
        ::MMCKINFO     parent;
        ::MMCKINFO     child;
        ::ZeroMemory (&buffer_desc, sizeof(::DSBUFFERDESC));
        ::ZeroMemory (&parent,      sizeof(::MMCKINFO));
        ::ZeroMemory (&child,       sizeof(::MMCKINFO));

        void *write_one = 0;
        void *write_two = 0;

        unsigned long length_one = 0;
        unsigned long length_two = 0;

        wave_file = ::mmioOpenW (file, 0, MMIO_READ | MMIO_ALLOCBUF);

        if (wave_file == NULL)
        {
            return 0;
        }

        parent.fccType = mmioFOURCC ('W', 'A', 'V', 'E');
        ::mmioDescend (wave_file, &parent, 0, MMIO_FINDRIFF);
        
        child.fccType = mmioFOURCC ('f', 'm', 't', ' ');
        ::mmioDescend (wave_file, &child, &parent, 0);

        ::mmioRead (wave_file, reinterpret_cast <char*> (&wave_format), sizeof(wave_format));

        if(wave_format.wFormatTag != WAVE_FORMAT_PCM)
        {
            return 0;
        }

        ::mmioAscend (wave_file, &child, 0);
        child.ckid = mmioFOURCC ('d', 'a', 't', 'a');
        ::mmioDescend (wave_file, &child, &parent, MMIO_FINDCHUNK);

        buffer_desc.dwSize        = sizeof (::DSBUFFERDESC);
        buffer_desc.dwFlags       = 0;
        buffer_desc.dwBufferBytes = child.cksize;
        buffer_desc.lpwfxFormat   = &wave_format;

        if((core::directsound::getInst().direct_sound->CreateSoundBuffer (&buffer_desc, &buffer_, NULL)) != DS_OK)
        {
            return 0;
        }

        buffer_->Lock (0, child.cksize, &write_one, &length_one, &write_two, &length_two, 0);

        if (write_one > 0)
        ::mmioRead (wave_file, reinterpret_cast <char*> (write_one), length_one);

        if (write_two > 0)
        ::mmioRead (wave_file, reinterpret_cast <char*> (write_two), length_two);

        buffer_->Unlock (write_one, length_one, write_two, length_two);

        ::mmioClose (wave_file, 0);