← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/oss4/oneiric-proposed

« back to all changes in this revision

Viewing changes to attic/drv/oss_allegro/srcmgr.inc

  • Committer: Bazaar Package Importer
  • Author(s): Stefano Rivera
  • Date: 2011-06-16 20:37:48 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20110616203748-jbrxik6ql33z54co
Tags: 4.2-build2004-1ubuntu1
https://launchpad.net/bugs/746048
https://launchpad.net/bugs/770972
* Merge from Debian unstable.
  - Supports our current kernel (LP: #746048)
  Remaining changes:
  - debian/oss4-dkms.dkms.in: s/source/build/ in Kernel headers paths.
* ld-as-needed.patch: Re-order CC arguments to enable building with ld
  --as-needed (LP: #770972)

Show diffs side-by-side

added added

removed removed

Lines of Context:
attic/drv/oss_allegro/srcmgr.inc
 
1
/*
 
2
 *      srcmgr.c  --  ESS Technology allegro audio driver.
 
3
 *
 
4
 *      Copyright (C) 1992-2000  Don Kim (don.kim@esstech.com)
 
5
 *
 
6
 */
 
7
 
 
8
#include "hckernel.h"
 
9
static int num_errors = 0; /* Dummy variable used to supress lint warnings. */
 
10
 
 
11
#define DMAREC
 
12
 
 
13
/*/////////////////////////////////////////////////////////////////////////// */
 
14
/*  DSP kernel support */
 
15
/* index 0 - 44.1k; 1 - 32k; 2 - 22.05k; 3 - 11.025k; 4 - 8k */
 
16
/* */
 
17
/*/////////////////////////////////////////////////////////////////////////// */
 
18
WORD gwSRC3_PB_SIZE_OUT[5] =
 
19
  { 37 * 2 * 2, 6 * 2, 37 * 2 * 2, 26 * 2, 12 * 2 };
 
20
WORD gwSRC3_PB_SIZE_IN[5] = { 34 * 2, 4, 17 * 2, 6, 2 };
 
21
WORD gwSRC3_PB_FILTER_LENGTH[5] = { 666, 60, 666, 338, 360 };
 
22
WORD gwSRC3_PB_FILTER_TAP_SIZE[5] = { 17, 19, 17, 25, 59 };     /* SIZE - 1 */
 
23
WORD gwSRC3_PB_BIG_LOOP_COUNTER[5] = { 11, 1, 5, 2, 0 };
 
24
WORD gwSRC3_PB_SMALL_LOOP_COUNTER[5] = { 0, 0, 1, 3, 4 };
 
25
WORD gwSRC3_IN_BufferSize[5] =
 
26
  { 2 * 17 * 16, 192 * 2, 2 * 17 * 16, 192 * 2, 192 * 2 };
 
27
WORD gwSRC3_OUT_BufferSize[5] =
 
28
  { 160 * 4, 160 * 2, 160 * 4, 160 * 2, 160 * 2 };
 
29
 
 
30
WORD gwSRC3_REC_SIZE_OUT[5] = { 34 * 2, 4, 12, 6, 2 };
 
31
WORD gwSRC3_REC_SIZE_IN[5] = { 37 * 2, 6, 26, 26, 12 };
 
32
WORD gwSRC3_REC_FILTER_LENGTH[5] = { 680, 60, 312, 156, 60 };
 
33
WORD gwSRC3_REC_FILTER_TAP_SIZE[5] = { 19, 29, 51, 51, 59 };    /* SIZE - 1 */
 
34
 
 
35
/* WORD gwSRC3_REC_BIG_LOOP_COUNTER[5]     = {      9,       0,      4,      1,     -1    }; */
 
36
WORD gwSRC3_REC_SMALL_LOOP_COUNTER[5] = { 0, 0, 1, 3, 4 };
 
37
WORD gwSRC3_REC_IN_BufferSize[5] = { 37 * 16 * 2, 32 * 6 * 2, 416, 416, 384 };
 
38
WORD gwSRC3_REC_OUT_BufferSize[5] =
 
39
  { 160 * 4, 160 * 2, 160 * 2, 160 * 2, 160 * 2 };
 
40
 
 
41
#define PB_DMA_BUFFER_SIZE      0x2400
 
42
#define PLAYBACK_BUFFER_SIZE    PB_DMA_BUFFER_SIZE
 
43
/*#define WAVE_BUFFER_BLOCK_SIZE  (MAXNUM_WAVE_RENDER * PLAYBACK_BUFFER_SIZE) + 0x8000 */
 
44
 
 
45
#define STREAM_TYPE_DSPSRC   1  /*  high quality SRC stream */
 
46
#define STREAM_TYPE_DSPMSRC  2  /*  general mini SRC stream */
 
47
#define STREAM_TYPE_NULL     (( ULONG ) -1 )
 
48
 
 
49
BYTE AllocateSRCPlay = FALSE;
 
50
BYTE AllocateSRCRec = FALSE;
 
51
/* -------------------------------------------------------------------------- */
 
52
 
 
53
/* khs, for full-dupulex */
 
54
#define MAX_SRC_STREAMS  2
 
55
 
 
56
 
 
57
PHWI gphwi = NULL;
 
58
 
 
59
#define _Debug_Printf_Service(x) dprintf3((x))
 
60
 
 
61
#if 0
 
62
extern PHYSICAL_ADDRESS PPhysicalAddress;
 
63
extern PHYSICAL_ADDRESS RPhysicalAddress;
 
64
extern ULONG SWTAddress;
 
65
#endif
 
66
 
 
67
#define wSPDIFVarLen (CDATA_HEADER_LEN + 10)
 
68
#define gwSPDIF_IN_BufferSize 192
 
69
/* -------------------------------------------------------------------------- */
 
70
 
 
71
#define MAXNUM_WAVE_RENDER    1
 
72
#define MAXNUM_WAVE_CAPTURE   1
 
73
#define MAXNUM_WAVE_MIXER     1
 
74
#define MAXNUM_WAVE_CHANNELS  MAXNUM_WAVE_RENDER + MAXNUM_WAVE_CAPTURE + MAXNUM_WAVE_MIXER
 
75
 
 
76
 
 
77
ALLEGRO_WAVE WaveStreams[MAXNUM_WAVE_CHANNELS] = { {0} };
 
78
 
 
79
PALLEGRO_WAVE CaptureStream = NULL;
 
80
PALLEGRO_WAVE PlaybackStream = NULL;
 
81
PALLEGRO_WAVE MidiStream = NULL;
 
82
 
 
83
MBUFFER CaptureBuffer;
 
84
MBUFFER RenderBuffer;
 
85
MBUFFER MidiBuffer;
 
86
 
 
87
static int StreamsRunning = 0;
 
88
 
 
89
void
 
90
InitStream ()
 
91
{
 
92
  int i;
 
93
  for (i = 0; i < 3; i++)
 
94
    {
 
95
      WaveStreams[i].PositionBeforePaused = 0;
 
96
      WaveStreams[i].DspClientInstance = NULL;
 
97
      WaveStreams[i].StreamType = STREAM_TYPE_NULL;
 
98
      WaveStreams[i].State = KSSTATE_STOP;
 
99
    }
 
100
 
 
101
  WaveStreams[0].WaveType = WAVE_PLAYBACK;
 
102
  WaveStreams[1].WaveType = WAVE_CAPTURE;
 
103
  WaveStreams[2].WaveType = WAVE_MIXER;
 
104
 
 
105
#if 0
 
106
  RenderBuffer.Physical = (ULONG) PPhysicalAddress.LowPart;
 
107
  RenderBuffer.Length = 0x2000;
 
108
  WaveStreams[0].Buffer = &RenderBuffer;
 
109
  WaveStreams[0].Length = RenderBuffer.Length;
 
110
 
 
111
  CaptureBuffer.Physical = (ULONG) RPhysicalAddress.LowPart;
 
112
  CaptureBuffer.Length = 0x4000;
 
113
  WaveStreams[1].Buffer = &CaptureBuffer;
 
114
  WaveStreams[1].Length = CaptureBuffer.Length;
 
115
 
 
116
  MidiBuffer.Physical = (ULONG) SWTAddress;
 
117
  MidiBuffer.Length = 3520;
 
118
  WaveStreams[2].Buffer = &MidiBuffer;
 
119
  WaveStreams[2].Length = MidiBuffer.Length;
 
120
  WaveStreams[2].StreamType = STREAM_TYPE_DSPMSRC;
 
121
#endif
 
122
 
 
123
  PlaybackStream = &WaveStreams[0];
 
124
  CaptureStream = &WaveStreams[1];
 
125
  MidiStream = &WaveStreams[2];
 
126
}
 
127
 
 
128
/*ARGSUSED*/
 
129
void
 
130
AllocateStream (allegro_devc * devc, IN BYTE waveType)
 
131
{
 
132
  dprintf1 (("AllocateStream %d", waveType));
 
133
  WaveStreams[waveType].DspClientInstance = NULL;
 
134
  WaveStreams[waveType].StreamType = STREAM_TYPE_NULL;
 
135
  WaveStreams[waveType].State = KSSTATE_STOP;
 
136
 
 
137
  /* */
 
138
  /* at the request of record, turn off SPDIF out if already on. */
 
139
  /* at the end of record, turn on */
 
140
#ifdef later
 
141
  if ((WAVE_CAPTURE == waveType) && fSPDIFOUT)
 
142
    HWMGR_Enable_SPDIF (devc, FALSE);
 
143
#endif
 
144
 
 
145
/*    SetFormat( &WaveStreams[ waveType ], WaveInfo ); */
 
146
}                               /* AllocateStream */
 
147
 
 
148
void
 
149
FreeStream (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
150
{
 
151
  /* close DSP instance */
 
152
  dprintf3 (("FreeStream:%x", AllegroWave->DspClientInstance));
 
153
  if (AllegroWave->DspClientInstance)
 
154
    {
 
155
      if (kCloseInstance (devc, gphwi, AllegroWave->DspClientInstance,
 
156
                          KOPENCLOSE_SYNCHRONOUS) != KRETURN_SUCCESS)
 
157
        {
 
158
                        /*_Debug_Printf_Service( "Close Inst!\n" ); */
 
159
          dprintf1 (("ERROR: FreeStream kCloseInstance"));
 
160
          num_errors++;
 
161
        }
 
162
      AllegroWave->DspClientInstance = NULL;
 
163
    }
 
164
 
 
165
  if (IsAC3Format)
 
166
    {
 
167
      /*  */
 
168
      /* reset the spdif out data type to PCM */
 
169
      HWMGR_WriteDataWord (devc, ASSP_MEMORY_PORT, DSP_DATA_MEMORY);
 
170
      HWMGR_WriteDataWord (devc, ASSP_INDEX_PORT, KDATA_SPDIF_FRAME0);
 
171
      HWMGR_WriteDataWord (devc, ASSP_DATA_PORT, 0x100);
 
172
    }
 
173
 
 
174
  if (STREAM_TYPE_DSPSRC == AllegroWave->StreamType)
 
175
    {
 
176
      AllocateSRCRec = FALSE;
 
177
      AllocateSRCPlay = FALSE;
 
178
    }
 
179
}                               /* FreeStream */
 
180
 
 
181
 
 
182
void
 
183
SRCMGR_Stop (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
184
{
 
185
  dprintf1 (("SRCMGR_Stop: Client = %x", AllegroWave->DspClientInstance));
 
186
  if (AllegroWave->DspClientInstance)
 
187
    {
 
188
 
 
189
      /* stop DMA transfer */
 
190
      kStopTransfer (devc, gphwi, AllegroWave->DspClientInstance);
 
191
 
 
192
      /* stop the DSP client */
 
193
      kSetInstanceNotReady (devc, gphwi, AllegroWave->DspClientInstance);
 
194
    }
 
195
}                               /* SRCMGR_Stop */
 
196
 
 
197
void
 
198
SRCMGR_StartSPDIFIN (allegro_devc * devc, IN BOOLEAN start)
 
199
{
 
200
  ULONG FilterLength;
 
201
  ULONG i;
 
202
  USHORT wCC_offset;
 
203
  USHORT wCD_offset;
 
204
 
 
205
  if (start)
 
206
    {
 
207
      if (pClient_SPDIFIN)
 
208
        {
 
209
          kCloseInstance (devc, gphwi, pClient_SPDIFIN,
 
210
                          KOPENCLOSE_SYNCHRONOUS);
 
211
          pClient_SPDIFIN = NULL;
 
212
#if 0
 
213
          StreamsRunning--;
 
214
          if (0 == StreamsRunning)
 
215
            {
 
216
              WRITE_PORT_USHORT (devc->osdev, devc->base + HOST_INT_CTRL,
 
217
                                 (USHORT) (READ_PORT_USHORT
 
218
                                           (devc->osdev,
 
219
                                            devc->base +
 
220
                                            HOST_INT_CTRL) &
 
221
                                           ~CLKRUN_GEN_ENABLE));
 
222
            }
 
223
#endif
 
224
        }
 
225
      kOpenInstance (devc, gphwi,
 
226
                     CLIENT_MINISRC,
 
227
                     0,
 
228
                     2 * (MINISRC_TMP_BUFFER_SIZE / 2 +
 
229
                          MINISRC_IN_BUFFER_SIZE / 2 + 1 +
 
230
                          MINISRC_OUT_BUFFER_SIZE / 2 + 1), &pClient_SPDIFIN);
 
231
      if (pClient_SPDIFIN)
 
232
        {
 
233
#if 0
 
234
          StreamsRunning++;
 
235
          if (1 == StreamsRunning)
 
236
            {
 
237
              WRITE_PORT_USHORT (devc->osdev, devc->base + HOST_INT_CTRL,
 
238
                                 (USHORT) (READ_PORT_USHORT
 
239
                                           (devc->osdev,
 
240
                                            devc->base +
 
241
                                            HOST_INT_CTRL) |
 
242
                                           CLKRUN_GEN_ENABLE));
 
243
            }
 
244
#endif
 
245
          wCC_offset = (WORD) (pClient_SPDIFIN->dwDspCodeClientArea);
 
246
          wCD_offset = (WORD) (pClient_SPDIFIN->dwDspDataClientArea);
 
247
 
 
248
          dprintf1 (("success %x %x %x", pClient_SPDIFIN, wCC_offset,
 
249
                     wCD_offset));
 
250
          kStartTransfer (devc, gphwi, pClient_SPDIFIN, TRUE, 0L, 0L, 0L, 0L,
 
251
                          (ULONG) (wCD_offset + MINISRC_TMP_BUFFER_SIZE / 2),
 
252
                          (ULONG) (MINISRC_IN_BUFFER_SIZE),
 
253
                          (ULONG) (wCD_offset + MINISRC_TMP_BUFFER_SIZE / 2 +
 
254
                                   MINISRC_IN_BUFFER_SIZE / 2 + 1),
 
255
                          (ULONG) (MINISRC_OUT_BUFFER_SIZE), KCONNECT_SPDIFIN,
 
256
                          KCONNECT_MIXER);
 
257
 
 
258
          /* ------------------------------------------------------------------------- */
 
259
          /* load the coefficient starting at offset of program size in program memory */
 
260
          /* ------------------------------------------------------------------------- */
 
261
 
 
262
          /* filter length calculation */
 
263
          FilterLength = sizeof (MINISRC_LPF) / 2;
 
264
 
 
265
          for (i = 0; i < FilterLength; i++)
 
266
            {
 
267
              kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_CODE, wCC_offset + MINISRC_COEF_LOC + i, (USHORT) (MINISRC_LPF[i]));    /*since it is in sequence. */
 
268
            }
 
269
 
 
270
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_CODE,
 
271
                         wCC_offset + MINISRC_COEF_LOC + FilterLength,
 
272
                         0X8000);
 
273
 
 
274
/*------------------------------------------------------------------------------------------- */
 
275
/* Transfer all parameters into DSP Data memory */
 
276
/* All the change below should be consistent with DSP client       --- khs 04/17/98 */
 
277
/*------------------------------------------------------------------------------------------- */
 
278
 
 
279
          /* left Volume */
 
280
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
281
                         wCD_offset + CDATA_LEFT_VOLUME, 0X7FFF);
 
282
 
 
283
          /* right Volume */
 
284
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
285
                         wCD_offset + CDATA_LEFT_VOLUME + 1, 0X7FFF);
 
286
 
 
287
          /* DIRECTION */
 
288
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA, wCD_offset + SRC3_DIRECTION_OFFSET, 0 /* playback */
 
289
            );
 
290
 
 
291
          /* MODE */
 
292
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA, wCD_offset + SRC3_DIRECTION_OFFSET + 1, 0     /* stereo */
 
293
            );
 
294
 
 
295
          /* WORDLEN */
 
296
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA, wCD_offset + SRC3_DIRECTION_OFFSET + 2, 0     /* 16bit */
 
297
            );
 
298
 
 
299
          /* FRACTION */
 
300
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
301
                         wCD_offset + SRC3_DIRECTION_OFFSET + 3, 0X0000);
 
302
 
 
303
          /* FIRST_L */
 
304
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
305
                         wCD_offset + SRC3_DIRECTION_OFFSET + 4, 0);
 
306
 
 
307
          /* FIRST_R */
 
308
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
309
                         wCD_offset + SRC3_DIRECTION_OFFSET + 5, 0);
 
310
 
 
311
          /* SECOND_L */
 
312
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
313
                         wCD_offset + SRC3_DIRECTION_OFFSET + 6, 0);
 
314
 
 
315
          /* SECOND_R */
 
316
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
317
                         wCD_offset + SRC3_DIRECTION_OFFSET + 7, 0);
 
318
 
 
319
          /* DELTA_L */
 
320
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
321
                         wCD_offset + SRC3_DIRECTION_OFFSET + 8, 0);
 
322
 
 
323
          /* DELTA_R */
 
324
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
325
                         wCD_offset + SRC3_DIRECTION_OFFSET + 9, 0);
 
326
 
 
327
          /* ROUND */
 
328
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
329
                         wCD_offset + SRC3_DIRECTION_OFFSET + 10, 0X8000);
 
330
 
 
331
          /* HIGHER BYTE MASK */
 
