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.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()
		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" % self.keyframe_count
			self.player.set_state(gst.STATE_NULL)
			self.playmode = False
		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"
		#print buffer
		bf=gst.BufferFlag(gst.BUFFER_FLAG_DELTA_UNIT)
		if not buffer.flag_is_set(bf) :
			print "Is a key frame"
			self.keyframe_count+=1
			print buffer.offset

		self.frame_count+=1

	def entry_added_callback(self,index,arg):
		print "Index entry added!"
		print arg.type
		
		if arg.type == 1 :
			print arg.type
			print arg.id
                        #this does not work
                        #how do i check for flags in pygst?
			print arg.data.assoc.flags

        
        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()