← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/audacity/gutsy-backports

« back to all changes in this revision

Viewing changes to lib-src/rtaudio/tests/Windows/asiodrivers.cpp

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-02-18 21:58:19 UTC
  • mfrom: (13.1.2 hardy)
  • Revision ID: james.westby@ubuntu.com-20080218215819-tmbcf1rx238r8gdv
Tags: 1.3.4-1.1ubuntu1~gutsy1
Automated backport upload; no source changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib-src/rtaudio/tests/Windows/asiodrivers.cpp
1
 
#include <string.h>
2
 
#include "asiodrivers.h"
3
 
 
4
 
AsioDrivers* asioDrivers = 0;
5
 
 
6
 
bool loadAsioDriver(char *name);
7
 
 
8
 
bool loadAsioDriver(char *name)
9
 
{
10
 
        if(!asioDrivers)
11
 
                asioDrivers = new AsioDrivers();
12
 
        if(asioDrivers)
13
 
                return asioDrivers->loadDriver(name);
14
 
        return false;
15
 
}
16
 
 
17
 
//------------------------------------------------------------------------------------
18
 
 
19
 
#if MAC
20
 
 
21
 
bool resolveASIO(unsigned long aconnID);
22
 
 
23
 
AsioDrivers::AsioDrivers() : CodeFragments("ASIO Drivers", 'AsDr', 'Asio')
24
 
{
25
 
        connID = -1;
26
 
        curIndex = -1;
27
 
}
28
 
 
29
 
AsioDrivers::~AsioDrivers()
30
 
{
31
 
        removeCurrentDriver();
32
 
}
33
 
 
34
 
bool AsioDrivers::getCurrentDriverName(char *name)
35
 
{
36
 
        if(curIndex >= 0)
37
 
                return getName(curIndex, name);
38
 
        return false;
39
 
}
40
 
 
41
 
long AsioDrivers::getDriverNames(char **names, long maxDrivers)
42
 
{
43
 
        for(long i = 0; i < getNumFragments() && i < maxDrivers; i++)
44
 
                getName(i, names[i]);
45
 
        return getNumFragments() < maxDrivers ? getNumFragments() : maxDrivers;
46
 
}
47
 
 
48
 
bool AsioDrivers::loadDriver(char *name)
49
 
{
50
 
        char dname[64];
51
 
        unsigned long newID;
52
 
 
53
 
        for(long i = 0; i < getNumFragments(); i++)
54
 
        {
55
 
                if(getName(i, dname) && !strcmp(name, dname))
56
 
                {
57
 
                        if(newInstance(i, &newID))
58
 
                        {
59
 
                                if(resolveASIO(newID))
60
 
                                {
61
 
                                        if(connID != -1)
62
 
                                                removeInstance(curIndex, connID);
63
 
                                        curIndex = i;
64
 
                                        connID = newID;
65
 
                                        return true;
66
 
                                }
67
 
                        }
68
 
                        break;
69
 
                }
70
 
        }
71
 
        return false;
72
 
}
73
 
 
74
 
void AsioDrivers::removeCurrentDriver()
75
 
{
76
 
        if(connID != -1)
77
 
                removeInstance(curIndex, connID);
78
 
        connID = -1;
79
 
        curIndex = -1;
80
 
}
81
 
 
82
 
//------------------------------------------------------------------------------------
83
 
 
84
 
#elif WINDOWS
85
 
 
86
 
#include "iasiodrv.h"
87
 
 
88
 
extern IASIO* theAsioDriver;
89
 
 
90
 
AsioDrivers::AsioDrivers() : AsioDriverList()
91
 
{
92
 
        curIndex = -1;
93
 
}
94
 
 
95
 
AsioDrivers::~AsioDrivers()
96
 
{
97
 
}
98
 
 
99
 
bool AsioDrivers::getCurrentDriverName(char *name)
100
 
{
101
 
        if(curIndex >= 0)
102
 
                return asioGetDriverName(curIndex, name, 32) == 0 ? true : false;
103
 
        name[0] = 0;
104
 
        return false;
105
 
}
106
 
 
107
 
long AsioDrivers::getDriverNames(char **names, long maxDrivers)
108
 
{
109
 
        for(long i = 0; i < asioGetNumDev() && i < maxDrivers; i++)
110
 
                asioGetDriverName(i, names[i], 32);
111
 
        return asioGetNumDev() < maxDrivers ? asioGetNumDev() : maxDrivers;
112
 
}
113
 
 
114
 
bool AsioDrivers::loadDriver(char *name)
115
 
{
116
 
        char dname[64];
117
 
        char curName[64];
118
 
 
119
 
        for(long i = 0; i < asioGetNumDev(); i++)
120
 
        {
121
 
                if(!asioGetDriverName(i, dname, 32) && !strcmp(name, dname))
122
 
                {
123
 
                        curName[0] = 0;
124
 
                        getCurrentDriverName(curName);  // in case we fail...
125
 
                        removeCurrentDriver();
126
 
 
127
 
                        if(!asioOpenDriver(i, (void **)&theAsioDriver))
128
 
                        {
129
 
                                curIndex = i;
130
 
                                return true;
131
 
                        }
132
 
                        else
133
 
                        {
134
 
                                theAsioDriver = 0;
135
 
                                if(curName[0] && strcmp(dname, curName))
136
 
                                        loadDriver(curName);    // try restore
137
 
                        }
138
 
                        break;
139
 
                }
140
 
        }
141
 
        return false;
142
 
}
143
 
 
144
 
void AsioDrivers::removeCurrentDriver()
145
 
{
146
 
        if(curIndex != -1)
147
 
                asioCloseDriver(curIndex);
148
 
        curIndex = -1;
149
 
}
150
 
 
151
 
#elif SGI || BEOS
152
 
 
153
 
#include "asiolist.h"
154
 
 
155
 
AsioDrivers::AsioDrivers() 
156
 
        : AsioDriverList()
157
 
{
158
 
        curIndex = -1;
159
 
}
160
 
 
161
 
AsioDrivers::~AsioDrivers()
162
 
{
163
 
}
164
 
 
165
 
bool AsioDrivers::getCurrentDriverName(char *name)
166
 
{
167
 
        return false;
168
 
}
169
 
 
170
 
long AsioDrivers::getDriverNames(char **names, long maxDrivers)
171
 
{
172
 
        return 0;
173
 
}
174
 
 
175
 
bool AsioDrivers::loadDriver(char *name)
176
 
{
177
 
        return false;
178
 
}
179
 
 
180
 
void AsioDrivers::removeCurrentDriver()
181
 
{
182
 
}
183
 
 
184
 
#else
185
 
#error implement me
186
 
#endif