Alc/backends/null.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2010 by Chris Robinson
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include "alMain.h"
  25 #include "AL/al.h"
  26 #include "AL/alc.h"
  27
  28
  29 typedef struct {
  30     volatile int killNow;
  31     ALvoid *thread;
  32 } null_data;
  33
  34
  35 static const ALCchar nullDevice[] = "No Output";
  36
  37 static ALuint NullProc(ALvoid *ptr)
  38 {
  39     ALCdevice *Device = (ALCdevice*)ptr;
  40     null_data *data = (null_data*)Device->ExtraData;
  41     ALuint now, start;
  42     ALuint64 avail, done;
  43     const ALuint restTime = (ALuint64)Device->UpdateSize * 1000 /
  44                             Device->Frequency / 2;
  45
  46     done = 0;
  47     start = timeGetTime();
  48     while(!data->killNow && Device->Connected)
  49     {
  50         now = timeGetTime();
  51
  52         avail = (ALuint64)(now-start) * Device->Frequency / 1000;
  53         if(avail < done)
  54         {
  55             /* Timer wrapped (50 days???). Add the remainder of the cycle to
  56              * the available count and reset the number of samples done */
  57             avail += ((ALuint64)1<<32)*Device->Frequency/1000 - done;
  58             done = 0;
  59         }
  60         if(avail-done < Device->UpdateSize)
  61         {
  62             Sleep(restTime);
  63             continue;
  64         }
  65
  66         while(avail-done >= Device->UpdateSize)
  67         {
  68             aluMixData(Device, NULL, Device->UpdateSize);
  69             done += Device->UpdateSize;
  70         }
  71     }
  72
  73     return 0;
  74 }
  75
  76 static ALCenum null_open_playback(ALCdevice *device, const ALCchar *deviceName)
  77 {
  78     null_data *data;
  79
  80     if(!deviceName)
  81         deviceName = nullDevice;
  82     else if(strcmp(deviceName, nullDevice) != 0)
  83         return ALC_INVALID_VALUE;
  84
  85     data = (null_data*)calloc(1, sizeof(*data));
  86
  87     device->DeviceName = strdup(deviceName);
  88     device->ExtraData = data;
  89     return ALC_NO_ERROR;
  90 }
  91
  92 static void null_close_playback(ALCdevice *device)
  93 {
  94     null_data *data = (null_data*)device->ExtraData;
  95
  96     free(data);
  97     device->ExtraData = NULL;
  98 }
  99
 100 static ALCboolean null_reset_playback(ALCdevice *device)
 101 {
 102     SetDefaultWFXChannelOrder(device);
 103     return ALC_TRUE;
 104 }
 105
 106 static ALCboolean null_start_playback(ALCdevice *device)
 107 {
 108     null_data *data = (null_data*)device->ExtraData;
 109
 110     data->thread = StartThread(NullProc, device);
 111     if(data->thread == NULL)
 112         return ALC_FALSE;
 113
 114     return ALC_TRUE;
 115 }
 116
 117 static void null_stop_playback(ALCdevice *device)
 118 {
 119     null_data *data = (null_data*)device->ExtraData;
 120
 121     if(!data->thread)
 122         return;
 123
 124     data->killNow = 1;
 125     StopThread(data->thread);
 126     data->thread = NULL;
 127
 128     data->killNow = 0;
 129 }
 130
 131
 132 static ALint64 null_get_latency(ALCdevice *device)
 133 {
 134     /* FIXME: Time until next update + "safe" offset */
 135     (void)device;
 136     return 0;
 137 }
 138
 139
 140 static const BackendFuncs null_funcs = {
 141     null_open_playback,
 142     null_close_playback,
 143     null_reset_playback,
 144     null_start_playback,
 145     null_stop_playback,
 146     NULL,
 147     NULL,
 148     NULL,
 149     NULL,
 150     NULL,
 151     NULL,
 152     ALCdevice_LockDefault,
 153     ALCdevice_UnlockDefault,
 154     null_get_latency
 155 };
 156
 157 ALCboolean alc_null_init(BackendFuncs *func_list)
 158 {
 159     *func_list = null_funcs;
 160     return ALC_TRUE;
 161 }
 162
 163 void alc_null_deinit(void)
 164 {
 165 }
 166
 167 void alc_null_probe(enum DevProbe type)
 168 {
 169     switch(type)
 170     {
 171         case ALL_DEVICE_PROBE:
 172             AppendAllDevicesList(nullDevice);
 173             break;
 174         case CAPTURE_DEVICE_PROBE:
 175             break;
 176     }
 177 }