示例#1
0
        def initMPEG(self, filename, width, height, codec):
            """
            initialize MPEG capture

            bool <- initMPEG(filename, width, height):

            filename is hte name of the MPEG file
            width is the width of a frame in pixel
            height is the height of a frame in pixel
            """
            self.videoOutputFile = open(filename, 'wb')
            assert self.videoOutputFile, 'ERROR, failed to open file: ' + filename

            if width is None:
                width = self.width
            w = self.videoFrameWidth = width - width % 2

            if height is None:
                height = self.height
            h = self.videoFrameHeight = height - height % 2

            if codec == 'mpeg2':
                params = {
                    'type': 0,
                    'gop_size': 12,
                    'frame_rate_base': 125,
                    'max_b_frames': 0,
                    'width': w,
                    'height': h,
                    'frame_rate': 2997,
                    'deinterlace': 0,
                    'bitrate': 9800000,
                    'id': vcodec.getCodecID('mpeg2video')
                }
            else:  # default is mpeg1
                params = {
                    'type': 0,
                    'gop_size': 12,
                    'frame_rate_base': 125,
                    'max_b_frames': 0,
                    'width': w,
                    'height': h,
                    'frame_rate': 2997,
                    'deinterlace': 0,
                    'bitrate': 2700000,
                    'id': vcodec.getCodecID('mpeg1video')
                }
            self.encoder = vcodec.Encoder(params)
            self.nbFrames = 0
示例#2
0
  def open (self):
    MovieOutputStream.open(self)
    print >>stderr, 'Creating MPEG: %r: codec=%s, size=%dx%d, framerate=%s' % \
          (self.info.filename, self.mpeg_codec,
           self.info.width, self.info.height,
           self.info.framerate)

    (x,y,w,h) = self.info.clipping
    # Crop to match codec constraints
    w = w - w % 2 # width constraint : multiple of 2
    h = h - h % 2 # height constraint : multiple of 2
    self.screen = SWFScreen(x, y, w, h, scaling=self.info.scaling)
    params = {
      'type': 0,
      'gop_size': 12,
      'frame_rate_base': 125,
      'max_b_frames': 0,
      'height': self.screen.out_height,
      'width': self.screen.out_width,
      'frame_rate': 2997,
      'deinterlace': 0,
      'id':  vcodec.getCodecID(self.mpeg_codec),
      'format': vcodec.formats.PIX_FMT_YUV420P
      }
    params['frame_rate'] = int(params['frame_rate_base'] * self.info.framerate)
    if self.mpeg_codec == 'mpeg1video':
      params['bitrate'] = 2700000
    else:
      params['bitrate'] = 9800000
    if self.debug:
      print >>stderr, 'Setting codec to ', params
    self.encoder = vcodec.Encoder(params)
    self.out_file = open(self.info.filename, 'wb')
    return
示例#3
0
    def open(self):
        MovieOutputStream.open(self)
        print >>stderr, 'Creating MPEG: %r: codec=%s, size=%dx%d, framerate=%s' % \
              (self.info.filename, self.mpeg_codec,
               self.info.width, self.info.height,
               self.info.framerate)

        (x, y, w, h) = self.info.clipping
        # Crop to match codec constraints
        w = w - w % 2  # width constraint : multiple of 2
        h = h - h % 2  # height constraint : multiple of 2
        self.screen = SWFScreen(x, y, w, h, scaling=self.info.scaling)
        params = {
            'type': 0,
            'gop_size': 12,
            'frame_rate_base': 125,
            'max_b_frames': 0,
            'height': self.screen.out_height,
            'width': self.screen.out_width,
            'frame_rate': 2997,
            'deinterlace': 0,
            'id': vcodec.getCodecID(self.mpeg_codec),
            'format': vcodec.formats.PIX_FMT_YUV420P
        }
        params['frame_rate'] = int(params['frame_rate_base'] *
                                   self.info.framerate)
        if self.mpeg_codec == 'mpeg1video':
            params['bitrate'] = 2700000
        else:
            params['bitrate'] = 9800000
        if self.debug:
            print >> stderr, 'Setting codec to ', params
        self.encoder = vcodec.Encoder(params)
        self.out_file = open(self.info.filename, 'wb')
        return
