View Single Post
Old 30 December 2013, 14:11   #36
NovaCoder
Registered User
NovaCoder's Avatar
 
Join Date: Sep 2007
Location: Melbourne/Australia
Posts: 3,444
This is my latest DOOM sound engine interface code, seems to work really nicely.

PHP Code:
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include "doomdef.h"
#include "doomtype.h"
#include "m_alloc.h"


#include "wave.h"
#include "m_swap.h"
#include "z_zone.h"

#include "c_cvars.h"
#include "i_system.h"
#include "i_sound.h"
#include "i_music.h"
#include "m_argv.h"
#include "m_misc.h"
#include "w_wad.h"
#include "i_video.h"
#include "s_sound.h"


// Amiga includes.
#include <proto/exec.h>

#include "amiga_sound_library.h"


#define MAX_AMIGA_CHANNELS  16

#define AMIGA_NORMAL_SEP 128
#define AMIGA_MAX_SFX_VOLUME 128
#define AMIGA_MAX_MUSIC_VOLUME 64


// killough 2/21/98: optionally use varying pitched sounds
CVAR (snd_pitched"0"CVAR_ARCHIVE)
#define PITCH(f,x) (snd_pitched.value ? ((f)*(x))/128 : (f))

static struct Library *DoomSndBase NULL;

static 
int no_music 0;
static 
int no_sfx 0;
static 
float vol_sfx 0;






void I_InitSound (void)
{
    
no_sfx = (!!Args.CheckParm ("-nosfx") || !!Args.CheckParm ("-nosound"));

    
no_music = (!!Args.CheckParm("-nomusic") || !!Args.CheckParm("-nosound"));
    
    if (
no_sfx && no_music) {
        return;
    }
    

    
DoomSndBase = (struct Library *)OpenLibrary ("doomsound.library"37);
    if (!
DoomSndBase) {
        
I_Error("Could not open doomsound.library!");
    }


    
// Finished initialization.
    
Printf (PRINT_HIGH"Sound Module ready....\n");
}

void I_ShutdownSound (void)
{
    
int i;

    if (
no_sfx && no_music) {
        return;
    }


    
// [RH] Free all loaded samples
    
for (0numsfxi++)
    {
        if (!
S_sfx[i].link)
        {
            if (
S_sfx[i].data)
            {
                
free (S_sfx[i].data);
            }
        }

        
S_sfx[i].data S_sfx[i].link NULL;
    }


    if (
DoomSndBase != NULL) {
        
CloseLibrary(DoomSndBase);
        
DoomSndBase NULL;
    }
}


static 
void getsfx (sfxinfo_t *sfx)
{
    
char                sndtemp[128];
    
unsigned char        *sfxdata;
    
unsigned char        *sfxcopy;
    
int                 size;
    
int                    i;
    
int                    s,d;
    

    
// Get the sound data from the WAD

    // If the sound doesn't exist, try a generic male sound (if this is a player sound) or the empty sound.
    
if (sfx->lumpnum == -1) {
        
char *basename;
        
int sfx_id;

        if (!
strnicmp (sfx->name"player/"7) && (basename strchr (sfx->name 7'/'))) {
            
sprintf (sndtemp"player/male/%s"basename+1);
            
sfx_id S_FindSound (sndtemp);
            if (
sfx_id != -1)
                
sfx->lumpnum S_sfx[sfx_id].lumpnum;
        }

        if (
sfx->lumpnum == -1)
badwave:
            
sfx->lumpnum W_GetNumForName ("dsempty");
    }
    
    
// See if there is another sound already initialized with this lump. If so,
    // then set this one up as a link, and don't load the sound again.
    
for (0numsfxi++)
        if (
S_sfx[i].data && !S_sfx[i].link && S_sfx[i].lumpnum == sfx->lumpnum) {
            
DPrintf ("Linked to %s (%d)\n"S_sfx[i].namei);
            
sfx->link S_sfx i;
            
sfx->ms S_sfx[i].ms;
            
sfx->data S_sfx[i].data;
            
sfx->normal S_sfx[i].normal;
            
sfx->looping S_sfx[i].looping;
            return;
        }

    
size W_LumpLength (sfx->lumpnum);
    if (
size == 0) {
        goto 
badwave;
    }
        

    
sfxdata = (unsigned char *)W_CacheLumpNum(sfx->lumpnumPU_CACHE);


    if (
LONG_SWAP(*((unsigned int *)sfxdata)) == ID_RIFF) {
        
// RIFF WAVE sound
        
I_Error("RIFF WAVE sound detected");
    } else {
        
// DMX sound
        //DPrintf ("DMX sound detected\n");
        

        
sfx->frequency SHORT_SWAP(((short *)sfxdata)[1]);
        
//sfx->frequency = (unsigned int)snd_samplerate.value;
        
        
        
sfx->length = (size 8);
        
        
//DPrintf ("getsfx() - sfx->frequency = %d\n", sfx->frequency);
        //DPrintf ("getsfx() - sfx->length = %d\n", sfx->length);    
    
}

    
sfxcopy = (unsigned char *)Malloc(size);
    
    
    
// Now copy and pad.
    
1;
    for (
0sized++) {
        
sfxcopy[d] = sfxdata[s] ^ 0x80;
        
        
s++;    
    }
    
    
Z_Free (sfxdata);

        
    
sfx->ms = (sfx->length 1000) / (sfx->frequency);
    
sfx->data sfxcopy;
}



