← Back to branch summary

~inkscape.dev/inkscape-devlibs64/trunk

« back to all changes in this revision

Viewing changes to python/Lib/audiodev.py

  • Committer: Eduard Braun
  • Date: 2016-10-22 16:51:19 UTC
  • Revision ID: eduard.braun2@gmx.de-20161022165119-9eosgy6lp8j1kzli
Update Python to version 2.7.12

Included modules:
  coverage 4.2
  lxml 3.6.4
  numpy 1.11.2
  scour 0.35
  six 1.10.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
python/Lib/audiodev.py
1
 
"""Classes for manipulating audio devices (currently only for Sun and SGI)"""
2
 
from warnings import warnpy3k
3
 
warnpy3k("the audiodev module has been removed in Python 3.0", stacklevel=2)
4
 
del warnpy3k
5
 
 
6
 
__all__ = ["error","AudioDev"]
7
 
 
8
 
class error(Exception):
9
 
    pass
10
 
 
11
 
class Play_Audio_sgi:
12
 
    # Private instance variables
13
 
##      if 0: access frameratelist, nchannelslist, sampwidthlist, oldparams, \
14
 
##                params, config, inited_outrate, inited_width, \
15
 
##                inited_nchannels, port, converter, classinited: private
16
 
 
17
 
    classinited = 0
18
 
    frameratelist = nchannelslist = sampwidthlist = None
19
 
 
20
 
    def initclass(self):
21
 
        import AL
22
 
        self.frameratelist = [
23
 
                  (48000, AL.RATE_48000),
24
 
                  (44100, AL.RATE_44100),
25
 
                  (32000, AL.RATE_32000),
26
 
                  (22050, AL.RATE_22050),
27
 
                  (16000, AL.RATE_16000),
28
 
                  (11025, AL.RATE_11025),
29
 
                  ( 8000,  AL.RATE_8000),
30
 
                  ]
31
 
        self.nchannelslist = [
32
 
                  (1, AL.MONO),
33
 
                  (2, AL.STEREO),
34
 
                  (4, AL.QUADRO),
35
 
                  ]
36
 
        self.sampwidthlist = [
37
 
                  (1, AL.SAMPLE_8),
38
 
                  (2, AL.SAMPLE_16),
39
 
                  (3, AL.SAMPLE_24),
40
 
                  ]
41
 
        self.classinited = 1
42
 
 
43
 
    def __init__(self):
44
 
        import al, AL
45
 
        if not self.classinited:
46
 
            self.initclass()
47
 
        self.oldparams = []
48
 
        self.params = [AL.OUTPUT_RATE, 0]
49
 
        self.config = al.newconfig()
50
 
        self.inited_outrate = 0
51
 
        self.inited_width = 0
52
 
        self.inited_nchannels = 0
53
 
        self.converter = None
54
 
        self.port = None
55
 
        return
56
 
 
57
 
    def __del__(self):
58
 
        if self.port:
59
 
            self.stop()
60
 
        if self.oldparams:
61
 
            import al, AL
62
 
            al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
63
 
            self.oldparams = []
64
 
 
65
 
    def wait(self):
66
 
        if not self.port:
67
 
            return
68
 
        import time
69
 
        while self.port.getfilled() > 0:
70
 
            time.sleep(0.1)
71
 
        self.stop()
72
 
 
73
 
    def stop(self):
74
 
        if self.port:
75
 
            self.port.closeport()
76
 
            self.port = None
77
 
        if self.oldparams:
78
 
            import al, AL
79
 
            al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
80
 
            self.oldparams = []
81
 
 
82
 
    def setoutrate(self, rate):
83
 
        for (raw, cooked) in self.frameratelist:
84
 
            if rate == raw:
85
 
                self.params[1] = cooked
86
 
                self.inited_outrate = 1
87
 
                break
88
 
        else:
89
 
            raise error, 'bad output rate'
90
 
 
91
 
    def setsampwidth(self, width):
