workbench/devs/AHI/Drivers/AROS/aros-main.c

   1
   2 /*
   3  *  This is a driver for hosted AROS, using oss.library.
   4  */
   5
   6 #include <config.h>
   7
   8 #include <devices/ahi.h>
   9 #include <dos/dostags.h>
  10 #include <exec/memory.h>
  11 #include <libraries/ahi_sub.h>
  12 #include <proto/ahi_sub.h>
  13 #include <proto/exec.h>
  14 #include <proto/dos.h>
  15 #include <proto/utility.h>
  16
  17 #include <stddef.h>
  18
  19 #include "library.h"
  20 #include "DriverData.h"
  21
  22 void
  23 SlaveEntry( void );
  24
  25 PROCGW( static, void,  slaveentry, SlaveEntry );
  26
  27
  28 /*  Since I have no idea what frequencies OSS supports, and there
  29  *  doesn't seem to be an easy way to find out either, I've just
  30  *  selected a few common frequencies that are likely to work.
  31  */
  32
  33 static const LONG frequencies[] =
  34 {
  35   8000,     // µ- and A-Law (telephone)
  36   11025,    // CD/4
  37   22050,    // CD/2
  38   44100,    // CD
  39   48000,    // DAT
  40 };
  41
  42 #define FREQUENCIES (sizeof frequencies / sizeof frequencies[ 0 ])
  43
  44 /******************************************************************************
  45 ** AHIsub_AllocAudio **********************************************************
  46 ******************************************************************************/
  47
  48 ULONG
  49 _AHIsub_AllocAudio( struct TagItem*         taglist,
  50                     struct AHIAudioCtrlDrv* AudioCtrl,
  51                     struct DriverBase*      AHIsubBase )
  52 {
  53   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
  54   int freq = AudioCtrl->ahiac_MixFreq;
  55
  56   AudioCtrl->ahiac_DriverData = AllocVec( sizeof( struct AROSData ),
  57                  MEMF_CLEAR | MEMF_PUBLIC );
  58
  59 #define dd ((struct AROSData*) AudioCtrl->ahiac_DriverData)
  60
  61   if( dd != NULL )
  62   {
  63     dd->slavesignal      = -1;
  64     dd->mastersignal     = AllocSignal( -1 );
  65     dd->mastertask       = (struct Process*) FindTask( NULL );
  66     dd->ahisubbase       = AROSBase;
  67   }
  68   else
  69   {
  70     return AHISF_ERROR;
  71   }
  72
  73   if( dd->mastersignal == -1 )
  74   {
  75     return AHISF_ERROR;
  76   }
  77
  78   if( ! OSS_Open( "/dev/dsp", FALSE, TRUE, FALSE ) )
  79   {
  80     return AHISF_ERROR;
  81   }
  82
  83   // 32 fragments times 256 bytes each
  84
  85   if( ! OSS_SetFragmentSize( 32, 8 ) )
  86   {
  87     Req( "OSS device does not support a fragment size of 1024." );
  88     return AHIE_UNKNOWN;
  89   }
  90
  91   if( ! OSS_FormatSupported_S16LE() || ! OSS_SetFormat_S16LE() )
  92   {
  93     Req( "OSS device does not support 16 bit little endian samples!" );
  94     return AHISF_ERROR;
  95   }
  96
  97   if( ! OSS_SetWriteRate( freq, &freq ) )
  98   {
  99     Req( "OSS device does not support the requested frequency." );
 100     return AHISF_ERROR;
 101   }
 102
 103   AudioCtrl->ahiac_MixFreq = freq;
 104
 105   return ( AHISF_KNOWHIFI |
 106            AHISF_KNOWSTEREO |
 107            AHISF_MIXING |
 108            AHISF_TIMING );
 109 }
 110
 111
 112 /******************************************************************************
 113 ** AHIsub_FreeAudio ***********************************************************
 114 ******************************************************************************/
 115
 116 void
 117 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
 118                    struct DriverBase*      AHIsubBase )
 119 {
 120   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 121
 122   if( AudioCtrl->ahiac_DriverData != NULL )
 123   {
 124     OSS_Reset();
 125     OSS_Close();
 126     FreeSignal( dd->mastersignal );
 127     FreeVec( AudioCtrl->ahiac_DriverData );
 128     AudioCtrl->ahiac_DriverData = NULL;
 129   }
 130 }
 131
 132
 133 /******************************************************************************
 134 ** AHIsub_Disable *************************************************************
 135 ******************************************************************************/
 136
 137 void
 138 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 139                  struct DriverBase*      AHIsubBase )
 140 {
 141   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 142
 143   // V6 drivers do not have to preserve all registers
 144
 145   Forbid();
 146 }
 147
 148
 149 /******************************************************************************
 150 ** AHIsub_Enable **************************************************************
 151 ******************************************************************************/
 152
 153 void
 154 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 155                 struct DriverBase*      AHIsubBase )
 156 {
 157   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 158
 159   // V6 drivers do not have to preserve all registers
 160
 161   Permit();
 162 }
 163
 164
 165 /******************************************************************************
 166 ** AHIsub_Start ***************************************************************
 167 ******************************************************************************/
 168
 169 ULONG
 170 _AHIsub_Start( ULONG                   flags,
 171                struct AHIAudioCtrlDrv* AudioCtrl,
 172                struct DriverBase*      AHIsubBase )
 173 {
 174   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 175
 176   AHIsub_Stop( flags, AudioCtrl );
 177
 178   if(flags & AHISF_PLAY)
 179   {
 180     int freq = AudioCtrl->ahiac_MixFreq;
 181
 182     struct TagItem proctags[] =
 183       {
 184         { NP_Entry,     (IPTR) &slaveentry },
 185         { NP_Name,      (IPTR) LibName     },
 186         { NP_Priority,  127                 },
 187         { TAG_DONE,     0                   }
 188       };
 189
 190
 191     dd->mixbuffer = AllocVec( AudioCtrl->ahiac_BuffSize,
 192                               MEMF_ANY | MEMF_PUBLIC );
 193
 194     if( dd->mixbuffer == NULL ) return AHIE_NOMEM;
 195
 196     Forbid();
 197
 198     dd->slavetask = CreateNewProc( proctags );
 199
 200     if( dd->slavetask != NULL )
 201     {
 202       dd->slavetask->pr_Task.tc_UserData = AudioCtrl;
 203     }
 204
 205     Permit();
 206
 207     if( dd->slavetask != NULL )
 208     {
 209       Wait( 1L << dd->mastersignal );  // Wait for slave to come alive
 210
 211       if( dd->slavetask == NULL )      // Is slave alive or dead?
 212       {
 213         return AHIE_UNKNOWN;
 214       }
 215     }
 216     else
 217     {
 218       return AHIE_NOMEM;                 // Well, out of memory or whatever...
 219     }
 220
 221     // Since OSS kind of sucks, we have to close and reopen it here ...
 222
 223     Forbid(); /* To prevent slave task from calling OSS_GetOutputInfo
 224                  inbetween OSS_Open/OSS_Close */
 225     OSS_Close();
 226
 227     if( ! OSS_Open( "/dev/dsp", FALSE, TRUE, FALSE ) )
 228     {
 229       Req( "OSS device would not reopen." );
 230       return AHIE_UNKNOWN;
 231     }
 232     Permit();
 233
 234     // 32 fragments times 256 bytes each
 235
 236     if( ! OSS_SetFragmentSize( 32, 8 ) )
 237     {
 238       Req( "OSS device does not support a fragment size of 1024." );
 239       return AHIE_UNKNOWN;
 240     }
 241
 242     switch( AudioCtrl->ahiac_BuffType )
 243     {
 244       case AHIST_M16S:
 245       case AHIST_M32S:
 246         if( ! OSS_SetMono() )
 247         {
 248           Req( "OSS device does not support mono samples." );
 249           return AHIE_UNKNOWN;
 250         }
 251         break;
 252
 253       case AHIST_S16S:
 254       case AHIST_S32S:
 255         if( ! OSS_SetStereo() )
 256         {
 257           Req( "OSS device does not support stereo samples." );
 258           return AHIE_UNKNOWN;
 259         }
 260         break;
 261
 262       default:
 263         Req( "Unknown sample format requested: %08lx",
 264              AudioCtrl->ahiac_BuffType );
 265         return AHIE_UNKNOWN;
 266     }
 267
 268     if( ! OSS_SetFormat_S16LE() )
 269     {
 270       Req( "OSS device does not support 16 bit little endian samples!" );
 271       return AHIE_UNKNOWN;
 272     }
 273
 274     if( ! OSS_SetWriteRate( freq, &freq ) )
 275     {
 276       Req( "OSS device does not support the requested frequency." );
 277       return AHIE_UNKNOWN;
 278     }
 279   }
 280
 281   if( flags & AHISF_RECORD )
 282   {
 283     return AHIE_UNKNOWN;
 284   }
 285
 286   return AHIE_OK;
 287 }
 288
 289
 290 /******************************************************************************
 291 ** AHIsub_Update **************************************************************
 292 ******************************************************************************/
 293
 294 void
 295 _AHIsub_Update( ULONG                   flags,
 296                 struct AHIAudioCtrlDrv* AudioCtrl,
 297                 struct DriverBase*      AHIsubBase )
 298 {
 299   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 300
 301   // Empty function
 302 }
 303
 304
 305 /******************************************************************************
 306 ** AHIsub_Stop ****************************************************************
 307 ******************************************************************************/
 308
 309 void
 310 _AHIsub_Stop( ULONG                   flags,
 311               struct AHIAudioCtrlDrv* AudioCtrl,
 312               struct DriverBase*      AHIsubBase )
 313 {
 314   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 315
 316   if( flags & AHISF_PLAY )
 317   {
 318     if( dd->slavetask != NULL )
 319     {
 320       if( dd->slavesignal != -1 )
 321       {
 322         Signal( (struct Task*) dd->slavetask,
 323                 1L << dd->slavesignal );         // Kill him!
 324       }
 325
 326       Wait( 1L << dd->mastersignal );            // Wait for slave to die
 327     }
 328
 329     FreeVec( dd->mixbuffer );
 330     dd->mixbuffer = NULL;
 331   }
 332
 333   if(flags & AHISF_RECORD)
 334   {
 335     // Do nothing
 336   }
 337 }
 338
 339
 340 /******************************************************************************
 341 ** AHIsub_GetAttr *************************************************************
 342 ******************************************************************************/
 343
 344 IPTR
 345 _AHIsub_GetAttr( ULONG                   attribute,
 346                  LONG                    argument,
 347                  IPTR                    def,
 348                  struct TagItem*         taglist,
 349                  struct AHIAudioCtrlDrv* AudioCtrl,
 350                  struct DriverBase*      AHIsubBase )
 351 {
 352   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 353   size_t i;
 354
 355   switch( attribute )
 356   {
 357     case AHIDB_Bits:
 358       return 16;
 359
 360     case AHIDB_Frequencies:
 361       return FREQUENCIES;
 362
 363     case AHIDB_Frequency: // Index->Frequency
 364       return (LONG) frequencies[ argument ];
 365
 366     case AHIDB_Index: // Frequency->Index
 367       if( argument <= frequencies[ 0 ] )
 368       {
 369         return 0;
 370       }
 371
 372       if( argument >= frequencies[ FREQUENCIES - 1 ] )
 373       {
 374         return FREQUENCIES - 1;
 375       }
 376
 377       for( i = 1; i < FREQUENCIES; i++ )
 378       {
 379         if( frequencies[ i ] > argument )
 380         {
 381           if( ( argument - frequencies[ i - 1 ] ) <
 382               ( frequencies[ i ] - argument ) )
 383           {
 384             return i-1;
 385           }
 386           else
 387           {
 388             return i;
 389           }
 390         }
 391       }
 392
 393       return 0;  // Will not happen
 394
 395     case AHIDB_Author:
 396       return (IPTR) "Martin 'Leviticus' Blom";
 397
 398     case AHIDB_Copyright:
 399       return (IPTR) "Public Domain";
 400
 401     case AHIDB_Version:
 402       return (IPTR) LibIDString;
 403
 404     case AHIDB_Record:
 405       return FALSE;
 406
 407     case AHIDB_Realtime:
 408       return TRUE;
 409
 410     case AHIDB_Outputs:
 411       return 1;
 412
 413     case AHIDB_Output:
 414       return (IPTR) "AROS";    // We have only one "output"!
 415
 416     default:
 417       return def;
 418   }
 419 }
 420
 421
 422 /******************************************************************************
 423 ** AHIsub_HardwareControl *****************************************************
 424 ******************************************************************************/
 425
 426 ULONG
 427 _AHIsub_HardwareControl( ULONG                   attribute,
 428                          LONG                    argument,
 429                          struct AHIAudioCtrlDrv* AudioCtrl,
 430                          struct DriverBase*      AHIsubBase )
 431 {
 432   struct AROSBase* AROSBase = (struct AROSBase*) AHIsubBase;
 433
 434   return 0;
 435 }