示例#4
0
    def initVideo(self):
        dm = muxer.Demuxer(self.format)

        #try to get multiple streams of a multiplexed file
        junk = dm.parse(self.rawData[30000])
        if len(dm.streams) == 0:
            #set bitrate
            if self.codec == 'mpeg1video':
                bitrate = 2700000
            else:
                bitrate = 9800000
            self.params= { \
                'type': 0,
                'gop_size': 12,
                'frame_rate_base': 125,
                'max_b_frames': 0,
                'width': 800,
                'height': 600,
                'frame_rate': 3125,
                'deinterlace': 0,
                'bitrate': bitrate,
                'id': vcodec.getCodecID( self.codec )
                }
        elif len(dm.streams) == 1:
            self.params = dm.streams[0]
        else:
            #loop through to find the first video stream in the file
            for vindex in xrange(len(dm.streams)):
                if dm.streams[vindex]['type'] == muxer.CODEC_TYPE_VIDEO:
                    self.params = dm.streams[vindex]
                    break

        print self.params

        try:
            # Set the initial sound delay to 0 for now

            # It defines initial offset from video in the beginning of the stream

            self.initADelta = -1
            self.seekADelta = 0
            # Setting up the HW video codec

            self.vc = ext_codecs.Decoder(self.params)
        except:
            self.vc = vcodec.Decoder(self.params)
            try:
                # Fall back to SW video codec

                self.vc = vcodec.Decoder(self.params)
            except:
                traceback.print_exc()
                self.err.append(sys.exc_info()[1])
示例#5
0
 def initVideo(self):
     dm= muxer.Demuxer( self.format )
     
     #try to get multiple streams of a multiplexed file
     junk = dm.parse( self.rawData[30000] )
     if len(dm.streams)==0:
             #set bitrate
             if self.codec== 'mpeg1video':
                 bitrate= 2700000
             else:
                 bitrate= 9800000
             self.params= { \
                 'type': 0,
                 'gop_size': 12,
                 'frame_rate_base': 125,
                 'max_b_frames': 0,
                 'width': 800,
                 'height': 600,
                 'frame_rate': 3125,
                 'deinterlace': 0,
                 'bitrate': bitrate,
                 'id': vcodec.getCodecID( self.codec )
                 }
     elif len(dm.streams)==1:
         self.params = dm.streams[0]
     else:
         #loop through to find the first video stream in the file
         for vindex in xrange( len( dm.streams )):
             if dm.streams[ vindex ][ 'type' ]== muxer.CODEC_TYPE_VIDEO:
               self.params= dm.streams[ vindex ] 
               break
     
     print self.params
     
     try:
         # Set the initial sound delay to 0 for now
   
         # It defines initial offset from video in the beginning of the stream
   
         self.initADelta= -1
         self.seekADelta= 0
         # Setting up the HW video codec
   
         self.vc= ext_codecs.Decoder( self.params ) 
     except:
         self.vc= vcodec.Decoder( self.params )
         try:
           # Fall back to SW video codec
   
           self.vc= vcodec.Decoder( self.params )
         except:
           traceback.print_exc()
           self.err.append( sys.exc_info()[1] )
示例#6
0
def makeVideo( inPattern, outFile, outCodec ):
    # Get video stream dimensions from the image size

    pygame.init()
    i= 1
    # Opening mpeg file for output

    e= None
    i= 1
    fw= open( outFile, 'wb' )
    while i:
        print "Adding Frame %i (%s)" % (i, inPattern % i )
        if os.path.isfile( inPattern % i ):
            s= pygame.image.load( inPattern % i )
            if not e:
                if outCodec== 'mpeg1video':
                    bitrate= 2700000
                else:
                    bitrate= 9800000

                params= { \
                  'type': 0,
                  'gop_size': 12,
                  'frame_rate_base': 125,
                  'max_b_frames': 0,
                  'height': s.get_height(),
                  'width': s.get_width(),
                  'frame_rate': 2997,
                  'deinterlace': 0,
                  'bitrate': bitrate,
                  'id': vcodec.getCodecID( outCodec )
                }
                print 'Setting codec to ', params
                e= vcodec.Encoder( params )
                t= time.time()

            # Create VFrame

            ss= pygame.image.tostring(s, "RGB")
            bmpFrame= vcodec.VFrame( vcodec.formats.PIX_FMT_RGB24, s.get_size(), (ss,None,None))
            yuvFrame= bmpFrame.convert( vcodec.formats.PIX_FMT_YUV420P )
            d= e.encode( yuvFrame )
            #print "\n\n", type(e), type(d), "\n\n"
            fw.write( d )
            i+= 1
        else:
            print '%d frames written in %.2f secs( %.2f fps )' % ( i, time.time()- t, float( i )/ ( time.time()- t ) )
            i= 0

    fw.close()
    pygame.quit()
示例#7
0
def makeMPEG(filename,
             images,
             codec='mpeg1video',
             codecParams=None,
             verbose=False):
    if not havePyMedia:
        logging.error('pymedia (www.pymedia.org) needed to make mpeg movies')
        return 0

    fw = open(filename, 'wb')
    t = time.time()

    # set bitrate
    if codec == 'mpeg1video':
        bitrate = 2700000
    else:
        bitrate = 9800000

    # set other params (or receive params dictionary)
    if codecParams is None:
        codecParams = {
            'type': 0,
            'gop_size': 12,
            'frame_rate_base': 125,
            'max_b_frames': 0,
            'width': images[0].size[0],
            'height': images[0].size[1],
            'frame_rate': 3125,
            'deinterlace': 0,
            'bitrate': bitrate,
            'id': vcodec.getCodecID(codec)
        }
        logging.info('Setting codec to ' + str(codecParams))
    encoder = vcodec.Encoder(codecParams)

    for im in images:
        # Create VFrame
        imStr = im.tostring()
        bmpFrame = vcodec.VFrame(vcodec.formats.PIX_FMT_RGB24, im.size,
                                 (imStr, None, None))
        yuvFrame = bmpFrame.convert(vcodec.formats.PIX_FMT_YUV420P, im.size)
        d = encoder.encode(yuvFrame)
        try:
            fw.write(d.data)  # this is what works!
        except Exception:
            fw.write(d)  # this is what pymedia demo recommends
    else:
        logging.info('%d frames written in %.2f secs' %
                     (len(images), time.time() - t))
        i = 0
    fw.close()
示例#8
0
def makeVideo( inPattern, outFile, outCodec ):
  # Get video stream dimensions from the image size
  pygame.init()
  i= 1
  # Opening mpeg file for output
  e= None
  i= 1
  fw= open( outFile, 'wb' )
  while i:
    if os.path.isfile( inPattern % i ):
      s= pygame.image.load( inPattern % i )
      if not e:
        if outCodec== 'mpeg1video':
          bitrate= 2700000
        else:
          bitrate= 9800000
        
        params= { \
          'type': 0,
          'gop_size': 12,
          'frame_rate_base': 125,
          'max_b_frames': 0,
          'height': s.get_height(),
          'width': s.get_width(),
          'frame_rate': 2997,
          'deinterlace': 0,
          'bitrate': bitrate,
          'id': vcodec.getCodecID( outCodec )
        }
        print 'Setting codec to ', params
        e= vcodec.Encoder( params )
        t= time.time()
      
      # Create VFrame
      if inPattern.index( '.bmp' )> 0:
        ss= pygame.image.tostring(s, "RGB")
        bmpFrame= vcodec.VFrame( vcodec.formats.PIX_FMT_RGB24, s.get_size(), (ss,None,None))
        yuvFrame= bmpFrame.convert( vcodec.formats.PIX_FMT_YUV420P )

      d= e.encode( yuvFrame )
      fw.write( d.data )
      i+= 1
    else:
      print '%d frames written in %.2f secs( %.2f fps )' % ( i, time.time()- t, float( i )/ ( time.time()- t ) )
      i= 0
  
  fw.close()
  pygame.quit()
示例#9
0
def makeMPEG(filename, images, codec='mpeg1video', codecParams=None, verbose=False):
    if not havePyMedia:
        logging.error('pymedia (www.pymedia.org) needed to make mpeg movies')
        return 0

    fw = open(filename, 'wb')
    t = time.time()

    # set bitrate
    if codec == 'mpeg1video':
        bitrate = 2700000
    else:
        bitrate = 9800000

    # set other params (or receive params dictionary)
    if codecParams is None:
        codecParams = {
            'type': 0,
            'gop_size': 12,
            'frame_rate_base': 125,
            'max_b_frames': 0,
            'width': images[0].size[0],
            'height': images[0].size[1],
            'frame_rate': 3125,
            'deinterlace': 0,
            'bitrate': bitrate,
            'id': vcodec.getCodecID(codec)
        }
        logging.info('Setting codec to ' + str(codecParams))
    encoder = vcodec.Encoder(codecParams)

    for im in images:
        # Create VFrame
        imStr = im.tostring()
        bmpFrame = vcodec.VFrame(
            vcodec.formats.PIX_FMT_RGB24, im.size, (imStr, None, None))
        yuvFrame = bmpFrame.convert(vcodec.formats.PIX_FMT_YUV420P, im.size)
        d = encoder.encode(yuvFrame)
        try:
            fw.write(d.data)  # this is what works!
        except Exception:
            fw.write(d)  # this is what pymedia demo recommends
    else:
        logging.info('%d frames written in %.2f secs' %
                     (len(images), time.time() - t))
        i = 0
    fw.close()
示例#10
0
def createQuicklookVideo(dataset, filename, images_per_sec=2):
    """
    Creates an mpeg2 video clip of quicklook images of images in the dataset. The
    dataset argument should be an allskyData.dataset object, the filename is the output
    filename.
    """   
    #ensure correct file extension
    if not filename.endswith((".mpg",".mpeg")):
        filename = filename + ".mpeg"
    
    #work out size that a quicklook will be
    first_im = dataset.getImage(dataset.getTimes()[0])
    size = first_im.createQuicklook().size
    
    #create video encoder
    params= { \
          'type': 0,
          'gop_size': 12,
          'frame_rate_base': 1,
          'max_b_frames': 0,
          'height': size[1],
          'width': size[0],
          'frame_rate': images_per_sec,
          'deinterlace': 2000,
          'bitrate': 9800000,
          'id': vcodec.getCodecID('mpeg2video')
        }
    encoder = vcodec.Encoder( params )
        
    with open(filename, 'wb') as ofp:
        for im in dataset:
            ql = im.createQuicklook()
            
            if ql.size != size:
                ql = ql.resize(size)
            
            bmpFrame= vcodec.VFrame( vcodec.formats.PIX_FMT_RGB24, size, (ql.convert('RGB').tostring(),None,None))
            yuvFrame= bmpFrame.convert( vcodec.formats.PIX_FMT_YUV420P )
            d = encoder.encode( yuvFrame )
            ofp.write(d.data)
        
        #add the last image to the stream again - otherwise you won't see it!    
        bmpFrame = vcodec.VFrame(vcodec.formats.PIX_FMT_RGB24, size, (ql.convert('RGB').tostring(),None,None))
        yuvFrame = bmpFrame.convert(vcodec.formats.PIX_FMT_YUV420P)
        d = encoder.encode(yuvFrame)
        ofp.write(d.data)
示例#11
0
def makeMPEG(filename, images, codec="mpeg1video", codecParams=None, verbose=False):
    if not havePyMedia:
        logging.error("pymedia (www.pymedia.org) needed to make mpeg movies")
        return 0

    fw = open(filename, "wb")
    t = time.time()

    # set bitrate
    if codec == "mpeg1video":
        bitrate = 2700000
    else:
        bitrate = 9800000

    # set other params (or receive params dictionary)
    if codecParams == None:
        codecParams = {
            "type": 0,
            "gop_size": 12,
            "frame_rate_base": 125,
            "max_b_frames": 0,
            "width": images[0].size[0],
            "height": images[0].size[1],
            "frame_rate": 3125,
            "deinterlace": 0,
            "bitrate": bitrate,
            "id": vcodec.getCodecID(codec),
        }
        logging.info("Setting codec to " + str(codecParams))
    encoder = vcodec.Encoder(codecParams)

    for im in images:
        # Create VFrame
        imStr = im.tostring()
        bmpFrame = vcodec.VFrame(vcodec.formats.PIX_FMT_RGB24, im.size, (imStr, None, None))
        yuvFrame = bmpFrame.convert(vcodec.formats.PIX_FMT_YUV420P, im.size)
        d = encoder.encode(yuvFrame)
        try:
            fw.write(d.data)  # this is what works!
        except:
            fw.write(d)  # this is what pymedia demo recommends
    else:
        logging.info("%d frames written in %.2f secs" % (len(images), time.time() - t))
        i = 0
    fw.close()
