workbench/devs/AHI/Drivers/Void/void-main.c

   1
   2 /*
   3  *  This is a do-nothing example AHI driver that just discards the
   4  *  sound data that is sent to it. Recording is not supported.
   5  */
   6
   7 #include <config.h>
   8
   9 #include <devices/ahi.h>
  10 #include <dos/dostags.h>
  11 #include <exec/memory.h>
  12 #include <libraries/ahi_sub.h>
  13 #include <proto/ahi_sub.h>
  14 #include <proto/exec.h>
  15 #include <proto/dos.h>
  16 #include <proto/utility.h>
  17
  18 #include <stddef.h>
  19
  20 #include "library.h"
  21 #include "DriverData.h"
  22
  23 #define dd ((struct VoidData*) AudioCtrl->ahiac_DriverData)
  24
  25 void
  26 SlaveEntry( void );
  27
  28 PROCGW( static, void,  slaveentry, SlaveEntry );
  29
  30
  31 /*  There is probably no reason to support all these frequencies. If,
  32  *  for example, your hardware is locked at 48 kHz, it's ok to only
  33  *  present one single mixing/recording frequency to the user. If your
  34  *  hardware has internal resamples and accept any frequency, select a
  35  *  few common ones.
  36  */
  37
  38 static const LONG frequencies[] =
  39 {
  40   5513,     // CD/8
  41   8000,     // µ- and A-Law (telephone)
  42   9600,     // DAT/5
  43   10000,    // VHS monaural track
  44   11025,    // CD/4
  45   12000,    // DAT/4
  46   14700,    // CD/3
  47   16000,    // DAT/3, FM/2
  48   17640,    // CD/2.5
  49   18900,
  50   19200,    // DAT/2.5
  51   20000,    // VHS Hi-Fi/Video track
  52   22050,    // CD/2
  53   24000,    // DAT/2
  54   27429,    // Highest Paula/OCS frequency
  55   29400,    // CD/1.5
  56   31968,    // NTSC FM 2-3 pull-down
  57   32000,    // DAT/1.5
  58   32032,    // NTSC FM 2-3 pull-up
  59   33075,
  60   37800,
  61   44056,    // NTSC CD 2-3 pull-down
  62   44100,    // CD
  63   44144,    // NTSC CD 2-3 pull-up
  64   47952,    // NTSC DAT 2-3 pull-down
  65   48000,    // DAT
  66   48048,    // NTSC DAT 2-3 pull-up
  67   88200,    // CD*2
  68   96000     // DAT*2
  69 };
  70
  71 #define FREQUENCIES (sizeof frequencies / sizeof frequencies[ 0 ])
  72
  73 /******************************************************************************
  74 ** AHIsub_AllocAudio **********************************************************
  75 ******************************************************************************/
  76
  77 ULONG
  78 _AHIsub_AllocAudio( struct TagItem*         taglist,
  79                     struct AHIAudioCtrlDrv* AudioCtrl,
  80                     struct DriverBase*      AHIsubBase )
  81 {
  82   struct VoidBase* VoidBase = (struct VoidBase*) AHIsubBase;
  83
  84   // NOTE! A Real sound card driver would allocate *and lock* the
  85   // audio hardware here. If this function gets called a second time,
  86   // and the hardware is not capable of handling several audio streams
  87   // at the same time, return AHISF_ERROR now!
  88
  89   AudioCtrl->ahiac_DriverData = AllocVec( sizeof( struct VoidData ),
  90                  MEMF_CLEAR | MEMF_PUBLIC );
  91
  92   if( dd != NULL )
  93   {
  94     dd->slavesignal      = -1;
  95     dd->mastersignal     = AllocSignal( -1 );
  96     dd->mastertask       = (struct Process*) FindTask( NULL );
  97     dd->ahisubbase       = VoidBase;
  98   }
  99   else
 100   {
 101     return AHISF_ERROR;
 102   }
 103
 104   if( dd->mastersignal == -1 )
 105   {
 106     return AHISF_ERROR;
 107   }
 108
 109   return ( AHISF_KNOWHIFI |
 110            AHISF_KNOWSTEREO |
 111            AHISF_KNOWMULTICHANNEL |
 112            AHISF_MIXING |
 113            AHISF_TIMING );
 114 }
 115
 116
 117 /******************************************************************************
 118 ** AHIsub_FreeAudio ***********************************************************
 119 ******************************************************************************/
 120
 121 void
 122 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
 123                    struct DriverBase*      AHIsubBase )
 124 {
 125   if( AudioCtrl->ahiac_DriverData != NULL )
 126   {
 127     FreeSignal( dd->mastersignal );
 128     FreeVec( AudioCtrl->ahiac_DriverData );
 129     AudioCtrl->ahiac_DriverData = NULL;
 130   }
 131 }
 132
 133
 134 /******************************************************************************
 135 ** AHIsub_Disable *************************************************************
 136 ******************************************************************************/
 137
 138 void
 139 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 140                  struct DriverBase*      AHIsubBase )
 141 {
 142   // V6 drivers do not have to preserve all registers
 143
 144   Forbid();
 145 }
 146
 147
 148 /******************************************************************************
 149 ** AHIsub_Enable **************************************************************
 150 ******************************************************************************/
 151
 152 void
 153 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 154                 struct DriverBase*      AHIsubBase )
 155 {
 156   // V6 drivers do not have to preserve all registers
 157
 158   Permit();
 159 }
 160
 161
 162 /******************************************************************************
 163 ** AHIsub_Start ***************************************************************
 164 ******************************************************************************/
 165
 166 ULONG
 167 _AHIsub_Start( ULONG                   flags,
 168                struct AHIAudioCtrlDrv* AudioCtrl,
 169                struct DriverBase*      AHIsubBase )
 170 {
 171   struct VoidBase* VoidBase = (struct VoidBase*) AHIsubBase;
 172
 173   AHIsub_Stop( flags, AudioCtrl );
 174
 175   if(flags & AHISF_PLAY)
 176   {
 177     struct TagItem proctags[] =
 178     {
 179       { NP_Entry,     (IPTR) &slaveentry },
 180       { NP_Name,      (IPTR) LibName     },
 181       { NP_Priority,  -1                  },
 182       { TAG_DONE,     0                   }
 183     };
 184
 185     dd->mixbuffer = AllocVec( AudioCtrl->ahiac_BuffSize,
 186                                 MEMF_ANY | MEMF_PUBLIC );
 187
 188     if( dd->mixbuffer == NULL ) return AHIE_NOMEM;
 189
 190     Forbid();
 191
 192     dd->slavetask = CreateNewProc( proctags );
 193
 194     if( dd->slavetask != NULL )
 195     {
 196       dd->slavetask->pr_Task.tc_UserData = AudioCtrl;
 197     }
 198
 199     Permit();
 200
 201     if( dd->slavetask != NULL )
 202     {
 203       Wait( 1L << dd->mastersignal );  // Wait for slave to come alive
 204
 205       if( dd->slavetask == NULL )      // Is slave alive or dead?
 206       {
 207         return AHIE_UNKNOWN;
 208       }
 209     }
 210     else
 211     {
 212       return AHIE_NOMEM;                 // Well, out of memory or whatever...
 213     }
 214   }
 215
 216   if( flags & AHISF_RECORD )
 217   {
 218     return AHIE_UNKNOWN;
 219   }
 220
 221   return AHIE_OK;
 222 }
 223
 224
 225 /******************************************************************************
 226 ** AHIsub_Update **************************************************************
 227 ******************************************************************************/
 228
 229 void
 230 _AHIsub_Update( ULONG                   flags,
 231                 struct AHIAudioCtrlDrv* AudioCtrl,
 232                 struct DriverBase*      AHIsubBase )
 233 {
 234   // Empty function
 235 }
 236
 237
 238 /******************************************************************************
 239 ** AHIsub_Stop ****************************************************************
 240 ******************************************************************************/
 241
 242 void
 243 _AHIsub_Stop( ULONG                   flags,
 244               struct AHIAudioCtrlDrv* AudioCtrl,
 245               struct DriverBase*      AHIsubBase )
 246 {
 247   if( flags & AHISF_PLAY )
 248   {
 249     if( dd->slavetask != NULL )
 250     {
 251       if( dd->slavesignal != -1 )
 252       {
 253         Signal( (struct Task*) dd->slavetask,
 254                 1L << dd->slavesignal );         // Kill him!
 255       }
 256
 257       Wait( 1L << dd->mastersignal );            // Wait for slave to die
 258     }
 259
 260     FreeVec( dd->mixbuffer );
 261     dd->mixbuffer = NULL;
 262   }
 263
 264   if(flags & AHISF_RECORD)
 265   {
 266     // Do nothing
 267   }
 268 }
 269
 270
 271 /******************************************************************************
 272 ** AHIsub_GetAttr *************************************************************
 273 ******************************************************************************/
 274
 275 IPTR
 276 _AHIsub_GetAttr( ULONG                   attribute,
 277                  LONG                    argument,
 278                  IPTR                    def,
 279                  struct TagItem*         taglist,
 280                  struct AHIAudioCtrlDrv* AudioCtrl,
 281                  struct DriverBase*      AHIsubBase )
 282 {
 283   size_t i;
 284
 285   switch( attribute )
 286   {
 287     case AHIDB_Bits:
 288       return 32;
 289
 290     case AHIDB_Frequencies:
 291       return FREQUENCIES;
 292
 293     case AHIDB_Frequency: // Index->Frequency
 294       return (LONG) frequencies[ argument ];
 295
 296     case AHIDB_Index: // Frequency->Index
 297       if( argument <= frequencies[ 0 ] )
 298       {
 299         return 0;
 300       }
 301
 302       if( argument >= frequencies[ FREQUENCIES - 1 ] )
 303       {
 304         return FREQUENCIES - 1;
 305       }
 306
 307       for( i = 1; i < FREQUENCIES; i++ )
 308       {
 309         if( frequencies[ i ] > argument )
 310         {
 311           if( ( argument - frequencies[ i - 1 ] ) <
 312               ( frequencies[ i ] - argument ) )
 313           {
 314             return i-1;
 315           }
 316           else
 317           {
 318             return i;
 319           }
 320         }
 321       }
 322
 323       return 0;  // Will not happen
 324
 325     case AHIDB_Author:
 326       return (IPTR) "Martin 'Leviticus' Blom";
 327
 328     case AHIDB_Copyright:
 329       return (IPTR) "Public Domain";
 330
 331     case AHIDB_Version:
 332       return (IPTR) LibIDString;
 333
 334     case AHIDB_Record:
 335       return FALSE;
 336
 337     case AHIDB_Realtime:
 338       return TRUE;             // This is not actually true
 339
 340     case AHIDB_Outputs:
 341       return 1;
 342
 343     case AHIDB_Output:
 344       return (IPTR) "Void";    // We have only one "output"!
 345
 346     default:
 347       return def;
 348   }
 349 }
 350
 351
 352 /******************************************************************************
 353 ** AHIsub_HardwareControl *****************************************************
 354 ******************************************************************************/
 355
 356 ULONG
 357 _AHIsub_HardwareControl( ULONG                   attribute,
 358                          LONG                    argument,
 359                          struct AHIAudioCtrlDrv* AudioCtrl,
 360                          struct DriverBase*      AHIsubBase )
 361 {
 362   return 0;
 363 }