gv.h

/*
GameSpy Voice2 SDK
Dan "Mr. Pants" Schoenblum
dan@gamespy.com
 
Copyright 2004 GameSpy Industries, Inc
 
devsupport@gamespy.com
http://gamespy.net
*/
 
/************************
** GameSpy Voice 2 SDK **
************************/
 
#ifndef _GV_H_
#define _GV_H_
 
#include "../common/gsCommon.h"
 
#if defined(__cplusplus)
extern "C" {
#endif
 
//DEFINES
#define GV_BYTES_PER_SAMPLE          (sizeof(GVSample) / sizeof(GVByte))
#define GV_BITS_PER_SAMPLE           (GV_BYTES_PER_SAMPLE * 8)
 
#define GV_DEVICE_NAME_LEN   64
#define GV_CHANNEL_NAME_LEN  64
 
#define GV_CAPTURE   1
#define GV_PLAYBACK  2
#define GV_CAPTURE_AND_PLAYBACK  (GV_CAPTURE|GV_PLAYBACK)
 
#define GVRate_8KHz   8000
#define GVRate_16KHz 16000
//Used by PSP
#define GVRate_11KHz 11025
 
//For backwards compatability
#define GV_SAMPLES_PER_SECOND    (gvGetSampleRate())
#define GV_BYTES_PER_SECOND      (gvGetSampleRate() * GV_BYTES_PER_SAMPLE)
 
//TYPES
typedef enum
{
    GVCodecRaw,
    GVCodecSuperHighQuality,
    GVCodecHighQuality,
    GVCodecAverage,
    GVCodecLowBandwidth,
    GVCodecSuperLowBandwidth
} GVCodec;
 
typedef enum
{
    GVHardwareDirectSound,   // Win32
    GVHardwarePS2Spu2,       // PS2 (System output)
    GVHardwarePS2Headset,    // PS2 (USB)
    GVHardwarePS2Microphone, // PS2 (USB)
    GVHardwarePS2Speakers,   // PS2 (USB)
    GVHardwarePS2Eyetoy,     // PS2 (USB)
    GVHardwarePS3Headset,    // PS3 (USB)
    GVHardwarePSPHeadset,    // PSP
    GVHardwareMacOSX,        // MacOSX
    GVHardwareCustom         // Any
} GVHardwareType;
 
typedef enum
{
    GVCaptureModeThreshold,
    GVCaptureModePushToTalk
} GVCaptureMode;
 
typedef int GVBool;
#define GVFalse 0
#define GVTrue 1
 
typedef gsi_u8                 GVByte;
typedef gsi_i16                GVSample;
 
typedef int                    GVRate;
 
#if defined(_PSP) || defined(_PS2) || defined(_PS3)
    typedef float              GVScalar;  // range 0-1
#else
    typedef double             GVScalar;  // range 0-1
#endif
typedef gsi_u16                GVFrameStamp;
typedef void *                 GVDecoderData;
typedef int                    GVDeviceType;
typedef struct GVIDevice *     GVDevice;
 
#if defined(GV_CUSTOM_SOURCE_TYPE)
typedef GV_CUSTOM_SOURCE_TYPE  GVSource;
#else
typedef int                    GVSource;
#endif
 
#if defined(_WIN32)
typedef GUID                   GVDeviceID;
#else
typedef int                    GVDeviceID;
#endif
 
typedef struct
{
    GVDeviceID m_id;
    gsi_char m_name[GV_DEVICE_NAME_LEN];
    GVDeviceType m_deviceType;
    GVDeviceType m_defaultDevice;    // not supported on PS2
    GVHardwareType m_hardwareType;
} GVDeviceInfo;
 
typedef struct
{
    int m_samplesPerFrame;  // number of samples in an unencoded frame
    int m_encodedFrameSize; // number of bytes in an encoded frame
 
    GVBool (* m_newDecoderCallback)(GVDecoderData * data);
    void (* m_freeDecoderCallback)(GVDecoderData data);
 
    void (* m_encodeCallback)(GVByte * out, const GVSample * in);
    void (* m_decodeAddCallback)(GVSample * out, const GVByte * in, GVDecoderData data);  // adds to output (required)
    void (* m_decodeSetCallback)(GVSample * out, const GVByte * in, GVDecoderData data);  // sets output (optional)
} GVCustomCodecInfo;
 
//GLOBALS
#if defined(_WIN32)
extern const GVDeviceID GVDefaultCaptureDeviceID;
extern const GVDeviceID GVDefaultPlaybackDeviceID;
#elif defined(_PS2)
extern const GVDeviceID GVPS2Spu2DeviceID;
#endif
 
//GENERAL
#if defined(_WIN32)
GVBool gvStartup(HWND hWnd);
#else
GVBool gvStartup(void);
#endif
void gvCleanup(void);
 
void gvThink(void);
 
//CODEC
GVBool gvSetCodec(GVCodec codec);
void gvSetCustomCodec(GVCustomCodecInfo * info);
 
void gvGetCodecInfo(int * samplesPerFrame, int * encodedFrameSize, int * bitsPerSecond);
 
//SAMPLE RATE
void gvSetSampleRate(GVRate sampleRate);
GVRate gvGetSampleRate(void);
 
//DEVICES
int gvListDevices(GVDeviceInfo devices[], int maxDevices, GVDeviceType types);
 
#if defined(_WIN32)
GVBool gvRunSetupWizard(GVDeviceID captureDeviceID, GVDeviceID playbackDeviceID);
GVBool gvAreDevicesSetup(GVDeviceID captureDeviceID, GVDeviceID playbackDeviceID);
#endif
 
GVDevice gvNewDevice(GVDeviceID deviceID, GVDeviceType type);
void gvFreeDevice(GVDevice device);
 
GVBool gvStartDevice(GVDevice device, GVDeviceType type);
void gvStopDevice(GVDevice device, GVDeviceType type);
GVBool gvIsDeviceStarted(GVDevice device, GVDeviceType type);
 
void gvSetDeviceVolume(GVDevice device, GVDeviceType type, GVScalar volume);
GVScalar gvGetDeviceVolume(GVDevice device, GVDeviceType type);
 
typedef void (* gvUnpluggedCallback)(GVDevice device);
void gvSetUnpluggedCallback(GVDevice device, gvUnpluggedCallback unpluggedCallback);
 
typedef void (* gvFilterCallback)(GVDevice device, GVSample * audio, GVFrameStamp frameStamp);
void gvSetFilter(GVDevice device, GVDeviceType type, gvFilterCallback callback);
 
//CAPTURE
// len is both an input and output parameter
GVBool gvCapturePacket(GVDevice device, GVByte * packet, int * len, GVFrameStamp * frameStamp, GVScalar * volume);
int gvGetAvailableCaptureBytes(GVDevice device);
 
void gvSetCaptureThreshold(GVDevice device, GVScalar threshold);
GVScalar gvGetCaptureThreshold(GVDevice device);
 
void gvSetCaptureMode(GVDevice device, GVCaptureMode captureMode);
GVCaptureMode gvGetCaptureMode(GVDevice device);
 
void gvSetPushToTalk(GVDevice device, GVBool talkOn);
GVBool gvGetPushToTalk(GVDevice device);
 
//PLAYBACK
void gvPlayPacket(GVDevice device, const GVByte * packet, int len, GVSource source, GVFrameStamp frameStamp, GVBool mute);
 
GVBool gvIsSourceTalking(GVDevice device, GVSource source);
int gvListTalkingSources(GVDevice device, GVSource sources[], int maxSources);
 
void gvSetGlobalMute(GVBool mute);
GVBool gvGetGlobalMute(void);
 
//CUSTOM DEVICE
GVDevice gvNewCustomDevice(GVDeviceType type);
 
// for both of these, numSamples must be a multiple of the codec's samplesPerFrame
// this ensures that no data needs to be buffered by the SDK
GVBool gvGetCustomPlaybackAudio(GVDevice device, GVSample * audio, int numSamples);
GVBool gvSetCustomCaptureAudio(GVDevice device, const GVSample * audio, int numSamples,
                               GVByte * packet, int * packetLen, GVFrameStamp * frameStamp, GVScalar * volume);
 
//CHANNELS
int gvGetNumChannels(GVDevice device, GVDeviceType type);
void gvGetChannelName(GVDevice device, GVDeviceType type, int channel, gsi_char name[GV_CHANNEL_NAME_LEN]);
void gvSetChannel(GVDevice device, GVDeviceType type, int channel);
int gvGetChannel(GVDevice device, GVDeviceType type);
 
#if defined(__cplusplus)
}
#endif
 
#endif