| 1 | # Class interface to the CD module.
|
|---|
| 2 | from warnings import warnpy3k
|
|---|
| 3 | warnpy3k("the readcd module has been removed in Python 3.0", stacklevel=2)
|
|---|
| 4 | del warnpy3k
|
|---|
| 5 |
|
|---|
| 6 | import cd, CD
|
|---|
| 7 |
|
|---|
| 8 | class Error(Exception):
|
|---|
| 9 | pass
|
|---|
| 10 | class _Stop(Exception):
|
|---|
| 11 | pass
|
|---|
| 12 |
|
|---|
| 13 | def _doatime(self, cb_type, data):
|
|---|
| 14 | if ((data[0] * 60) + data[1]) * 75 + data[2] > self.end:
|
|---|
| 15 | ## print 'done with list entry', repr(self.listindex)
|
|---|
| 16 | raise _Stop
|
|---|
| 17 | func, arg = self.callbacks[cb_type]
|
|---|
| 18 | if func:
|
|---|
| 19 | func(arg, cb_type, data)
|
|---|
| 20 |
|
|---|
| 21 | def _dopnum(self, cb_type, data):
|
|---|
| 22 | if data > self.end:
|
|---|
| 23 | ## print 'done with list entry', repr(self.listindex)
|
|---|
| 24 | raise _Stop
|
|---|
| 25 | func, arg = self.callbacks[cb_type]
|
|---|
| 26 | if func:
|
|---|
| 27 | func(arg, cb_type, data)
|
|---|
| 28 |
|
|---|
| 29 | class Readcd:
|
|---|
| 30 | def __init__(self, *arg):
|
|---|
| 31 | if len(arg) == 0:
|
|---|
| 32 | self.player = cd.open()
|
|---|
| 33 | elif len(arg) == 1:
|
|---|
| 34 | self.player = cd.open(arg[0])
|
|---|
| 35 | elif len(arg) == 2:
|
|---|
| 36 | self.player = cd.open(arg[0], arg[1])
|
|---|
| 37 | else:
|
|---|
| 38 | raise Error, 'bad __init__ call'
|
|---|
| 39 | self.list = []
|
|---|
| 40 | self.callbacks = [(None, None)] * 8
|
|---|
| 41 | self.parser = cd.createparser()
|
|---|
| 42 | self.playing = 0
|
|---|
| 43 | self.end = 0
|
|---|
| 44 | self.status = None
|
|---|
| 45 | self.trackinfo = None
|
|---|
| 46 |
|
|---|
| 47 | def eject(self):
|
|---|
| 48 | self.player.eject()
|
|---|
| 49 | self.list = []
|
|---|
| 50 | self.end = 0
|
|---|
| 51 | self.listindex = 0
|
|---|
| 52 | self.status = None
|
|---|
| 53 | self.trackinfo = None
|
|---|
| 54 | if self.playing:
|
|---|
| 55 | ## print 'stop playing from eject'
|
|---|
| 56 | raise _Stop
|
|---|
| 57 |
|
|---|
| 58 | def pmsf2msf(self, track, min, sec, frame):
|
|---|
| 59 | if not self.status:
|
|---|
| 60 | self.cachestatus()
|
|---|
| 61 | if track < self.status[5] or track > self.status[6]:
|
|---|
| 62 | raise Error, 'track number out of range'
|
|---|
| 63 | if not self.trackinfo:
|
|---|
| 64 | self.cacheinfo()
|
|---|
| 65 | start, total = self.trackinfo[track]
|
|---|
| 66 | start = ((start[0] * 60) + start[1]) * 75 + start[2]
|
|---|
| 67 | total = ((total[0] * 60) + total[1]) * 75 + total[2]
|
|---|
| 68 | block = ((min * 60) + sec) * 75 + frame
|
|---|
| 69 | if block > total:
|
|---|
| 70 | raise Error, 'out of range'
|
|---|
| 71 | block = start + block
|
|---|
| 72 | min, block = divmod(block, 75*60)
|
|---|
| 73 | sec, frame = divmod(block, 75)
|
|---|
| 74 | return min, sec, frame
|
|---|
| 75 |
|
|---|
| 76 | def reset(self):
|
|---|
| 77 | self.list = []
|
|---|
| 78 |
|
|---|
| 79 | def appendtrack(self, track):
|
|---|
| 80 | self.appendstretch(track, track)
|
|---|
| 81 |
|
|---|
| 82 | def appendstretch(self, start, end):
|
|---|
| 83 | if not self.status:
|
|---|
| 84 | self.cachestatus()
|
|---|
| 85 | if not start:
|
|---|
| 86 | start = 1
|
|---|
| 87 | if not end:
|
|---|
| 88 | end = self.status[6]
|
|---|
| 89 | if type(end) == type(0):
|
|---|
| 90 | if end < self.status[5] or end > self.status[6]:
|
|---|
| 91 | raise Error, 'range error'
|
|---|
| 92 | else:
|
|---|
| 93 | l = len(end)
|
|---|
| 94 | if l == 4:
|
|---|
| 95 | prog, min, sec, frame = end
|
|---|
| 96 | if prog < self.status[5] or prog > self.status[6]:
|
|---|
| 97 | raise Error, 'range error'
|
|---|
| 98 | end = self.pmsf2msf(prog, min, sec, frame)
|
|---|
| 99 | elif l != 3:
|
|---|
| 100 | raise Error, 'syntax error'
|
|---|
| 101 | if type(start) == type(0):
|
|---|
| 102 | if start < self.status[5] or start > self.status[6]:
|
|---|
| 103 | raise Error, 'range error'
|
|---|
| 104 | if len(self.list) > 0:
|
|---|
| 105 | s, e = self.list[-1]
|
|---|
| 106 | if type(e) == type(0):
|
|---|
| 107 | if start == e+1:
|
|---|
| 108 | start = s
|
|---|
| 109 | del self.list[-1]
|
|---|
| 110 | else:
|
|---|
| 111 | l = len(start)
|
|---|
| 112 | if l == 4:
|
|---|
| 113 | prog, min, sec, frame = start
|
|---|
| 114 | if prog < self.status[5] or prog > self.status[6]:
|
|---|
| 115 | raise Error, 'range error'
|
|---|
| 116 | start = self.pmsf2msf(prog, min, sec, frame)
|
|---|
| 117 | elif l != 3:
|
|---|
| 118 | raise Error, 'syntax error'
|
|---|
| 119 | self.list.append((start, end))
|
|---|
| 120 |
|
|---|
| 121 | def settracks(self, list):
|
|---|
| 122 | self.list = []
|
|---|
| 123 | for track in list:
|
|---|
| 124 | self.appendtrack(track)
|
|---|
| 125 |
|
|---|
| 126 | def setcallback(self, cb_type, func, arg):
|
|---|
| 127 | if cb_type < 0 or cb_type >= 8:
|
|---|
| 128 | raise Error, 'type out of range'
|
|---|
| 129 | self.callbacks[cb_type] = (func, arg)
|
|---|
| 130 | if self.playing:
|
|---|
| 131 | start, end = self.list[self.listindex]
|
|---|
| 132 | if type(end) == type(0):
|
|---|
| 133 | if cb_type != CD.PNUM:
|
|---|
| 134 | self.parser.setcallback(cb_type, func, arg)
|
|---|
| 135 | else:
|
|---|
| 136 | if cb_type != CD.ATIME:
|
|---|
| 137 | self.parser.setcallback(cb_type, func, arg)
|
|---|
| 138 |
|
|---|
| 139 | def removecallback(self, cb_type):
|
|---|
| 140 | if cb_type < 0 or cb_type >= 8:
|
|---|
| 141 | raise Error, 'type out of range'
|
|---|
| 142 | self.callbacks[cb_type] = (None, None)
|
|---|
| 143 | if self.playing:
|
|---|
| 144 | start, end = self.list[self.listindex]
|
|---|
| 145 | if type(end) == type(0):
|
|---|
| 146 | if cb_type != CD.PNUM:
|
|---|
| 147 | self.parser.removecallback(cb_type)
|
|---|
| 148 | else:
|
|---|
| 149 | if cb_type != CD.ATIME:
|
|---|
| 150 | self.parser.removecallback(cb_type)
|
|---|
| 151 |
|
|---|
| 152 | def gettrackinfo(self, *arg):
|
|---|
| 153 | if not self.status:
|
|---|
| 154 | self.cachestatus()
|
|---|
| 155 | if not self.trackinfo:
|
|---|
| 156 | self.cacheinfo()
|
|---|
| 157 | if len(arg) == 0:
|
|---|
| 158 | return self.trackinfo[self.status[5]:self.status[6]+1]
|
|---|
| 159 | result = []
|
|---|
| 160 | for i in arg:
|
|---|
| 161 | if i < self.status[5] or i > self.status[6]:
|
|---|
| 162 | raise Error, 'range error'
|
|---|
| 163 | result.append(self.trackinfo[i])
|
|---|
| 164 | return result
|
|---|
| 165 |
|
|---|
| 166 | def cacheinfo(self):
|
|---|
| 167 | if not self.status:
|
|---|
| 168 | self.cachestatus()
|
|---|
| 169 | self.trackinfo = []
|
|---|
| 170 | for i in range(self.status[5]):
|
|---|
| 171 | self.trackinfo.append(None)
|
|---|
| 172 | for i in range(self.status[5], self.status[6]+1):
|
|---|
| 173 | self.trackinfo.append(self.player.gettrackinfo(i))
|
|---|
| 174 |
|
|---|
| 175 | def cachestatus(self):
|
|---|
| 176 | self.status = self.player.getstatus()
|
|---|
| 177 | if self.status[0] == CD.NODISC:
|
|---|
| 178 | self.status = None
|
|---|
| 179 | raise Error, 'no disc in player'
|
|---|
| 180 |
|
|---|
| 181 | def getstatus(self):
|
|---|
| 182 | return self.player.getstatus()
|
|---|
| 183 |
|
|---|
| 184 | def play(self):
|
|---|
| 185 | if not self.status:
|
|---|
| 186 | self.cachestatus()
|
|---|
| 187 | size = self.player.bestreadsize()
|
|---|
| 188 | self.listindex = 0
|
|---|
| 189 | self.playing = 0
|
|---|
| 190 | for i in range(8):
|
|---|
| 191 | func, arg = self.callbacks[i]
|
|---|
| 192 | if func:
|
|---|
| 193 | self.parser.setcallback(i, func, arg)
|
|---|
| 194 | else:
|
|---|
| 195 | self.parser.removecallback(i)
|
|---|
| 196 | if len(self.list) == 0:
|
|---|
| 197 | for i in range(self.status[5], self.status[6]+1):
|
|---|
| 198 | self.appendtrack(i)
|
|---|
| 199 | try:
|
|---|
| 200 | while 1:
|
|---|
| 201 | if not self.playing:
|
|---|
| 202 | if self.listindex >= len(self.list):
|
|---|
| 203 | return
|
|---|
| 204 | start, end = self.list[self.listindex]
|
|---|
| 205 | if type(start) == type(0):
|
|---|
| 206 | dummy = self.player.seektrack(
|
|---|
| 207 | start)
|
|---|
| 208 | else:
|
|---|
| 209 | min, sec, frame = start
|
|---|
| 210 | dummy = self.player.seek(
|
|---|
| 211 | min, sec, frame)
|
|---|
| 212 | if type(end) == type(0):
|
|---|
| 213 | self.parser.setcallback(
|
|---|
| 214 | CD.PNUM, _dopnum, self)
|
|---|
| 215 | self.end = end
|
|---|
| 216 | func, arg = \
|
|---|
| 217 | self.callbacks[CD.ATIME]
|
|---|
| 218 | if func:
|
|---|
| 219 | self.parser.setcallback(CD.ATIME, func, arg)
|
|---|
| 220 | else:
|
|---|
| 221 | self.parser.removecallback(CD.ATIME)
|
|---|
| 222 | else:
|
|---|
| 223 | min, sec, frame = end
|
|---|
| 224 | self.parser.setcallback(
|
|---|
| 225 | CD.ATIME, _doatime,
|
|---|
| 226 | self)
|
|---|
| 227 | self.end = (min * 60 + sec) * \
|
|---|
| 228 | 75 + frame
|
|---|
| 229 | func, arg = \
|
|---|
| 230 | self.callbacks[CD.PNUM]
|
|---|
| 231 | if func:
|
|---|
| 232 | self.parser.setcallback(CD.PNUM, func, arg)
|
|---|
| 233 | else:
|
|---|
| 234 | self.parser.removecallback(CD.PNUM)
|
|---|
| 235 | self.playing = 1
|
|---|
| 236 | data = self.player.readda(size)
|
|---|
| 237 | if data == '':
|
|---|
| 238 | self.playing = 0
|
|---|
| 239 | self.listindex = self.listindex + 1
|
|---|
| 240 | continue
|
|---|
| 241 | try:
|
|---|
| 242 | self.parser.parseframe(data)
|
|---|
| 243 | except _Stop:
|
|---|
| 244 | self.playing = 0
|
|---|
| 245 | self.listindex = self.listindex + 1
|
|---|
| 246 | finally:
|
|---|
| 247 | self.playing = 0
|
|---|