示例#12
0
def recodeVideo( inFile, outFile, outCodec ):
	dm= muxer.Demuxer( inFile.split( '.' )[ -1 ] )
	f= open( inFile, 'rb' )
	fw= open( outFile, 'wb' )
	s= f.read( 400000 )
	r= dm.parse( s )
	v= filter( lambda x: x[ 'type' ]== muxer.CODEC_TYPE_VIDEO, dm.streams )
	if len( v )== 0:
		raise 'There is no video stream in a file %s' % inFile
	
	v_id= v[ 0 ][ 'index' ]
	print 'Assume video stream at %d index: ' % v_id
	c= vcodec.Decoder( dm.streams[ v_id ] )
	e= None
	while len( s )> 0:
		for fr in r:
			if fr[ 0 ]== v_id:
				d= c.decode( fr[ 1 ] )
				if d and d.data:
					if e== None:
						params= c.getParams()
						params[ 'id' ]= vcodec.getCodecID( outCodec )
						# Just try to achive max quality( 2.7 MB/sec mpeg1 and 9.8 for mpeg2 )
						if outCodec== 'mpeg1video':
							params[ 'bitrate' ]= 2700000
						else:
							params[ 'bitrate' ]= 9800000
						# It should be some logic to work with frame rates and such.
						# I'm not aware of what it would be...
						print 'Setting codec to ', params
						e= vcodec.Encoder( params )
					
					dw= e.encode( d )
					print 'Frame size ', len( dw )
					fw.write( dw )
		
		s= f.read( 400000 )
		r= dm.parse( s )
def recodeVideo( inFile, outFile, outCodec ):
	dm= muxer.Demuxer( inFile.split( '.' )[ -1 ] )
	f= open( inFile, 'rb' )
	fw= open( outFile, 'wb' )
	s= f.read( 400000 )
	r= dm.parse( s )
	v= filter( lambda x: x[ 'type' ]== muxer.CODEC_TYPE_VIDEO, dm.streams )
	if len( v )== 0:
		raise 'There is no video stream in a file %s' % inFile
	
	v_id= v[ 0 ][ 'index' ]
	print 'Assume video stream at %d index: ' % v_id
	c= vcodec.Decoder( dm.streams[ v_id ] )
	e= None
	while len( s )> 0:
		for fr in r:
			if fr[ 0 ]== v_id:
				d= c.decode( fr[ 1 ] )
				if e== None and d:
					params= c.getParams()
					params[ 'id' ]= vcodec.getCodecID( outCodec )
					# Just try to achive max quality( 2.7 MB/sec mpeg1 and 9.8 for mpeg2 )
					if outCodec== 'mpeg1video':
						params[ 'bitrate' ]= 2700000
					else:
						params[ 'bitrate' ]= 9800000
					# It should be some logic to work with frame rates and such.
					# I'm not aware of what it would be...
					print 'Setting codec to ', params
					e= vcodec.Encoder( params )
				if e and d:
					dw= e.encode( d )
					#print 'Frame size ', len( dw )
					fw.write( dw )
		
		s= f.read( 400000 )
		r= dm.parse( s )
示例#14
0
blankframe = np.zeros((height, width), dtype=np.int8) + 127
blankyuvFrame = prepframe(blankframe, enlargex=enlargex)

f = file(out, 'wb')

params = {
    'type': 0,
    'gop_size': 12,
    'max_b_frames': 0,
    'frame_rate_base': 1,
    'frame_rate': 50,
    'width': width,
    'height': height,
    'deinterlace': 0,
    'bitrate': 3000000,  # normally 2700000 for a framerate of 2997/125 Hz
    'id': vcodec.getCodecID('mpeg1video')
}

e = vcodec.Encoder(params)

for runi in range(nruns):
    for frame in m.data:
        yuvFrame = prepframe(frame, enlargex=enlargex)
        d = e.encode(yuvFrame)
        f.write(d.data)
        sys.stdout.write('.')
    if iri:
        for framei in range(iri):
            d = e.encode(blankyuvFrame)
            f.write(d.data)
            sys.stdout.write('.')
示例#15
0
def encodeVideo(fName, fOutFile, codecName):
    # ------------------------------------
    import time, traceback
    import pymedia.muxer as muxer
    import pymedia.audio.acodec as acodec
    import pymedia.video.vcodec as vcodec

    format = fName.split('.')[-1].lower()
    dm = muxer.Demuxer(format)
    f = open(fName, 'rb')
    fw = open(fOutFile, 'wb')
    s = f.read(390000)
    r = dm.parse(s)

    print "Streams found:", dm.streams
    ss = filter(lambda x: x['type'] == muxer.CODEC_TYPE_AUDIO, dm.streams)
    if len(ss) == 0:
        raise 'No suitable audio streams in a file'
    a_id = ss[0]['index']
    ac = acodec.Decoder(ss[0])

    ss = filter(lambda x: x['type'] == muxer.CODEC_TYPE_VIDEO, dm.streams)
    if len(ss) == 0:
        raise 'No video streams in a file'
    v_id = ss[0]['index']
    vc = vcodec.Decoder(ss[0])

    #create muxer
    mux = muxer.Muxer('ts')
    header = a_id1 = v_id1 = None
    m_data = []
    while len(s):
        for d in r:
            if d[0] == v_id:
                vfr = vc.decode(d[1])
                if vfr:
                    if v_id1 == None:
                        params = vc.getParams()
                        params['id'] = vcodec.getCodecID(codecName)
                        if codecName == 'mpeg1video':
                            params['bitrate'] = 2700000
                        elif codecName == 'mpeg2video':
                            params['bitrate'] = 9800000

                        print 'Video: encoder params ', params
                        vc1 = vcodec.Encoder(params)
                        v_id1 = mux.addStream(muxer.CODEC_TYPE_VIDEO,
                                              vc1.getParams())
                        print "video stream id in muxer:", v_id1

                    s1 = vc1.encode(vfr)
                    m_data.append((v_id1, s1))
            elif d[0] == a_id:
                frame = ac.decode(d[1])
                if a_id1 == None:
                    params = {
                        'channels': frame.channels,
                        'sample_rate': frame.sample_rate,
                        'bitrate': frame.bitrate,
                        'id': acodec.getCodecID('mp3')
                    }
                    print 'Audio: encoder params ', params
                    ac1 = acodec.Encoder(
                        params)  #or any other supported audio encoder
                    a_id1 = mux.addStream(muxer.CODEC_TYPE_AUDIO,
                                          ac1.getParams())
                    print "audio stream id in muxer:", a_id1

                encFrames = ac1.encode(frame.data)
                for fr in encFrames:
                    m_data.append((a_id1, fr))

        # We know that video and audio exists already
        if a_id1 != None and v_id1 != None:
            # Start header when all streams are captured
            if header == None:
                header = mux.start()
                fw.write(header)

            for st_id, ss in m_data:
                s1 = mux.write(st_id, ss)
                if s1:
                    fw.write(s1)

            m_data = []

        s = f.read(100000)
        r = dm.parse(s)

    fw.close()
