Someone

import sys, os, time, thread
import glib, gobject
import pygst
pygst.require("0.10")
import gst

class CLI_Main:
	
	def __init__(self):
		
		self.frame_count = 0
		self.keyframe_count = 0
		self.keyframe_count2 = 0
		self.IndexStats = {}
		self.player = gst.Pipeline("player")
		self.filesrc = gst.element_factory_make("filesrc","filesource")
		self.decoder = gst.element_factory_make("decodebin2", "decoder")
                #self.decoder.connect("element-added",self.element_added_callback)
		#self.decoder.connect("autoplug-continue",self.decoder_autoplug_continue)
		#self.decoder.connect("autoplug-select", self.decoder_autoplug_select)
		self.decoder.connect("new-decoded-pad",self.decoder_new_pad)
		#self.parser = gst.element_factory_make("h264parse", "parser")
		self.fakesink = gst.element_factory_make("fakesink","fakesink")
		self.fakesink.set_property("signal-handoffs","1")
		self.fakesink.connect("handoff",self.handoff_callback)

		self.player.add(self.filesrc,self.decoder,self.fakesink)
		gst.element_link_many(self.filesrc,self.decoder)
		bus = self.player.get_bus()
		bus.add_signal_watch()
		bus.connect("message", self.on_message)
		self.index = gst.Index()
		#help(self.index)
		self.index.set_property("resolver",1)
		self.player.set_index(self.index)
		self.index.connect("entry-added", self.entry_added_callback)


 	def on_message(self, bus, message):
		t = message.type
		print t

		if t == gst.MESSAGE_EOS:
			print "End of Stream!"
			#print "Frame count: %s" % self.frame_count
			print "Key Frame count: %s %s" % (self.keyframe_count, self.keyframe_count2)
			self.player.set_state(gst.STATE_NULL)
			self.playmode = False
			
			print "Index Stats"

			#for i in self.IndexStats :
				#print "Index ID : %s" % i 
				#s= self.IndexStats[i]
				#for entry in s:
					#print "Format %s" % entry
					#print "Value %s" % self.IndexStats[entry] 

			print repr(self.IndexStats)
		elif t == gst.MESSAGE_ERROR:
			self.player.set_state(gst.STATE_NULL)
			err, debug = message.parse_error()
			print "Error: %s" % err, debug
			self.playmode = False

	def start(self):
		for filepath in sys.argv[1:]:
			if os.path.isfile(filepath):
				print filepath
				self.filesrc.set_property("location",filepath)
				self.playmode=True
				self.player.set_state(gst.STATE_PLAYING)

				while self.playmode:
					time.sleep(1)
		
		time.sleep(1)
		loop.quit()

	def decoder_new_pad(self,decoder,pad,data) :
		print "New Decoded Pad"

		name= pad.get_caps()[0].get_name()
		
		print "Got pad!: %s" % name
                	
		if name.startswith("video"):
			print "Linking to fakesink"
			#ppad = self.parser.get_pad("sink")
			#pad.link(ppad)
			#spad = self.parser.get_pad("src")
			fpad = self.fakesink.get_pad("sink")
			pad.link(fpad)
			"""
                        if self.parser.is_indexable() :
				print "Is Indexable!"
				self.index=self.parser.get_index()
				if self.index != None :
					print "Connecting Index to signal"
					self.index.connect("entry-added",self.index_entry_added)
			else : 
				print "Not Indexable"
                        """

	def decoder_autoplug_continue(self,decoder,pad,caps) :
		print "Autoplug Continue"
		
		name= caps[0].get_name()
		print name
		print caps.to_string()
                return 1
                """
		if name.startswith("video"):
			return 0
		else:
			return 1
                """

	def decoder_autoplug_select(self,decoder,pad,caps,factory):
		print "Autoplug select"
		print caps.to_string()
		print factory.get_longname()
		return 0
	
	def handoff_callback(self,sink,buffer,pad) :
		print "Handoff"

		bf=gst.BufferFlag(gst.BUFFER_FLAG_DELTA_UNIT)
		if not buffer.flag_is_set(bf) :
			print "Is a key frame"
			self.keyframe_count2+=1
			print buffer.offset
			print buffer.offset_end

		self.frame_count+=1

	def entry_added_callback(self,index,arg):

		#print "Index entry added!"
		#print arg.type
		#print arg.id

		#help(arg)
		
		if arg.type == 0 : # GST_INDEX_ENTRY_ID
			self.IndexStats[arg.id] ={}
			s = self.IndexStats[arg.id]
			# storing the description of the index writer
			s["ID_DESCRIPTION"] = arg.ID_DESCRIPTION
			print arg.ID_DESCRIPTION

		elif arg.type == 1 : # GST_INDEX_ENTRY_ASSOCIATION

			#if arg.ASSOC_FLAGS == (1<<1) :
				#print "Delta Unit"
			if arg.ASSOC_FLAGS == (1<<0):
				print "Key Unit"
				self.keyframe_count+=1
				
				s=self.IndexStats[arg.id]				
				
				s[arg.ASSOC_VALUE(0)]=arg.ASSOC_VALUE(1)

        def element_added_callback(self,bin,element):
            print "Element Added"
            print element.get_name()
			

mainclass = CLI_Main()
thread.start_new_thread(mainclass.start, ())
gobject.threads_init()
loop = glib.MainLoop()
loop.run()