332
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
333
                         wCD_offset + SRC3_DIRECTION_OFFSET + 11, 0XFF00);
 
334
 
 
335
          /* TEMPORARY INPUT BUFFER ADDRESS */
 
336
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
337
                         wCD_offset + SRC3_DIRECTION_OFFSET + 12,
 
338
                         (WORD) (wCD_offset + 40 + 8));
 
339
 
 
340
          /* TEMP0 */
 
341
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
342
                         wCD_offset + SRC3_DIRECTION_OFFSET + 13, 0);
 
343
 
 
344
          /* C_FRACTION */
 
345
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
346
                         wCD_offset + SRC3_DIRECTION_OFFSET + 14, 0);
 
347
 
 
348
          /* COUNTER */
 
349
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
350
                         wCD_offset + SRC3_DIRECTION_OFFSET + 15, 0);
 
351
 
 
352
          /* NUMIN */
 
353
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
354
                         wCD_offset + SRC3_DIRECTION_OFFSET + 16, 8);
 
355
 
 
356
          /* NUMOUT */
 
357
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
358
                         wCD_offset + SRC3_DIRECTION_OFFSET + 17, 24);
 
359
 
 
360
          /* NUMSTAGE */
 
361
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
362
                         wCD_offset + SRC3_DIRECTION_OFFSET + 18,
 
363
                         (MINISRC_BIQUAD_STAGE - 1));
 
364
 
 
365
          /* COEF */
 
366
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
367
                         wCD_offset + SRC3_DIRECTION_OFFSET + 19,
 
368
                         (WORD) (wCC_offset + MINISRC_COEF_LOC));
 
369
 
 
370
          /* FILTERTAP */
 
371
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
372
                         wCD_offset + SRC3_DIRECTION_OFFSET + 20, 0);
 
373
 
 
374
          /* BOOSTER */
 
375
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
376
                         wCD_offset + SRC3_DIRECTION_OFFSET + 21, 0);
 
377
 
 
378
          /* SKIPLPF */
 
379
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
380
                         wCD_offset + SRC3_DIRECTION_OFFSET + 22, 0xFF);
 
381
 
 
382
 
 
383
          /* set the run-flag to start */
 
384
          kSetInstanceReady (devc, gphwi, pClient_SPDIFIN);
 
385
        }
 
386
    }
 
387
  else
 
388
    {
 
389
      if (pClient_SPDIFIN)
 
390
        {
 
391
 
 
392
          /* stop DMA transfer */
 
393
          kStopTransfer (devc, gphwi, pClient_SPDIFIN);
 
394
 
 
395
          /* stop the DSP client */
 
396
          kSetInstanceNotReady (devc, gphwi, pClient_SPDIFIN);
 
397
 
 
398
          kCloseInstance (devc, gphwi, pClient_SPDIFIN,
 
399
                          KOPENCLOSE_SYNCHRONOUS);
 
400
          pClient_SPDIFIN = NULL;
 
401
#if 0
 
402
          StreamsRunning--;
 
403
          if (0 == StreamsRunning)
 
404
            {
 
405
              WRITE_PORT_USHORT (devc->osdev, devc->base + HOST_INT_CTRL,
 
406
                                 (USHORT) (READ_PORT_USHORT
 
407
                                           (devc->osdev,
 
408
                                            devc->base +
 
409
                                            HOST_INT_CTRL) &
 
410
                                           ~CLKRUN_GEN_ENABLE));
 
411
            }
 
412
#endif
 
413
        }
 
414
    }
 
415
}                               /* SRCMGR_StartSPDIFIN */
 
416
 
 
417
#define REAL_SHIFT  15
 
418
#define REAL_SCALE  ( 1 << REAL_SHIFT )
 
419
 
 
420
void
 