示例#16
0
def encodeVideo( fName, fOutFile, codecName ):
	# ------------------------------------
	import time, traceback
	import pymedia.muxer as muxer
	import pymedia.audio.acodec as acodec
	import pymedia.video.vcodec as vcodec
	
	format= fName.split( '.' )[ -1 ].lower()
	dm= muxer.Demuxer( format )
	f=  open( fName, 'rb' )
	fw= open(fOutFile, 'wb')
	s=  f.read( 390000 )
	r=  dm.parse( s )
	
	print "Streams found:", dm.streams
	ss= filter( lambda x: x[ 'type' ]== muxer.CODEC_TYPE_AUDIO, dm.streams )
	if len( ss )== 0:
		raise 'No suitable audio streams in a file'
	a_id= ss[ 0 ][ 'index' ]
	ac= acodec.Decoder( ss[ 0 ] )
	
	ss= filter( lambda x: x[ 'type' ]== muxer.CODEC_TYPE_VIDEO, dm.streams )
	if len( ss )== 0:
		raise 'No video streams in a file'
	v_id= ss[ 0 ][ 'index' ]
	vc = vcodec.Decoder( ss[ 0 ] )
	
	#create muxer
	mux= muxer.Muxer( 'ts' )
	header= a_id1= v_id1= None
	m_data= []
	while len(s):
		for d in r:
			if d[ 0 ]== v_id:
				vfr= vc.decode( d[ 1 ] )
				if vfr:
					if v_id1== None:
						params= vc.getParams()
						params[ 'id' ]= vcodec.getCodecID( codecName )
						if codecName== 'mpeg1video':
							params[ 'bitrate' ]= 2700000
						elif codecName== 'mpeg2video':
							params[ 'bitrate' ]= 9800000
						
						print 'Video: encoder params ', params
						vc1= vcodec.Encoder( params )
						v_id1 = mux.addStream( muxer.CODEC_TYPE_VIDEO, vc1.getParams() )
						print "video stream id in muxer:", v_id1
					
					s1= vc1.encode( vfr )
					m_data.append( ( v_id1, s1 ))
			elif d[ 0 ]== a_id:
				frame= ac.decode( d[ 1 ] )
				if a_id1== None:
					params= { 'channels': 		frame.channels,
										'sample_rate': 	frame.sample_rate,
										'bitrate': 			frame.bitrate,
										'id': 					acodec.getCodecID( 'mp3' ) }
					print 'Audio: encoder params ', params
					ac1= acodec.Encoder( params ) 				#or any other supported audio encoder
					a_id1 = mux.addStream( muxer.CODEC_TYPE_AUDIO, ac1.getParams() )
					print "audio stream id in muxer:", a_id1
				
				encFrames= ac1.encode( frame.data )
				for fr in encFrames:
					m_data.append( ( a_id1, fr ) )
		
		# We know that video and audio exists already
		if a_id1!= None and v_id1!= None:
			# Start header when all streams are captured
			if header== None:
				header= mux.start()
				fw.write( header )
			
			for st_id, ss in m_data:
				s1= mux.write( st_id, ss )
				if s1:
					fw.write( s1 )
			
			m_data= []
			
		s= f.read( 100000 )
		r= dm.parse( s )
	
	fw.close()
示例#17
0
    def setupDump(self):
        # Capture the output as a sequence of numbered frame images.
        self.PlayTime = 0
        self.PlayStartTime = 0
        self.PlayFrame = 0
        self.State = STATE_CAPTURING

        self.dumpFrameRate = manager.options.dump_fps
        assert self.dumpFrameRate

        filename = manager.options.dump
        base, ext = os.path.splitext(filename)
        ext_lower = ext.lower()

        self.dumpEncoder = None
        if ext_lower == '.mpg':
            # Use pymedia to convert frames to an mpeg2 stream
            # on-the-fly.
            import pymedia
            import pymedia.video.vcodec as vcodec

            self.dumpFile = open(filename, 'wb')
            frameRate = int(self.dumpFrameRate * 100 + 0.5)
            self.dumpFrameRate = float(frameRate) / 100.0
            
            params= { \
              'type': 0,
              'gop_size': 12,
              'frame_rate_base': 125,
              'max_b_frames': 0,
              'height': manager.options.size_y,
              'width': manager.options.size_x,
              'frame_rate': frameRate,
              'deinterlace': 0,
              'bitrate': 9800000,
              'id': vcodec.getCodecID('mpeg2video')
            }
            self.dumpEncoder = vcodec.Encoder( params )
            return
            
        # Don't dump a video file; dump a sequence of frames instead.
        self.dumpPPM = (ext_lower == '.ppm' or ext_lower == '.pnm')
        self.dumpAppend = False
        
        # Convert the filename to a pattern.
        if '#' in filename:
            hash = filename.index('#')
            end = hash
            while end < len(filename) and filename[end] == '#':
                end += 1
            count = end - hash
            filename = filename[:hash] + '%0' + str(count) + 'd' + filename[end:]
        else:
            # There's no hash in the filename.
            if self.dumpPPM:
                # We can dump a series of frames all to the same file,
                # if we're dumping ppm frames.  Mjpegtools likes this.
                self.dumpAppend = True
                try:
                    os.remove(filename)
                except OSError:
                    pass
            else:
                # Implicitly append a frame number.
                filename = base + '%04d' + ext
            
        self.dumpFilename = filename
