home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pyos2bin.zip / Demo / sgi / video / Vrecb.py < prev    next >
Text File  |  1996-11-27  |  11KB  |  430 lines
  1. #! /usr/bin/env python
  2.  
  3. # Capture a CMIF movie using the Indigo video library and board in burst mode
  4.  
  5.  
  6. # User interface:
  7. #
  8. # Start the application.  Resize the window to the desired movie size.
  9. # Press the left mouse button to start recording, release it to end
  10. # recording.  You can record as many times as you wish, but each time
  11. # you overwrite the output file(s), so only the last recording is
  12. # kept.
  13. #
  14. # Press ESC or select the window manager Quit or Close window option
  15. # to quit.  If you quit before recording anything, the output file(s)
  16. # are not touched.
  17.  
  18.  
  19. import sys
  20. sys.path.append('/ufs/guido/src/video')
  21. import sv, SV
  22. import VFile
  23. import gl, GL, DEVICE
  24. import al, AL
  25. import time
  26. import posix
  27. import getopt
  28. import string
  29. import imageop
  30. import sgi
  31.  
  32.  
  33. # Usage and help functions (keep this up-to-date if you change the program!)
  34.  
  35. def usage():
  36.     print 'Usage: Vrecb [options] [moviefile [audiofile]]'
  37.     print
  38.     print 'Options:'
  39.     print '-a            : record audio as well'
  40.     print '-r rate       : capture 1 out of every "rate" frames', \
  41.                          '(default and min 1)'
  42.     print '-w width      : initial window width', \
  43.                              '(default 256, use 0 for interactive placement)'
  44.     print '-d            : drop fields if needed'
  45.     print '-g bits       : greyscale (2, 4 or 8 bits)'
  46.     print '-G            : 2-bit greyscale dithered'
  47.     print '-m            : monochrome dithered'
  48.     print '-M value      : monochrome tresholded with value'
  49.     print '-f            : Capture fields (instead of frames)'
  50.     print '-n number     : Capture this many frames (default 60)'
  51.     print '-N memsize    : Capture frames fitting in this many kbytes'
  52.     print 'moviefile     : here goes the movie data (default film.video)'
  53.  
  54. def help():
  55.     print 'Press the left mouse button to start recording.'
  56.     print 'Recording time is determined by the -n option.'
  57.     print 'You can record as many times as you wish, but each'
  58.     print 'recording overwrites the output file(s) -- only the'
  59.     print 'last recording is kept.'
  60.     print
  61.     print 'Press ESC or use the window manager Quit or Close window option'
  62.     print 'to quit.  If you quit before recording anything, the output'
  63.     print 'file(s) are not touched.'
  64.  
  65.  
  66. # Main program
  67.  
  68. def main():
  69.     format = SV.RGB8_FRAMES
  70.     audio = 0
  71.     rate = 1
  72.     width = 256
  73.     drop = 0
  74.     mono = 0
  75.     grey = 0
  76.     greybits = 0
  77.     monotreshold = -1
  78.     fields = 0
  79.     number = 0
  80.     memsize = 0
  81.  
  82.     try:
  83.         opts, args = getopt.getopt(sys.argv[1:], 'ar:w:dg:mM:Gfn:N:')
  84.     except getopt.error, msg:
  85.         sys.stdout = sys.stderr
  86.         print 'Error:', msg, '\n'
  87.         usage()
  88.         sys.exit(2)
  89.  
  90.     try:
  91.         for opt, arg in opts:
  92.             if opt == '-a':
  93.                 audio = 1
  94.             if opt == '-r':
  95.                 rate = string.atoi(arg)
  96.                 if rate < 1:
  97.                     sys.stderr.write('-r rate must be >= 1\n')
  98.                     sys.exit(2)
  99.             elif opt == '-w':
  100.                 width = string.atoi(arg)
  101.             elif opt == '-d':
  102.                 drop = 1
  103.             elif opt == '-g':
  104.                 grey = 1
  105.                 greybits = string.atoi(arg)
  106.                 if not greybits in (2,4,8):
  107.                     sys.stderr.write( \
  108.                     'Only 2, 4 or 8 bit greyscale supported\n')
  109.                     sys.exit(2)
  110.             elif opt == '-G':
  111.                 grey = 1
  112.                 greybits = -2
  113.             elif opt == '-m':
  114.                 mono = 1
  115.             elif opt == '-M':
  116.                 mono = 1
  117.                 monotreshold = string.atoi(arg)
  118.             elif opt == '-f':
  119.                 fields = 1
  120.             elif opt == '-n':
  121.                 number = string.atoi(arg)
  122.             elif opt == '-N':
  123.                 memsize = string.atoi(arg)
  124.                 if 0 < memsize < 1024:
  125.                     memsize = memsize * 1024
  126.                 if 0 < memsize < 1024*1024:
  127.                     memsize = memsize * 1024
  128.                 print 'memsize', memsize
  129.     except string.atoi_error:
  130.         sys.stdout = sys.stderr
  131.         print 'Option', opt, 'requires integer argument'
  132.         sys.exit(2)
  133.  
  134.     if number <> 0 and memsize <> 0:
  135.         sys.stderr.write('-n and -N are mutually exclusive\n')
  136.         sys.exit(2)
  137.     if number == 0 and memsize == 0:
  138.         number = 60
  139.  
  140.     if not fields:
  141.         print '-f option assumed until somebody fixes it'
  142.         fields = 1
  143.  
  144.     if args[2:]:
  145.         sys.stderr.write('usage: Vrecb [options] [file [audiofile]]\n')
  146.         sys.exit(2)
  147.  
  148.     if args:
  149.         filename = args[0]
  150.     else:
  151.         filename = 'film.video'
  152.  
  153.     if args[1:] and not audio:
  154.         sys.stderr.write('-a turned on by appearance of 2nd file\n')
  155.         audio = 1
  156.  
  157.     if audio:
  158.         if args[1:]:
  159.             audiofilename = args[1]
  160.         else:
  161.             audiofilename = 'film.aiff'
  162.     else:
  163.         audiofilename = None
  164.  
  165.     v = sv.OpenVideo()
  166.     # Determine maximum window size based on signal standard
  167.     param = [SV.BROADCAST, 0]
  168.     v.GetParam(param)
  169.     if param[1] == SV.PAL:
  170.         x = SV.PAL_XMAX
  171.         y = SV.PAL_YMAX
  172.     elif param[1] == SV.NTSC:
  173.         x = SV.NTSC_XMAX
  174.         y = SV.NTSC_YMAX
  175.     else:
  176.         print 'Unknown video standard', param[1]
  177.         sys.exit(1)
  178.  
  179.     gl.foreground()
  180.     gl.maxsize(x, y)
  181.     gl.keepaspect(x, y)
  182.     gl.stepunit(8, 6)
  183.     if width:
  184.         height = width*3/4
  185.         x1 = 150
  186.         x2 = x1 + width-1
  187.         y2 = 768-150
  188.         y1 = y2-height+1
  189.         gl.prefposition(x1, x2, y1, y2)
  190.     win = gl.winopen(filename)
  191.     if width:
  192.         gl.maxsize(x, y)
  193.         gl.keepaspect(x, y)
  194.         gl.stepunit(8, 6)
  195.         gl.winconstraints()
  196.     x, y = gl.getsize()
  197.     print x, 'x', y
  198.     if memsize:
  199.         number = calcnumber(x, y, grey or mono, memsize)
  200.         print number, 'frames'
  201.     v.SetSize(x, y)
  202.  
  203.     if drop:
  204.         param = [SV.FIELDDROP, 1, SV.GENLOCK, SV.GENLOCK_OFF]
  205.     else:
  206.         param = [SV.FIELDDROP, 0, SV.GENLOCK, SV.GENLOCK_ON]
  207.     if mono or grey:
  208.         param = param+[SV.COLOR, SV.MONO, SV.DITHER, 0, \
  209.                    SV.INPUT_BYPASS, 1]
  210.     else:
  211.         param = param+[SV.COLOR, SV.DEFAULT_COLOR, SV.INPUT_BYPASS, 0]
  212.  
  213.     v.BindGLWindow(win, SV.IN_REPLACE)
  214.     v.SetParam(param)
  215.  
  216.     gl.qdevice(DEVICE.LEFTMOUSE)
  217.     gl.qdevice(DEVICE.WINQUIT)
  218.     gl.qdevice(DEVICE.WINSHUT)
  219.     gl.qdevice(DEVICE.ESCKEY)
  220.  
  221.     help()
  222.  
  223.     while 1:
  224.         dev, val = gl.qread()
  225.         if dev == DEVICE.LEFTMOUSE:
  226.             if val == 1:
  227.                 info = format, x, y, number, rate
  228.                 record(v, info, filename, audiofilename, \
  229.                       mono, grey, \
  230.                       greybits, monotreshold, fields)
  231.         elif dev == DEVICE.REDRAW:
  232.             # Window resize (or move)
  233.             x, y = gl.getsize()
  234.             print x, 'x', y
  235.             if memsize:
  236.                 number = calcnumber(x, y, grey or mono, memsize)
  237.                 print number, 'frames'
  238.             v.SetSize(x, y)
  239.             v.BindGLWindow(win, SV.IN_REPLACE)
  240.         elif dev in (DEVICE.ESCKEY, DEVICE.WINQUIT, DEVICE.WINSHUT):
  241.             # Quit
  242.             v.CloseVideo()
  243.             gl.winclose(win)
  244.             break
  245.  
  246.  
  247. def calcnumber(x, y, grey, memsize):
  248.     pixels = x*y
  249.     pixels = pixels/2        # XXX always assume fields
  250.     if grey: n = memsize/pixels
  251.     else: n = memsize/(4*pixels)
  252.     return max(1, n)
  253.  
  254.  
  255. # Record until the mouse is released (or any other GL event)
  256. # XXX audio not yet supported
  257.  
  258. def record(v, info, filename, audiofilename, \
  259.                    mono, grey, greybits, monotreshold, fields):
  260.     import thread
  261.     format, x, y, number, rate = info
  262.     fps = 59.64 # Fields per second
  263.     # XXX (Strange: need fps of Indigo monitor, not of PAL or NTSC!)
  264.     tpf = 1000.0 / fps # Time per field in msec
  265.     #
  266.     # Go grab
  267.     #
  268.     if audiofilename:
  269.         gl.wintitle('(start audio) ' + filename)
  270.         audiodone = thread.allocate_lock()
  271.         audiodone.acquire_lock()
  272.         audiostart = thread.allocate_lock()
  273.         audiostart.acquire_lock()
  274.         audiostop = []
  275.         initaudio(audiofilename, audiostop, audiostart, audiodone)
  276.         audiostart.acquire_lock()
  277.     gl.wintitle('(rec) ' + filename)
  278.     try:
  279.         ninfo, data, bitvec = v.CaptureBurst(info)
  280.     except sv.error, arg:
  281.         print 'CaptureBurst failed:', arg
  282.         print 'info:', info
  283.         gl.wintitle(filename)
  284.         return
  285.     gl.wintitle('(save) '+ filename)
  286.     #
  287.     # Check results
  288.     #
  289.     if info <> ninfo:
  290.         print 'Sorry, format changed.'
  291.         print 'Wanted:',info
  292.         print 'Got   :',ninfo
  293.         gl.wintitle(filename)
  294.         return
  295.     # print bitvec
  296.     if x*y*number <> len(data):
  297.         print 'Funny data length: wanted',x,'*',y,'*', number,'=',\
  298.               x*y*number,'got',len(data)
  299.         gl.wintitle(filename)
  300.         return
  301.     #
  302.     # Save
  303.     #
  304.     if filename and audiofilename:
  305.         audiostop.append(None)
  306.         audiodone.acquire_lock()
  307.     if filename:
  308.         #
  309.         # Construct header and write it
  310.         #
  311.         try:
  312.             vout = VFile.VoutFile(filename)
  313.         except IOError, msg:
  314.             print filename, ':', msg
  315.             sys.exit(1)
  316.         if mono:
  317.             vout.format = 'mono'
  318.         elif grey and greybits == 8:
  319.             vout.format = 'grey'
  320.         elif grey:
  321.             vout.format = 'grey'+`abs(greybits)`
  322.         else:
  323.             vout.format = 'rgb8'
  324.         vout.width = x
  325.         vout.height = y
  326.         if fields:
  327.             vout.packfactor = (1,-2)
  328.         else:
  329.             print 'Sorry, can only save fields at the moment'
  330.             print '(i.e. you *must* use the -f option)'
  331.             gl.wintitle(filename)
  332.             return
  333.         vout.writeheader()
  334.         #
  335.         # Compute convertor, if needed
  336.         #
  337.         convertor = None
  338.         if grey:
  339.             if greybits == 2:
  340.                 convertor = imageop.grey2grey2
  341.             elif greybits == 4:
  342.                 convertor = imageop.grey2grey4
  343.             elif greybits == -2:
  344.                 convertor = imageop.dither2grey2
  345.         fieldsize = x*y/2
  346.         nskipped = 0
  347.         realframeno = 0
  348.         tpf = 1000 / 50.0     #XXXX
  349.         # Trying to find the pattern in frame skipping
  350.         okstretch = 0
  351.         skipstretch = 0
  352.         for frameno in range(0, number*2):
  353.             if frameno <> 0 and \
  354.                   bitvec[frameno] == bitvec[frameno-1]:
  355.                 nskipped = nskipped + 1
  356.                 if okstretch:
  357.                     print okstretch, 'ok',
  358.                     okstretch = 0
  359.                 skipstretch = skipstretch + 1
  360.                 continue
  361.             if skipstretch:
  362.                 print skipstretch, 'skipped'
  363.                 skipstretch = 0
  364.             okstretch = okstretch + 1
  365.             #
  366.             # Save field.
  367.             # XXXX Works only for fields and top-to-bottom
  368.             #
  369.             start = frameno*fieldsize
  370.             field = data[start:start+fieldsize]
  371.             if convertor:
  372.                 field = convertor(field, len(field), 1)
  373.             elif mono and monotreshold >= 0:
  374.                 field = imageop.grey2mono( \
  375.                       field, len(field), 1, monotreshold)
  376.             elif mono:
  377.                 field = imageop.dither2mono( \
  378.                       field, len(field), 1)
  379.             realframeno = realframeno + 1
  380.             vout.writeframe(int(realframeno*tpf), field, None)
  381.         print okstretch, 'ok',
  382.         print skipstretch, 'skipped'
  383.         print 'Skipped', nskipped, 'duplicate frames'
  384.         vout.close()
  385.             
  386.     gl.wintitle('(done) ' + filename)
  387. # Initialize audio recording
  388.  
  389. AQSIZE = 8*8000 # XXX should be a user option
  390.  
  391. def initaudio(filename, stop, start, done):
  392.     import thread, aifc
  393.     afile = aifc.open(filename, 'w')
  394.     afile.setnchannels(AL.MONO)
  395.     afile.setsampwidth(AL.SAMPLE_8)
  396.     params = [AL.INPUT_RATE, 0]
  397.     al.getparams(AL.DEFAULT_DEVICE, params)
  398.     print 'audio sampling rate =', params[1]
  399.     afile.setframerate(params[1])
  400.     c = al.newconfig()
  401.     c.setchannels(AL.MONO)
  402.     c.setqueuesize(AQSIZE)
  403.     c.setwidth(AL.SAMPLE_8)
  404.     aport = al.openport(filename, 'r', c)
  405.     thread.start_new_thread(audiorecord, (afile, aport, stop, start, done))
  406.  
  407.  
  408. # Thread to record audio samples
  409.  
  410. def audiorecord(afile, aport, stop, start, done):
  411.     start.release_lock()
  412.     leeway = 4
  413.     while leeway > 0:
  414.         if stop:
  415.             leeway = leeway - 1
  416.         data = aport.readsamps(AQSIZE/8)
  417.         afile.writesampsraw(data)
  418.         del data
  419.     afile.close()
  420.     print 'Done writing audio'
  421.     done.release_lock()
  422.  
  423.  
  424. # Don't forget to call the main program
  425.  
  426. try:
  427.     main()
  428. except KeyboardInterrupt:
  429.     print '[Interrupt]'
  430.