421
SRCMGR_SetFrequency (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
422
{
 
423
  LONG frequency;
 
424
 
 
425
  if (AllegroWave->DspClientInstance)
 
426
    {
 
427
      frequency = (AllegroWave->Frequency * REAL_SCALE + 24000) / 48000;
 
428
      if (frequency > 0)
 
429
        --frequency;
 
430
      kSetFrequency (devc, gphwi, AllegroWave->DspClientInstance,
 
431
                     (WORD) frequency);
 
432
    }
 
433
}                               /* SRCMGR_SetFrequency */
 
434
 
 
435
void
 
436
SRCMGR_StartPlay (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
437
{
 
438
  ULONG FilterLength;
 
439
  ULONG i;
 
440
  ULONG Length;
 
441
  ULONG SizeIn;
 
442
  ULONG SizeOut;
 
443
  ULONG StartOffset;
 
444
  USHORT wCC_offset;
 
445
  USHORT wCD_offset;
 
446
 
 
447
  if (AllegroWave->DspClientInstance)
 
448
    {
 
449
 
 
450
      if (!IsAC3Format)
 
451
        SRCMGR_SetFrequency (devc, AllegroWave);
 
452
 
 
453
      wCC_offset =
 
454
        (WORD) (AllegroWave->DspClientInstance->dwDspCodeClientArea);
 
455
      wCD_offset =
 
456
        (WORD) (AllegroWave->DspClientInstance->dwDspDataClientArea);
 
457
 
 
458
      Length = devc->dma_dac.dmasize;   /*AllegroWave->Buffer->Length; */
 
459
      AllegroWave->Length = Length;
 
460
 
 
461
      if (!IsAC3Format)
 
462
        {
 
463
          StartOffset = 0x20 * 2;
 
464
          SizeIn = MINISRC_IN_BUFFER_SIZE - StartOffset;
 
465
          SizeOut = MINISRC_OUT_BUFFER_SIZE + StartOffset;
 
466
          StartOffset = wCD_offset + MINISRC_TMP_BUFFER_SIZE / 2;
 
467
 
 
468
          kStartTransfer (devc, gphwi, AllegroWave->DspClientInstance, TRUE, devc->dma_dac.base,        /*AllegroWave->Buffer->Physical, */
 
469
                          Length,
 
470
                          0L,
 
471
                          0L,
 
472
                          StartOffset,
 
473
                          SizeIn,
 
474
                          StartOffset + SizeIn / 2 + 1,
 
475
                          SizeOut, KCONNECT_DMA, KCONNECT_MIXER);
 
476
 
 
477
          /* ------------------------------------------------------------------------- */
 
478
          /* load the coefficient starting at offset of program size in program memory */
 
479
          /* ------------------------------------------------------------------------- */
 
480
 
 
481
          /* filter length calculation */
 
482
          FilterLength = sizeof (MINISRC_LPF) / 2;
 
483
 
 
484
          for (i = 0; i < FilterLength; i++)
 
485
            {
 
486
              kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_CODE, wCC_offset + MINISRC_COEF_LOC + i, (USHORT) (MINISRC_LPF[i]));    /*since it is in sequence. */
 
487
            }
 
488
 
 
489
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_CODE,
 
490
                         wCC_offset + MINISRC_COEF_LOC + FilterLength,
 
491
                         0X8000);
 
492
 
 
493
/*------------------------------------------------------------------------------------------- */
 
494
/* Transfer all parameters into DSP Data memory */
 
495
/* All the change below should be consistent with DSP client       --- khs 04/17/98 */
 
496
/*------------------------------------------------------------------------------------------- */
 
497
 
 
498
          /* left Volume */
 
499
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
500
                         wCD_offset + CDATA_LEFT_VOLUME, 0X7FFF);
 
501
 
 
502
          /* right Volume */
 
503
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
504
                         wCD_offset + CDATA_LEFT_VOLUME + 1, 0X7FFF);
 
505
 
 
506
          /* DIRECTION */
 
507
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA, wCD_offset + SRC3_DIRECTION_OFFSET, 0 /* playback */
 
508
            );
 
509
 
 
510
          /* MODE */
 
511
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
512
                         wCD_offset + SRC3_DIRECTION_OFFSET + 1,
 
513
                         (WORD) ! AllegroWave->FormatStereo);
 
514
 
 
515
          /* WORDLEN */
 
516
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
517
                         wCD_offset + SRC3_DIRECTION_OFFSET + 2,
 
518
                         (WORD) ! AllegroWave->Format16Bit);
 
519
 
 
520
          /* FRACTION */
 
521
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
522
                         wCD_offset + SRC3_DIRECTION_OFFSET + 3, 0X0000);
 
523
 
 
524
          /* FIRST_L */
 
525
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
526
                         wCD_offset + SRC3_DIRECTION_OFFSET + 4, 0);
 
527
 
 
528
          /* FIRST_R */
 
529
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
530
                         wCD_offset + SRC3_DIRECTION_OFFSET + 5, 0);
 
531
 
 
532
          /* SECOND_L */
 
533
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
534
                         wCD_offset + SRC3_DIRECTION_OFFSET + 6, 0);
 
535
 
 
536
          /* SECOND_R */
 
537
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
538
                         wCD_offset + SRC3_DIRECTION_OFFSET + 7, 0);
 
539
 
 
540
          /* DELTA_L */
 
541
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
542
                         wCD_offset + SRC3_DIRECTION_OFFSET + 8, 0);
 
543
 
 
544
          /* DELTA_R */
 
545
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
546
                         wCD_offset + SRC3_DIRECTION_OFFSET + 9, 0);
 
547
 
 
548
          /* ROUND */
 
549
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
550
                         wCD_offset + SRC3_DIRECTION_OFFSET + 10, 0X8000);
 
551
 
 
552
          /* HIGHER BYTE MASK */
 
553
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
554
                         wCD_offset + SRC3_DIRECTION_OFFSET + 11, 0XFF00);
 
555
 
 
556
          /* TEMPORARY INPUT BUFFER ADDRESS */
 
557
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
558
                         wCD_offset + SRC3_DIRECTION_OFFSET + 12,
 
559
                         (WORD) (wCD_offset + 40 + 8));
 
560
 
 
561
          /* TEMP0 */
 
562
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
563
                         wCD_offset + SRC3_DIRECTION_OFFSET + 13, 0);
 
564
 
 
565
          /* C_FRACTION */
 
566
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
567
                         wCD_offset + SRC3_DIRECTION_OFFSET + 14, 0);
 
568
 
 
569
          /* COUNTER */
 
570
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
571
                         wCD_offset + SRC3_DIRECTION_OFFSET + 15, 0);
 
572
 
 
573
          /* NUMIN */
 
574
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
575
                         wCD_offset + SRC3_DIRECTION_OFFSET + 16, 8);
 
576
 
 
577
          if (0 < AllegroWave->Frequency && AllegroWave->Frequency < 8000)
 
578
            {
 
579
              Length = 48000 * 8 / AllegroWave->Frequency;
 
580
 
 
581
              /* add one more for remainder */
 
582
              ++Length;
 
583
 
 
584
              /* make it even */
 
585
              if (Length & 1)
 
586
                ++Length;
 
587
 
 
588
              /* NUMOUT */
 
589
              kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
590
                             wCD_offset + SRC3_DIRECTION_OFFSET + 17,
 
591
                             (USHORT) Length * 2);
 
592
            }
 
593
          else
 
594
            /* NUMOUT */
 
595
            kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
596
                           wCD_offset + SRC3_DIRECTION_OFFSET + 17, 50 * 2);
 
597
 
 
598
          /* NUMSTAGE */
 
599
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
600
                         wCD_offset + SRC3_DIRECTION_OFFSET + 18,
 
601
                         (MINISRC_BIQUAD_STAGE - 1));
 
602
 
 
603
          /* COEF */
 
604
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
605
                         wCD_offset + SRC3_DIRECTION_OFFSET + 19,
 
606
                         (WORD) (wCC_offset + MINISRC_COEF_LOC));
 
607
 
 
608
          /* FILTERTAP */
 
609
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
610
                         wCD_offset + SRC3_DIRECTION_OFFSET + 20, 0);
 
611
 
 
612
          /* BOOSTER */
 
613
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
614
                         wCD_offset + SRC3_DIRECTION_OFFSET + 21, 0);
 
615
 
 
616
          /* SKIPLPF */
 
617
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
618
                         wCD_offset + SRC3_DIRECTION_OFFSET + 22,
 
619
                         (WORD) ((AllegroWave->Frequency >
 
620
                                  45000) ? 0xFF : 0));
 
621
 
 
622
 
 
623
          if (AllegroWave->PositionBeforePaused)
 
624
            kAlterTransfer (devc, gphwi,
 
625
                            AllegroWave->DspClientInstance,
 
626
                            KALTER_POSITION,
 
627
                            TRUE, AllegroWave->PositionBeforePaused);
 
628
        }
 
629
      else
 