示例#18
0
    def setupDump(self):
        # Capture the output as a sequence of numbered frame images.
        self.PlayTime = 0
        self.PlayStartTime = 0
        self.PlayFrame = 0
        self.State = STATE_CAPTURING

        self.dumpFrameRate = manager.options.dump_fps
        assert self.dumpFrameRate

        filename = manager.options.dump
        base, ext = os.path.splitext(filename)
        ext_lower = ext.lower()

        self.dumpEncoder = None
        if ext_lower == '.mpg':
            # Use pymedia to convert frames to an mpeg2 stream
            # on-the-fly.
            import pymedia
            import pymedia.video.vcodec as vcodec

            self.dumpFile = open(filename, 'wb')
            frameRate = int(self.dumpFrameRate * 100 + 0.5)
            self.dumpFrameRate = float(frameRate) / 100.0

            params= { \
              'type': 0,
              'gop_size': 12,
              'frame_rate_base': 125,
              'max_b_frames': 0,
              'height': manager.options.size_y,
              'width': manager.options.size_x,
              'frame_rate': frameRate,
              'deinterlace': 0,
              'bitrate': 9800000,
              'id': vcodec.getCodecID('mpeg2video')
            }
            self.dumpEncoder = vcodec.Encoder(params)
            return

        # Don't dump a video file; dump a sequence of frames instead.
        self.dumpPPM = (ext_lower == '.ppm' or ext_lower == '.pnm')
        self.dumpAppend = False

        # Convert the filename to a pattern.
        if '#' in filename:
            hash = filename.index('#')
            end = hash
            while end < len(filename) and filename[end] == '#':
                end += 1
            count = end - hash
            filename = filename[:hash] + '%0' + str(
                count) + 'd' + filename[end:]
        else:
            # There's no hash in the filename.
            if self.dumpPPM:
                # We can dump a series of frames all to the same file,
                # if we're dumping ppm frames.  Mjpegtools likes this.
                self.dumpAppend = True
                try:
                    os.remove(filename)
                except OSError:
                    pass
            else:
                # Implicitly append a frame number.
                filename = base + '%04d' + ext

        self.dumpFilename = filename
示例#19
0


width = m.ncellswide * enlargex
height = m.ncellshigh * enlargex

vparams = {'type': 0,
           'gop_size': 12,
           'max_b_frames': 0,
           'frame_rate_base': 1,
           'frame_rate': 50,
           'width': width,
           'height': height,
           'deinterlace': 0,
           'bitrate': 300000, # normally 2700000 for a framerate of 2997/125 Hz
           'id': vcodec.getCodecID('mpeg1video')
          }

ve = vcodec.Encoder(vparams) # encodes raw video data into the desired format


mux = muxer.Muxer('avi') # create muxer, one of: ['avi', 'wmv', 'mov', 'mp4', 'wma', 'mp2', 'mp3', 'ac3', 'aac', 'flac', 'mpeg', 'mpg', 'mpeg', 'dat', 'vob', 'm1v', 'ogg']
vstreamid = mux.addStream(muxer.CODEC_TYPE_VIDEO, vparams) # add a video stream
#astreamid = mux.addStream(muxer.CODEC_TYPE_AUDIO, aparams) # add an audio stream
#import pdb; pdb.set_trace()
# write header to disk
header = mux.start()
print 'hello'
f.write(header)

# write mp3 to disk