Demo/sgi/video/VcrIndex.py

   1 #
   2 # A VCR index.
   3 #
   4 import os
   5 import string
   6
   7 error='VcrIndex.error'
   8 VERSION_STRING='#!VcrIndex 1.1\n'
   9 PREV_VERSION_STRING='#!VcrIndex 1.0\n'
  10
  11 class VcrIndex:
  12         def __init__(self, name):
  13                 self.curmovie = None
  14                 self.curscene = None
  15                 self.modified = 0
  16                 self.filename = name
  17                 self.basename = os.path.basename(name)
  18                 self.editable = []
  19                 if not name:
  20                         self.movies = {}
  21                         return
  22                 try:
  23                         fp = open(name, 'r')
  24                 except IOError:
  25                         self.movies = {}
  26                         return
  27                 header = fp.readline()
  28                 if header == PREV_VERSION_STRING:
  29                         print 'Converting old-format database...'
  30                         data = fp.read(100000)
  31                         self.movies = eval(data)
  32                         for m in self.movies.keys():
  33                                 d = self.movies[m]
  34                                 newd = {}
  35                                 for s in d.keys():
  36                                         newsd = {}
  37                                         newsd['START'] = d[s]
  38                                         if s == 'START':
  39                                                 s = '-ALL-'
  40                                         newd[s] = newsd
  41
  42                                 self.movies[m] = newd
  43                         print 'Done.'
  44                         return
  45                 if header <> VERSION_STRING:
  46                         print 'VcrIndex: incorrect version string:', header
  47                         self.movies = {}
  48                         return
  49                 data = fp.read(100000)
  50                 self.movies = eval(data)
  51         #
  52         # Save database to given file (or same file as read from if no
  53         # filename given).
  54         #
  55         def save(self, name):
  56                 if not name:
  57                         name = self.filename
  58                 if not name:
  59                         raise error, 'No filename given'
  60                 self.filename = name
  61                 bupname = name + '~'
  62                 try:
  63                         os.unlink(bupname)
  64                 except os.error:
  65                         pass
  66                 try:
  67                         os.rename(name, bupname)
  68                 except os.error:
  69                         pass
  70                 fp = open(name, 'w')
  71                 data = str(self.movies)
  72                 fp.write(VERSION_STRING)
  73                 fp.write(data)
  74                 fp.write('\n')
  75                 fp.close()
  76                 self.modified = 0
  77         #
  78         # Get a list of movie names in tape order
  79         #
  80         def get_movienames(self):
  81                 names = self.movies.keys()
  82                 sorted = []
  83                 for name in names:
  84                         sorted.append(self.movies[name]['-ALL-']['START'], name)
  85                 sorted.sort()
  86                 rv = []
  87                 for pos, name in sorted:
  88                         rv.append(name)
  89                 return rv
  90         #
  91         # Get a list of scene names in tape order
  92         #
  93         def get_scenenames(self):
  94                 if not self.curmovie:
  95                         return []
  96                 scenedict = self.movies[self.curmovie]
  97                 names = scenedict.keys()
  98                 sorted = []
  99                 for name in names:
 100                         sorted.append(scenedict[name], name)
 101                 sorted.sort()
 102                 rv = []
 103                 for pos, name in sorted:
 104                         rv.append(name)
 105                 return rv
 106         #
 107         # Get a list of scene ids (format '00:02:32:12 name') in tape order
 108         #
 109         def get_sceneids(self):
 110                 if not self.curmovie:
 111                         return []
 112                 scenedict = self.movies[self.curmovie]
 113                 names = scenedict.keys()
 114                 sorted = []
 115                 for name in names:
 116                         sorted.append(scenedict[name]['START'], name)
 117                 sorted.sort()
 118                 rv = []
 119                 for pos, name in sorted:
 120                         str = '%02d:%02d:%02d:%02d ' % pos
 121                         rv.append(str + name)
 122                 return rv
 123         #
 124         # Does a movie exist?
 125         #
 126         def movie_exists(self, name):
 127                 return self.movies.has_key(name)
 128         #
 129         # Select a movie.
 130         #
 131         def movie_select(self, name):
 132                 if not self.movies.has_key(name):
 133                         raise error, 'No such movie: '+name
 134                 self.curmovie = name
 135                 self.curscene = None
 136         #
 137         # Get movie dictionary, or raise an error if no current movie.
 138         #
 139         def _getmoviedict(self):
 140                 if not self.curmovie:
 141                         raise error, 'No current movie'
 142                 return self.movies[self.curmovie]
 143         #
 144         # Rename a movie.
 145         #
 146         def movie_rename(self, newname):
 147                 scenedict = self._getmoviedict()
 148                 if self.movie_exists(newname):
 149                         raise error, 'Movie already exists: '+newname
 150                 del self.movies[self.curmovie]
 151                 self.movies[newname] = scenedict
 152                 self.curmovie = newname
 153                 self.modified = 1
 154         #
 155         # Copy a movie.
 156         #
 157         def movie_copy(self, newname):
 158                 scenedict = self._getmoviedict()
 159                 if self.movie_exists(newname):
 160                         raise error, 'Movie already exists: '+newname
 161                 newdict = {}
 162                 for k in scenedict.keys():
 163                         olddata = scenedict[k]
 164                         newdata = {}
 165                         for i in olddata.keys():
 166                                 newdata[i] = olddata[i]
 167                         newdict[k] = newdata
 168                 self.movies[newname] = newdict
 169                 self.curmovie = newname
 170                 self.modified = 1
 171         #
 172         # Delete a movie.
 173         #
 174         def movie_delete(self):
 175                 if not self.curmovie:
 176                         raise error, 'No current movie'
 177                 del self.movies[self.curmovie]
 178                 self.curmovie = None
 179                 self.curscene = None
 180                 self.modified = 1
 181         #
 182         # Create a new movie.
 183         #
 184         def movie_new(self, name, pos):
 185                 if self.movie_exists(name):
 186                         raise error, 'Movie already exists: '+name
 187                 newdict = {}
 188                 newsdict = {}
 189                 newsdict['START'] = pos
 190                 newdict['-ALL-'] = newsdict
 191                 self.movies[name] = newdict
 192                 self.curmovie = name
 193                 self.curscene = None
 194                 self.modified = 1
 195         #
 196         # Does a scene exist?
 197         #
 198         def scene_exists(self, name):
 199                 scenedict = self._getmoviedict()
 200                 return scenedict.has_key(name)
 201         #
 202         # Select a current scene.
 203         #
 204         def scene_select(self, name):
 205                 scenedict = self._getmoviedict()
 206                 if not scenedict.has_key(name):
 207                         raise error, 'No such scene: '+name
 208                 self.curscene = name
 209         #
 210         # Rename a scene.
 211         #
 212         def scene_rename(self, newname):
 213                 scenedict = self._getmoviedict()
 214                 if not self.curscene:
 215                         raise error, 'No current scene'
 216                 if scenedict.has_key(newname):
 217                         raise error, 'Scene already exists: '+newname
 218                 if self.curscene == '-ALL-':
 219                         raise error, 'Cannot rename -ALL-'
 220                 scenedict[newname] = scenedict[self.curscene]
 221                 del scenedict[self.curscene]
 222                 self.curscene = newname
 223                 self.modified = 1
 224         #
 225         # Copy a scene.
 226         #
 227         def scene_copy(self, newname):
 228                 scenedict = self._getmoviedict()
 229                 if not self.curscene:
 230                         raise error, 'No current scene'
 231                 if scenedict.has_key(newname):
 232                         raise error, 'Scene already exists: '+newname
 233                 scenedict[newname] = scenedict[self.curscene]
 234                 self.curscene = newname
 235                 self.modified = 1
 236         #
 237         # Delete a scene.
 238         #
 239         def scene_delete(self):
 240                 scenedict = self._getmoviedict()
 241                 if not self.curscene:
 242                         raise error, 'No current scene'
 243                 if self.curscene == '-ALL-':
 244                         raise error, 'Cannot delete -ALL-'
 245                 del scenedict[self.curscene]
 246                 self.curscene = None
 247                 self.modified = 1
 248         #
 249         # Add a new scene.
 250         #
 251         def scene_new(self, newname, pos):
 252                 scenedict = self._getmoviedict()
 253                 if scenedict.has_key(newname):
 254                         raise error, 'Scene already exists: '+newname
 255                 newdict = {}
 256                 newdict['START'] = pos
 257                 scenedict[newname] = newdict
 258                 self.curscene = newname
 259                 self.modified = 1
 260         #
 261         # Get scene data.
 262         #
 263         def _getscenedata(self):
 264                 scenedict = self._getmoviedict()
 265                 if not self.curscene:
 266                         raise error, 'No current scene'
 267                 return scenedict[self.curscene]
 268         #
 269         # Data manipulation routines.
 270         #
 271         def pos_get(self):
 272                 return self._getscenedata()['START']
 273         #
 274         def pos_set(self, pos):
 275                 data = self._getscenedata()
 276                 data['START'] = pos
 277                 self.modified = 1
 278         #
 279         def comment_get(self):
 280                 data = self._getscenedata()
 281                 if data.has_key('COMMENT'):
 282                         return data['COMMENT']
 283                 else:
 284                         return ''
 285         #
 286         def comment_set(self, comment):
 287                 data = self._getscenedata()
 288                 data['COMMENT'] = comment
 289                 self.modified = 1
 290         #
 291         # Get the scene id of the current scene.
 292         #
 293         def get_cursceneid(self):
 294                 pos = self._getscenedata()['START']
 295                 str = '%02d:%02d:%02d:%02d ' % pos
 296                 return str + self.curscene
 297         #
 298         # Convert a scene id to a scene name.
 299         #
 300         def scene_id2name(self, id):
 301                 pos = string.find(id, ' ')
 302                 if pos <= 0:
 303                         raise error, 'Not a scene id: '+id
 304                 return id[pos+1:]
 305         #
 306         # Select a scene given a position.
 307         #
 308         def pos_select(self, pos):
 309                 prevmovie = None
 310                 movies = self.get_movienames()
 311                 for movie in movies:
 312                         mpos = self.movies[movie]['-ALL-']['START']
 313                         if mpos > pos:
 314                                 break
 315                         prevmovie = movie
 316                 if not prevmovie:
 317                         raise error, 'Scene before BOT'
 318
 319                 self.movie_select(prevmovie)
 320                 scenes = self.get_scenenames()
 321                 scenedict = self._getmoviedict()
 322                 prevscene = 'START'
 323                 for scene in scenes:
 324                         if scenedict[scene]['START'] > pos:
 325                                 break
 326                         prevscene = scene
 327                 self.scene_select(prevscene)