92
 
        for (raw, cooked) in self.sampwidthlist:
93
 
            if width == raw:
94
 
                self.config.setwidth(cooked)
95
 
                self.inited_width = 1
96
 
                break
97
 
        else:
98
 
            if width == 0:
99
 
                import AL
100
 
                self.inited_width = 0
101
 
                self.config.setwidth(AL.SAMPLE_16)
102
 
                self.converter = self.ulaw2lin
103
 
            else:
104
 
                raise error, 'bad sample width'
105
 
 
106
 
    def setnchannels(self, nchannels):
107
 
        for (raw, cooked) in self.nchannelslist:
108
 
            if nchannels == raw:
109
 
                self.config.setchannels(cooked)
110
 
                self.inited_nchannels = 1
111
 
                break
112
 
        else:
113
 
            raise error, 'bad # of channels'
114
 
 
115
 
    def writeframes(self, data):
116
 
        if not (self.inited_outrate and self.inited_nchannels):
117
 
            raise error, 'params not specified'
118
 
        if not self.port:
119
 
            import al, AL
120
 
            self.port = al.openport('Python', 'w', self.config)
121
 
            self.oldparams = self.params[:]
122
 
            al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
123
 
            al.setparams(AL.DEFAULT_DEVICE, self.params)
124
 
        if self.converter:
125
 
            data = self.converter(data)
126
 
        self.port.writesamps(data)
127
 
 
128
 
    def getfilled(self):
129
 
        if self.port:
130
 
            return self.port.getfilled()
131
 
        else:
132
 
            return 0
133
 
 
134
 
    def getfillable(self):
135
 
        if self.port:
136
 
            return self.port.getfillable()
137
 
        else:
138
 
            return self.config.getqueuesize()
139
 
 
140
 
    # private methods
141
 
##      if 0: access *: private
142
 
 
143
 
    def ulaw2lin(self, data):
144
 
        import audioop
145
 
        return audioop.ulaw2lin(data, 2)
146
 
 
147
 
class Play_Audio_sun:
148
 
##      if 0: access outrate, sampwidth, nchannels, inited_outrate, inited_width, \
149
 
##                inited_nchannels, converter: private
150
 
 
151
 
    def __init__(self):
152
 
        self.outrate = 0
153
 
        self.sampwidth = 0
154
 
        self.nchannels = 0
155
 
        self.inited_outrate = 0
156
 
        self.inited_width = 0
157
 
        self.inited_nchannels = 0
158
 
        self.converter = None
159
 
        self.port = None
160
 
        return
161
 
 
162
 
    def __del__(self):
163
 
        self.stop()
164
 
 
165
 
    def setoutrate(self, rate):
166
 
        self.outrate = rate
167
 
        self.inited_outrate = 1
168
 
 
169
 
    def setsampwidth(self, width):
170
 
        self.sampwidth = width
171
 
        self.inited_width = 1
172
 
 
173
 
    def setnchannels(self, nchannels):
174
 
        self.nchannels = nchannels
175
 
        self.inited_nchannels = 1
176
 
 
177
 
    def writeframes(self, data):
178
 
        if not (self.inited_outrate and self.inited_width and self.inited_nchannels):
179
 
            raise error, 'params not specified'
180
 
        if not self.port:
181
 
            import sunaudiodev, SUNAUDIODEV
182
 
            self.port = sunaudiodev.open('w')
183
 
            info = self.port.getinfo()
184
 
            info.o_sample_rate = self.outrate
185
 
            info.o_channels = self.nchannels
186
 
            if self.sampwidth == 0:
187
 
                info.o_precision = 8
188
 
                self.o_encoding = SUNAUDIODEV.ENCODING_ULAW
189
 
                # XXX Hack, hack -- leave defaults
190
 
            else:
191
 
                info.o_precision = 8 * self.sampwidth
192
 
                info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
193
 
                self.port.setinfo(info)
194
 
        if self.converter:
195
 
            data = self.converter(data)
196
 
        self.port.write(data)
197
 
 
198
 
    def wait(self):
199
 
        if not self.port:
200
 
            return
201
 
        self.port.drain()
202
 
        self.stop()
203
 
 
204
 
    def stop(self):
205
 
        if self.port:
206
 
            self.port.flush()
207
 
            self.port.close()
208
 
            self.port = None
209
 
 
210
 
    def getfilled(self):
211
 
        if self.port:
212
 
            return self.port.obufcount()
213
 
        else:
214
 
            return 0
215
 
 
216
 
##    # Nobody remembers what this method does, and it's broken. :-(
217
 
##    def getfillable(self):
218
 
##        return BUFFERSIZE - self.getfilled()
219
 
 
220
 
def AudioDev():
221
 
    # Dynamically try to import and use a platform specific module.
222
 
    try:
223
 
        import al
224
 
    except ImportError:
225
 
        try:
226
 
            import sunaudiodev
227
 
            return Play_Audio_sun()
228
 
        except ImportError:
229
 
            try:
230
 
                import Audio_mac
231
 
            except ImportError:
232
 
                raise error, 'no audio device'
233
 
            else:
234
 
                return Audio_mac.Play_Audio_mac()
235
 
    else:
236
 
        return Play_Audio_sgi()
237
 
 
238
 
def test(fn = None):
239
 
    import sys
240
 
    if sys.argv[1:]:
241
 
        fn = sys.argv[1]
242
 
    else:
243
 
        fn = 'f:just samples:just.aif'
244
 
    import aifc
245
 
    af = aifc.open(fn, 'r')
246
 
    print fn, af.getparams()
247
 
    p = AudioDev()
248
 
    p.setoutrate(af.getframerate())
249
 
    p.setsampwidth(af.getsampwidth())
250
 
    p.setnchannels(af.getnchannels())
251
 
    BUFSIZ = af.getframerate()/af.getsampwidth()/af.getnchannels()
252
 
    while 1:
253
 
        data = af.readframes(BUFSIZ)
254
 
        if not data: break
255
 
        print len(data)
256
 
        p.writeframes(data)
257
 
    p.wait()
258
 
 
259
 
if __name__ == '__main__':
260
 
    test()
 
1
"""Classes for manipulating audio devices (currently only for Sun and SGI)"""
 
2
from warnings import warnpy3k
 
3
warnpy3k("the audiodev module has been removed in Python 3.0", stacklevel=2)
 
4
del warnpy3k
 
5
 
 
6
__all__ = ["error","AudioDev"]
 
7
 
 
8
class error(Exception):
 
9
    pass
 
10
 
 
11
class Play_Audio_sgi:
 
12
    # Private instance variables
 
13
##      if 0: access frameratelist, nchannelslist, sampwidthlist, oldparams, \
 
14
##                params, config, inited_outrate, inited_width, \
 
15
##                inited_nchannels, port, converter, classinited: private
 
16
 
 
17
    classinited = 0
 
18
    frameratelist = nchannelslist = sampwidthlist = None
 
19
 
 
20
    def initclass(self):
 
21
        import AL
 
22
        self.frameratelist = [
 
23
                  (48000, AL.RATE_48000),
 
24
                  (44100, AL.RATE_44100),
 
25
                  (32000, AL.RATE_32000),
 
26
                  (22050, AL.RATE_22050),
 
27
                  (16000, AL.RATE_16000),
 
28
                  (11025, AL.RATE_11025),
 
29
                  ( 8000,  AL.RATE_8000),
 
30
                  ]
 
31
        self.nchannelslist = [
 
32
                  (1, AL.MONO),
 
33
                  (2, AL.STEREO),
 
34
                  (4, AL.QUADRO),
 
35
                  ]
 
36
        self.sampwidthlist = [
 
37
                  (1, AL.SAMPLE_8),
 
38
                  (2, AL.SAMPLE_16),
 
39
                  (3, AL.SAMPLE_24),
 
40
                  ]
 