630
        {
 
631
          kStartTransfer (devc, gphwi, AllegroWave->DspClientInstance, TRUE, devc->dma_dac.base,        /*AllegroWave->Buffer->Physical, */
 
632
                          Length,
 
633
                          0L,
 
634
                          0L,
 
635
                          (ULONG) (wCD_offset + wSPDIFVarLen),
 
636
                          (ULONG) (gwSPDIF_IN_BufferSize),
 
637
                          (DWORD) NULL, 0, KCONNECT_DMA, 0);
 
638
 
 
639
          /* only one parameter */
 
640
          /* when you close ac3-spdif, you have to put it back with "0x100" */
 
641
          HWMGR_WriteDataWord (devc, ASSP_MEMORY_PORT, DSP_DATA_MEMORY);
 
642
          HWMGR_WriteDataWord (devc, ASSP_INDEX_PORT, KDATA_SPDIF_FRAME0);
 
643
          HWMGR_WriteDataWord (devc, ASSP_DATA_PORT, 0x102);    /*;0x102 -- AC3 data */
 
644
        }
 
645
      /*;0x100 -- pcm data */
 
646
      /* set the run-flag to start */
 
647
      kSetInstanceReady (devc, gphwi, AllegroWave->DspClientInstance);
 
648
    }
 
649
}                               /* SRCMGR_StartPlay */
 
650
 
 
651
 
 
652
void
 
653
SRCMGR_StartRecord (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
654
{
 
655
  ULONG Length;
 
656
  ULONG SizeIn;
 
657
  ULONG SizeOut;
 
658
  ULONG StartOffset;
 
659
  USHORT wCD_offset;
 
660
 
 
661
  if (AllegroWave->DspClientInstance)
 
662
    {
 
663
 
 
664
      SRCMGR_SetFrequency (devc, AllegroWave);
 
665
 
 
666
      wCD_offset =
 
667
        (WORD) (AllegroWave->DspClientInstance->dwDspDataClientArea);
 
668
 
 
669
      Length = devc->dma_adc.dmasize;   /*AllegroWave->Buffer->Length; */
 
670
      AllegroWave->Length = Length;
 
671
      StartOffset = 0x10 * 2;
 
672
      SizeIn = MINISRC_IN_BUFFER_SIZE + StartOffset;
 
673
      SizeOut = MINISRC_OUT_BUFFER_SIZE - StartOffset;
 
674
      StartOffset = wCD_offset + MINISRC_TMP_BUFFER_SIZE / 2;
 
675
 
 
676
      kStartTransfer (devc, gphwi, AllegroWave->DspClientInstance, TRUE, 0L, 0L, devc->dma_adc.base,    /*AllegroWave->Buffer->Physical, */
 
677
                      Length,
 
678
                      StartOffset,
 
679
                      SizeIn,
 
680
                      StartOffset + SizeIn / 2 + 1,
 
681
                      SizeOut, gwDSPConnectIn, KCONNECT_DMA);
 
682
 
 
683
/*------------------------------------------------------------------------------------------- */
 
684
/* Transfer all parameters into DSP Data memory */
 
685
/* All the change below should be consistent with DSP client       --- khs 04/17/98 */
 
686
/*------------------------------------------------------------------------------------------- */
 
687
 
 
688
      /* left Volume */
 
689
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
690
                     wCD_offset + CDATA_LEFT_VOLUME, 0X7FFF);
 
691
 
 
692
      /* right Volume */
 
693
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
694
                     wCD_offset + CDATA_LEFT_VOLUME + 1, 0X7FFF);
 
695
 
 
696
      /* DIRECTION */
 
697
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA, wCD_offset + SRC3_DIRECTION_OFFSET, 1     /* recording */
 
698
        );
 
699
 
 
700
      /* MODE */
 
701
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
702
                     wCD_offset + SRC3_DIRECTION_OFFSET + 1,
 
703
                     (WORD) ! AllegroWave->FormatStereo);
 
704
 
 
705
      /* WORDLEN */
 
706
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
707
                     wCD_offset + SRC3_DIRECTION_OFFSET + 2,
 
708
                     (WORD) ! AllegroWave->Format16Bit);
 
709
 
 
710
      /* FRACTION */
 
711
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
712
                     wCD_offset + SRC3_DIRECTION_OFFSET + 3, 0X0000);
 
713
 
 
714
      /* FIRST_L */
 
715
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
716
                     wCD_offset + SRC3_DIRECTION_OFFSET + 4, 0);
 
717
 
 
718
      /* FIRST_R */
 
719
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
720
                     wCD_offset + SRC3_DIRECTION_OFFSET + 5, 0);
 
721
 
 
722
      /* SECOND_L */
 
723
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
724
                     wCD_offset + SRC3_DIRECTION_OFFSET + 6, 0);
 
725
 
 
726
      /* SECOND_R */
 
727
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
728
                     wCD_offset + SRC3_DIRECTION_OFFSET + 7, 0);
 
729
 
 
730
      /* DELTA_L */
 
731
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
732
                     wCD_offset + SRC3_DIRECTION_OFFSET + 8, 0);
 
733
 
 
734
      /* DELTA_R */
 
735
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
736
                     wCD_offset + SRC3_DIRECTION_OFFSET + 9, 0);
 
737
 
 
738
      /* ROUND */
 
739
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
740
                     wCD_offset + SRC3_DIRECTION_OFFSET + 10, 0X8000);
 
741
 
 
742
      /* HIGHER BYTE MASK */
 
743
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
744
                     wCD_offset + SRC3_DIRECTION_OFFSET + 11, 0XFF00);
 
745
 
 
746
      /* TEMPORARY INPUT BUFFER ADDRESS */
 
747
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
748
                     wCD_offset + SRC3_DIRECTION_OFFSET + 12,
 
749
                     (WORD) (wCD_offset + 40 + 8));
 
750
 
 
751
      /* TEMP0 */
 
752
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
753
                     wCD_offset + SRC3_DIRECTION_OFFSET + 13, 0);
 
754
 
 
755
      /* C_FRACTION */
 
756
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
757
                     wCD_offset + SRC3_DIRECTION_OFFSET + 14, 0);
 
758
 
 
759
      /* COUNTER */
 
760
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
761
                     wCD_offset + SRC3_DIRECTION_OFFSET + 15, 0);
 
762
 
 
763
      if (0 < AllegroWave->Frequency && AllegroWave->Frequency < 8000)
 
764
        {
 
765
          Length = 48000 * 8 / AllegroWave->Frequency;
 
766
 
 
767
          /* add one more for remainder */
 
768
          ++Length;
 
769
 
 
770
          /* make it even */
 
771
          if (Length & 1)
 
772
            ++Length;
 
773
 
 
774
          /* NUMIN */
 
775
          kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
776
                         wCD_offset + SRC3_DIRECTION_OFFSET + 16,
 
777
                         (USHORT) Length);
 
778
        }
 
779
      else
 
780
        /* NUMIN */
 
781
        kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
782
                       wCD_offset + SRC3_DIRECTION_OFFSET + 16, 50);
 
783
 
 
784
      /* NUMOUT */
 
785
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
786
                     wCD_offset + SRC3_DIRECTION_OFFSET + 17, 8);
 
787
 
 
788
      /*AY */
 
789
      /* NUMSTAGE */
 
790
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
791
                     wCD_offset + SRC3_DIRECTION_OFFSET + 18, 0);
 
792
 
 
793
      /* COEF */
 
794
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
795
                     wCD_offset + SRC3_DIRECTION_OFFSET + 19, 0);
 
796
 
 
797
      /* FILTERTAP */
 
798
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
799
                     wCD_offset + SRC3_DIRECTION_OFFSET + 20, 0);
 
800
 
 
801
      /* BOOSTER */
 
802
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
803
                     wCD_offset + SRC3_DIRECTION_OFFSET + 21, 0);
 
804
 
 
805
      /* SKIPLPF = FF ; no LPF for any recording */
 
806
      kDspWriteWord (devc, devc->base, MEMTYPE_INTERNAL_DATA,
 
807
                     wCD_offset + SRC3_DIRECTION_OFFSET + 22, 0xFF);
 
808
 
 
809
      /* set the run-flag to start */
 
810
      kSetInstanceReady (devc, gphwi, AllegroWave->DspClientInstance);
 
