]> git.pld-linux.org Git - packages/audacity.git/blame - portaudio_asihpi_406.patch
projects / packages / audacity.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- polished (removed just created memleak)
[packages/audacity.git] / portaudio_asihpi_406.patch
CommitLineData
0b5e52e1
JB		 1Index: src/hostapi/asihpi/pa_linux_asihpi.c
2===================================================================
3--- src/hostapi/asihpi/pa_linux_asihpi.c (revision 1645)
4+++ src/hostapi/asihpi/pa_linux_asihpi.c (working copy)
5@@ -193,7 +193,7 @@
6 /** Check return value of HPI function, and map it to PaError */
7 #define PA_ASIHPI_UNLESS_(expr, paError) \
8 do { \
9- HW16 hpiError = (expr); \
10+ hpi_err_t hpiError = (expr); \
11 /* If HPI error occurred */ \
12 if( UNLIKELY( hpiError ) ) \
13 { \
14@@ -265,8 +265,6 @@
15 /* implementation specific data goes here */
16
17 PaHostApiIndex hostApiIndex;
18- /** HPI subsystem pointer */
19- HPI_HSUBSYS *subSys;
20 }
21 PaAsiHpiHostApiRepresentation;
22
23@@ -280,20 +278,18 @@
24
25 /* implementation specific data goes here */
26
27- /** HPI subsystem (required for most HPI calls) */
28- HPI_HSUBSYS *subSys;
29 /** Adapter index */
30- HW16 adapterIndex;
31+ uint16_t adapterIndex;
32 /** Adapter model number (hex) */
33- HW16 adapterType;
34+ uint16_t adapterType;
35 /** Adapter HW/SW version */
36- HW16 adapterVersion;
37+ uint16_t adapterVersion;
38 /** Adapter serial number */
39- HW32 adapterSerialNumber;
40+ uint32_t adapterSerialNumber;
41 /** Stream number */
42- HW16 streamIndex;
43+ uint16_t streamIndex;
44 /** 0=Input, 1=Output (HPI streams are either input or output but not both) */
45- HW16 streamIsOutput;
46+ uint16_t streamIsOutput;
47 }
48 PaAsiHpiDeviceInfo;
49
50@@ -328,27 +324,25 @@
51 {
52 /** Device information (HPI handles, etc) */
53 PaAsiHpiDeviceInfo *hpiDevice;
54- /** Stream handle, as passed to HPI interface.
55- HACK: we assume types HPI_HISTREAM and HPI_HOSTREAM are the same...
56- (both are HW32 up to version 3.00 of ASIHPI, and hopefully they stay that way) */
57- HPI_HISTREAM hpiStream;
58+ /** Stream handle, as passed to HPI interface. */
59+ hpi_handle_t hpiStream;
60 /** Stream format, as passed to HPI interface */
61- HPI_FORMAT hpiFormat;
62+ struct hpi_format hpiFormat;
63 /** Number of bytes per frame, derived from hpiFormat and saved for convenience */
64- HW32 bytesPerFrame;
65+ uint32_t bytesPerFrame;
66 /** Size of hardware (on-card) buffer of stream in bytes */
67- HW32 hardwareBufferSize;
68+ uint32_t hardwareBufferSize;
69 /** Size of host (BBM) buffer of stream in bytes (if used) */
70- HW32 hostBufferSize;
71+ uint32_t hostBufferSize;
72 /** Upper limit on the utilization of output stream buffer (both hardware and host).
73 This prevents large latencies in an output-only stream with a potentially huge buffer
74 and a fast data generator, which would otherwise keep the hardware buffer filled to
75 capacity. See also the "Hardware Buffering=off" option in the AudioScience WAV driver. */
76- HW32 outputBufferCap;
77+ uint32_t outputBufferCap;
78 /** Sample buffer (halfway station between HPI and buffer processor) */
79- HW8 *tempBuffer;
80+ uint8_t *tempBuffer;
81 /** Sample buffer size, in bytes */
82- HW32 tempBufferSize;
83+ uint32_t tempBufferSize;
84 }
85 PaAsiHpiStreamComponent;
86
87@@ -369,7 +363,7 @@
88 PaAsiHpiStreamComponent *input, *output;
89
90 /** Polling interval (in milliseconds) */
91- HW32 pollingInterval;
92+ uint32_t pollingInterval;
93 /** Are we running in callback mode? */
94 int callbackMode;
95 /** Number of frames to transfer at a time to/from HPI */
96@@ -401,23 +395,23 @@
97 typedef struct PaAsiHpiStreamInfo
98 {
99 /** HPI stream state (HPI_STATE_STOPPED, HPI_STATE_PLAYING, etc.) */
100- HW16 state;
101+ uint16_t state;
102 /** Size (in bytes) of recording/playback data buffer in HPI driver */
103- HW32 bufferSize;
104+ uint32_t bufferSize;
105 /** Amount of data (in bytes) available in the buffer */
106- HW32 dataSize;
107+ uint32_t dataSize;
108 /** Number of frames played/recorded since last stream reset */
109- HW32 frameCounter;
110+ uint32_t frameCounter;
111 /** Amount of data (in bytes) in hardware (on-card) buffer.
112 This differs from dataSize if bus mastering (BBM) is used, which introduces another
113 driver-level buffer to which dataSize/bufferSize then refers. */
114- HW32 auxDataSize;
115+ uint32_t auxDataSize;
116 /** Total number of data frames currently buffered by HPI driver (host + hw buffers) */
117- HW32 totalBufferedData;
118+ uint32_t totalBufferedData;
119 /** Size of immediately available data (for input) or space (for output) in frames.
120 This only checks the first-level buffer (typically host buffer). This amount can be
121 transferred immediately. */
122- HW32 availableFrames;
123+ uint32_t availableFrames;
124 /** Indicates that hardware buffer is getting too full */
125 int overflow;
126 /** Indicates that hardware buffer is getting too empty */
127@@ -479,21 +473,21 @@
128
129 /* Functions specific to this API */
130 static PaError PaAsiHpi_BuildDeviceList( PaAsiHpiHostApiRepresentation *hpiHostApi );
131-static HW16 PaAsiHpi_PaToHpiFormat( PaSampleFormat paFormat );
132-static PaSampleFormat PaAsiHpi_HpiToPaFormat( HW16 hpiFormat );
133+static uint16_t PaAsiHpi_PaToHpiFormat( PaSampleFormat paFormat );
134+static PaSampleFormat PaAsiHpi_HpiToPaFormat( uint16_t hpiFormat );
135 static PaError PaAsiHpi_CreateFormat( struct PaUtilHostApiRepresentation *hostApi,
136 const PaStreamParameters *parameters, double sampleRate,
137- PaAsiHpiDeviceInfo **hpiDevice, HPI_FORMAT *hpiFormat );
138+ PaAsiHpiDeviceInfo **hpiDevice, struct hpi_format *hpiFormat );
139 static PaError PaAsiHpi_OpenInput( struct PaUtilHostApiRepresentation *hostApi,
140- const PaAsiHpiDeviceInfo *hpiDevice, const HPI_FORMAT *hpiFormat,
141- HPI_HISTREAM *hpiStream );
142+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
143+ hpi_handle_t *hpiStream );
144 static PaError PaAsiHpi_OpenOutput( struct PaUtilHostApiRepresentation *hostApi,
145- const PaAsiHpiDeviceInfo *hpiDevice, const HPI_FORMAT *hpiFormat,
146- HPI_HOSTREAM *hpiStream );
147+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
148+ hpi_handle_t *hpiStream );
149 static PaError PaAsiHpi_GetStreamInfo( PaAsiHpiStreamComponent *streamComp, PaAsiHpiStreamInfo *info );
150 static void PaAsiHpi_StreamComponentDump( PaAsiHpiStreamComponent *streamComp, PaAsiHpiStream *stream );
151 static void PaAsiHpi_StreamDump( PaAsiHpiStream *stream );
152-static PaError PaAsiHpi_SetupBuffers( PaAsiHpiStreamComponent *streamComp, HW32 pollingInterval,
153+static PaError PaAsiHpi_SetupBuffers( PaAsiHpiStreamComponent *streamComp, uint32_t pollingInterval,
154 unsigned long framesPerPaHostBuffer, PaTime suggestedLatency );
155 static PaError PaAsiHpi_PrimeOutputWithSilence( PaAsiHpiStream *stream );
156 static PaError PaAsiHpi_StartStream( PaAsiHpiStream *stream, int outputPrimed );
157@@ -529,42 +523,40 @@
158 PaUtilHostApiRepresentation *hostApi = &hpiHostApi->baseHostApiRep;
159 PaHostApiInfo *baseApiInfo = &hostApi->info;
160 PaAsiHpiDeviceInfo *hpiDeviceList;
161- HW16 adapterList[ HPI_MAX_ADAPTERS ];
162- HW16 numAdapters;
163- HW16 hpiError = 0;
164+ int numAdapters;
165+ hpi_err_t hpiError = 0;
166 int i, j, deviceCount = 0, deviceIndex = 0;
167
168 assert( hpiHostApi );
169- assert( hpiHostApi->subSys );
170
171 /* Look for adapters (not strictly necessary, as AdapterOpen can do the same, but this */
172 /* way we have less errors since we do not try to open adapters we know aren't there) */
173 /* Errors not considered critical here (subsystem may report 0 devices), but report them */
174 /* in debug mode. */
175- PA_ASIHPI_UNLESS_( HPI_SubSysFindAdapters( hpiHostApi->subSys, &numAdapters,
176- adapterList, HPI_MAX_ADAPTERS ), paNoError );
177+ PA_ASIHPI_UNLESS_( HPI_SubSysGetNumAdapters( NULL, &numAdapters), paNoError );
178
179 /* First open and count the number of devices (= number of streams), to ease memory allocation */
180- for( i=0; i < HPI_MAX_ADAPTERS; ++i )
181+ for( i=0; i < numAdapters; ++i )
182 {
183- HW16 inStreams, outStreams;
184- HW16 version;
185- HW32 serial;
186- HW16 type;
187+ uint16_t inStreams, outStreams;
188+ uint16_t version;
189+ uint32_t serial;
190+ uint16_t type;
191+ uint32_t idx;
192
193- /* If no adapter found at this index, skip it */
194- if( adapterList[i] == 0 )
195+ hpiError = HPI_SubSysGetAdapter(NULL, i, &idx, &type);
196+ if (hpiError)
197 continue;
198
199 /* Try to open adapter */
200- hpiError = HPI_AdapterOpen( hpiHostApi->subSys, i );
201+ hpiError = HPI_AdapterOpen( NULL, idx );
202 /* Report error and skip to next device on failure */
203 if( hpiError )
204 {
205 PA_ASIHPI_REPORT_ERROR_( hpiError );
206 continue;
207 }
208- hpiError = HPI_AdapterGetInfo( hpiHostApi->subSys, i,
209+ hpiError = HPI_AdapterGetInfo( NULL, idx,
210 &outStreams, &inStreams, &version, &serial, &type );
211 /* Skip to next device on failure */
212 if( hpiError )
213@@ -597,19 +589,20 @@
214 paInsufficientMemory );
215
216 /* Now query devices again for information */
217- for( i=0; i < HPI_MAX_ADAPTERS; ++i )
218+ for( i=0; i < numAdapters; ++i )
219 {
220- HW16 inStreams, outStreams;
221- HW16 version;
222- HW32 serial;
223- HW16 type;
224+ uint16_t inStreams, outStreams;
225+ uint16_t version;
226+ uint32_t serial;
227+ uint16_t type;
228+ uint32_t idx;
229
230- /* If no adapter found at this index, skip it */
231- if( adapterList[i] == 0 )
232+ hpiError = HPI_SubSysGetAdapter(NULL, i, &idx, &type);
233+ if (hpiError)
234 continue;
235
236 /* Assume adapter is still open from previous round */
237- hpiError = HPI_AdapterGetInfo( hpiHostApi->subSys, i,
238+ hpiError = HPI_AdapterGetInfo( NULL, idx,
239 &outStreams, &inStreams, &version, &serial, &type );
240 /* Report error and skip to next device on failure */
241 if( hpiError )
242@@ -620,7 +613,7 @@
243 else
244 {
245 PA_DEBUG(( "Found HPI Adapter ID=%4X Idx=%d #In=%d #Out=%d S/N=%d HWver=%c%d DSPver=%03d\n",
246- type, i, inStreams, outStreams, serial,
247+ type, idx, inStreams, outStreams, serial,
248 ((version>>3)&0xf)+'A', /* Hw version major */
249 version&0x7, /* Hw version minor */
250 ((version>>13)*100)+((version>>7)&0x3f) /* DSP code version */
251@@ -637,8 +630,7 @@
252
253 memset( hpiDevice, 0, sizeof(PaAsiHpiDeviceInfo) );
254 /* Set implementation-specific device details */
255- hpiDevice->subSys = hpiHostApi->subSys;
256- hpiDevice->adapterIndex = i;
257+ hpiDevice->adapterIndex = idx;
258 hpiDevice->adapterType = type;
259 hpiDevice->adapterVersion = version;
260 hpiDevice->adapterSerialNumber = serial;
261@@ -680,8 +672,7 @@
262
263 memset( hpiDevice, 0, sizeof(PaAsiHpiDeviceInfo) );
264 /* Set implementation-specific device details */
265- hpiDevice->subSys = hpiHostApi->subSys;
266- hpiDevice->adapterIndex = i;
267+ hpiDevice->adapterIndex = idx;
268 hpiDevice->adapterType = type;
269 hpiDevice->adapterVersion = version;
270 hpiDevice->adapterSerialNumber = serial;
a1c9d4d0 271@@ -746,25 +737,25 @@
0b5e52e1
JB		 272 PA_UNLESS_( hpiHostApi->allocations = PaUtil_CreateAllocationGroup(), paInsufficientMemory );
273
274 hpiHostApi->hostApiIndex = hostApiIndex;
275- hpiHostApi->subSys = NULL;
276
277 /* Try to initialize HPI subsystem */
278- if( ( hpiHostApi->subSys = HPI_SubSysCreate() ) == NULL)
279+ if(HPI_SubSysCreate() == NULL)
280 {
281 /* the V19 development docs say that if an implementation
282 * detects that it cannot be used, it should return a NULL
046e67a4
SS		 283 * interface and paNoError */
284 PA_DEBUG(( "Could not open HPI interface\n" ));
285 result = paNoError;
a1c9d4d0
SS		 286 *hostApi = NULL;
287+ (&hpiHostApi->baseHostApiRep)->info.deviceCount = 0;
046e67a4 288 goto error;
0b5e52e1
JB		 289 }
290 else
291 {
292- HW32 hpiVersion;
293- PA_ASIHPI_UNLESS_( HPI_SubSysGetVersion( hpiHostApi->subSys, &hpiVersion ), paUnanticipatedHostError );
294- PA_DEBUG(( "HPI interface v%d.%02d\n",
295- hpiVersion >> 8, 10*((hpiVersion & 0xF0) >> 4) + (hpiVersion & 0x0F) ));
296+ uint32_t hpiVersion;
297+ PA_ASIHPI_UNLESS_( HPI_SubSysGetVersionEx( NULL, &hpiVersion ), paUnanticipatedHostError );
298+ PA_DEBUG(( "HPI interface v%d.%02d.%02d\n",
299+ hpiVersion >> 16, (hpiVersion >> 8) & 0x0F, (hpiVersion & 0x0F) ));
300 }
301
302 *hostApi = &hpiHostApi->baseHostApiRep;
303@@ -820,25 +810,22 @@
304 if( hpiHostApi )
305 {
306 /* Get rid of HPI-specific structures */
307- if( hpiHostApi->subSys )
308+ uint16_t lastAdapterIndex = HPI_MAX_ADAPTERS;
309+ /* Iterate through device list and close adapters */
310+ for( i=0; i < hostApi->info.deviceCount; ++i )
311 {
312- HW16 lastAdapterIndex = HPI_MAX_ADAPTERS;
313- /* Iterate through device list and close adapters */
314- for( i=0; i < hostApi->info.deviceCount; ++i )
315+ PaAsiHpiDeviceInfo *hpiDevice = (PaAsiHpiDeviceInfo *) hostApi->deviceInfos[ i ];
316+ /* Close adapter only if it differs from previous one */
317+ if( hpiDevice->adapterIndex != lastAdapterIndex )
318 {
319- PaAsiHpiDeviceInfo *hpiDevice = (PaAsiHpiDeviceInfo *) hostApi->deviceInfos[ i ];
320- /* Close adapter only if it differs from previous one */
321- if( hpiDevice->adapterIndex != lastAdapterIndex )
322- {
323- /* Ignore errors (report only during debugging) */
324- PA_ASIHPI_UNLESS_( HPI_AdapterClose( hpiHostApi->subSys,
325- hpiDevice->adapterIndex ), paNoError );
326- lastAdapterIndex = hpiDevice->adapterIndex;
327- }
328+ /* Ignore errors (report only during debugging) */
329+ PA_ASIHPI_UNLESS_( HPI_AdapterClose( NULL,
330+ hpiDevice->adapterIndex ), paNoError );
331+ lastAdapterIndex = hpiDevice->adapterIndex;
332 }
333- /* Finally dismantle HPI subsystem */
334- HPI_SubSysFree( hpiHostApi->subSys );
335 }
336+ /* Finally dismantle HPI subsystem */
337+ HPI_SubSysFree( NULL );
338
339 if( hpiHostApi->allocations )
340 {
341@@ -859,7 +846,7 @@
342
343 @return HPI sample format
344 */
345-static HW16 PaAsiHpi_PaToHpiFormat( PaSampleFormat paFormat )
346+static uint16_t PaAsiHpi_PaToHpiFormat( PaSampleFormat paFormat )
347 {
348 /* Ignore interleaving flag */
349 switch( paFormat & ~paNonInterleaved )
350@@ -893,7 +880,7 @@
351
352 @return PortAudio sample format
353 */
354-static PaSampleFormat PaAsiHpi_HpiToPaFormat( HW16 hpiFormat )
355+static PaSampleFormat PaAsiHpi_HpiToPaFormat( uint16_t hpiFormat )
356 {
357 switch( hpiFormat )
358 {
359@@ -938,11 +925,11 @@
360 */
361 static PaError PaAsiHpi_CreateFormat( struct PaUtilHostApiRepresentation *hostApi,
362 const PaStreamParameters *parameters, double sampleRate,
363- PaAsiHpiDeviceInfo **hpiDevice, HPI_FORMAT *hpiFormat )
364+ PaAsiHpiDeviceInfo **hpiDevice, struct hpi_format *hpiFormat )
365 {
366 int maxChannelCount = 0;
367 PaSampleFormat hostSampleFormat = 0;
368- HW16 hpiError = 0;
369+ hpi_err_t hpiError = 0;
370
371 /* Unless alternate device specification is supported, reject the use of
372 paUseHostApiSpecificDeviceSpecification */
373@@ -979,9 +966,9 @@
374 hostSampleFormat = PaUtil_SelectClosestAvailableFormat(PA_ASIHPI_AVAILABLE_FORMATS_,
375 parameters->sampleFormat );
376 /* Setup format + info objects */
377- hpiError = HPI_FormatCreate( hpiFormat, (HW16)parameters->channelCount,
378+ hpiError = HPI_FormatCreate( hpiFormat, (uint16_t)parameters->channelCount,
379 PaAsiHpi_PaToHpiFormat( hostSampleFormat ),
380- (HW32)sampleRate, 0, 0 );
381+ (uint32_t)sampleRate, 0, 0 );
382 if( hpiError )
383 {
384 PA_ASIHPI_REPORT_ERROR_( hpiError );
385@@ -1016,25 +1003,25 @@
386 @return PortAudio error code (typically indicating a problem with stream format or device)
387 */
388 static PaError PaAsiHpi_OpenInput( struct PaUtilHostApiRepresentation *hostApi,
389- const PaAsiHpiDeviceInfo *hpiDevice, const HPI_FORMAT *hpiFormat,
390- HPI_HISTREAM *hpiStream )
391+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
392+ hpi_handle_t *hpiStream )
393 {
394 PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
395 PaError result = paNoError;
396- HW16 hpiError = 0;
397+ hpi_err_t hpiError = 0;
398
399 /* Catch misplaced output devices, as they typically have 0 input channels */
400 PA_UNLESS_( !hpiDevice->streamIsOutput, paInvalidChannelCount );
401 /* Try to open input stream */
402- PA_ASIHPI_UNLESS_( HPI_InStreamOpen( hpiHostApi->subSys, hpiDevice->adapterIndex,
403+ PA_ASIHPI_UNLESS_( HPI_InStreamOpen( NULL, hpiDevice->adapterIndex,
404 hpiDevice->streamIndex, hpiStream ), paDeviceUnavailable );
405 /* Set input format (checking it in the process) */
406 /* Could also use HPI_InStreamQueryFormat, but this economizes the process */
407- hpiError = HPI_InStreamSetFormat( hpiHostApi->subSys, *hpiStream, (HPI_FORMAT*)hpiFormat );
408+ hpiError = HPI_InStreamSetFormat( NULL, *hpiStream, (struct hpi_format*)hpiFormat );
409 if( hpiError )
410 {
411 PA_ASIHPI_REPORT_ERROR_( hpiError );
412- PA_ASIHPI_UNLESS_( HPI_InStreamClose( hpiHostApi->subSys, *hpiStream ), paNoError );
413+ PA_ASIHPI_UNLESS_( HPI_InStreamClose( NULL, *hpiStream ), paNoError );
414 switch( hpiError )
415 {
416 case HPI_ERROR_INVALID_FORMAT:
417@@ -1071,25 +1058,25 @@
418 @return PortAudio error code (typically indicating a problem with stream format or device)
419 */
420 static PaError PaAsiHpi_OpenOutput( struct PaUtilHostApiRepresentation *hostApi,
421- const PaAsiHpiDeviceInfo *hpiDevice, const HPI_FORMAT *hpiFormat,
422- HPI_HOSTREAM *hpiStream )
423+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
424+ hpi_handle_t *hpiStream )
425 {
426 PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
427 PaError result = paNoError;
428- HW16 hpiError = 0;
429+ hpi_err_t hpiError = 0;
430
431 /* Catch misplaced input devices, as they typically have 0 output channels */
432 PA_UNLESS_( hpiDevice->streamIsOutput, paInvalidChannelCount );
433 /* Try to open output stream */
434- PA_ASIHPI_UNLESS_( HPI_OutStreamOpen( hpiHostApi->subSys, hpiDevice->adapterIndex,
435+ PA_ASIHPI_UNLESS_( HPI_OutStreamOpen( NULL, hpiDevice->adapterIndex,
436 hpiDevice->streamIndex, hpiStream ), paDeviceUnavailable );
437
438 /* Check output format (format is set on first write to output stream) */
439- hpiError = HPI_OutStreamQueryFormat( hpiHostApi->subSys, *hpiStream, (HPI_FORMAT*)hpiFormat );
440+ hpiError = HPI_OutStreamQueryFormat( NULL, *hpiStream, (struct hpi_format*)hpiFormat );
441 if( hpiError )
442 {
443 PA_ASIHPI_REPORT_ERROR_( hpiError );
444- PA_ASIHPI_UNLESS_( HPI_OutStreamClose( hpiHostApi->subSys, *hpiStream ), paNoError );
445+ PA_ASIHPI_UNLESS_( HPI_OutStreamClose( NULL, *hpiStream ), paNoError );
446 switch( hpiError )
447 {
448 case HPI_ERROR_INVALID_FORMAT:
449@@ -1135,12 +1122,12 @@
450 PaError result = paFormatIsSupported;
451 PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
452 PaAsiHpiDeviceInfo *hpiDevice = NULL;
453- HPI_FORMAT hpiFormat;
454+ struct hpi_format hpiFormat;
455
456 /* Input stream */
457 if( inputParameters )
458 {
459- HPI_HISTREAM hpiStream;
460+ hpi_handle_t hpiStream;
461 PA_DEBUG(( "%s: Checking input params: dev=%d, sr=%d, chans=%d, fmt=%d\n",
462 __FUNCTION__, inputParameters->device, (int)sampleRate,
463 inputParameters->channelCount, inputParameters->sampleFormat ));
464@@ -1150,13 +1137,13 @@
465 /* Open stream to further check format */
466 PA_ENSURE_( PaAsiHpi_OpenInput( hostApi, hpiDevice, &hpiFormat, &hpiStream ) );
467 /* Close stream again */
468- PA_ASIHPI_UNLESS_( HPI_InStreamClose( hpiHostApi->subSys, hpiStream ), paNoError );
469+ PA_ASIHPI_UNLESS_( HPI_InStreamClose( NULL, hpiStream ), paNoError );
470 }
471
472 /* Output stream */
473 if( outputParameters )
474 {
475- HPI_HOSTREAM hpiStream;
476+ hpi_handle_t hpiStream;
477 PA_DEBUG(( "%s: Checking output params: dev=%d, sr=%d, chans=%d, fmt=%d\n",
478 __FUNCTION__, outputParameters->device, (int)sampleRate,
479 outputParameters->channelCount, outputParameters->sampleFormat ));
480@@ -1166,7 +1153,7 @@
481 /* Open stream to further check format */
482 PA_ENSURE_( PaAsiHpi_OpenOutput( hostApi, hpiDevice, &hpiFormat, &hpiStream ) );
483 /* Close stream again */
484- PA_ASIHPI_UNLESS_( HPI_OutStreamClose( hpiHostApi->subSys, hpiStream ), paNoError );
485+ PA_ASIHPI_UNLESS_( HPI_OutStreamClose( NULL, hpiStream ), paNoError );
486 }
487
488 error:
489@@ -1188,9 +1175,9 @@
490 static PaError PaAsiHpi_GetStreamInfo( PaAsiHpiStreamComponent *streamComp, PaAsiHpiStreamInfo *info )
491 {
492 PaError result = paDeviceUnavailable;
493- HW16 state;
494- HW32 bufferSize, dataSize, frameCounter, auxDataSize, threshold;
495- HW32 hwBufferSize, hwDataSize;
496+ uint16_t state;
497+ uint32_t bufferSize, dataSize, frameCounter, auxDataSize, threshold;
498+ uint32_t hwBufferSize, hwDataSize;
499
500 assert( streamComp );
501 assert( info );
502@@ -1212,14 +1199,14 @@
503 /* Obtain detailed stream info (either input or output) */
504 if( streamComp->hpiDevice->streamIsOutput )
505 {
506- PA_ASIHPI_UNLESS_( HPI_OutStreamGetInfoEx( streamComp->hpiDevice->subSys,
507+ PA_ASIHPI_UNLESS_( HPI_OutStreamGetInfoEx( NULL,
508 streamComp->hpiStream,
509 &state, &bufferSize, &dataSize, &frameCounter,
510 &auxDataSize ), paUnanticipatedHostError );
511 }
512 else
513 {
514- PA_ASIHPI_UNLESS_( HPI_InStreamGetInfoEx( streamComp->hpiDevice->subSys,
515+ PA_ASIHPI_UNLESS_( HPI_InStreamGetInfoEx( NULL,
516 streamComp->hpiStream,
517 &state, &bufferSize, &dataSize, &frameCounter,
518 &auxDataSize ), paUnanticipatedHostError );
519@@ -1479,7 +1466,7 @@
520
521 @return PortAudio error code (possibly paBufferTooBig or paInsufficientMemory)
522 */
523-static PaError PaAsiHpi_SetupBuffers( PaAsiHpiStreamComponent *streamComp, HW32 pollingInterval,
524+static PaError PaAsiHpi_SetupBuffers( PaAsiHpiStreamComponent *streamComp, uint32_t pollingInterval,
525 unsigned long framesPerPaHostBuffer, PaTime suggestedLatency )
526 {
527 PaError result = paNoError;
528@@ -1499,8 +1486,8 @@
529 /* Check if BBM (background bus mastering) is to be enabled */
530 if( PA_ASIHPI_USE_BBM_ )
531 {
532- HW32 bbmBufferSize = 0, preLatencyBufferSize = 0;
533- HW16 hpiError = 0;
534+ uint32_t bbmBufferSize = 0, preLatencyBufferSize = 0;
535+ hpi_err_t hpiError = 0;
536 PaTime pollingOverhead;
537
538 /* Check overhead of Pa_Sleep() call (minimum sleep duration in ms -> OS dependent) */
539@@ -1510,7 +1497,7 @@
540 PA_DEBUG(( "polling overhead = %f ms (length of 0-second sleep)\n", pollingOverhead ));
541 /* Obtain minimum recommended size for host buffer (in bytes) */
542 PA_ASIHPI_UNLESS_( HPI_StreamEstimateBufferSize( &streamComp->hpiFormat,
543- pollingInterval + (HW32)ceil( pollingOverhead ),
544+ pollingInterval + (uint32_t)ceil( pollingOverhead ),
545 &bbmBufferSize ), paUnanticipatedHostError );
546 /* BBM places more stringent requirements on buffer size (see description */
547 /* of HPI_StreamEstimateBufferSize in HPI API document) */
548@@ -1528,27 +1515,26 @@
549 {
550 /* Save old buffer size, to be retried if new size proves too big */
551 preLatencyBufferSize = bbmBufferSize;
552- bbmBufferSize = (HW32)ceil( suggestedLatency * streamComp->bytesPerFrame
553+ bbmBufferSize = (uint32_t)ceil( suggestedLatency * streamComp->bytesPerFrame
554 * streamComp->hpiFormat.dwSampleRate );
555 }
556 }
557 /* Choose closest memory block boundary (HPI API document states that
558 "a buffer size of Nx4096 - 20 makes the best use of memory"
559 (under the entry for HPI_StreamEstimateBufferSize)) */
560- bbmBufferSize = ((HW32)ceil((bbmBufferSize + 20)/4096.0))*4096 - 20;
561+ bbmBufferSize = ((uint32_t)ceil((bbmBufferSize + 20)/4096.0))*4096 - 20;
562 streamComp->hostBufferSize = bbmBufferSize;
563 /* Allocate BBM host buffer (this enables bus mastering transfers in background) */
564 if( streamComp->hpiDevice->streamIsOutput )
565- hpiError = HPI_OutStreamHostBufferAllocate( streamComp->hpiDevice->subSys,
566+ hpiError = HPI_OutStreamHostBufferAllocate( NULL,
567 streamComp->hpiStream,
568 bbmBufferSize );
569 else
570- hpiError = HPI_InStreamHostBufferAllocate( streamComp->hpiDevice->subSys,
571+ hpiError = HPI_InStreamHostBufferAllocate( NULL,
572 streamComp->hpiStream,
573 bbmBufferSize );
574 if( hpiError )
575 {
576- PA_ASIHPI_REPORT_ERROR_( hpiError );
577 /* Indicate that BBM is disabled */
578 streamComp->hostBufferSize = 0;
579 /* Retry with smaller buffer size (transfers will still work, but not via BBM) */
580@@ -1561,11 +1547,11 @@
581 preLatencyBufferSize, bbmBufferSize ));
582 bbmBufferSize = preLatencyBufferSize;
583 if( streamComp->hpiDevice->streamIsOutput )
584- hpiError = HPI_OutStreamHostBufferAllocate( streamComp->hpiDevice->subSys,
585+ hpiError = HPI_OutStreamHostBufferAllocate( NULL,
586 streamComp->hpiStream,
587 bbmBufferSize );
588 else
589- hpiError = HPI_InStreamHostBufferAllocate( streamComp->hpiDevice->subSys,
590+ hpiError = HPI_InStreamHostBufferAllocate( NULL,
591 streamComp->hpiStream,
592 bbmBufferSize );
593 /* Another round of error checking */
594@@ -1598,8 +1584,10 @@
595 }
596 /* If BBM not supported, foreground transfers will be used, but not a show-stopper */
597 /* Anything else is an error */
598- else if( hpiError != HPI_ERROR_INVALID_OPERATION )
599+ else if (( hpiError != HPI_ERROR_INVALID_OPERATION ) &&
600+ ( hpiError != HPI_ERROR_INVALID_FUNC ))
601 {
602+ PA_ASIHPI_REPORT_ERROR_( hpiError );
603 result = paUnanticipatedHostError;
604 goto error;
605 }
606@@ -1623,7 +1611,7 @@
607 PaTime latency = suggestedLatency > 0.0 ? suggestedLatency :
608 streamComp->hpiDevice->baseDeviceInfo.defaultHighOutputLatency;
609 streamComp->outputBufferCap =
610- (HW32)ceil( latency * streamComp->bytesPerFrame * streamComp->hpiFormat.dwSampleRate );
611+ (uint32_t)ceil( latency * streamComp->bytesPerFrame * streamComp->hpiFormat.dwSampleRate );
612 /* The cap should not be too small, to prevent underflow */
613 if( streamComp->outputBufferCap < 4*paHostBufferSize )
614 streamComp->outputBufferCap = 4*paHostBufferSize;
615@@ -1635,7 +1623,7 @@
616 /* Temp buffer size should be multiple of PA host buffer size (or 1x, if using fixed blocks) */
617 streamComp->tempBufferSize = paHostBufferSize;
618 /* Allocate temp buffer */
619- PA_UNLESS_( streamComp->tempBuffer = (HW8 *)PaUtil_AllocateMemory( streamComp->tempBufferSize ),
620+ PA_UNLESS_( streamComp->tempBuffer = (uint8_t *)PaUtil_AllocateMemory( streamComp->tempBufferSize ),
621 paInsufficientMemory );
622 error:
623 return result;
624@@ -1725,7 +1713,7 @@
625 By keeping the frames a multiple of 4, this is ensured even for 8-bit mono sound. */
626 framesPerHostBuffer = (framesPerHostBuffer / 4) * 4;
627 /* Polling is based on time length (in milliseconds) of user-requested block size */
628- stream->pollingInterval = (HW32)ceil( 1000.0*framesPerHostBuffer/sampleRate );
629+ stream->pollingInterval = (uint32_t)ceil( 1000.0*framesPerHostBuffer/sampleRate );
630 assert( framesPerHostBuffer > 0 );
631
632 /* Open underlying streams, check formats and allocate buffers */
633@@ -1890,7 +1878,7 @@
634 /* Close HPI stream (freeing BBM host buffer in the process, if used) */
635 if( stream->input->hpiStream )
636 {
637- PA_ASIHPI_UNLESS_( HPI_InStreamClose( stream->input->hpiDevice->subSys,
638+ PA_ASIHPI_UNLESS_( HPI_InStreamClose( NULL,
639 stream->input->hpiStream ), paUnanticipatedHostError );
640 }
641 /* Free temp buffer and stream component */
642@@ -1902,7 +1890,7 @@
643 /* Close HPI stream (freeing BBM host buffer in the process, if used) */
644 if( stream->output->hpiStream )
645 {
646- PA_ASIHPI_UNLESS_( HPI_OutStreamClose( stream->output->hpiDevice->subSys,
647+ PA_ASIHPI_UNLESS_( HPI_OutStreamClose( NULL,
648 stream->output->hpiStream ), paUnanticipatedHostError );
649 }
650 /* Free temp buffer and stream component */
651@@ -1933,9 +1921,6 @@
652 PaAsiHpiStreamComponent *out;
653 PaUtilZeroer *zeroer;
654 PaSampleFormat outputFormat;
655-#if (HPI_VER < HPI_VERSION_CONSTRUCTOR( 3, 5, 5 ))
656- HPI_DATA data;
657-#endif
658 assert( stream );
659 out = stream->output;
660 /* Only continue if stream has output channels */
661@@ -1944,28 +1929,19 @@
662 assert( out->tempBuffer );
663
664 /* Clear all existing data in hardware playback buffer */
665- PA_ASIHPI_UNLESS_( HPI_OutStreamReset( out->hpiDevice->subSys,
666+ PA_ASIHPI_UNLESS_( HPI_OutStreamReset( NULL,
667 out->hpiStream ), paUnanticipatedHostError );
668 /* Fill temp buffer with silence */
669 outputFormat = PaAsiHpi_HpiToPaFormat( out->hpiFormat.wFormat );
670 zeroer = PaUtil_SelectZeroer( outputFormat );
671 zeroer(out->tempBuffer, 1, out->tempBufferSize / Pa_GetSampleSize(outputFormat) );
672 /* Write temp buffer to hardware fifo twice, to get started */
673-#if (HPI_VER >= HPI_VERSION_CONSTRUCTOR( 3, 5, 5 ))
674- PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( out->hpiDevice->subSys, out->hpiStream,
675+ PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( NULL, out->hpiStream,
676 out->tempBuffer, out->tempBufferSize, &out->hpiFormat),
677 paUnanticipatedHostError );
678- PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( out->hpiDevice->subSys, out->hpiStream,
679+ PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( NULL, out->hpiStream,
680 out->tempBuffer, out->tempBufferSize, &out->hpiFormat),
681 paUnanticipatedHostError );
682-#else
683- PA_ASIHPI_UNLESS_( HPI_DataCreate( &data, &out->hpiFormat, out->tempBuffer, out->tempBufferSize ),
684- paUnanticipatedHostError );
685- PA_ASIHPI_UNLESS_( HPI_OutStreamWrite( out->hpiDevice->subSys,
686- out->hpiStream, &data ), paUnanticipatedHostError );
687- PA_ASIHPI_UNLESS_( HPI_OutStreamWrite( out->hpiDevice->subSys,
688- out->hpiStream, &data ), paUnanticipatedHostError );
689-#endif
690 error:
691 return result;
692 }
693@@ -1989,7 +1965,7 @@
694
695 if( stream->input )
696 {
697- PA_ASIHPI_UNLESS_( HPI_InStreamStart( stream->input->hpiDevice->subSys,
698+ PA_ASIHPI_UNLESS_( HPI_InStreamStart( NULL,
699 stream->input->hpiStream ), paUnanticipatedHostError );
700 }
701 if( stream->output )
702@@ -1999,7 +1975,7 @@
703 /* Buffer isn't primed, so load stream with silence */
704 PA_ENSURE_( PaAsiHpi_PrimeOutputWithSilence( stream ) );
705 }
706- PA_ASIHPI_UNLESS_( HPI_OutStreamStart( stream->output->hpiDevice->subSys,
707+ PA_ASIHPI_UNLESS_( HPI_OutStreamStart( NULL,
708 stream->output->hpiStream ), paUnanticipatedHostError );
709 }
710 stream->state = paAsiHpiActiveState;
711@@ -2071,7 +2047,7 @@
712 /* Input channels */
713 if( stream->input )
714 {
715- PA_ASIHPI_UNLESS_( HPI_InStreamReset( stream->input->hpiDevice->subSys,
716+ PA_ASIHPI_UNLESS_( HPI_InStreamReset( NULL,
717 stream->input->hpiStream ), paUnanticipatedHostError );
718 }
719 /* Output channels */
720@@ -2097,7 +2073,7 @@
721 Pa_Sleep( (long)ceil( timeLeft ) );
722 }
723 }
724- PA_ASIHPI_UNLESS_( HPI_OutStreamReset( stream->output->hpiDevice->subSys,
725+ PA_ASIHPI_UNLESS_( HPI_OutStreamReset( NULL,
726 stream->output->hpiStream ), paUnanticipatedHostError );
727 }
728
729@@ -2315,7 +2291,7 @@
730 PaError result = paNoError;
731 double sampleRate;
732 unsigned long framesTarget;
733- HW32 outputData = 0, outputSpace = 0, inputData = 0, framesLeft = 0;
734+ uint32_t outputData = 0, outputSpace = 0, inputData = 0, framesLeft = 0;
735
736 assert( stream );
737 assert( stream->input || stream->output );
738@@ -2484,12 +2460,9 @@
739 if( stream->input )
740 {
741 PaAsiHpiStreamInfo info;
742-
743-#if (HPI_VER < HPI_VERSION_CONSTRUCTOR( 3, 5, 5 ))
744- HPI_DATA data;
745-#endif
746- HW32 framesToGet = *numFrames;
747
748+ uint32_t framesToGet = *numFrames;
749+
750 /* Check for overflows and underflows yet again */
751 PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->input, &info ) );
752 if( info.overflow )
753@@ -2513,22 +2486,12 @@
754 stream->input->tempBufferSize / Pa_GetSampleSize(inputFormat) );
755 }
756
757-#if (HPI_VER >= HPI_VERSION_CONSTRUCTOR( 3, 5, 5 ))
758 /* Read block of data into temp buffer */
759- PA_ASIHPI_UNLESS_( HPI_InStreamReadBuf( stream->input->hpiDevice->subSys,
760- stream->input->hpiStream,
761+ PA_ASIHPI_UNLESS_( HPI_InStreamReadBuf( NULL,
762+ stream->input->hpiStream,
763 stream->input->tempBuffer,
764 framesToGet * stream->input->bytesPerFrame),
765 paUnanticipatedHostError );
766-#else
767- /* Setup HPI data structure around temp buffer */
768- HPI_DataCreate( &data, &stream->input->hpiFormat, stream->input->tempBuffer,
769- framesToGet * stream->input->bytesPerFrame );
770- /* Read block of data into temp buffer */
771- PA_ASIHPI_UNLESS_( HPI_InStreamRead( stream->input->hpiDevice->subSys,
772- stream->input->hpiStream, &data ),
773- paUnanticipatedHostError );
774-#endif
775 /* Register temp buffer with buffer processor (always FULL buffer) */
776 PaUtil_SetInputFrameCount( &stream->bufferProcessor, *numFrames );
777 /* HPI interface only allows interleaved channels */
778@@ -2572,9 +2535,6 @@
779 if( stream->output )
780 {
781 PaAsiHpiStreamInfo info;
782-#if (HPI_VER < HPI_VERSION_CONSTRUCTOR( 3, 5, 5 ))
783- HPI_DATA data;
784-#endif
785 /* Check for underflows after the (potentially time-consuming) callback */
786 PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->output, &info ) );
787 if( info.underflow )
788@@ -2582,23 +2542,13 @@
789 *cbFlags |= paOutputUnderflow;
790 }
791
792-#if (HPI_VER >= HPI_VERSION_CONSTRUCTOR( 3, 5, 5 ))
793 /* Write temp buffer to HPI stream */
794- PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( stream->output->hpiDevice->subSys,
795- stream->output->hpiStream,
796+ PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( NULL,
797+ stream->output->hpiStream,
798 stream->output->tempBuffer,
799- numFrames * stream->output->bytesPerFrame,
800+ numFrames * stream->output->bytesPerFrame,
801 &stream->output->hpiFormat),
802 paUnanticipatedHostError );
803-#else
804- /* Setup HPI data structure around temp buffer */
805- HPI_DataCreate( &data, &stream->output->hpiFormat, stream->output->tempBuffer,
806- numFrames * stream->output->bytesPerFrame );
807- /* Write temp buffer to HPI stream */
808- PA_ASIHPI_UNLESS_( HPI_OutStreamWrite( stream->output->hpiDevice->subSys,
809- stream->output->hpiStream, &data ),
810- paUnanticipatedHostError );
811-#endif
812 }
813
814 error:
Audacity - manipulate digital audio waveforms
This page took 0.186157 seconds and 4 git commands to generate.