vorbisfile-python/vorbisfile.py

   1 import types
   2 from _vorbisfile import *
   3
   4 MODE_RAW = 0
   5 MODE_PCM = 1
   6 MODE_TIME = 2
   7 MODE_PAGE = 4
   8 MODE_LAP = 8
   9
  10 FORMAT_INT = 0
  11 FORMAT_FLOAT = 1
  12
  13 class VorbisFileHoleError(StandardError):
  14     pass
  15
  16 class VorbisFile(object):
  17     def __init__(self):
  18         self.vf = None
  19         self.testing = 0
  20
  21     def open(self, file=None):
  22         if not self.testing and not file:
  23             raise StandardException, "Expected a file object or "\
  24                   "string, or test mode."
  25         elif self.testing:
  26             ret = ov_test_open(self.vf)
  27             # FIXME: check return value
  28         else:
  29             if type(file) == types.StringType:
  30                 self.vf = ov_open(open(file))
  31             else:
  32                 self.vf = ov_open(file)
  33
  34         return self.vf != None
  35
  36     def test(self, file):
  37         self.testing = 1
  38
  39         if type(file) == types.StringType:
  40             self.vf = ov_test(open(file))
  41         else:
  42             self.vf = ov_test(file)
  43
  44         return self.vf != None
  45
  46     def clear(self):
  47         return ov_clear(self.vf)
  48
  49     def bitrate(self, link=-1, instant=0):
  50         if instant:
  51             return ov_bitrate_instant(self.vf)
  52         else:
  53             return ov_bitrate(self.vf, link)
  54
  55     def links(self):
  56         return ov_streams(self.vf)
  57
  58     def seekable(self):
  59         return ov_seekable(self.vf)
  60
  61     def serialnumber(self, link=-1):
  62         return ov_serialnumber(self.vf, link)
  63
  64     def length(self, link=-1, mode=MODE_TIME):
  65         if mode == MODE_RAW:
  66             return ov_raw_total(self.vf, link)
  67         elif mode == MODE_PCM:
  68             return ov_pcm_total(self.vf, link)
  69         elif mode == MODE_TIME:
  70             return ov_time_total(self.vf, link)
  71         else:
  72             raise StandardError, "Unknown mode requested"
  73
  74     def seek(self, pos, mode=MODE_TIME):
  75         if mode == MODE_RAW:
  76             return ov_raw_seek(self.vf, pos)
  77         elif mode == MODE_RAW | MODE_LAP:
  78             return ov_raw_seek_lap(self.vf, pos)
  79         elif mode == MODE_PCM:
  80             return ov_pcm_seek(self.vf, pos)
  81         elif mode == MODE_PCM | MODE_LAP:
  82             return ov_pcm_seek_lap(self.vf, pos)
  83         elif mode == MODE_PCM | MODE_PAGE:
  84             return ov_pcm_seek_page(self.vf, pos)
  85         elif mode == MODE_PCM | MODE_PAGE | MODE_LAP:
  86             return ov_pcm_seek_page_lap(self.vf, pos)
  87         elif mode == MODE_TIME:
  88             return ov_time_seek(self.vf, pos)
  89         elif mode == MODE_TIME | MODE_LAP:
  90             return ov_time_seek_lap(self.vf, pos)
  91         elif mode == MODE_TIME | MODE_PAGE:
  92             return ov_time_seek_page(self.vf, pos)
  93         elif mode == MODE_TIME | MODE_PAGE | MODE_LAP:
  94             return ov_time_seek_page_lap(self.vf, pos)
  95         else:
  96             raise StandardError, "Unknown mode requested"
  97
  98     def tell(self, mode=MODE_TIME):
  99         if mode == MODE_RAW:
 100             return ov_raw_tell(self.vf)
 101         elif mode == MODE_PCM:
 102             return ov_pcm_tell(self.vf)
 103         elif mode == MODE_TIME:
 104             return ov_time_tell(self.vf)
 105         else:
 106             raise StandardError, "Unknown mode requested"
 107
 108     def info(self):
 109         return ov_info(self.vf)
 110
 111     def comments(self):
 112         return ov_comment(self.vf)
 113
 114     def read(self, num, format=FORMAT_INT, wordsize=2, signed=1, bendian=0):
 115         if format == FORMAT_FLOAT:
 116             samps, data, cs = ov_read_float(self.vf, num)
 117             return data, cs
 118         elif format == FORMAT_INT:
 119             real_num = num * wordsize * 2 # FIXME: get number channels
 120             samps, data, cs = ov_read(self.vf, real_num, bendian,
 121                                       wordsize, signed)
 122             if samps < 0:
 123                 raise VorbisFileHoleError, "vorbisfile error %d" % samps
 124             return data, cs
 125         else:
 126             raise StandardError, "Unknown format requested"
 127
 128     def halfrate(self, flag):
 129         return ov_halfrate(self.vf, flag)
 130
 131     def halfratable(self):
 132         return ov_halfrate(self.vf)