//
// SFX API
//
void I_SetChannels (int numchannels)
{
    
// Not needed. 
}

 
void I_SetSfxVolume (int volume)
{
    if (
no_sfx) {
        return;
    }

    
vol_sfx = (float)((volume 15.0) * (256.0 255.0));    
}


//
// Starting a sound means adding it
//        to the current list of active sounds
//        in the internal channels.
// As the SFX info struct contains
//        e.g. a pointer to the raw data,
//        it is ignored.
//
int I_StartSound(sfxinfo_t *sfxint volint sepint pitchZDOOM_BOOL looping)
{
    static 
int handle 0;
    
int volume;
    
    if (
no_sfx) {
        return 
0;
    }    
    
    
handle++;
    if (
handle >= MAX_AMIGA_CHANNELS) {
        
handle 0;
    }
    
    
volume = ((int)(vol vol_sfx))/2;   /* original range 0-255, AMIGA range 0-128 */
    
    
if ( volume AMIGA_MAX_SFX_VOLUME volume AMIGA_MAX_SFX_VOLUME;
    else if ( 
volume volume 0;    
    

    
//DPrintf ("I_StartSound() - sfx->name = %s\n", sfx->name);
    //DPrintf ("I_StartSound() - sfx->frequency = %d\n", sfx->frequency);
    //DPrintf ("I_StartSound() - sfx->length = %d\n", sfx->length);
    //DPrintf ("I_StartSound() - vol = %d\n", vol);
    //DPrintf ("I_StartSound() - volume = %d\n", volume);
    //DPrintf ("I_StartSound() - vol_hacked = %d\n", vol >> 1);        
    //DPrintf ("I_StartSound() - sep = %d\n", sep);    
    
    
if (sep 0) {
        
sep AMIGA_NORMAL_SEP;
    }

    
I_StopSound(handle);
    
    
Sfx_Start((char *)sfx->datahandlePITCH(sfx->frequencypitch), volumesepsfx->length);
    
    return 
handle;
}

void I_StopSound(int handle)
{
    if (
no_sfx) {
        return;
    }    
    
    if (
I_SoundIsPlaying(handle)) {
        
Sfx_Stop(handle);
    }
}


int I_SoundIsPlaying (int handle)
{
    if (
no_sfx) {
        return 
0;
    }
        
    return 
Sfx_Done(handle) ? 0;
}


void I_UpdateSoundParams(int handlesfxinfo_t *sfxint volint sepint pitch)
{
    
int volume;
    
    if (
no_sfx) {
        return;
    }
    
    
volume = ((int)(vol vol_sfx))/2;   /* original range 0-255, AMIGA range 0-128 */
    
if ( volume AMIGA_MAX_SFX_VOLUME volume AMIGA_MAX_SFX_VOLUME;
    else if ( 
volume volume 0;    
        
    if (
sep 0) {
        
sep AMIGA_NORMAL_SEP;
    }
    
    if (
I_SoundIsPlaying(handle)) {
        
Sfx_Update(handlePITCH(sfx->frequencypitch), volumesep);
    }
}


void I_LoadSound (struct sfxinfo_struct *sfx)
{
    if (
no_sfx) {
        return;
    }

    if (!
sfx->data)
    {
        
int i sfx S_sfx;
        
//DPrintf ("loading sound \"%s\" (%d)\n", sfx->name, i);
        
getsfx (sfx);
    }
}



/***********************MUSIC API*********************************************/

int I_RegisterSong (void *dataint musicLen)
{
    
int handle 0;
    
int musicType;
    
    if (!
no_music) { 
        
musicType LONG_SWAP(*(int *)data);  
        if (
musicType == (('M')|(('U')<<8)|(('S')<<16)|((0x1a)<<24))) {        
           
// This is a mus file
           
handle Mus_Register(data);
        }
    }
    
    return 
handle;                  
}

void I_UnRegisterSong (int handle)
{
    if (!
no_music) {
        if (
handle 0) {
            
Mus_Unregister(handle);
        }
    }
}

void I_PlaySong (int handleint looping)
{
    if (!
no_music) {
        if (
handle 0) {
            
Mus_Play(handlelooping);
        }
    }
}


void I_SetMusicVolume (int volume)
{
    
//DPrintf ("I_SetMusicVolume(%d)\n", volume);
    
    
if (!no_music) {
        if ( 
volume AMIGA_MAX_MUSIC_VOLUME volume AMIGA_MAX_MUSIC_VOLUME;
        else if ( 
volume volume 0;
        
        
        
Mus_SetVol(volume);
        
//DPrintf ("I_SetMusicVolume() - volume = %d\n", volume);
    
}
}

void I_SetMIDIVolume (float volume)
{
    
// Not needed (yet!)
}

void I_PauseSong (int handle)
{
    if (!
no_music) {
        if (
handle >= 0) {
            
Mus_Pause(handle);
        }
    }
}

void I_ResumeSong (int handle)
{
    if (!
no_music) {
        if (
handle 0) {
            
Mus_Resume(handle);
        }
    }
}

void I_StopSong (int handle)
{
    if (!
no_music) {
        if (
handle 0) {
            
Mus_Stop(handle);
        }
    }



And this is how I do my input handling these days..

PHP Code:
#include "doomdef.h"
#include "doomtype.h"
#include "c_dispatch.h"
#include "c_console.h"
#include "d_main.h"

#include "i_system.h"
#include "i_input.h"

// Amiga stuff.
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <clib/keymap_protos.h>


#include "amiga_keyboard_codes.h"


/** Global Hardware window */
extern struct Window *_hardwareWindow;



static 
int keycode_lookup[256];


ZDOOM_BOOL I_InitInput(void) {
    
    
int i;


    for (
i=0i<256i++) {
        
keycode_lookup[i] = 0;
    }


    
// Top row
    
keycode_lookup[RAWKEY_ESCAPE] = KEY_ESCAPE;
    
keycode_lookup[RAWKEY_F1] = KEY_F1;
    
keycode_lookup[RAWKEY_F2] = KEY_F2;
    
keycode_lookup[RAWKEY_F3] = KEY_F3;
    
keycode_lookup[RAWKEY_F4] = KEY_F4;
    
keycode_lookup[RAWKEY_F5] = KEY_F5;
    
keycode_lookup[RAWKEY_F6] = KEY_F6;
    
keycode_lookup[RAWKEY_F7] = KEY_F7;
    
keycode_lookup[RAWKEY_F8] = KEY_F8;
    
keycode_lookup[RAWKEY_F9] = KEY_F9;
    
keycode_lookup[RAWKEY_F10] = KEY_F10;
    
keycode_lookup[RAWKEY_F11] = KEY_F11;
    
keycode_lookup[RAWKEY_F12] = KEY_F12;


    
// Second row
    
keycode_lookup[RAWKEY_TILDE] = 41;
    
keycode_lookup[RAWKEY_1] = 2;
    
keycode_lookup[RAWKEY_2] = 3;
    
keycode_lookup[RAWKEY_3] = 4;
    
keycode_lookup[RAWKEY_4] = 5;
    
keycode_lookup[RAWKEY_5] = 6;
    
keycode_lookup[RAWKEY_6] = 7;
    
keycode_lookup[RAWKEY_7] = 8;
    
keycode_lookup[RAWKEY_8] = 9;
    
keycode_lookup[RAWKEY_9] = 10;
    
keycode_lookup[RAWKEY_0] = 11;
    
keycode_lookup[RAWKEY_MINUS] = KEY_MINUS;
    
keycode_lookup[RAWKEY_EQUAL] = KEY_EQUALS;
    
keycode_lookup[RAWKEY_BACKSLASH] = 43;
    
keycode_lookup[RAWKEY_BACKSPACE] = KEY_BACKSPACE;



    
// Third row.
    
keycode_lookup[RAWKEY_TAB] = KEY_TAB;
    
keycode_lookup[RAWKEY_Q] = 16;
    
keycode_lookup[RAWKEY_W] = 17;
    
keycode_lookup[RAWKEY_E] = 18;
    
keycode_lookup[RAWKEY_R] = 19;
    
keycode_lookup[RAWKEY_T] = 20;
    
keycode_lookup[RAWKEY_Y] = 21;
    
keycode_lookup[RAWKEY_U] = 22;
    
keycode_lookup[RAWKEY_I] = 23;
    
keycode_lookup[RAWKEY_O] = 24;
    
keycode_lookup[RAWKEY_P] = 25;
    
keycode_lookup[RAWKEY_LBRACKET] = 26;
    
keycode_lookup[RAWKEY_RBRACKET] = 27;


    
// Fourth row.
    
keycode_lookup[RAWKEY_LCONTROL] = KEY_LCTRL;
    
keycode_lookup[RAWKEY_A] = 30;
    
keycode_lookup[RAWKEY_S] = 31;
    
keycode_lookup[RAWKEY_D] = 32;
    
keycode_lookup[RAWKEY_F] = 33;
    
keycode_lookup[RAWKEY_G] = 34;
    
keycode_lookup[RAWKEY_H] = 35;
    
keycode_lookup[RAWKEY_J] = 36;
    
keycode_lookup[RAWKEY_K] = 37;
    
keycode_lookup[RAWKEY_L] = 38;
    
keycode_lookup[RAWKEY_SEMICOLON] = 39;
    
keycode_lookup[RAWKEY_RETURN] = KEY_ENTER;

    

    
// Fifth row.
    
keycode_lookup[RAWKEY_LSHIFT] = KEY_LSHIFT;
    
keycode_lookup[RAWKEY_Z] = 44;
    
keycode_lookup[RAWKEY_X] = 45;
    
keycode_lookup[RAWKEY_C] = 46;
    
keycode_lookup[RAWKEY_V] = 47;
    
keycode_lookup[RAWKEY_B] = 48;
    
keycode_lookup[RAWKEY_N] = 49;
    
keycode_lookup[RAWKEY_M] = 50;
    
keycode_lookup[RAWKEY_COMMA] = 51;
    
keycode_lookup[RAWKEY_PERIOD] = 52;
    
keycode_lookup[RAWKEY_SLASH] = 53;
    
keycode_lookup[RAWKEY_RSHIFT] = KEY_RSHIFT;


    
// Sixth row.
    
keycode_lookup[RAWKEY_LALT] = KEY_LALT;
    
keycode_lookup[RAWKEY_SPACE] = KEY_SPACE;
    
keycode_lookup[RAWKEY_RALT] = KEY_RALT;
       
    
    
// Middle column.
    
keycode_lookup[RAWKEY_DELETE] = KEY_DEL;
    
keycode_lookup[RAWKEY_UP] = KEY_UPARROW;
    
keycode_lookup[RAWKEY_LEFT] = KEY_LEFTARROW;
    
keycode_lookup[RAWKEY_DOWN] = KEY_DOWNARROW;
    
keycode_lookup[RAWKEY_RIGHT] = KEY_RIGHTARROW;


    
// Keypad 0-9
    
keycode_lookup[RAWKEY_KP_7] = 71;
    
keycode_lookup[RAWKEY_KP_8] = 72;
    
keycode_lookup[RAWKEY_KP_9] = 73;
    
keycode_lookup[RAWKEY_KP_4] = 75;
    
keycode_lookup[RAWKEY_KP_5] = 76;
    
keycode_lookup[RAWKEY_KP_6] = 77;
    
keycode_lookup[RAWKEY_KP_1] = 79;                  
    
keycode_lookup[RAWKEY_KP_2] = 80;
    
keycode_lookup[RAWKEY_KP_3] = 81;
    
keycode_lookup[RAWKEY_KP_0] = 82;
    
keycode_lookup[RAWKEY_KP_DECIMAL] = 83;
    
keycode_lookup[RAWKEY_KP_ENTER] = 156;

        
    return 
true;
}

void I_ShutdownInput(void) {
    
// Nothing to do...   
}


void I_GetEvent(void) {

    
event_t event;
    
int code;
    
int qual;
    
int mousexmousey;
    
struct IntuiMessage *imsg;
    
    
// Setup.
    
event.data1 event.data2 event.data3 0;
 

    if (
_hardwareWindow != NULL) {
        while (
imsg = (struct IntuiMessage *)GetMsg(_hardwareWindow->UserPort)) {

            
ReplyMsg((struct Message *)imsg);

            
code imsg->Code;
            
qual imsg->Qualifier;

            switch (
imsg->Class) {
                case 
IDCMP_MOUSEMOVE:
                    
event.type ev_mouse;
                    
                    
event.data2 imsg->MouseX << 2;
                    
event.data3 = -imsg->MouseY << 2;
                    
                    
D_PostEvent(&event);
                    break;
        
                case 
IDCMP_MOUSEBUTTONS:
                    
event.type = (code IECODE_UP_PREFIX) ? ev_keyup ev_keydown;
                    
                    
code &= ~IECODE_UP_PREFIX;
                     
                    switch(
code)
                    {
                        case 
IECODE_LBUTTON:
                            
event.data1 KEY_MOUSE1;
                            
event.data2 KEY_MOUSE1;
                            
event.data3 event.data2;
                            
                            
D_PostEvent(&event);
                            break;
                
                        case 
IECODE_MBUTTON:
                            
event.data1 KEY_MOUSE2;
                            
event.data2 KEY_MOUSE2;
                            
event.data3 event.data2;

                            
D_PostEvent(&event);
                            break;
                
                        case 
IECODE_RBUTTON:
                            
event.data1 KEY_MOUSE3;
                            
event.data2 KEY_MOUSE3;
                            
event.data3 event.data2;

                            
D_PostEvent(&event);
                            break;
                    }                    
                    break;                
                
                case 
IDCMP_RAWKEY:
                    
event.type = (code IECODE_UP_PREFIX) ? ev_keyup ev_keydown;
                    
                    switch (
code) {
                        case 
RAWKEY_NM_WHEEL_UP:
                            
event.data1 KEY_MWHEELUP;
                            
D_PostEvent(&event);
                            break;

                        case 
RAWKEY_NM_WHEEL_DOWN:
                            
event.data1 KEY_MWHEELDOWN;
                            
D_PostEvent(&event);
                            break;

                        default:
                            
code &= ~IECODE_UP_PREFIX;
                            
                            if (
code 255) {
                                
I_Error("Could not translate key, scan-code outside array bounds");
                            }
                            
                            
event.data1 keycode_lookup[code];
                            
                            if (
event.data1 != 0) {
                                
// We handle this key, now attempt to get an ascii value.
                                
char charbuf;
                                
InputEvent FakedIEvent;
                                
                                
//DPrintf ("IDCMP_RAWKEY, handled Amiga code = %d\n", code);    
                                //DPrintf ("IDCMP_RAWKEY, mapped to keyboard code = %d\n", event.data1);    
                                
                                
memset(&FakedIEvent0sizeof(InputEvent));
                                
FakedIEvent.ie_Class IECLASS_RAWKEY;
                                
FakedIEvent.ie_Code code;
                                                      
                                
                                if (
MapRawKey(&FakedIEvent, &charbuf1NULL) == 1) {
                                    
event.data2 charbuf;
                                    
                                    
//DPrintf ("IDCMP_RAWKEY, ascii code = %d\n", event.data2);
                                    
                                    
event.data3 event.data2;
                                    
                                    if (
qual IEQUALIFIER_LSHIFT || qual IEQUALIFIER_RSHIFT) {
                                        
FakedIEvent.ie_Qualifier IEQUALIFIER_LSHIFT;
                                        if (
MapRawKey(&FakedIEvent, &charbuf1NULL) == 1) {
                                            
event.data3 charbuf;
                                        }
                                    }
                                }
                                
                                
D_PostEvent(&event);
                            }
                            break;
                    }
            }
        }
    }

Might give you some ideas

Last edited by NovaCoder; 12 May 2014 at 06:31.
NovaCoder is offline  
 
Page generated in 0.07770 seconds with 9 queries