workbench/devs/AHI/Drivers/Alsa/alsa-main.c

   1 #include <aros/debug.h>
   2 #include <config.h>
   3
   4 #include <devices/ahi.h>
   5 #include <dos/dostags.h>
   6 #include <exec/memory.h>
   7 #include <libraries/ahi_sub.h>
   8 #include <proto/ahi_sub.h>
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11 #include <proto/utility.h>
  12
  13 #include <stddef.h>
  14
  15 #include "library.h"
  16 #include "DriverData.h"
  17 #include "alsa-bridge/alsa.h"
  18
  19 #define dd ((struct AlsaData*) AudioCtrl->ahiac_DriverData)
  20
  21 void
  22 SlaveEntry( void );
  23
  24 PROCGW( static, void,  slaveentry, SlaveEntry );
  25
  26 static const LONG frequencies[] =
  27 {
  28   8000,     // µ- and A-Law (telephone)
  29   11025,    // CD/4
  30   22050,    // CD/2
  31   44100,    // CD
  32   48000     // DAT
  33 };
  34
  35 #define FREQUENCIES (sizeof frequencies / sizeof frequencies[ 0 ])
  36
  37 static const ULONG table_5bit[] = {
  38   0xb53c,
  39   0x804e,
  40   0x5ad5,
  41   0x404e,
  42   0x2d86,
  43   0x203a,
  44   0x16d1,
  45   0x1027,
  46   0x0b6f,
  47   0x0818,
  48   0x05bb,
  49   0x040f,
  50   0x02df,
  51   0x0209,
  52   0x0171,
  53   0x0105,
  54   0x00b9,
  55   0x0083,
  56   0x005d,
  57   0x0042,
  58   0x002e,
  59   0x0021,
  60   0x0017,
  61   0x0010,
  62   0x000c,
  63   0x0008,
  64   0x0006,
  65   0x0004,
  66   0x0003,
  67   0x0002,
  68   0x0001,
  69   0x0000
  70 };
  71
  72 static UWORD LinToLog(ULONG vol)
  73 {
  74   int i;
  75
  76   if (!vol) return 0x20;
  77
  78   for (i = 0; i < 32; i++)
  79   {
  80     if (vol > table_5bit[i])
  81     {
  82       return i;
  83     }
  84   }
  85   return 0x1f;
  86 }
  87
  88 static ULONG LogToLin(UWORD i)
  89 {
  90     if (i > 31) return 0x10000;
  91     return table_5bit[i];
  92 }
  93
  94 /******************************************************************************
  95 ** AHIsub_AllocAudio **********************************************************
  96 ******************************************************************************/
  97
  98 ULONG
  99 _AHIsub_AllocAudio( struct TagItem*         taglist,
 100             struct AHIAudioCtrlDrv* AudioCtrl,
 101             struct DriverBase*      AHIsubBase )
 102 {
 103   struct AlsaBase* AlsaBase = (struct AlsaBase*) AHIsubBase;
 104   ULONG freq = AudioCtrl->ahiac_MixFreq;
 105
 106   D(bug("[Alsa]: AllocAudio enter\n"));
 107
 108   AudioCtrl->ahiac_DriverData = AllocVec( sizeof( struct AlsaData ),
 109          MEMF_CLEAR | MEMF_PUBLIC );
 110
 111   if( dd != NULL )
 112   {
 113     dd->slavesignal      = -1;
 114     dd->mastersignal     = AllocSignal( -1 );
 115     dd->mastertask       = (struct Process*) FindTask( NULL );
 116     dd->ahisubbase       = AlsaBase;
 117   }
 118   else
 119   {
 120     return AHISF_ERROR;
 121   }
 122
 123   if( dd->mastersignal == -1 )
 124   {
 125     return AHISF_ERROR;
 126   }
 127
 128   dd->alsahandle = ALSA_Open();
 129
 130   if (dd->alsahandle == NULL)
 131   {
 132     bug("[Alsa]: Failed opening ALSA\n");
 133     return AHISF_ERROR;
 134   }
 135
 136   if (!ALSA_SetHWParams(dd->alsahandle, &freq))
 137   {
 138       bug("[Alsa]: Failed setting ALSA hardware parameters\n");
 139       ALSA_DropAndClose(dd->alsahandle);
 140       dd->alsahandle = NULL;
 141       return AHISF_ERROR;
 142   }
 143
 144   AudioCtrl->ahiac_MixFreq = freq;
 145
 146   D(bug("[Alsa]: AllocAudio completed\n"));
 147
 148   return ( AHISF_KNOWSTEREO | AHISF_MIXING | AHISF_TIMING );
 149 }
 150
 151
 152 /******************************************************************************
 153 ** AHIsub_FreeAudio ***********************************************************
 154 ******************************************************************************/
 155
 156 void
 157 _AHIsub_FreeAudio( struct AHIAudioCtrlDrv* AudioCtrl,
 158            struct DriverBase*      AHIsubBase )
 159 {
 160   if( AudioCtrl->ahiac_DriverData != NULL )
 161   {
 162     ALSA_DropAndClose(dd->alsahandle);
 163     FreeSignal( dd->mastersignal );
 164     FreeVec( AudioCtrl->ahiac_DriverData );
 165     AudioCtrl->ahiac_DriverData = NULL;
 166   }
 167 }
 168
 169
 170 /******************************************************************************
 171 ** AHIsub_Disable *************************************************************
 172 ******************************************************************************/
 173
 174 void
 175 _AHIsub_Disable( struct AHIAudioCtrlDrv* AudioCtrl,
 176          struct DriverBase*      AHIsubBase )
 177 {
 178   // V6 drivers do not have to preserve all registers
 179
 180   Forbid();
 181 }
 182
 183
 184 /******************************************************************************
 185 ** AHIsub_Enable **************************************************************
 186 ******************************************************************************/
 187
 188 void
 189 _AHIsub_Enable( struct AHIAudioCtrlDrv* AudioCtrl,
 190         struct DriverBase*      AHIsubBase )
 191 {
 192   // V6 drivers do not have to preserve all registers
 193
 194   Permit();
 195 }
 196
 197
 198 /******************************************************************************
 199 ** AHIsub_Start ***************************************************************
 200 ******************************************************************************/
 201
 202 ULONG
 203 _AHIsub_Start( ULONG                   flags,
 204            struct AHIAudioCtrlDrv* AudioCtrl,
 205            struct DriverBase*      AHIsubBase )
 206 {
 207   struct AlsaBase* AlsaBase = (struct AlsaBase*) AHIsubBase;
 208
 209   AHIsub_Stop( flags, AudioCtrl );
 210
 211   if(flags & AHISF_PLAY)
 212   {
 213     struct TagItem proctags[] =
 214     {
 215       { NP_Entry,     (IPTR) &slaveentry },
 216       { NP_Name,      (IPTR) LibName     },
 217       { NP_Priority,  127                 },
 218       { TAG_DONE,     0                   }
 219     };
 220
 221     dd->mixbuffer = AllocVec( AudioCtrl->ahiac_BuffSize,
 222                 MEMF_ANY | MEMF_PUBLIC );
 223
 224     if( dd->mixbuffer == NULL ) return AHIE_NOMEM;
 225
 226     D(bug("[Alsa]: AHIsub_Start\n"));
 227
 228     Forbid();
 229
 230     dd->slavetask = CreateNewProc( proctags );
 231
 232     if( dd->slavetask != NULL )
 233     {
 234       dd->slavetask->pr_Task.tc_UserData = AudioCtrl;
 235     }
 236
 237     Permit();
 238
 239     if( dd->slavetask != NULL )
 240     {
 241       Wait( 1L << dd->mastersignal );  // Wait for slave to come alive
 242
 243       if( dd->slavetask == NULL )      // Is slave alive or dead?
 244       {
 245         return AHIE_UNKNOWN;
 246       }
 247     }
 248     else
 249     {
 250       return AHIE_NOMEM;                 // Well, out of memory or whatever...
 251     }
 252   }
 253
 254   if( flags & AHISF_RECORD )
 255   {
 256     return AHIE_UNKNOWN;
 257   }
 258
 259   return AHIE_OK;
 260 }
 261
 262
 263 /******************************************************************************
 264 ** AHIsub_Update **************************************************************
 265 ******************************************************************************/
 266
 267 void
 268 _AHIsub_Update( ULONG                   flags,
 269         struct AHIAudioCtrlDrv* AudioCtrl,
 270         struct DriverBase*      AHIsubBase )
 271 {
 272   // Empty function
 273 }
 274
 275
 276 /******************************************************************************
 277 ** AHIsub_Stop ****************************************************************
 278 ******************************************************************************/
 279
 280 void
 281 _AHIsub_Stop( ULONG                   flags,
 282           struct AHIAudioCtrlDrv* AudioCtrl,
 283           struct DriverBase*      AHIsubBase )
 284 {
 285   if( flags & AHISF_PLAY )
 286   {
 287     if( dd->slavetask != NULL )
 288     {
 289       if( dd->slavesignal != -1 )
 290       {
 291         Signal( (struct Task*) dd->slavetask,
 292                 1L << dd->slavesignal );         // Kill him!
 293         D(bug("[Alsa]: AHIsub_Stop\n"));
 294       }
 295
 296       Wait( 1L << dd->mastersignal );            // Wait for slave to die
 297     }
 298
 299     FreeVec( dd->mixbuffer );
 300     dd->mixbuffer = NULL;
 301   }
 302
 303   if(flags & AHISF_RECORD)
 304   {
 305     // Do nothing
 306   }
 307 }
 308
 309
 310 /******************************************************************************
 311 ** AHIsub_GetAttr *************************************************************
 312 ******************************************************************************/
 313
 314 IPTR
 315 _AHIsub_GetAttr( ULONG                   attribute,
 316          LONG                    argument,
 317          IPTR                    def,
 318          struct TagItem*         taglist,
 319          struct AHIAudioCtrlDrv* AudioCtrl,
 320          struct DriverBase*      AHIsubBase )
 321 {
 322   struct AlsaBase* AlsaBase = (struct AlsaBase*) AHIsubBase;
 323   size_t i;
 324
 325   switch( attribute )
 326   {
 327     case AHIDB_Bits:
 328       return 32;
 329
 330     case AHIDB_Frequencies:
 331       return FREQUENCIES;
 332
 333     case AHIDB_Frequency: // Index->Frequency
 334       return (LONG) frequencies[ argument ];
 335
 336     case AHIDB_Index: // Frequency->Index
 337       if( argument <= frequencies[ 0 ] )
 338       {
 339         return 0;
 340       }
 341
 342       if( argument >= frequencies[ FREQUENCIES - 1 ] )
 343       {
 344         return FREQUENCIES - 1;
 345       }
 346
 347       for( i = 1; i < FREQUENCIES; i++ )
 348       {
 349         if( frequencies[ i ] > argument )
 350         {
 351           if( ( argument - frequencies[ i - 1 ] ) <
 352           ( frequencies[ i ] - argument ) )
 353           {
 354             return i-1;
 355           }
 356           else
 357           {
 358             return i;
 359           }
 360         }
 361       }
 362
 363       return 0;  // Will not happen
 364
 365     case AHIDB_Author:
 366       return (IPTR) "Krzysztof Smiechowicz";
 367
 368     case AHIDB_Copyright:
 369       return (IPTR) "APL";
 370
 371     case AHIDB_Version:
 372       return (IPTR) LibIDString;
 373
 374     case AHIDB_Record:
 375       return FALSE;
 376
 377     case AHIDB_Realtime:
 378       return TRUE;
 379
 380     case AHIDB_Outputs:
 381       return 1;
 382
 383     case AHIDB_Output:
 384       return (IPTR) "Alsa";    // We have only one "output"!
 385
 386     case AHIDB_MinOutputVolume:
 387       return 0x00000;
 388
 389     case AHIDB_MaxOutputVolume:
 390       if (AlsaBase->al_MixerElem)
 391         return 0x10000;
 392       else
 393         return 0x00000;
 394
 395     default:
 396       return def;
 397   }
 398 }
 399
 400
 401 /******************************************************************************
 402 ** AHIsub_HardwareControl *****************************************************
 403 ******************************************************************************/
 404
 405 ULONG
 406 _AHIsub_HardwareControl( ULONG                   attribute,
 407              LONG                    argument,
 408              struct AHIAudioCtrlDrv* AudioCtrl,
 409              struct DriverBase*      AHIsubBase )
 410 {
 411   struct AlsaBase* AlsaBase = (struct AlsaBase*) AHIsubBase;
 412
 413   switch(attribute)
 414   {
 415   case AHIC_OutputVolume:
 416     if (AlsaBase->al_MixerElem)
 417     {
 418         LONG val = (0x20 - LinToLog(argument)) * AlsaBase->al_MaxVolume / 0x20;
 419         ALSA_MixerSetVolume(AlsaBase->al_MixerElem, (LONG)val);
 420     }
 421
 422     return TRUE;
 423
 424   case AHIC_OutputVolume_Query:
 425     if (AlsaBase->al_MixerElem)
 426     {
 427       LONG val = ALSA_MixerGetVolume(AlsaBase->al_MixerElem);
 428       val = val * 0x20 / AlsaBase->al_MaxVolume;
 429       return LogToLin(0x20 - val);
 430     }
 431
 432     return 0;
 433   }
 434
 435   return 0;
 436 }