811
    }
 
812
}                               /* SRCMGR_StartRec */
 
813
void
 
814
SRCMGR_SetVolume (allegro_devc * devc, IN PCLIENT_INST client, IN USHORT left,
 
815
                  IN USHORT right)
 
816
{
 
817
  USHORT lvalue;
 
818
  USHORT rvalue;
 
819
 
 
820
  if (client)
 
821
    {
 
822
      lvalue = left >> 1;
 
823
      rvalue = right >> 1;
 
824
 
 
825
      kSetVolume (devc, gphwi, client, lvalue, rvalue, 0);
 
826
    }
 
827
}                               /* SRCMGR_SetVolume */
 
828
 
 
829
void
 
830
SRCMGR_SetRearVolume (allegro_devc * devc, IN PCLIENT_INST client,
 
831
                      IN USHORT left, IN USHORT right)
 
832
{
 
833
  USHORT lvalue;
 
834
  USHORT rvalue;
 
835
 
 
836
  if (client)
 
837
    {
 
838
      lvalue = left >> 1;
 
839
      rvalue = right >> 1;
 
840
 
 
841
      kSetRearVolume (devc, gphwi, client, lvalue, rvalue);
 
842
    }
 
843
}                               /* SRCMGR_SetVolume */
 
844
 
 
845
void
 