41
        self.classinited = 1
 
42
 
 
43
    def __init__(self):
 
44
        import al, AL
 
45
        if not self.classinited:
 
46
            self.initclass()
 
47
        self.oldparams = []
 
48
        self.params = [AL.OUTPUT_RATE, 0]
 
49
        self.config = al.newconfig()
 
50
        self.inited_outrate = 0
 
51
        self.inited_width = 0
 
52
        self.inited_nchannels = 0
 
53
        self.converter = None
 
54
        self.port = None
 
55
        return
 
56
 
 
57
    def __del__(self):
 
58
        if self.port:
 
59
            self.stop()
 
60
        if self.oldparams:
 
61
            import al, AL
 
62
            al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
 
63
            self.oldparams = []
 
64
 
 
65
    def wait(self):
 
66
        if not self.port:
 
67
            return
 
68
        import time
 
69
        while self.port.getfilled() > 0:
 
70
            time.sleep(0.1)
 
71
        self.stop()
 
72
 
 
73
    def stop(self):
 
74
        if self.port:
 
75
            self.port.closeport()
 
76
            self.port = None
 
77
        if self.oldparams:
 
78
            import al, AL
 
79
            al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
 
80
            self.oldparams = []
 
81
 
 
82
    def setoutrate(self, rate):
 
83
        for (raw, cooked) in self.frameratelist:
 
84
            if rate == raw:
 
85
                self.params[1] = cooked
 
86
                self.inited_outrate = 1
 
87
                break
 
88
        else:
 
89
            raise error, 'bad output rate'
 
90
 
 
91
    def setsampwidth(self, width):
 
92
        for (raw, cooked) in self.sampwidthlist:
 
93
            if width == raw:
 
94
                self.config.setwidth(cooked)
 
95
                self.inited_width = 1
 
96
                break
 
97
        else:
 
98
            if width == 0:
 
99
                import AL
 
100
                self.inited_width = 0
 
101
                self.config.setwidth(AL.SAMPLE_16)
 
102
                self.converter = self.ulaw2lin
 
103
            else:
 
104
                raise error, 'bad sample width'
 
105
 
 
106
    def setnchannels(self, nchannels):
 
107
        for (raw, cooked) in self.nchannelslist:
 
108
            if nchannels == raw:
 
109
                self.config.setchannels(cooked)
 
110
                self.inited_nchannels = 1
 
111
                break
 
112
        else:
 
113
            raise error, 'bad # of channels'
 
114
 
 
115
    def writeframes(self, data):
 
116
        if not (self.inited_outrate and self.inited_nchannels):
 
117
            raise error, 'params not specified'
 
118
        if not self.port:
 
119
            import al, AL
 
120
            self.port = al.openport('Python', 'w', self.config)
 
121
            self.oldparams = self.params[:]
 
122
            al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
 
123
            al.setparams(AL.DEFAULT_DEVICE, self.params)
 
124
        if self.converter:
 
125
            data = self.converter(data)
 
126
        self.port.writesamps(data)
 
127
 
 
128
    def getfilled(self):
 
129
        if self.port:
 
130
            return self.port.getfilled()
 
131
        else:
 
132
            return 0
 
133
 
 
134
    def getfillable(self):
 
135
        if self.port:
 
136
            return self.port.getfillable()
 
137
        else:
 
138
            return self.config.getqueuesize()
 
139
 
 
140
    # private methods
 
141
##      if 0: access *: private
 
142
 
 
143
    def ulaw2lin(self, data):
 
144
        import audioop
 
145
        return audioop.ulaw2lin(data, 2)
 
146
 
 
147
class Play_Audio_sun:
 
148
##      if 0: access outrate, sampwidth, nchannels, inited_outrate, inited_width, \
 
149
##                inited_nchannels, converter: private
 
150
 
 
151
    def __init__(self):
 
