| # Video file reader, using QuickTime |
| # |
| # This module was quickly ripped out of another software package, so there is a good |
| # chance that it does not work as-is and it needs some hacking. |
| # |
| # Jack Jansen, August 2000 |
| # |
| |
| from warnings import warnpy3k |
| warnpy3k("In 3.x, the videoreader module is removed.", stacklevel=2) |
| |
| |
| import sys |
| from Carbon import Qt |
| from Carbon import QuickTime |
| from Carbon import Qd |
| from Carbon import Qdoffs |
| from Carbon import QDOffscreen |
| from Carbon import Res |
| try: |
| from Carbon import MediaDescr |
| except ImportError: |
| def _audiodescr(data): |
| return None |
| else: |
| def _audiodescr(data): |
| return MediaDescr.SoundDescription.decode(data) |
| try: |
| from imgformat import macrgb |
| except ImportError: |
| macrgb = "Macintosh RGB format" |
| import os |
| # import audio.format |
| |
| class VideoFormat: |
| def __init__(self, name, descr, width, height, format): |
| self.__name = name |
| self.__descr = descr |
| self.__width = width |
| self.__height = height |
| self.__format = format |
| |
| def getname(self): |
| return self.__name |
| |
| def getdescr(self): |
| return self.__descr |
| |
| def getsize(self): |
| return self.__width, self.__height |
| |
| def getformat(self): |
| return self.__format |
| |
| class _Reader: |
| def __init__(self, path): |
| fd = Qt.OpenMovieFile(path, 0) |
| self.movie, d1, d2 = Qt.NewMovieFromFile(fd, 0, 0) |
| self.movietimescale = self.movie.GetMovieTimeScale() |
| try: |
| self.audiotrack = self.movie.GetMovieIndTrackType(1, |
| QuickTime.AudioMediaCharacteristic, QuickTime.movieTrackCharacteristic) |
| self.audiomedia = self.audiotrack.GetTrackMedia() |
| except Qt.Error: |
| self.audiotrack = self.audiomedia = None |
| self.audiodescr = {} |
| else: |
| handle = Res.Handle('') |
| n = self.audiomedia.GetMediaSampleDescriptionCount() |
| self.audiomedia.GetMediaSampleDescription(1, handle) |
| self.audiodescr = _audiodescr(handle.data) |
| self.audiotimescale = self.audiomedia.GetMediaTimeScale() |
| del handle |
| |
| try: |
| self.videotrack = self.movie.GetMovieIndTrackType(1, |
| QuickTime.VisualMediaCharacteristic, QuickTime.movieTrackCharacteristic) |
| self.videomedia = self.videotrack.GetTrackMedia() |
| except Qt.Error: |
| self.videotrack = self.videomedia = self.videotimescale = None |
| if self.videotrack: |
| self.videotimescale = self.videomedia.GetMediaTimeScale() |
| x0, y0, x1, y1 = self.movie.GetMovieBox() |
| self.videodescr = {'width':(x1-x0), 'height':(y1-y0)} |
| self._initgworld() |
| self.videocurtime = None |
| self.audiocurtime = None |
| |
| |
| def __del__(self): |
| self.audiomedia = None |
| self.audiotrack = None |
| self.videomedia = None |
| self.videotrack = None |
| self.movie = None |
| |
| def _initgworld(self): |
| old_port, old_dev = Qdoffs.GetGWorld() |
| try: |
| movie_w = self.videodescr['width'] |
| movie_h = self.videodescr['height'] |
| movie_rect = (0, 0, movie_w, movie_h) |
| self.gworld = Qdoffs.NewGWorld(32, movie_rect, None, None, QDOffscreen.keepLocal) |
| self.pixmap = self.gworld.GetGWorldPixMap() |
| Qdoffs.LockPixels(self.pixmap) |
| Qdoffs.SetGWorld(self.gworld.as_GrafPtr(), None) |
| Qd.EraseRect(movie_rect) |
| self.movie.SetMovieGWorld(self.gworld.as_GrafPtr(), None) |
| self.movie.SetMovieBox(movie_rect) |
| self.movie.SetMovieActive(1) |
| self.movie.MoviesTask(0) |
| self.movie.SetMoviePlayHints(QuickTime.hintsHighQuality, QuickTime.hintsHighQuality) |
| # XXXX framerate |
| finally: |
| Qdoffs.SetGWorld(old_port, old_dev) |
| |
| def _gettrackduration_ms(self, track): |
| tracktime = track.GetTrackDuration() |
| return self._movietime_to_ms(tracktime) |
| |
| def _movietime_to_ms(self, time): |
| value, d1, d2 = Qt.ConvertTimeScale((time, self.movietimescale, None), 1000) |
| return value |
| |
| def _videotime_to_ms(self, time): |
| value, d1, d2 = Qt.ConvertTimeScale((time, self.videotimescale, None), 1000) |
| return value |
| |
| def _audiotime_to_ms(self, time): |
| value, d1, d2 = Qt.ConvertTimeScale((time, self.audiotimescale, None), 1000) |
| return value |
| |
| def _videotime_to_movietime(self, time): |
| value, d1, d2 = Qt.ConvertTimeScale((time, self.videotimescale, None), |
| self.movietimescale) |
| return value |
| |
| def HasAudio(self): |
| return not self.audiotrack is None |
| |
| def HasVideo(self): |
| return not self.videotrack is None |
| |
| def GetAudioDuration(self): |
| if not self.audiotrack: |
| return 0 |
| return self._gettrackduration_ms(self.audiotrack) |
| |
| def GetVideoDuration(self): |
| if not self.videotrack: |
| return 0 |
| return self._gettrackduration_ms(self.videotrack) |
| |
| def GetAudioFormat(self): |
| if not self.audiodescr: |
| return None, None, None, None, None |
| bps = self.audiodescr['sampleSize'] |
| nch = self.audiodescr['numChannels'] |
| if nch == 1: |
| channels = ['mono'] |
| elif nch == 2: |
| channels = ['left', 'right'] |
| else: |
| channels = map(lambda x: str(x+1), range(nch)) |
| if bps % 8: |
| # Funny bits-per sample. We pretend not to understand |
| blocksize = 0 |
| fpb = 0 |
| else: |
| # QuickTime is easy (for as far as we support it): samples are always a whole |
| # number of bytes, so frames are nchannels*samplesize, and there's one frame per block. |
| blocksize = (bps/8)*nch |
| fpb = 1 |
| if self.audiodescr['dataFormat'] == 'raw ': |
| encoding = 'linear-excess' |
| elif self.audiodescr['dataFormat'] == 'twos': |
| encoding = 'linear-signed' |
| else: |
| encoding = 'quicktime-coding-%s'%self.audiodescr['dataFormat'] |
| ## return audio.format.AudioFormatLinear('quicktime_audio', 'QuickTime Audio Format', |
| ## channels, encoding, blocksize=blocksize, fpb=fpb, bps=bps) |
| return channels, encoding, blocksize, fpb, bps |
| |
| def GetAudioFrameRate(self): |
| if not self.audiodescr: |
| return None |
| return int(self.audiodescr['sampleRate']) |
| |
| def GetVideoFormat(self): |
| width = self.videodescr['width'] |
| height = self.videodescr['height'] |
| return VideoFormat('dummy_format', 'Dummy Video Format', width, height, macrgb) |
| |
| def GetVideoFrameRate(self): |
| tv = self.videocurtime |
| if tv is None: |
| tv = 0 |
| flags = QuickTime.nextTimeStep|QuickTime.nextTimeEdgeOK |
| tv, dur = self.videomedia.GetMediaNextInterestingTime(flags, tv, 1.0) |
| dur = self._videotime_to_ms(dur) |
| return int((1000.0/dur)+0.5) |
| |
| def ReadAudio(self, nframes, time=None): |
| if not time is None: |
| self.audiocurtime = time |
| flags = QuickTime.nextTimeStep|QuickTime.nextTimeEdgeOK |
| if self.audiocurtime is None: |
| self.audiocurtime = 0 |
| tv = self.audiomedia.GetMediaNextInterestingTimeOnly(flags, self.audiocurtime, 1.0) |
| if tv < 0 or (self.audiocurtime and tv < self.audiocurtime): |
| return self._audiotime_to_ms(self.audiocurtime), None |
| h = Res.Handle('') |
| desc_h = Res.Handle('') |
| size, actualtime, sampleduration, desc_index, actualcount, flags = \ |
| self.audiomedia.GetMediaSample(h, 0, tv, desc_h, nframes) |
| self.audiocurtime = actualtime + actualcount*sampleduration |
| return self._audiotime_to_ms(actualtime), h.data |
| |
| def ReadVideo(self, time=None): |
| if not time is None: |
| self.videocurtime = time |
| flags = QuickTime.nextTimeStep |
| if self.videocurtime is None: |
| flags = flags | QuickTime.nextTimeEdgeOK |
| self.videocurtime = 0 |
| tv = self.videomedia.GetMediaNextInterestingTimeOnly(flags, self.videocurtime, 1.0) |
| if tv < 0 or (self.videocurtime and tv <= self.videocurtime): |
| return self._videotime_to_ms(self.videocurtime), None |
| self.videocurtime = tv |
| moviecurtime = self._videotime_to_movietime(self.videocurtime) |
| self.movie.SetMovieTimeValue(moviecurtime) |
| self.movie.MoviesTask(0) |
| return self._videotime_to_ms(self.videocurtime), self._getpixmapcontent() |
| |
| def _getpixmapcontent(self): |
| """Shuffle the offscreen PixMap data, because it may have funny stride values""" |
| rowbytes = Qdoffs.GetPixRowBytes(self.pixmap) |
| width = self.videodescr['width'] |
| height = self.videodescr['height'] |
| start = 0 |
| rv = [] |
| for i in range(height): |
| nextline = Qdoffs.GetPixMapBytes(self.pixmap, start, width*4) |
| start = start + rowbytes |
| rv.append(nextline) |
| return ''.join(rv) |
| |
| def reader(url): |
| try: |
| rdr = _Reader(url) |
| except IOError: |
| return None |
| return rdr |
| |
| def _test(): |
| import EasyDialogs |
| try: |
| from PIL import Image |
| except ImportError: |
| Image = None |
| import MacOS |
| Qt.EnterMovies() |
| path = EasyDialogs.AskFileForOpen(message='Video to convert') |
| if not path: sys.exit(0) |
| rdr = reader(path) |
| if not rdr: |
| sys.exit(1) |
| dstdir = EasyDialogs.AskFileForSave(message='Name for output folder') |
| if not dstdir: sys.exit(0) |
| num = 0 |
| os.mkdir(dstdir) |
| videofmt = rdr.GetVideoFormat() |
| imgfmt = videofmt.getformat() |
| imgw, imgh = videofmt.getsize() |
| timestamp, data = rdr.ReadVideo() |
| while data: |
| fname = 'frame%04.4d.jpg'%num |
| num = num+1 |
| pname = os.path.join(dstdir, fname) |
| if not Image: print 'Not', |
| print 'Writing %s, size %dx%d, %d bytes'%(fname, imgw, imgh, len(data)) |
| if Image: |
| img = Image.fromstring("RGBA", (imgw, imgh), data) |
| img.save(pname, 'JPEG') |
| timestamp, data = rdr.ReadVideo() |
| MacOS.SetCreatorAndType(pname, 'ogle', 'JPEG') |
| if num > 20: |
| print 'stopping at 20 frames so your disk does not fill up:-)' |
| break |
| print 'Total frames:', num |
| |
| if __name__ == '__main__': |
| _test() |
| sys.exit(1) |