846
SRCMGR_SetupStream (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
847
{
 
848
 
 
849
#ifdef SRC4
 
850
  /* using host src */
 
851
  AllegroWave->SR_8khzFlag = FALSE;
 
852
 
 
853
#else
 
854
  /* not using host src */
 
855
  AllegroWave->SR_8khzFlag = TRUE;
 
856
#endif
 
857
  if (STREAM_TYPE_NULL == AllegroWave->StreamType)
 
858
    {
 
859
      AllegroWave->StreamType = STREAM_TYPE_DSPSRC;
 
860
 
 
861
      /* 8-bit not supported by SRC */
 
862
      if (!AllegroWave->Format16Bit)
 
863
        AllegroWave->StreamType = STREAM_TYPE_DSPMSRC;
 
864
    }
 
865
 
 
866
#if ALLEGRO_DEBUG
 
867
  if (AllegroWave->StreamType == STREAM_TYPE_DSPMSRC)
 
868
    {
 
869
      _Debug_Printf_Service ("M. SRC\r\n");
 
870
    }
 
871
  else
 
872
    {
 
873
      _Debug_Printf_Service ("SRC 3.X\r\n");
 
874
    }                           /* endif */
 
875
#endif
 
876
  /*  see if we can acquire a DSP client instance for the new */
 
877
  /*  requested format */
 
878
  if (AllegroWave->StreamType == STREAM_TYPE_DSPSRC)
 
879
    {
 
880
      switch (AllegroWave->Frequency)
 
881
        {
 
882
        case 44100:
 
883
          AllegroWave->wFreqIndex = SRC3_SR_44100;
 
884
          break;
 
885
 
 
886
        case 32000:
 
887
          AllegroWave->wFreqIndex = SRC3_SR_32000;
 
888
          break;
 
889
#if 1
 
890
        case 22050:
 
891
          AllegroWave->wFreqIndex = SRC3_SR_22050;
 
892
          break;
 
893
        case 11025:
 
894
          AllegroWave->wFreqIndex = SRC3_SR_11025;
 
895
          break;
 
896
        case 8000:
 
897
          AllegroWave->wFreqIndex = SRC3_SR_8000;
 
898
 
 
899
          /* khs */
 
900
          AllegroWave->SR_8khzFlag = TRUE;
 
901
          break;
 
902
#endif
 
903
        default:
 
904
          AllegroWave->StreamType = STREAM_TYPE_DSPMSRC;
 
905
        }
 
906
    }
 
907
 
 
908
#if 1
 
909
  AllegroWave->StreamType = STREAM_TYPE_DSPMSRC;        /*DON */
 
910
  dprintf1 (("SRCMGR_SetupStream Mode %d", AllegroWave->StreamType));
 
911
#endif
 
912
#if ALLEGRO_DEBUG
 
913
  if (AllegroWave->StreamType == STREAM_TYPE_DSPMSRC)
 
914
    {
 
915
      _Debug_Printf_Service ("M. SRC\r\n");
 
916
    }
 
917
  else
 
918
    {
 
919
      _Debug_Printf_Service ("SRC 3.X\r\n");
 
920
    }                           /* endif */
 
921
#endif
 
922
 
 
923
  /* ok, if it was determined we are to attempt to do a SCR stream */
 
924
  /* we still don't know if we can so we have to see if the SRC */
 
925
  /* manager will allow us to do it... and if so we have to try and */
 
926
  /* get an instance from the DSP kernel, if the SRC manager didn't */
 
927
  /* let us get it or the DSP kernel didn't allow it we defer it */
 
928
  /* back to Mini SRC stream */
 
929
  if (AllegroWave->StreamType == STREAM_TYPE_DSPSRC)
 
930
    {
 
931
      if (WAVE_CAPTURE == AllegroWave->WaveType)
 
932
        {
 
933
          if (!AllocateSRCRec)
 
934
            {
 
935
 
 
936
              /* Temporary Buffer Size: Two Filter Tap buffer, one block of temporary output buffer */
 
937
              AllegroWave->wSRC3VarLen = SRC3_TEMP_OUTBUF_ADDR_OFFSET + 2
 
938
                + 2 * (gwSRC3_REC_FILTER_TAP_SIZE[AllegroWave->wFreqIndex] +
 
939
                       1) + 2 + gwSRC3_REC_SIZE_IN[AllegroWave->wFreqIndex] +
 
940
                1 + gwSRC3_REC_SIZE_OUT[AllegroWave->wFreqIndex] + 1 + 1 +
 
941
                FOR_FUTURE_USE;
 
942
 
 
943
              kOpenInstance (devc, gphwi,
 
944
                             CLIENT_SRC,
 
945
                             0,
 
946
                             2 * (AllegroWave->wSRC3VarLen +
 
947
                                  gwSRC3_REC_IN_BufferSize[AllegroWave->
 
948
                                                           wFreqIndex] / 2 +
 
949
                                  1 +
 
950
                                  gwSRC3_REC_OUT_BufferSize[AllegroWave->
 
951
                                                            wFreqIndex] / 2 +
 
952
                                  1), &AllegroWave->DspClientInstance);
 
953
              if (AllegroWave->DspClientInstance)
 
954
                {
 
955
 
 
956
/* SRC does not support full-duplex */
 
957
#if 1
 
958
                  AllocateSRCPlay = TRUE;
 
959
#endif
 
960
                  AllocateSRCRec = TRUE;
 
961
                }
 
962
            }
 
963
        }
 
964
      else
 
965
        {
 
966
          if (!AllocateSRCPlay)
 
967
            {
 
968
 
 
969
              /* khs 082098 */
 
970
              /* Temporary Buffer Size: Two Filter Tap buffer, one block of temporary input/output buffer */
 
971
              AllegroWave->wSRC3VarLen = SRC3_TEMP_OUTBUF_ADDR_OFFSET + 2
 
972
                + 2 * (gwSRC3_PB_FILTER_TAP_SIZE[AllegroWave->wFreqIndex] + 1)
 
973
                + 2
 
974
                + gwSRC3_PB_SIZE_OUT[AllegroWave->wFreqIndex] + 1
 
975
                + gwSRC3_PB_SIZE_IN[AllegroWave->wFreqIndex] + 1
 
976
                + FOR_FUTURE_USE;
 
977
 
 
978
              kOpenInstance (devc, gphwi, CLIENT_SRC, 0, 2 * (AllegroWave->wSRC3VarLen + gwSRC3_IN_BufferSize[AllegroWave->wFreqIndex] / 2 + 1 + gwSRC3_OUT_BufferSize[AllegroWave->wFreqIndex] / 2 + 1),       /* word */
 
979
                             &AllegroWave->DspClientInstance);
 
980
              dprintf3 (("kOpenIns:%x", AllegroWave->DspClientInstance));
 
981
              if (AllegroWave->DspClientInstance)
 
982
                {
 
983
                  AllocateSRCPlay = TRUE;
 
984
 
 
985
/* SRC does not support full-duplex */
 
986
#if 1
 
987
                  AllocateSRCRec = TRUE;
 
988
#endif
 
989
                }
 
990
            }
 
991
        }
 
992
      if (!AllegroWave->DspClientInstance)
 
993
        AllegroWave->StreamType = STREAM_TYPE_DSPMSRC;
 
994
    }
 
995
 
 
996
  if (STREAM_TYPE_DSPMSRC == AllegroWave->StreamType)
 
997
    {
 
998
      if (kOpenInstance (devc, gphwi,
 
999
                         IsAC3Format ? CLIENT_SPDIF : CLIENT_MINISRC,
 
1000
                         0,
 
1001
                         IsAC3Format ? 2 * (wSPDIFVarLen +
 
1002
                                            gwSPDIF_IN_BufferSize / 2) : 2 *
 
1003
                         (MINISRC_TMP_BUFFER_SIZE / 2 +
 
1004
                          MINISRC_IN_BUFFER_SIZE / 2 + 1 +
 
1005
                          MINISRC_OUT_BUFFER_SIZE / 2 + 1),
 
1006
                         &AllegroWave->DspClientInstance) != KRETURN_SUCCESS)
 
1007
        {
 
1008
          dprintf1 (("%x:Open M SRC Inst!\n"));
 
1009
          num_errors++;
 
1010
        }
 
1011
    }
 
1012
}                               /* SRCMGR_SetupStream */
 
1013
 
 
1014
ULONG
 
1015
SRCMGR_GetPosition (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave)
 
1016
{
 
1017
  int i;
 
1018
  ULONG Position;
 
1019
  ULONG BufferPosition = 0;
 
1020
  KIRQL OldIrql;
 
1021
 
 
1022
/*dprintf1(("GetPos=%x %x %x %x",  AllegroWave->State, AllegroWave->DspClientInstance, AllegroWave->Length, AllegroWave->WaveType)); */
 
1023
 
 
1024
  /*  to make sure nothing funny happens if this stream is in stop */
 
1025
  /*  state, just return 0 */
 
1026
  if (KSSTATE_STOP == AllegroWave->State || !AllegroWave->DspClientInstance)
 
1027
    return 0;
 
1028
 
 
1029
  KeAcquireSpinLock (&gpGDI->ControlSpinLock, &OldIrql);
 
1030
 
 
1031
  if (WAVE_CAPTURE == AllegroWave->WaveType)
 
1032
    {
 
1033
 
 
1034
#ifndef DMAREC
 
1035
      /* khs 090298 for PIO recording */
 
1036
      kPIOInterruptHandler (devc, gphwi, AllegroWave->DspClientInstance);
 
1037
#endif
 
1038
      for (i = 0; i < 100; i++)
 
1039
        {
 
1040
          if (kQueryPosition (devc, gphwi,
 
1041
                              AllegroWave->DspClientInstance,
 
1042
                              FALSE, &BufferPosition) == KRETURN_SUCCESS)
 
1043
            break;
 
1044
        }
 
1045
 
 
1046
#if 0
 
1047
      if (BufferPosition >= AllegroWave->Length)
 
1048
        {
 
1049
          dprintf1 (("!%d ", BufferPosition));
 
1050
          BufferPosition = 0;
 
1051
        }
 
1052
#endif
 
1053
      Position = BufferPosition % AllegroWave->Length;
 
1054
    }
 
1055
  else
 
1056
    {
 
1057
      for (i = 0; i < 100; i++)
 
1058
        {
 
1059
          if (kQueryPosition (devc, gphwi,
 
1060
                              AllegroWave->DspClientInstance,
 
1061
                              TRUE, &BufferPosition) == KRETURN_SUCCESS)
 
1062
            break;
 
1063
        }
 
1064
 
 
1065
#if 0
 
1066
      if (BufferPosition >= AllegroWave->Length)
 
1067
        {
 
1068
          dprintf1 (("!%d ", BufferPosition));
 
1069
          BufferPosition = 0;
 
1070
        }
 
1071
#endif
 
1072
      Position = BufferPosition % AllegroWave->Length;
 
1073
    }
 
1074
 
 
1075
  KeReleaseSpinLock (&gpGDI->ControlSpinLock, OldIrql);
 
1076
 
 
1077
  return (Position);
 
1078
}                               /* GetPosition */
 
1079
 
 
1080
 
 
1081
void
 
1082
SetFormat (allegro_devc * devc, IN PALLEGRO_WAVE AllegroWave,
 
1083
           IN PWAVE_INFO WaveInfo)
 
1084
{
 
1085
 
 
1086
  /* close previous client if it is SRC and sampling rate is different */
 
1087
  if (AllegroWave->DspClientInstance &&
 
1088
      STREAM_TYPE_DSPSRC == AllegroWave->StreamType &&
 
1089
      WaveInfo->SamplesPerSec != AllegroWave->Frequency)
 
1090
    {
 
1091
      dprintf1 (("SetFormat CloseInstance:%x",
 
1092
                 AllegroWave->DspClientInstance));
 
1093
      if (kCloseInstance
 
1094
          (devc, gphwi, AllegroWave->DspClientInstance,
 
1095
           KOPENCLOSE_SYNCHRONOUS) != KRETURN_SUCCESS)
 
1096
        {
 
1097
           _Debug_Printf_Service ("Close inst!\n");
 
1098
           num_errors++;
 
1099
        }
 
1100
 
 
1101
#if 0
 
1102
      if (WAVE_CAPTURE == AllegroWave->WaveType)
 
1103
        AllocateSRCRec = FALSE;
 
1104
      else
 
1105
        AllocateSRCPlay = FALSE;
 
1106
#else
 
1107
      AllocateSRCPlay = FALSE;
 
1108
      AllocateSRCRec = FALSE;
 
1109
#endif
 
1110
      AllegroWave->DspClientInstance = NULL;
 
1111
      AllegroWave->StreamType = STREAM_TYPE_NULL;
 
1112
    }
 
1113
  AllegroWave->FormatStereo = (WaveInfo->Channels == 2);
 
1114
  AllegroWave->Format16Bit = (WaveInfo->BitsPerSample == 16);
 
1115
  AllegroWave->Frequency = WaveInfo->SamplesPerSec;
 
1116
 
 
1117
  dprintf1 (("SetFormat:%d,%d,%d", WaveInfo->SamplesPerSec,
 
1118
             WaveInfo->BitsPerSample, WaveInfo->Channels));
 
1119
}                               /* SetFormat */
 
1120
 
 
1121
 
 
1122
void
 
1123
SetState (allegro_devc * devc,
 
1124
          IN PALLEGRO_WAVE AllegroWave, IN KSSTATE NewState)
 
1125
{
 
1126
  KIRQL OldIrql;
 
1127
 
 
1128
  dprintf1 (("SetState=(%x, %x)", AllegroWave->State, NewState));
 
1129
  KeAcquireSpinLock (&gpGDI->ControlSpinLock, &OldIrql);
 
1130
  if (AllegroWave->State != NewState)
 
1131
    {
 
1132
      switch (NewState)
 
1133
        {
 
1134
        case KSSTATE_STOP:
 
1135
 
 
1136
 
 
1137
          AllegroWave->PositionBeforePaused = 0;
 
1138
          if (KSSTATE_RUN == AllegroWave->State)
 
1139
            {
 
1140
              StreamsRunning--;
 
1141
 
 
1142
              if (!StreamsRunning)
 
1143
                {
 
1144
                  kSetTimer (devc, gphwi, 0);
 
1145
                  WRITE_PORT_USHORT (devc->osdev, (devc->base + 0x18),
 
1146
                                     READ_PORT_USHORT (devc->osdev,
 
1147
                                                       (devc->base + 0x18)) &
 
1148
                                     ~CLKRUN_GEN_ENABLE);
 
1149
                }
 
1150
              SRCMGR_Stop (devc, AllegroWave);
 
1151
            }
 
1152
          break;
 
1153
 
 
1154
        case KSSTATE_RUN:
 
1155
 
 
1156
 
 
1157
          /* client not opened */
 
1158
          if (!AllegroWave->DspClientInstance)
 
1159
            {
 
1160
              SRCMGR_SetupStream (devc, AllegroWave);
 
1161
            }
 
1162
 
 
1163
          /*  start the transfer on whatevr method specified */
 
1164
          switch (AllegroWave->StreamType)
 
1165
            {
 
1166
            case STREAM_TYPE_DSPMSRC:
 
1167
              if (WAVE_CAPTURE == AllegroWave->WaveType)
 
1168
                SRCMGR_StartRecord (devc, AllegroWave);
 
1169
              else
 
1170
                SRCMGR_StartPlay (devc, AllegroWave);
 
1171
              break;
 
1172
            }
 
1173
 
 
1174
          StreamsRunning++;
 
1175
 
 
1176
          if (1 == StreamsRunning)
 
1177
            {
 
1178
              /* 4 ms * 12000 / 1000 */
 
1179
              kSetTimer (devc, gphwi, 240);
 
1180
              WRITE_PORT_USHORT (devc->osdev, (devc->base + 0x18),
 
1181
                                 READ_PORT_USHORT (devc->osdev,
 
1182
                                                   (devc->base + 0x18)) |
 
1183
                                 CLKRUN_GEN_ENABLE);
 
1184
            }
 
1185
 
 
1186
          break;
 
1187
        }
 
1188
      AllegroWave->State = NewState;
 
1189
    }
 
1190
  KeReleaseSpinLock (&gpGDI->ControlSpinLock, OldIrql);
 
1191
}                               /* SetState */
 
1192
 
 
1193
#ifdef later
 
1194
ULONG
 
1195
GetMidiPosition ()
 
1196
{
 
1197
  return SRCMGR_GetPosition (devc, MidiStream);
 
1198
}
 
1199
 
 
1200
PCLIENT_INST pClient;
 
1201
#define DBG_TRACE dprintf1
 
1202
 
 
1203
DWORD
 
1204
InitModem (allegro_devc * devc)
 
1205
{
 
1206
  int cnt = 0;
 
1207
  int wRC, retry = 0;
 
1208
 
 
1209
  do
 
1210
    {
 
1211
      wRC = kOpenInstance (devc, gphwi, CLIENT_MODEM, 0, 512 * 2 + 64, &pClient);       /* HSP_Open */
 
1212
    }
 
1213
  while ((wRC != KRETURN_SUCCESS) && (cnt++ < 100));    /* enddo */
 
1214
 
 
1215
  if (wRC != KRETURN_SUCCESS)
 
1216
    {
 
1217
      DBG_TRACE (("KOpenInstance from HSP modem fail"));
 
1218
      return FALSE;
 
1219
    }                           /* endif */
 
1220
  DBG_TRACE (("KOpenInstance from HSP modem OK"));
 
1221
 
 
1222
  dprintf1 (("pClient Area=%x", pClient->dwDspDataClientArea));
 
1223
  /* setup the outbuffer address and length so Kernel can */
 
1224
  /* move the output data to MIXER */
 
1225
 
 
1226
  retry = 0;
 
1227
  do
 
1228
    {
 
1229
 
 
1230
      wRC = kStartTransfer (devc, gphwi,
 
1231
                            pClient,
 
1232
                            NULL,
 
1233
                            NULL,
 
1234
                            0,
 
1235
                            NULL,
 
1236
                            0,
 
1237
                            NULL,
 
1238
                            0,
 
1239
                            pClient->dwDspDataClientArea + 32,
 
1240
                            128, KCONNECT_NONE, KCONNECT_MIXER);
 
1241
 
 
1242
#if ALLEGRO_DEBUG
 
1243
      if (wRC != KRETURN_SUCCESS)
 
1244
        {
 
1245
          DBG_TRACE (("kStartTransfer fail"));
 
1246
        }                       /* endif */
 
1247
#endif
 
1248
    }
 
1249
  while ((wRC != KRETURN_SUCCESS) && (retry++ < 100));  /* enddo */
 
1250
 
 
1251
 
 
1252
  if (wRC != KRETURN_SUCCESS)
 
1253
    {
 
1254
      DBG_TRACE (("kStartTransfer fail"));
 
1255
      kCloseInstance (gphwi, pClient, 0);
 
1256
#pragma message("----Closing client, can we handle this?")
 
1257
      return FALSE;
 
1258
    }
 
1259
  else
 
1260
    {
 
1261
      DBG_TRACE (("kStartTransfer OK"));
 
1262
    }                           /* endif */
 
1263
  return TRUE;
 
1264
 
 
1265
}
 
1266
 
 
1267
VOID
 
1268
CloseModem ()
 
1269
{
 
1270
 
 
1271
  int cnt = 0;
 
1272
  int wRC;
 
1273
 
 
1274
  cnt = 0;
 
1275
  if (!pClient)
 
1276
    return;
 
1277
 
 
1278
  do
 
1279
    {
 
1280
      wRC = kStopTransfer (devc, gphwi, pClient);
 
1281
#if ALLEGRO_DEBUG
 
1282
      if (wRC != KRETURN_SUCCESS)
 
1283
        {
 
1284
          DBG_TRACE (("DSPStopXfer fail"));
 
1285
        }                       /* endif */
 
1286
#endif
 
1287
    }
 
1288
  while ((wRC != KRETURN_SUCCESS) && (cnt++ < 100));
 
1289
 
 
1290
  cnt = 0;
 
1291
  do
 
1292
    {
 
1293
      wRC = kCloseInstance (devc, gphwi, pClient, 0);
 
1294
    }
 
1295
  while ((wRC != KRETURN_SUCCESS) && (cnt++ < 100));    /* enddo */
 
1296
 
 
1297
}
 
1298
#endif
 
1299
 
 
1300
void
 
1301
SRCMGR_SetPassThruVolume (allegro_devc * devc, IN PPASSTHRU client,
 
1302
                          IN USHORT left, IN USHORT right)
 
1303
{
 
1304
  USHORT lvalue;
 
1305
  USHORT rvalue;
 
1306
 
 
1307
  if (client)
 
1308
    {
 
1309
      lvalue = left >> 1;
 
1310
      rvalue = right >> 1;
 
1311
 
 
1312
      kSetPassThruVolume (devc, gphwi, client, lvalue, rvalue);
 
1313
      dprintf3 (("kSetPassThruVolume %x %x", lvalue, rvalue));
 
1314
    }
 
1315
}                               /* SRCMGR_SetPassThruVolume */
 
1316
 
 
1317
void
 
1318
SRCMGR_SetPassThruRearVolume (allegro_devc * devc, IN PPASSTHRU client,
 
1319
                              IN USHORT left, IN USHORT right)
 
1320
{
 
1321
  USHORT lvalue;
 
1322
  USHORT rvalue;
 
1323
 
 
1324
  if (!client)
 
1325
    return;
 
1326
 
 
1327
  /*LeftPassThruVolRear = left; */
 
1328
  /*RightPassThruVolRear = right; */
 
1329
 
 
1330
 
 
1331
  if (client)
 
1332
    {
 
1333
      lvalue = left >> 1;
 
1334
      rvalue = right >> 1;
 
1335
 
 
1336
      kSetPassThruRearVolume (devc, gphwi, client, lvalue, rvalue);
 
1337
    }
 
1338
}                               /* SRCMGR_SetPassThruRearVolume */