152
        self.outrate = 0
 
153
        self.sampwidth = 0
 
154
        self.nchannels = 0
 
155
        self.inited_outrate = 0
 
156
        self.inited_width = 0
 
157
        self.inited_nchannels = 0
 
158
        self.converter = None
 
159
        self.port = None
 
160
        return
 
161
 
 
162
    def __del__(self):
 
163
        self.stop()
 
164
 
 
165
    def setoutrate(self, rate):
 
166
        self.outrate = rate
 
167
        self.inited_outrate = 1
 
168
 
 
169
    def setsampwidth(self, width):
 
170
        self.sampwidth = width
 
171
        self.inited_width = 1
 
172
 
 
173
    def setnchannels(self, nchannels):
 
174
        self.nchannels = nchannels
 
175
        self.inited_nchannels = 1
 
176
 
 
177
    def writeframes(self, data):
 
178
        if not (self.inited_outrate and self.inited_width and self.inited_nchannels):
 
179
            raise error, 'params not specified'
 
180
        if not self.port:
 
181
            import sunaudiodev, SUNAUDIODEV
 
182
            self.port = sunaudiodev.open('w')
 
183
            info = self.port.getinfo()
 
184
            info.o_sample_rate = self.outrate
 
185
            info.o_channels = self.nchannels
 
186
            if self.sampwidth == 0:
 
187
                info.o_precision = 8
 
188
                self.o_encoding = SUNAUDIODEV.ENCODING_ULAW
 
189
                # XXX Hack, hack -- leave defaults
 
190
            else:
 
191
                info.o_precision = 8 * self.sampwidth
 
192
                info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
 
193
                self.port.setinfo(info)
 
194
        if self.converter:
 
195
            data = self.converter(data)
 
196
        self.port.write(data)
 
197
 
 
198
    def wait(self):
 
199
        if not self.port:
 
200
            return
 
201
        self.port.drain()
 
202
        self.stop()
 
203
 
 
204
    def stop(self):
 
205
        if self.port:
 
206
            self.port.flush()
 
207
            self.port.close()
 
208
            self.port = None
 
209
 
 
210
    def getfilled(self):
 
211
        if self.port:
 
212
            return self.port.obufcount()
 
213
        else:
 
214
            return 0
 
215
 
 
216
##    # Nobody remembers what this method does, and it's broken. :-(
 
217
##    def getfillable(self):
 
218
##        return BUFFERSIZE - self.getfilled()
 
219
 
 
220
def AudioDev():
 
221
    # Dynamically try to import and use a platform specific module.
 
222
    try:
 
223
        import al
 
224
    except ImportError:
 
225
        try:
 
226
            import sunaudiodev
 
227
            return Play_Audio_sun()
 
228
        except ImportError:
 
229
            try:
 
230
                import Audio_mac
 
231
            except ImportError:
 
232
                raise error, 'no audio device'
 
233
            else:
 
234
                return Audio_mac.Play_Audio_mac()
 
235
    else:
 
236
        return Play_Audio_sgi()
 
237
 
 
238
def test(fn = None):
 
239
    import sys
 
240
    if sys.argv[1:]:
 
241
        fn = sys.argv[1]
 
242
    else:
 
243
        fn = 'f:just samples:just.aif'
 
244
    import aifc
 
245
    af = aifc.open(fn, 'r')
 
246
    print fn, af.getparams()
 
247
    p = AudioDev()
 
248
    p.setoutrate(af.getframerate())
 
249
    p.setsampwidth(af.getsampwidth())
 
250
    p.setnchannels(af.getnchannels())
 
251
    BUFSIZ = af.getframerate()/af.getsampwidth()/af.getnchannels()
 
252
    while 1:
 
253
        data = af.readframes(BUFSIZ)
 
254
        if not data: break
 
255
        print len(data)
 
256
        p.writeframes(data)
 
257
    p.wait()
 
258
 
 
259
if __name__ == '__main__':
 
260
    test()