workbench/devs/AHI/Drivers/Device/device-main.c

   1
   2 /*
   3  *  This is a driver for ahi.device loopback sound
   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 #define dd ((struct DeviceData*) AudioCtrl->ahiac_DriverData)
  23
  24 void
  25 SlaveEntry( void );
  26
  27 PROCGW( static, void,  slaveentry, SlaveEntry );
  28
  29 static const LONG frequencies[] =
  30 {
  31   8000,     // µ- and A-Law (telephone)
  32   11025,    // CD/4
  33   22050,    // CD/2
  34   44100,    // CD
  35   48000,    // DAT
  36 };
  37
  38 #define FREQUENCIES (sizeof frequencies / sizeof frequencies[ 0 ])
  39
  40 /******************************************************************************
  41 ** AHIsub_AllocAudio **********************************************************
  42 ******************************************************************************/
  43
  44 ULONG
  45 _AHIsub_AllocAudio( struct TagItem*         taglist,
  46                     struct AHIAudioCtrlDrv* AudioCtrl,
  47                     struct DriverBase*      AHIsubBase )
  48 {
  49   struct DeviceBase* DeviceBase = (struct DeviceBase*) AHIsubBase;
  50   int freq = AudioCtrl->ahiac_MixFreq;
  51
  52   AudioCtrl->ahiac_DriverData = AllocVec( sizeof( struct DeviceData ),
  53                  MEMF_CLEAR | MEMF_PUBLIC );
  54
  55   if( dd != NULL )
  56   {
  57     dd->slavesignal      = -1;
  58     dd->mastersignal     = AllocSignal( -1 );
  59     dd->mastertask       = (struct Process*) FindTask( NULL );
  60     dd->ahisubbase       = DeviceBase;
  61     dd->unit             = (GetTagData( AHIDB_AudioID, 0, taglist) & 0x0000f000) >> 12;
  62
  63   }
  64   else
  65   {
  66     return AHISF_ERROR;
  67   }
  68
  69   if( dd->mastersignal == -1 )
  70   {
  71     return AHISF_ERROR;
  72   }
  73
  74
  75   // TODO open ahi.device
  76
  77   AudioCtrl->ahiac_MixFreq = freq;
  78
  79   return ( AHISF_KNOWHIFI |
  80            AHISF_KNOWSTEREO |
  81            AHISF_MIXING |
  82            AHISF_TIMING );
  83 }
  84
  85
  86 /******************************************************************************
  87 ** AHIsub_FreeAudio ***********************************************************
  88 ******************************************************************************/
  89
  90 void
  91 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
  92                    struct DriverBase*      AHIsubBase )
  93 {
  94   if( AudioCtrl->ahiac_DriverData != NULL )
  95   {
  96     FreeSignal( dd->mastersignal );
  97     FreeVec( AudioCtrl->ahiac_DriverData );
  98     AudioCtrl->ahiac_DriverData = NULL;
  99   }
 100 }
 101
 102
 103 /******************************************************************************
 104 ** AHIsub_Disable *************************************************************
 105 ******************************************************************************/
 106
 107 void
 108 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 109                  struct DriverBase*      AHIsubBase )
 110 {
 111   // V6 drivers do not have to preserve all registers
 112
 113   Forbid();
 114 }
 115
 116
 117 /******************************************************************************
 118 ** AHIsub_Enable **************************************************************
 119 ******************************************************************************/
 120
 121 void
 122 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 123                 struct DriverBase*      AHIsubBase )
 124 {
 125   // V6 drivers do not have to preserve all registers
 126
 127   Permit();
 128 }
 129
 130
 131 /******************************************************************************
 132 ** AHIsub_Start ***************************************************************
 133 ******************************************************************************/
 134
 135 ULONG
 136 _AHIsub_Start( ULONG                   flags,
 137                struct AHIAudioCtrlDrv* AudioCtrl,
 138                struct DriverBase*      AHIsubBase )
 139 {
 140   struct DeviceBase* DeviceBase = (struct DeviceBase*) AHIsubBase;
 141
 142   AHIsub_Stop( flags, AudioCtrl );
 143
 144   if(flags & AHISF_PLAY)
 145   {
 146     struct TagItem proctags[] =
 147       {
 148         { NP_Entry,     (IPTR)&slaveentry },
 149         { NP_Name,      (IPTR)LibName     },
 150         { NP_Priority,  127               },
 151         { TAG_DONE,     0                 }
 152       };
 153
 154
 155     dd->mixbuffers[ 0 ] = AllocVec( AudioCtrl->ahiac_BuffSize,
 156                                     MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC );
 157
 158     if( dd->mixbuffers[ 0 ] == NULL ) return AHIE_NOMEM;
 159
 160     dd->mixbuffers[ 1 ] = AllocVec( AudioCtrl->ahiac_BuffSize,
 161                                     MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC );
 162
 163     if( dd->mixbuffers[ 1 ] == NULL ) return AHIE_NOMEM;
 164
 165     Forbid();
 166
 167     dd->slavetask = CreateNewProc( proctags );
 168
 169     if( dd->slavetask != NULL )
 170     {
 171       dd->slavetask->pr_Task.tc_UserData = AudioCtrl;
 172     }
 173
 174     Permit();
 175
 176     if( dd->slavetask != NULL )
 177     {
 178       Wait( 1L << dd->mastersignal );  // Wait for slave to come alive
 179
 180       if( dd->slavetask == NULL )      // Is slave alive or dead?
 181       {
 182         return AHIE_UNKNOWN;
 183       }
 184     }
 185     else
 186     {
 187       return AHIE_NOMEM;                 // Well, out of memory or whatever...
 188     }
 189   }
 190
 191   if( flags & AHISF_RECORD )
 192   {
 193     return AHIE_UNKNOWN;
 194   }
 195
 196   return AHIE_OK;
 197 }
 198
 199
 200 /******************************************************************************
 201 ** AHIsub_Update **************************************************************
 202 ******************************************************************************/
 203
 204 void
 205 _AHIsub_Update( ULONG                   flags,
 206                 struct AHIAudioCtrlDrv* AudioCtrl,
 207                 struct DriverBase*      AHIsubBase )
 208 {
 209   // Empty function
 210 }
 211
 212
 213 /******************************************************************************
 214 ** AHIsub_Stop ****************************************************************
 215 ******************************************************************************/
 216
 217 void
 218 _AHIsub_Stop( ULONG                   flags,
 219               struct AHIAudioCtrlDrv* AudioCtrl,
 220               struct DriverBase*      AHIsubBase )
 221 {
 222   if( flags & AHISF_PLAY )
 223   {
 224     if( dd->slavetask != NULL )
 225     {
 226       if( dd->slavesignal != -1 )
 227       {
 228         Signal( (struct Task*) dd->slavetask,
 229                 1L << dd->slavesignal );         // Kill him!
 230       }
 231
 232       Wait( 1L << dd->mastersignal );            // Wait for slave to die
 233     }
 234
 235     FreeVec( dd->mixbuffers[ 0 ] );
 236     FreeVec( dd->mixbuffers[ 1 ] );
 237     dd->mixbuffers[ 0 ] = NULL;
 238     dd->mixbuffers[ 1 ] = NULL;
 239   }
 240
 241   if(flags & AHISF_RECORD)
 242   {
 243     // Do nothing
 244   }
 245 }
 246
 247
 248 /******************************************************************************
 249 ** AHIsub_GetAttr *************************************************************
 250 ******************************************************************************/
 251
 252 IPTR
 253 _AHIsub_GetAttr( ULONG                   attribute,
 254                  LONG                    argument,
 255                  IPTR                    def,
 256                  struct TagItem*         taglist,
 257                  struct AHIAudioCtrlDrv* AudioCtrl,
 258                  struct DriverBase*      AHIsubBase )
 259 {
 260   size_t i;
 261
 262   switch( attribute )
 263   {
 264     case AHIDB_Bits:
 265       return 16;
 266
 267     case AHIDB_Frequencies:
 268       return FREQUENCIES;
 269
 270     case AHIDB_Frequency: // Index->Frequency
 271       return (LONG) frequencies[ argument ];
 272
 273     case AHIDB_Index: // Frequency->Index
 274       if( argument <= frequencies[ 0 ] )
 275       {
 276         return 0;
 277       }
 278
 279       if( argument >= frequencies[ FREQUENCIES - 1 ] )
 280       {
 281         return FREQUENCIES - 1;
 282       }
 283
 284       for( i = 1; i < FREQUENCIES; i++ )
 285       {
 286         if( frequencies[ i ] > argument )
 287         {
 288           if( ( argument - frequencies[ i - 1 ] ) <
 289               ( frequencies[ i ] - argument ) )
 290           {
 291             return i-1;
 292           }
 293           else
 294           {
 295             return i;
 296           }
 297         }
 298       }
 299
 300       return 0;  // Will not happen
 301
 302     case AHIDB_Author:
 303       return (IPTR) "Martin 'Leviticus' Blom";
 304
 305     case AHIDB_Copyright:
 306       return (IPTR) "Public Domain";
 307
 308     case AHIDB_Version:
 309       return (IPTR) LibIDString;
 310
 311     case AHIDB_Record:
 312       return TRUE;
 313
 314     case AHIDB_Realtime:
 315       return TRUE;
 316
 317     case AHIDB_Outputs:
 318       return 1;
 319
 320     case AHIDB_Output:
 321       return (IPTR) "Device";    // We have only one "output"!
 322
 323     default:
 324       return def;
 325   }
 326 }
 327
 328
 329 /******************************************************************************
 330 ** AHIsub_HardwareControl *****************************************************
 331 ******************************************************************************/
 332
 333 ULONG
 334 _AHIsub_HardwareControl( ULONG                   attribute,
 335                          LONG                    argument,
 336                          struct AHIAudioCtrlDrv* AudioCtrl,
 337                          struct DriverBase*      AHIsubBase )
 338 {
 339   return 0;
 340 }