id
/
quake2
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
quake2/rhapsody/snd_next.m

2152 lines
69 KiB
Mathematica
Raw Normal View History

as released 2001-12-22
2001-12-22 00:00:00 +00:00
#import <servers/netname.h>
#import <libc.h>
#include "../client/client.h"
double snd_basetime;
port_t devPort;
extern port_t task_self_;
#define task_self() task_self_
//========================================================================
#ifndef _ntsoundNTSound
#define _ntsoundNTSound
/* Module NTSound */
#include <mach/kern_return.h>
#include <mach/port.h>
#include <mach/message.h>
#ifndef mig_external
#define mig_external extern
#endif
#include <mach/std_types.h>
#include <mach/mach_types.h>
typedef short *sound_data_t;
#define NTSOUNDNAME "NEXTIME_Sound"
/* Routine ntsoundAcquire */
mig_external kern_return_t ntsoundAcquire (
port_t kern_serv_port,
port_t owner_port,
vm_offset_t *dmaAddress,
int *dmaSize,
int *success);
/* Routine ntsoundRelease */
mig_external kern_return_t ntsoundRelease (
port_t kern_serv_port,
port_t owner_port);
/* Routine ntsoundStart */
mig_external kern_return_t ntsoundStart (
port_t kern_serv_port,
port_t owner_port);
/* Routine ntsoundStop */
mig_external kern_return_t ntsoundStop (
port_t kern_serv_port,
port_t owner_port);
/* Routine ntsoundConfig */
mig_external kern_return_t ntsoundConfig (
port_t kern_serv_port,
port_t owner_port,
int channelCount,
int samplingRate,
int encoding,
int useInterrupts);
/* Routine ntsoundBytesProcessed */
mig_external kern_return_t ntsoundBytesProcessed (
port_t kern_serv_port,
port_t owner_port,
int *byte_count);
/* Routine ntsoundDMACount */
mig_external kern_return_t ntsoundDMACount (
port_t kern_serv_port,
port_t owner_port,
int *dma_count);
/* Routine ntsoundInterruptCount */
mig_external kern_return_t ntsoundInterruptCount (
port_t kern_serv_port,
port_t owner_port,
int *irq_count);
/* Routine ntsoundWrite */
mig_external kern_return_t ntsoundWrite (
port_t kern_serv_port,
port_t owner_port,
sound_data_t data,
unsigned int dataCnt,
int *actual_count);
/* Routine ntsoundSetVolume */
mig_external kern_return_t ntsoundSetVolume (
port_t kern_serv_port,
port_t owner_port,
int value);
/* Routine ntsoundWireRange */
mig_external kern_return_t ntsoundWireRange (
port_t device_port,
port_t token,
port_t task,
vm_offset_t addr,
vm_size_t size,
boolean_t wire);
#endif _ntsoundNTSound
//========================================================================
extern port_t name_server_port;
#define NX_SoundDeviceParameterKeyBase 0
#define NX_SoundDeviceParameterValueBase 200
#define NX_SoundStreamParameterKeyBase 400
#define NX_SoundStreamParameterValueBase 600
#define NX_SoundParameterTagMax 799
typedef enum _NXSoundParameterTag {
NX_SoundDeviceBufferSize = NX_SoundDeviceParameterKeyBase,
NX_SoundDeviceBufferCount,
NX_SoundDeviceDetectPeaks,
NX_SoundDeviceRampUp,
NX_SoundDeviceRampDown,
NX_SoundDeviceInsertZeros,
NX_SoundDeviceDeemphasize,
NX_SoundDeviceMuteSpeaker,
NX_SoundDeviceMuteHeadphone,
NX_SoundDeviceMuteLineOut,
NX_SoundDeviceOutputLoudness,
NX_SoundDeviceOutputAttenuationStereo,
NX_SoundDeviceOutputAttenuationLeft,
NX_SoundDeviceOutputAttenuationRight,
NX_SoundDeviceAnalogInputSource,
NX_SoundDeviceMonitorAttenuation,
NX_SoundDeviceInputGainStereo,
NX_SoundDeviceInputGainLeft,
NX_SoundDeviceInputGainRight,
NX_SoundDeviceAnalogInputSource_Microphone
= NX_SoundDeviceParameterValueBase,
NX_SoundDeviceAnalogInputSource_LineIn,
NX_SoundStreamDataEncoding = NX_SoundStreamParameterKeyBase,
NX_SoundStreamSamplingRate,
NX_SoundStreamChannelCount,
NX_SoundStreamHighWaterMark,
NX_SoundStreamLowWaterMark,
NX_SoundStreamSource,
NX_SoundStreamSink,
NX_SoundStreamDetectPeaks,
NX_SoundStreamGainStereo,
NX_SoundStreamGainLeft,
NX_SoundStreamGainRight,
NX_SoundStreamDataEncoding_Linear16 = NX_SoundStreamParameterValueBase,
NX_SoundStreamDataEncoding_Linear8,
NX_SoundStreamDataEncoding_Mulaw8,
NX_SoundStreamDataEncoding_Alaw8,
NX_SoundStreamDataEncoding_AES,
NX_SoundStreamSource_Analog,
NX_SoundStreamSource_AES,
NX_SoundStreamSink_Analog,
NX_SoundStreamSink_AES
} NXSoundParameterTag;
//========================================================================
//#include "NTSound.h"
#include <mach/mach_types.h>
#include <mach/message.h>
#include <mach/mig_errors.h>
#include <mach/msg_type.h>
#if !defined(KERNEL) && !defined(MIG_NO_STRINGS)
#include <strings.h>
#endif
/* LINTLIBRARY */
extern port_t mig_get_reply_port();
extern void mig_dealloc_reply_port();
#ifndef mig_internal
#define mig_internal static
#endif
#ifndef TypeCheck
#define TypeCheck 1
#endif
#ifndef UseExternRCSId
#ifdef hc
#define UseExternRCSId 1
#endif
#endif
#ifndef UseStaticMsgType
#if !defined(hc) || defined(__STDC__)
#define UseStaticMsgType 1
#endif
#endif
#define msg_request_port msg_remote_port
#define msg_reply_port msg_local_port
/* Routine Acquire */
mig_external kern_return_t ntsoundAcquire (
port_t kern_serv_port,
port_t owner_port,
vm_offset_t *dmaAddress,
int *dmaSize,
int *success)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
msg_type_t dmaAddressType;
vm_offset_t dmaAddress;
msg_type_t dmaSizeType;
int dmaSize;
msg_type_t successType;
int success;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t dmaAddressCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t dmaSizeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t successCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1008;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1108)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 56) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->dmaAddressType != * (int *) &dmaAddressCheck)
#else UseStaticMsgType
if ((OutP->dmaAddressType.msg_type_inline != TRUE) ||
(OutP->dmaAddressType.msg_type_longform != FALSE) ||
(OutP->dmaAddressType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->dmaAddressType.msg_type_number != 1) ||
(OutP->dmaAddressType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*dmaAddress /* dmaAddress */ = /* *dmaAddress */ OutP->dmaAddress;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->dmaSizeType != * (int *) &dmaSizeCheck)
#else UseStaticMsgType
if ((OutP->dmaSizeType.msg_type_inline != TRUE) ||
(OutP->dmaSizeType.msg_type_longform != FALSE) ||
(OutP->dmaSizeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->dmaSizeType.msg_type_number != 1) ||
(OutP->dmaSizeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*dmaSize /* dmaSize */ = /* *dmaSize */ OutP->dmaSize;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->successType != * (int *) &successCheck)
#else UseStaticMsgType
if ((OutP->successType.msg_type_inline != TRUE) ||
(OutP->successType.msg_type_longform != FALSE) ||
(OutP->successType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->successType.msg_type_number != 1) ||
(OutP->successType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*success /* success */ = /* *success */ OutP->success;
return OutP->RetCode;
}
/* Routine Release */
mig_external kern_return_t ntsoundRelease (
port_t kern_serv_port,
port_t owner_port)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1009;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1109)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 32) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
return OutP->RetCode;
}
/* Routine Start */
mig_external kern_return_t ntsoundStart (
port_t kern_serv_port,
port_t owner_port)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1010;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1110)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 32) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
return OutP->RetCode;
}
/* Routine Stop */
mig_external kern_return_t ntsoundStop (
port_t kern_serv_port,
port_t owner_port)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1011;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1111)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 32) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
return OutP->RetCode;
}
/* Routine Config */
mig_external kern_return_t ntsoundConfig (
port_t kern_serv_port,
port_t owner_port,
int channelCount,
int samplingRate,
int encoding,
int useInterrupts)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
msg_type_t channelCountType;
int channelCount;
msg_type_t samplingRateType;
int samplingRate;
msg_type_t encodingType;
int encoding;
msg_type_t useInterruptsType;
int useInterrupts;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 64;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t channelCountType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t samplingRateType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t encodingType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t useInterruptsType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
#if UseStaticMsgType
InP->channelCountType = channelCountType;
#else UseStaticMsgType
InP->channelCountType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->channelCountType.msg_type_size = 32;
InP->channelCountType.msg_type_number = 1;
InP->channelCountType.msg_type_inline = TRUE;
InP->channelCountType.msg_type_longform = FALSE;
InP->channelCountType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->channelCount /* channelCount */ = /* channelCount */ channelCount;
#if UseStaticMsgType
InP->samplingRateType = samplingRateType;
#else UseStaticMsgType
InP->samplingRateType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->samplingRateType.msg_type_size = 32;
InP->samplingRateType.msg_type_number = 1;
InP->samplingRateType.msg_type_inline = TRUE;
InP->samplingRateType.msg_type_longform = FALSE;
InP->samplingRateType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->samplingRate /* samplingRate */ = /* samplingRate */ samplingRate;
#if UseStaticMsgType
InP->encodingType = encodingType;
#else UseStaticMsgType
InP->encodingType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->encodingType.msg_type_size = 32;
InP->encodingType.msg_type_number = 1;
InP->encodingType.msg_type_inline = TRUE;
InP->encodingType.msg_type_longform = FALSE;
InP->encodingType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->encoding /* encoding */ = /* encoding */ encoding;
#if UseStaticMsgType
InP->useInterruptsType = useInterruptsType;
#else UseStaticMsgType
InP->useInterruptsType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->useInterruptsType.msg_type_size = 32;
InP->useInterruptsType.msg_type_number = 1;
InP->useInterruptsType.msg_type_inline = TRUE;
InP->useInterruptsType.msg_type_longform = FALSE;
InP->useInterruptsType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->useInterrupts /* useInterrupts */ = /* useInterrupts */ useInterrupts;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1012;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1112)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 32) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
return OutP->RetCode;
}
/* Routine BytesProcessed */
mig_external kern_return_t ntsoundBytesProcessed (
port_t kern_serv_port,
port_t owner_port,
int *byte_count)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
msg_type_t byte_countType;
int byte_count;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t byte_countCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1013;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1113)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 40) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->byte_countType != * (int *) &byte_countCheck)
#else UseStaticMsgType
if ((OutP->byte_countType.msg_type_inline != TRUE) ||
(OutP->byte_countType.msg_type_longform != FALSE) ||
(OutP->byte_countType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->byte_countType.msg_type_number != 1) ||
(OutP->byte_countType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*byte_count /* byte_count */ = /* *byte_count */ OutP->byte_count;
return OutP->RetCode;
}
/* Routine DMACount */
mig_external kern_return_t ntsoundDMACount (
port_t kern_serv_port,
port_t owner_port,
int *dma_count)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
msg_type_t dma_countType;
int dma_count;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t dma_countCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1014;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1114)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 40) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->dma_countType != * (int *) &dma_countCheck)
#else UseStaticMsgType
if ((OutP->dma_countType.msg_type_inline != TRUE) ||
(OutP->dma_countType.msg_type_longform != FALSE) ||
(OutP->dma_countType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->dma_countType.msg_type_number != 1) ||
(OutP->dma_countType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*dma_count /* dma_count */ = /* *dma_count */ OutP->dma_count;
return OutP->RetCode;
}
/* Routine InterruptCount */
mig_external kern_return_t ntsoundInterruptCount (
port_t kern_serv_port,
port_t owner_port,
int *irq_count)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
msg_type_t irq_countType;
int irq_count;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 32;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t irq_countCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1015;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1115)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 40) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->irq_countType != * (int *) &irq_countCheck)
#else UseStaticMsgType
if ((OutP->irq_countType.msg_type_inline != TRUE) ||
(OutP->irq_countType.msg_type_longform != FALSE) ||
(OutP->irq_countType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->irq_countType.msg_type_number != 1) ||
(OutP->irq_countType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*irq_count /* irq_count */ = /* *irq_count */ OutP->irq_count;
return OutP->RetCode;
}
/* Routine Write */
mig_external kern_return_t ntsoundWrite (
port_t kern_serv_port,
port_t owner_port,
sound_data_t data,
unsigned int dataCnt,
int *actual_count)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
msg_type_long_t dataType;
short data[7000];
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
msg_type_t actual_countType;
int actual_count;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 44;
/* Maximum request size 14044 */
unsigned int msg_size_delta;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_long_t dataType = {
{
/* msg_type_name = */ 0,
/* msg_type_size = */ 0,
/* msg_type_number = */ 0,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ TRUE,
/* msg_type_deallocate = */ FALSE,
},
/* msg_type_long_name = */ MSG_TYPE_INTEGER_16,
/* msg_type_long_size = */ 16,
/* msg_type_long_number = */ 7000,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t actual_countCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
#if UseStaticMsgType
InP->dataType = dataType;
#else UseStaticMsgType
InP->dataType.msg_type_long_name = MSG_TYPE_INTEGER_16;
InP->dataType.msg_type_long_size = 16;
InP->dataType.msg_type_header.msg_type_inline = TRUE;
InP->dataType.msg_type_header.msg_type_longform = TRUE;
InP->dataType.msg_type_header.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
if (dataCnt > 7000)
return MIG_ARRAY_TOO_LARGE;
bcopy((char *) data, (char *) InP->data, 2 * dataCnt);
InP->dataType.msg_type_long_number /* dataCnt */ = /* dataType.msg_type_long_number */ dataCnt;
msg_size_delta = (2 * dataCnt + 3) & ~3;
msg_size += msg_size_delta;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1016;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1116)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 40) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->actual_countType != * (int *) &actual_countCheck)
#else UseStaticMsgType
if ((OutP->actual_countType.msg_type_inline != TRUE) ||
(OutP->actual_countType.msg_type_longform != FALSE) ||
(OutP->actual_countType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->actual_countType.msg_type_number != 1) ||
(OutP->actual_countType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
*actual_count /* actual_count */ = /* *actual_count */ OutP->actual_count;
return OutP->RetCode;
}
/* Routine SetVolume */
mig_external kern_return_t ntsoundSetVolume (
port_t kern_serv_port,
port_t owner_port,
int value)
{
typedef struct {
msg_header_t Head;
msg_type_t owner_portType;
port_t owner_port;
msg_type_t valueType;
int value;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 40;
#if UseStaticMsgType
static const msg_type_t owner_portType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t valueType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->owner_portType = owner_portType;
#else UseStaticMsgType
InP->owner_portType.msg_type_name = MSG_TYPE_PORT;
InP->owner_portType.msg_type_size = 32;
InP->owner_portType.msg_type_number = 1;
InP->owner_portType.msg_type_inline = TRUE;
InP->owner_portType.msg_type_longform = FALSE;
InP->owner_portType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->owner_port /* owner_port */ = /* owner_port */ owner_port;
#if UseStaticMsgType
InP->valueType = valueType;
#else UseStaticMsgType
InP->valueType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->valueType.msg_type_size = 32;
InP->valueType.msg_type_number = 1;
InP->valueType.msg_type_inline = TRUE;
InP->valueType.msg_type_longform = FALSE;
InP->valueType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->value /* value */ = /* value */ value;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = kern_serv_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1017;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1117)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 32) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
return OutP->RetCode;
}
/* Routine WireRange */
mig_external kern_return_t ntsoundWireRange (
port_t device_port,
port_t token,
port_t task,
vm_offset_t addr,
vm_size_t size,
boolean_t wire)
{
typedef struct {
msg_header_t Head;
msg_type_t tokenType;
port_t token;
msg_type_t taskType;
port_t task;
msg_type_t addrType;
vm_offset_t addr;
msg_type_t sizeType;
vm_size_t size;
msg_type_t wireType;
boolean_t wire;
} Request;
typedef struct {
msg_header_t Head;
msg_type_t RetCodeType;
kern_return_t RetCode;
} Reply;
union {
Request In;
Reply Out;
} Mess;
register Request *InP = &Mess.In;
register Reply *OutP = &Mess.Out;
msg_return_t msg_result;
#if TypeCheck
boolean_t msg_simple;
#endif TypeCheck
unsigned int msg_size = 64;
#if UseStaticMsgType
static const msg_type_t tokenType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t taskType = {
/* msg_type_name = */ MSG_TYPE_PORT,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t addrType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t sizeType = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t wireType = {
/* msg_type_name = */ MSG_TYPE_BOOLEAN,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0,
};
#endif UseStaticMsgType
#if UseStaticMsgType
static const msg_type_t RetCodeCheck = {
/* msg_type_name = */ MSG_TYPE_INTEGER_32,
/* msg_type_size = */ 32,
/* msg_type_number = */ 1,
/* msg_type_inline = */ TRUE,
/* msg_type_longform = */ FALSE,
/* msg_type_deallocate = */ FALSE,
/* msg_type_unused = */ 0
};
#endif UseStaticMsgType
#if UseStaticMsgType
InP->tokenType = tokenType;
#else UseStaticMsgType
InP->tokenType.msg_type_name = MSG_TYPE_PORT;
InP->tokenType.msg_type_size = 32;
InP->tokenType.msg_type_number = 1;
InP->tokenType.msg_type_inline = TRUE;
InP->tokenType.msg_type_longform = FALSE;
InP->tokenType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->token /* token */ = /* token */ token;
#if UseStaticMsgType
InP->taskType = taskType;
#else UseStaticMsgType
InP->taskType.msg_type_name = MSG_TYPE_PORT;
InP->taskType.msg_type_size = 32;
InP->taskType.msg_type_number = 1;
InP->taskType.msg_type_inline = TRUE;
InP->taskType.msg_type_longform = FALSE;
InP->taskType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->task /* task */ = /* task */ task;
#if UseStaticMsgType
InP->addrType = addrType;
#else UseStaticMsgType
InP->addrType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->addrType.msg_type_size = 32;
InP->addrType.msg_type_number = 1;
InP->addrType.msg_type_inline = TRUE;
InP->addrType.msg_type_longform = FALSE;
InP->addrType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->addr /* addr */ = /* addr */ addr;
#if UseStaticMsgType
InP->sizeType = sizeType;
#else UseStaticMsgType
InP->sizeType.msg_type_name = MSG_TYPE_INTEGER_32;
InP->sizeType.msg_type_size = 32;
InP->sizeType.msg_type_number = 1;
InP->sizeType.msg_type_inline = TRUE;
InP->sizeType.msg_type_longform = FALSE;
InP->sizeType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->size /* size */ = /* size */ size;
#if UseStaticMsgType
InP->wireType = wireType;
#else UseStaticMsgType
InP->wireType.msg_type_name = MSG_TYPE_BOOLEAN;
InP->wireType.msg_type_size = 32;
InP->wireType.msg_type_number = 1;
InP->wireType.msg_type_inline = TRUE;
InP->wireType.msg_type_longform = FALSE;
InP->wireType.msg_type_deallocate = FALSE;
#endif UseStaticMsgType
InP->wire /* wire */ = /* wire */ wire;
InP->Head.msg_simple = FALSE;
InP->Head.msg_size = msg_size;
InP->Head.msg_type = MSG_TYPE_NORMAL | MSG_TYPE_RPC;
InP->Head.msg_request_port = device_port;
InP->Head.msg_reply_port = mig_get_reply_port();
InP->Head.msg_id = 1018;
msg_result = msg_rpc(&InP->Head, MSG_OPTION_NONE, sizeof(Reply), 0, 0);
if (msg_result != RPC_SUCCESS) {
if (msg_result == RCV_INVALID_PORT)
mig_dealloc_reply_port();
return msg_result;
}
#if TypeCheck
msg_size = OutP->Head.msg_size;
msg_simple = OutP->Head.msg_simple;
#endif TypeCheck
if (OutP->Head.msg_id != 1118)
return MIG_REPLY_MISMATCH;
#if TypeCheck
if (((msg_size != 32) || (msg_simple != TRUE)) &&
((msg_size != sizeof(death_pill_t)) ||
(msg_simple != TRUE) ||
(OutP->RetCode == KERN_SUCCESS)))
return MIG_TYPE_ERROR;
#endif TypeCheck
#if TypeCheck
#if UseStaticMsgType
if (* (int *) &OutP->RetCodeType != * (int *) &RetCodeCheck)
#else UseStaticMsgType
if ((OutP->RetCodeType.msg_type_inline != TRUE) ||
(OutP->RetCodeType.msg_type_longform != FALSE) ||
(OutP->RetCodeType.msg_type_name != MSG_TYPE_INTEGER_32) ||
(OutP->RetCodeType.msg_type_number != 1) ||
(OutP->RetCodeType.msg_type_size != 32))
#endif UseStaticMsgType
return MIG_TYPE_ERROR;
#endif TypeCheck
if (OutP->RetCode != KERN_SUCCESS)
return OutP->RetCode;
return OutP->RetCode;
}
//========================================================================
/*
==================
SNDDMA_Init
Try to find a sound device to mix for.
Returns false if nothing is found.
==================
*/
qboolean SNDDMA_Init(void)
{
int err;
int i;
byte *buf;
int bufsize;
int progress, oldprogress;
shm = &sn;
shm->channels = 2;
shm->samplebits = 16;
shm->speed = 11025;
err = netname_look_up(name_server_port,"", NTSOUNDNAME,&devPort);
if (err)
{
Com_Printf("SNDDMA_Init: Cannot access theater driver\n");
return false;
}
err = ntsoundAcquire(devPort,task_self(),(vm_offset_t *)&buf,&bufsize,&i);
if (err || !i)
{
Com_Printf("SNDDMA_Init: Sound driver is busy or messed up\n");
return false;
}
err = ntsoundConfig(devPort,task_self(),shm->channels,(int)shm->speed,
NX_SoundStreamDataEncoding_Linear16, 1);
if (err)
{
Com_Printf("SNDDMA_Init: ntsoundConfig error: %d\n",err);
return false;
}
else
Com_Printf("SNDDMA_Init: Configured for %d Hz, %d channels\n"
,(int)shm->speed,shm->channels);
// printf ("buf: 0x%x\n", buf);
// printf ("bufsize: %d\n", bufsize);
bzero(buf,bufsize);
// ntsoundSetVolume(devPort,task_self(),5);
ntsoundStart(devPort,task_self());
shm->soundalive = true;
shm->splitbuffer = false;
shm->samples = bufsize/(shm->samplebits/8);
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = buf;
//
// find a buffer crossing point for pos testing
//
ntsoundBytesProcessed(devPort,task_self(),&oldprogress);
do
{
ntsoundBytesProcessed(devPort,task_self(),&progress);
} while (progress == oldprogress);
snd_basetime = Sys_DoubleTime() - progress/(11025*2);
return true;
}
/*
==============
SNDDMA_GetDMAPos
return the current sample position (in mono samples read)
inside the recirculating dma buffer, so the mixing code will know
how many sample are required to fill it up.
===============
*/
int SNDDMA_GetDMAPos(void)
{
int progress;
#if 0
ntsoundBytesProcessed(devPort,task_self(),&progress);
// ntsoundDMACount(devPort,task_self(),&progress);
//printf ("(%i / %f) ", progress, (float)(Sys_DoubleTime ()));
progress += 2048;
progress >>= 1;
#else
progress = (Sys_DoubleTime() - snd_basetime)*11025*2;
progress += 8192;
progress &= ~1;
#endif
progress &= (shm->samples-1);
return progress;
}
/*
==============
SNDDMA_Submit
Reset the sound device for exiting
===============
*/
void SNDDMA_Submit(void)
{
}
/*
==============
SNDDMA_Shutdown
Reset the sound device for exiting
===============
*/
void SNDDMA_Shutdown(void)
{
ntsoundStop(devPort,task_self());
ntsoundRelease(devPort,task_self());
}