ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/audio.cpp
(Generate patch)

Comparing BasiliskII/src/audio.cpp (file contents):
Revision 1.1.1.1 by cebix, 1999-10-03T14:16:25Z vs.
Revision 1.9 by cebix, 2001-07-11T19:26:13Z

# Line 1 | Line 1
1   /*
2   *  audio.cpp - Audio support
3   *
4 < *  Basilisk II (C) 1997-1999 Christian Bauer
4 > *  Basilisk II (C) 1997-2001 Christian Bauer
5   *  Portions (C) 1997-1999 Marc Hellwig
6   *
7   *  This program is free software; you can redistribute it and/or modify
# Line 36 | Line 36
36   #include "debug.h"
37  
38  
39 + // Supported sample rates, sizes and channels
40 + vector<uint32> audio_sample_rates;
41 + vector<uint16> audio_sample_sizes;
42 + vector<uint16> audio_channel_counts;
43 +
44   // Global variables
45   struct audio_status AudioStatus;        // Current audio status (sample rate etc.)
46   bool audio_open = false;                        // Flag: audio is initialized and ready
# Line 48 | Line 53 | bool AudioAvailable = false;           // Flag: a
53  
54  
55   /*
56 + *  Reset audio emulation
57 + */
58 +
59 + void AudioReset(void)
60 + {
61 +        audio_data = 0;
62 + }
63 +
64 +
65 + /*
66   *  Get audio info
67   */
68  
# Line 55 | Line 70 | static int32 AudioGetInfo(uint32 infoPtr
70   {
71          D(bug(" AudioGetInfo %c%c%c%c, infoPtr %08lx, source ID %08lx\n", selector >> 24, (selector >> 16) & 0xff, (selector >> 8) & 0xff, selector & 0xff, infoPtr, sourceID));
72          M68kRegisters r;
58 –        int i;
73  
74          switch (selector) {
75                  case siSampleSize:
# Line 63 | Line 77 | static int32 AudioGetInfo(uint32 infoPtr
77                          break;
78  
79                  case siSampleSizeAvailable: {
80 <                        r.d[0] = audio_num_sample_sizes * 2;
80 >                        r.d[0] = audio_sample_sizes.size() * 2;
81                          Execute68kTrap(0xa122, &r);     // NewHandle()
82                          uint32 h = r.a[0];
83                          if (h == 0)
84                                  return memFullErr;
85 <                        WriteMacInt16(infoPtr + sil_count, audio_num_sample_sizes);
85 >                        WriteMacInt16(infoPtr + sil_count, audio_sample_sizes.size());
86                          WriteMacInt32(infoPtr + sil_infoHandle, h);
87                          uint32 sp = ReadMacInt32(h);
88 <                        for (i=0; i<audio_num_sample_sizes; i++)
88 >                        for (unsigned i=0; i<audio_sample_sizes.size(); i++)
89                                  WriteMacInt16(sp + i*2, audio_sample_sizes[i]);
90                          break;
91                  }
# Line 81 | Line 95 | static int32 AudioGetInfo(uint32 infoPtr
95                          break;
96  
97                  case siChannelAvailable: {
98 <                        r.d[0] = audio_num_channel_counts * 2;
98 >                        r.d[0] = audio_channel_counts.size() * 2;
99                          Execute68kTrap(0xa122, &r);     // NewHandle()
100                          uint32 h = r.a[0];
101                          if (h == 0)
102                                  return memFullErr;
103 <                        WriteMacInt16(infoPtr + sil_count, audio_num_channel_counts);
103 >                        WriteMacInt16(infoPtr + sil_count, audio_channel_counts.size());
104                          WriteMacInt32(infoPtr + sil_infoHandle, h);
105                          uint32 sp = ReadMacInt32(h);
106 <                        for (i=0; i<audio_num_channel_counts; i++)
106 >                        for (unsigned i=0; i<audio_channel_counts.size(); i++)
107                                  WriteMacInt16(sp + i*2, audio_channel_counts[i]);
108                          break;
109                  }
# Line 99 | Line 113 | static int32 AudioGetInfo(uint32 infoPtr
113                          break;
114  
115                  case siSampleRateAvailable: {
116 <                        r.d[0] = audio_num_sample_rates * 4;
116 >                        r.d[0] = audio_sample_rates.size() * 4;
117                          Execute68kTrap(0xa122, &r);     // NewHandle()
118                          uint32 h = r.a[0];
119                          if (h == 0)
120                                  return memFullErr;
121 <                        WriteMacInt16(infoPtr + sil_count, audio_num_sample_rates);
121 >                        WriteMacInt16(infoPtr + sil_count, audio_sample_rates.size());
122                          WriteMacInt32(infoPtr + sil_infoHandle, h);
123                          uint32 lp = ReadMacInt32(h);
124 <                        for (i=0; i<audio_num_sample_rates; i++)
124 >                        for (unsigned i=0; i<audio_sample_rates.size(); i++)
125                                  WriteMacInt32(lp + i*4, audio_sample_rates[i]);
126                          break;
127                  }
128  
129                  case siSpeakerMute:
130 <                        WriteMacInt16(infoPtr, audio_get_main_mute());
130 >                        WriteMacInt16(infoPtr, audio_get_speaker_mute());
131                          break;
132  
133                  case siSpeakerVolume:
134 <                        WriteMacInt32(infoPtr, audio_get_main_volume());
134 >                        WriteMacInt32(infoPtr, audio_get_speaker_volume());
135 >                        break;
136 >
137 >                case siHeadphoneMute:
138 >                        WriteMacInt16(infoPtr, 0);
139 >                        break;
140 >
141 >                case siHeadphoneVolume:
142 >                        WriteMacInt32(infoPtr, 0x01000100);
143 >                        break;
144 >
145 >                case siHeadphoneVolumeSteps:
146 >                        WriteMacInt16(infoPtr, 13);
147                          break;
148  
149                  case siHardwareMute:
150 <                        WriteMacInt16(infoPtr, audio_get_dac_mute());
150 >                        WriteMacInt16(infoPtr, audio_get_main_mute());
151                          break;
152  
153                  case siHardwareVolume:
154 <                        WriteMacInt32(infoPtr, audio_get_dac_volume());
154 >                        WriteMacInt32(infoPtr, audio_get_main_volume());
155                          break;
156  
157 <                case siHardwareBusy:
158 <                        WriteMacInt16(infoPtr, AudioStatus.num_sources != 0);
157 >                case siHardwareVolumeSteps:
158 >                        WriteMacInt16(infoPtr, 13);
159                          break;
160  
161 <                case siHardwareVolumeSteps:
162 <                        WriteMacInt16(infoPtr, 64);
161 >                case siHardwareBusy:
162 >                        WriteMacInt16(infoPtr, AudioStatus.num_sources != 0);
163                          break;
164  
165                  default:        // Delegate to Apple Mixer
# Line 160 | Line 186 | static int32 AudioSetInfo(uint32 infoPtr
186   {
187          D(bug(" AudioSetInfo %c%c%c%c, infoPtr %08lx, source ID %08lx\n", selector >> 24, (selector >> 16) & 0xff, (selector >> 8) & 0xff, selector & 0xff, infoPtr, sourceID));
188          M68kRegisters r;
163 –        int i;
189  
190          switch (selector) {
191                  case siSampleSize:
192                          D(bug("  set sample size %08lx\n", infoPtr));
193                          if (AudioStatus.num_sources)
194                                  return siDeviceBusyErr;
195 <                        for (i=0; i<audio_num_sample_sizes; i++)
195 >                        if (infoPtr == AudioStatus.sample_size)
196 >                                return noErr;
197 >                        for (unsigned i=0; i<audio_sample_sizes.size(); i++)
198                                  if (audio_sample_sizes[i] == infoPtr) {
199 <                                        audio_set_sample_size(i);
200 <                                        return noErr;
199 >                                        if (audio_set_sample_size(i))
200 >                                                return noErr;
201 >                                        else
202 >                                                return siInvalidSampleSize;
203                                  }
204                          return siInvalidSampleSize;
205  
# Line 178 | Line 207 | static int32 AudioSetInfo(uint32 infoPtr
207                          D(bug("  set sample rate %08lx\n", infoPtr));
208                          if (AudioStatus.num_sources)
209                                  return siDeviceBusyErr;
210 <                        for (i=0; i<audio_num_sample_rates; i++)
210 >                        if (infoPtr == AudioStatus.sample_rate)
211 >                                return noErr;
212 >                        for (unsigned i=0; i<audio_sample_rates.size(); i++)
213                                  if (audio_sample_rates[i] == infoPtr) {
214 <                                        audio_set_sample_rate(i);
215 <                                        return noErr;
214 >                                        if (audio_set_sample_rate(i))
215 >                                                return noErr;
216 >                                        else
217 >                                                return siInvalidSampleRate;
218                                  }
219                          return siInvalidSampleRate;
220  
# Line 189 | Line 222 | static int32 AudioSetInfo(uint32 infoPtr
222                          D(bug("  set number of channels %08lx\n", infoPtr));
223                          if (AudioStatus.num_sources)
224                                  return siDeviceBusyErr;
225 <                        for (i=0; i<audio_num_channel_counts; i++)
225 >                        if (infoPtr == AudioStatus.channels)
226 >                                return noErr;
227 >                        for (unsigned i=0; i<audio_channel_counts.size(); i++)
228                                  if (audio_channel_counts[i] == infoPtr) {
229 <                                        audio_set_channels(i);
230 <                                        return noErr;
229 >                                        if (audio_set_channels(i))
230 >                                                return noErr;
231 >                                        else
232 >                                                return badChannel;
233                                  }
234                          return badChannel;
235  
236                  case siSpeakerMute:
237 <                        audio_set_main_mute((uint16)infoPtr);
237 >                        audio_set_speaker_mute((uint16)infoPtr);
238                          break;
239  
240                  case siSpeakerVolume:
241                          D(bug("  set speaker volume %08lx\n", infoPtr));
242 <                        audio_set_main_volume(infoPtr);
242 >                        audio_set_speaker_volume(infoPtr);
243 >                        break;
244 >
245 >                case siHeadphoneMute:
246 >                case siHeadphoneVolume:
247                          break;
248  
249                  case siHardwareMute:
250 <                        audio_set_dac_mute((uint16)infoPtr);
250 >                        audio_set_main_mute((uint16)infoPtr);
251                          break;
252  
253                  case siHardwareVolume:
254                          D(bug("  set hardware volume %08lx\n", infoPtr));
255 <                        audio_set_dac_volume(infoPtr);
255 >                        audio_set_main_volume(infoPtr);
256                          break;
257  
258                  default:        // Delegate to Apple Mixer
# Line 351 | Line 392 | adat_error:    printf("FATAL: audio compone
392                          return noErr;
393  
394                  case kComponentVersionSelect:
395 <                        return 0x00010002;
395 >                        return 0x00010003;
396  
397                  case kComponentCloseSelect:
398                          open_count--;
# Line 378 | Line 419 | adat_error:    printf("FATAL: audio compone
419  
420                          // Init sound component data
421                          WriteMacInt32(audio_data + adatData + scd_flags, 0);
422 <                        WriteMacInt32(audio_data + adatData + scd_format, AudioStatus.sample_size == 16 ? 'twos' : 'raw ');
422 >                        WriteMacInt32(audio_data + adatData + scd_format, AudioStatus.sample_size == 16 ? FOURCC('t','w','o','s') : FOURCC('r','a','w',' '));
423                          WriteMacInt16(audio_data + adatData + scd_numChannels, AudioStatus.channels);
424                          WriteMacInt16(audio_data + adatData + scd_sampleSize, AudioStatus.sample_size);
425                          WriteMacInt32(audio_data + adatData + scd_sampleRate, AudioStatus.sample_rate);
# Line 444 | Line 485 | delegate:      // Delegate call to Apple Mixe
485                          return badComponentSelector;
486          }
487   }
488 +
489 +
490 + /*
491 + *  Sound input driver Open() routine
492 + */
493 +
494 + int16 SoundInOpen(uint32 pb, uint32 dce)
495 + {
496 +        D(bug("SoundInOpen\n"));
497 +        return noErr;
498 + }
499 +
500 +
501 + /*
502 + *  Sound input driver Prime() routine
503 + */
504 +
505 + int16 SoundInPrime(uint32 pb, uint32 dce)
506 + {
507 +        D(bug("SoundInPrime\n"));
508 +        //!!
509 +        return paramErr;
510 + }
511 +
512 +
513 + /*
514 + *  Sound input driver Control() routine
515 + */
516 +
517 + int16 SoundInControl(uint32 pb, uint32 dce)
518 + {
519 +        uint16 code = ReadMacInt16(pb + csCode);
520 +        D(bug("SoundInControl %d\n", code));
521 +
522 +        if (code == 1) {
523 +                D(bug(" SoundInKillIO\n"));
524 +                //!!
525 +                return noErr;
526 +        }
527 +
528 +        if (code != 2)
529 +                return -231;    // siUnknownInfoType
530 +
531 +        uint32 *param = (uint32 *)Mac2HostAddr(pb + csParam);
532 +        uint32 selector = param[0];
533 +        D(bug(" selector %c%c%c%c\n", selector >> 24, selector >> 16, selector >> 8, selector));
534 +
535 +        switch (selector) {
536 +                default:
537 +                        return -231;    // siUnknownInfoType
538 +        }
539 + }
540 +
541 +
542 + /*
543 + *  Sound input driver Status() routine
544 + */
545 +
546 + int16 SoundInStatus(uint32 pb, uint32 dce)
547 + {
548 +        uint16 code = ReadMacInt16(pb + csCode);
549 +        D(bug("SoundInStatus %d\n", code));
550 +        if (code != 2)
551 +                return -231;    // siUnknownInfoType
552 +
553 +        uint32 *param = (uint32 *)Mac2HostAddr(pb + csParam);
554 +        uint32 selector = param[0];
555 +        D(bug(" selector %c%c%c%c\n", selector >> 24, selector >> 16, selector >> 8, selector));
556 +        switch (selector) {
557 + #if 0
558 +                case siDeviceName: {
559 +                        const char *str = GetString(STR_SOUND_IN_NAME);
560 +                        param[0] = 0;
561 +                        memcpy((void *)param[1], str, strlen(str));
562 +                        return noErr;
563 +                }
564 +
565 +                case siDeviceIcon: {
566 +                        M68kRegisters r;
567 +                        static const uint16 proc[] = {
568 +                                0x558f,                                 //      subq.l  #2,sp
569 +                                0xa994,                                 //      CurResFile
570 +                                0x4267,                                 //      clr.w   -(sp)
571 +                                0xa998,                                 //      UseResFile
572 +                                0x598f,                                 //      subq.l  #4,sp
573 +                                0x4879, 0x4943, 0x4e23, //      move.l  #'ICN#',-(sp)
574 +                                0x3f3c, 0xbf76,                 //      move.w  #-16522,-(sp)
575 +                                0xa9a0,                                 //      GetResource
576 +                                0x245f,                                 //      move.l  (sp)+,a2
577 +                                0xa998,                                 //      UseResFile
578 +                                0x200a,                                 //      move.l  a2,d0
579 +                                0x6604,                                 //      bne             1
580 +                                0x7000,                                 //  moveq       #0,d0
581 +                                M68K_RTS,
582 +                                0x2f0a,                                 //1 move.l      a2,-(sp)
583 +                                0xa992,                                 //  DetachResource
584 +                                0x204a,                                 //  move.l      a2,a0
585 +                                0xa04a,                                 //      HNoPurge
586 +                                0x7001,                                 //      moveq   #1,d0
587 +                                M68K_RTS
588 +                        };
589 +                        Execute68k((uint32)proc, &r);
590 +                        if (r.d[0]) {
591 +                                param[0] = 4;           // Length of returned data
592 +                                param[1] = r.a[2];      // Handle to icon suite
593 +                                return noErr;
594 +                        } else
595 +                                return -192;            // resNotFound
596 +                }
597 + #endif
598 +                default:
599 +                        return -231;    // siUnknownInfoType
600 +        }
601 + }
602 +
603 +
604 + /*
605 + *  Sound input driver Close() routine
606 + */
607 +
608 + int16 SoundInClose(uint32 pb, uint32 dce)
609 + {
610 +        D(bug("SoundInClose\n"));
611 +        return noErr;
612 + }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines