Demo/sgi/video/Viewer.py

   1 import gl, GL
   2 import VFile
   3 import os
   4
   5
   6 class InputViewer:
   7
   8         def __init__(self, filename, title, *args):
   9                 try:
  10                         self.vin = VFile.VinFile(filename)
  11                 except (EOFError, VFile.Error):
  12                         raise IOError, 'bad video input file'
  13                 self.vin.warmcache()
  14                 if not title:
  15                         title = os.path.split(filename)[1]
  16                 self.filename = filename
  17                 self.title = title
  18                 self.qsize = len(self.vin.index)
  19                 gl.foreground()
  20                 gl.prefsize(self.vin.width, self.vin.height)
  21                 self.wid = -1
  22                 self.reset()
  23
  24         def close(self):
  25                 self.vin.close()
  26                 if self.wid > 0:
  27                         gl.winclose(self.wid)
  28
  29         def rewind(self):
  30                 self.vin.rewind()
  31                 self.reset()
  32
  33         def getinfo(self):
  34                 return self.vin.getinfo()
  35
  36         # Internal
  37         def reset(self):
  38                 if self.wid > 0:
  39                         gl.winset(self.wid)
  40                         gl.clear()
  41                         self.vin.initcolormap()
  42                 self.qindex = 0
  43
  44         def show(self):
  45                 if self.wid < 0:
  46                         gl.foreground()
  47                         gl.prefsize(self.vin.width, self.vin.height)
  48                         self.wid = gl.winopen(self.title)
  49                         gl.clear()
  50                         self.vin.initcolormap()
  51                 gl.winset(self.wid)
  52                 if self.qindex >= self.qsize:
  53                         self.vin.clear()
  54                         return
  55                 dt, d, cd = self.vin.getrandomframe(self.qindex)
  56                 self.vin.showframe(d, cd)
  57
  58         def redraw(self, wid):
  59                 if wid == self.wid >= 0:
  60                         gl.winset(self.wid)
  61                         gl.reshapeviewport()
  62                         self.vin.clear()
  63                         self.show()
  64
  65         def get(self):
  66                 if self.qindex >= self.qsize:
  67                         return None
  68                 if self.qindex > 0:
  69                         prevt, ds, cs = \
  70                                   self.vin.getrandomframeheader(self.qindex-1)
  71                 else:
  72                         prevt = 0
  73                 t, data, cdata = self.vin.getrandomframe(self.qindex)
  74                 self.qindex = self.qindex + 1
  75                 return t-prevt, data, cdata
  76
  77         def backup(self):
  78                 if self.qindex == 0:
  79                         return 0
  80                 self.qindex = self.qindex - 1
  81                 return 1
  82
  83         def seek(self, i):
  84                 if not 0 <= i <= self.qsize:
  85                         return 0
  86                 self.qindex = i
  87                 return 1
  88
  89         def tell(self):
  90                 return self.qindex
  91
  92         def qsizes(self):
  93                 return self.qindex, self.qsize - self.qindex
  94
  95         def qinfo(self):
  96                 return 0, self.qindex, self.qsize
  97
  98
  99 class OutputViewer:
 100
 101         def __init__(self, filename, title, qsize):
 102                 try:
 103                         self.vout = VFile.VoutFile(filename)
 104                 except (EOFError, VFile.Error):
 105                         raise IOError, 'bad video output file'
 106                 if not title:
 107                         title = os.path.split(filename)[1]
 108                 self.filename = filename
 109                 self.title = title
 110                 self.qsize = qsize
 111                 gl.foreground()
 112                 self.wid = -1
 113                 self.reset()
 114
 115         def close(self):
 116                 while self.queue:
 117                         self.flushq()
 118                 self.vout.close()
 119                 if self.wid > 0:
 120                         gl.winclose(self.wid)
 121
 122         def rewind(self):
 123                 info = self.vout.getinfo()
 124                 self.vout.close()
 125                 self.vout = VFile.VoutFile(self.filename)
 126                 self.vout.setinfo(info)
 127                 self.reset()
 128
 129         def getinfo(self):
 130                 return self.vout.getinfo()
 131
 132         def setinfo(self, info):
 133                 if info == self.getinfo(): return # No change
 134                 self.vout.setinfo(info)
 135                 if self.wid > 0:
 136                         gl.winclose(self.wid)
 137                         self.wid = -1
 138
 139         # Internal
 140         def reset(self):
 141                 if self.wid > 0:
 142                         gl.winset(self.wid)
 143                         gl.clear()
 144                         self.vout.initcolormap()
 145                 self.queue = []
 146                 self.spares = []
 147                 self.written = 0
 148                 self.lastt = 0
 149
 150         # Internal
 151         def flushq(self):
 152                 if self.written == 0:
 153                         self.vout.writeheader()
 154                 dt, d, cd = self.queue[0]
 155                 self.lastt = self.lastt + dt
 156                 self.vout.writeframe(self.lastt, d, cd)
 157                 del self.queue[0]
 158                 self.written = self.written + 1
 159
 160         def show(self):
 161                 if self.wid < 0:
 162                         gl.foreground()
 163                         gl.prefsize(self.vout.width, self.vout.height)
 164                         self.wid = gl.winopen(self.title)
 165                         gl.clear()
 166                         self.vout.initcolormap()
 167                 gl.winset(self.wid)
 168                 if not self.queue:
 169                         self.vout.clear()
 170                         return
 171                 dt, d, cd = self.queue[-1]
 172                 self.vout.showframe(d, cd)
 173
 174         def redraw(self, wid):
 175                 if wid == self.wid >= 0:
 176                         gl.winset(self.wid)
 177                         gl.reshapeviewport()
 178                         self.vout.clear()
 179                         self.show()
 180
 181         def backup(self):
 182                 if len(self.queue) < 1: return 0
 183                 self.spares.insert(0, self.queue[-1])
 184                 del self.queue[-1]
 185                 return 1
 186
 187         def forward(self):
 188                 if not self.spares: return 0
 189                 self.queue.append(self.spares[0])
 190                 del self.spares[0]
 191                 return 1
 192
 193         def put(self, item):
 194                 self.queue.append(item)
 195                 self.spares = []
 196                 while len(self.queue) > self.qsize:
 197                         self.flushq()
 198
 199         def seek(self, i):
 200                 i = i - self.written
 201                 if not 0 <= i <= len(self.queue) + len(self.spares):
 202                         return 0
 203                 while i < len(self.queue):
 204                         if not self.backup():
 205                                 return 0
 206                 while i > len(self.queue):
 207                         if not self.forward():
 208                                 return 0
 209                 return 1
 210
 211         def trunc(self):
 212                 del self.spares[:]
 213
 214         def tell(self):
 215                 return self.written + len(self.queue)
 216
 217         def qsizes(self):
 218                 return len(self.queue), len(self.spares)
 219
 220         def qinfo(self):
 221                 first = self.written
 222                 pos = first + len(self.queue)
 223                 last = pos + len(self.spares)
 224                 return first, pos, last
 225
 226
 227 def test():
 228         import sys
 229         a = InputViewer(sys.argv[1], '')
 230         b = OutputViewer(sys.argv[2], '')
 231         b.setinfo(a.getinfo())
 232
 233         while 1:
 234                 a.show()
 235                 data = a.get()
 236                 if data is None:
 237                         break
 238                 b.put(data)
 239                 b.show()
 240
 241         while a.backup():
 242                 data = a.get()
 243                 b.put(data)
 244                 b.show()
 245                 if a.backup(): a.show()
 246
 247         while 1:
 248                 data = a.get()
 249                 if data is None:
 250                         break
 251                 b.put(data)
 252                 b.show()
 253                 a.show()
 254
 255         b.close()