Home | History | Annotate | Download | only in plat-irix6 
      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
    248