def vPlayer(fName):
global ovl
f = open(fName, "rb")
fmt = f.readline().strip().decode()
res = f.readline().strip().decode()
unused_col = f.readline().strip()
if fmt != "P5":
print("Unknown format( len %d ). Exiting..." % len(fmt))
return
w, h = [int(x) for x in res.split(" ")]
h = int((h * 2) / 3)
# Read into strings
y = f.read(w * h)
u = bytes()
v = bytes()
for _ in xrange_(0, int(h / 2)):
u += (f.read(int(w / 2)))
v += (f.read(int(w / 2)))
# Open overlay with the resolution specified
ovl = pg.Overlay(pg.YV12_OVERLAY, (w, h))
ovl.set_location(0, 0, w, h)
ovl.display((y, u, v))
while 1:
pg.time.wait(10)
for ev in pg.event.get():
if ev.type in (pg.KEYDOWN, pg.QUIT):
return
def vPlayer( fName ):
global ovl
f= open( fName, 'rb' )
fmt= f.readline().strip()
res= f.readline().strip()
col= f.readline().strip()
if fmt!= "P5":
print ('Unknown format( len %d ). Exiting...' % len( fmt ))
return
w,h= [ int(x) for x in res.split( ' ' ) ]
h= ( h* 2 )/ 3
# Read into strings
y= f.read( w*h )
u= []
v= []
for i in xrange_( 0, h/2 ):
u.append( f.read( w/2 ))
v.append( f.read( w/2 ))
u= ''.join(u)
v= ''.join(v)
# Open overlay with the resolution specified
ovl= pygame.Overlay(pygame.YV12_OVERLAY, (w,h))
ovl.set_location(0, 0, w, h)
ovl.display((y,u,v))
while 1:
pygame.time.wait(10)
for ev in pygame.event.get():
if ev.type in (pygame.KEYDOWN, pygame.QUIT):
return
async def render(self, rcs):
current_time = 0
frame_size = (640, 480)
ovl = pygame.Overlay(pygame.YV12_OVERLAY, frame_size)
ovl.set_location(
pygame.Rect(0, 0, self.window_width - 20, self.window_height - 10))
while True:
pygame.event.pump()
last_time, current_time = current_time, time.time()
await asyncio.sleep(1 / self.FPS - (current_time - last_time)
) # tick
await self.car.update((current_time - last_time) / 1.0)
await rcs.updateControl(self.car.gear, self.car.steering,
self.car.throttle, self.car.braking)
self.screen.fill(self.black)
if isinstance(self.latest_frame, VideoFrame):
image_to_ndarray = self.latest_frame.to_rgb().to_ndarray()
surface = pygame.surfarray.make_surface(
image_to_ndarray.swapaxes(0, 1))
height = self.window_height - 10
width = height * self.latest_frame.width // self.latest_frame.height
x = (self.window_width - 20 - width) // 2
y = 0
scaled_frame = pygame.transform.scale(surface, (width, height))
self.screen.blit(scaled_frame, (x, y))
self.draw()
pygame.display.flip()
def setupWindow(self, frame):
self.window = pygame.display.set_mode((frame.width, frame.height))
self.overlay = pygame.Overlay(pygame.YV12_OVERLAY,
(frame.width, frame.height))
def SetSize(self, Width, Height):
zControl.Control.SetSize(self, Width, Height)
self._overlay = pygame.Overlay(YV12_OVERLAY, (Width,Height))
self._overlay.set_location(self.GetRect().GetPygameRect())
caps = "video/x-raw-yuv,bpp=24,depth=24,format=(fourcc)YV12,width="+str(Width)+",height="+str(Height)
self.SetCaps(caps)
def handleDisplayRequest(self):
"""\
Check "notify" inbox for requests for surfaces, events and overlays and
process them.
"""
while self.dataReady("notify"):
message = self.recv("notify")
# print message
if isinstance(message, Axon.Ipc.producerFinished): ### VOMIT : mixed data types
# print "OK, got a producerFinished Message", message.message
self.needsRedrawing = True
# print "SURFACE", message
surface = message.message
# print "SURFACE", surface
message.message = None
message = None
# print "BEFORE", [id(x[0]) for x in self.surfaces]
self.surfaces = [ x for x in self.surfaces if x[0] is not surface ] ##H ERE
# print "AFTER", self.surfaces
# print "Hmm...", self.surface_to_eventcomms.keys()
try:
eventcomms = self.surface_to_eventcomms[str(id(surface))]
except KeyError:
# This simply means the component wasn't listening for events!
pass
else:
# print "EVENT OUTBOX:", eventcomms
self.visibility = None
try:
self.removeOutbox(eventcomms)
except:
"This sucks"
pass
# print "REMOVED OUTBOX"
if (len(self.surfaces) == 0) and (len(self.overlays)==0):
# print "ALL CLIENTS DISAPPEARED, OUGHT TO CONSIDER DISAPPEARING TOO"
self.startShutdown = True
elif message.get("DISPLAYREQUEST", False):
# print "GOT A DISPLAY REQUEST"
self.needsRedrawing = True
callbackservice = message["callback"]
eventservice = message.get("events", None)
size = message["size"]
surface = pygame.Surface(size)
alpha = message.get("alpha", 255)
surface.set_alpha(alpha)
if message.get("transparency", None):
surface.set_colorkey(message["transparency"])
position = message.get("position", self.surfacePosition(surface))
callbackcomms = self.addOutbox("displayerfeedback")
eventcomms = None
if eventservice is not None:
eventcomms = self.addOutbox("eventsfeedback")
self.events_wanted[eventcomms] = {}
self.link((self,eventcomms), eventservice)
self.visibility[eventcomms] = (surface,size,position)
self.surface_to_eventcomms[str(id(surface))] = eventcomms
self.link((self, callbackcomms), callbackservice)
self.send(surface, callbackcomms)
onlymouseinside = message.get("onlymouseinside", False)
self.surfaces.append( (surface, position, callbackcomms, eventcomms, onlymouseinside) )
# if message.get("onlymouseinside", False):
# print "ONLYMOUSEINSIDE: TRUE"
# else:
# print "ONLYMOUSEINSIDE: FALSE"
if message.get("fullscreen", False):
if not self.fullscreen:
self.fullscreen = 1
pygame.display.toggle_fullscreen()
elif message.get("ADDLISTENEVENT", None) is not None:
eventcomms = self.surface_to_eventcomms[str(id(message["surface"]))]
self.events_wanted[eventcomms][message["ADDLISTENEVENT"]] = True
elif message.get("REMOVELISTENEVENT", None) is not None:
eventcomms = self.surface_to_eventcomms[str(id(message["surface"]))]
self.events_wanted[eventcomms][message["REMOVELISTENEVENT"]] = False
elif message.get("CHANGEDISPLAYGEO", False):
try:
surface = message.get("surface", None)
if surface is not None:
self.needsRedrawing = True
c = 0
found = False
while c < len(self.surfaces) and not found:
if self.surfaces[c][0] == surface:
found = True
break
c += 1
if found:
(surface, position, callbackcomms, eventcomms, onlymouseinside) = self.surfaces[c] ## HERE
new_position = message.get("position", position)
self.surfaces[c] = (surface, new_position, callbackcomms, eventcomms, onlymouseinside) ## HERE
except Exception, e:
print "It all went horribly wrong", e
elif message.get("OVERLAYREQUEST", False):
self.needsRedrawing = True
size = message["size"]
pixformat = message["pixformat"]
position = message.get("position", (0,0))
overlay = pygame.Overlay(pixformat, size)
yuvdata = message.get("yuv", ("","",""))
# transform (y,u,v) to (y,v,u) because pygame seems to want that(!)
if len(yuvdata) == 3:
yuvdata = (yuvdata[0], yuvdata[2], yuvdata[1])
yuvservice = message.get("yuvservice",False)
if yuvservice:
yuvinbox = self.addInbox("overlay_yuv")
self.link( yuvservice, (self, yuvinbox) )
yuvservice = (yuvinbox, yuvservice)
posservice = message.get("positionservice",False)
if posservice:
posinbox = self.addInbox("overlay_position")
self.link (posservice, (self, posinbox) )
posservice = (posinbox, posservice)
if position != (0,0):
overlay.set_location( ( position,
(size[0], size[1])
))
self.overlays.append( {"overlay":overlay,
"yuv":yuvdata,
"position":position,
"size":size,
"yuvservice":yuvservice,
"posservice":posservice}
)
def handleDisplayRequest(self):
"""\
Check "notify" inbox for requests for surfaces, events and overlays and
process them.
"""
# changed from if to while
while self.dataReady("notify"):
message = self.recv("notify")
if isinstance(
message,
Axon.Ipc.producerFinished): ### VOMIT : mixed data types
# print "SURFACE", message
surface = message.message
# print "SURFACE", surface
message.message = None
message = None
# print "BEFORE", [id(x[0]) for x in self.surfaces]
self.surfaces = [
x for x in self.surfaces if x[0] is not surface
]
# print "AFTER", self.surfaces
# print "Hmm...", self.surface_to_eventcomms.keys()
try:
eventcomms = self.surface_to_eventcomms[str(id(surface))]
except KeyError:
# This simply means the component wasn't listening for events!
pass
else:
# print "EVENT OUTBOX:", eventcomms
self.visibility = None
try:
self.removeOutbox(eventcomms)
except:
"This sucks"
pass
# print "REMOVED OUTBOX"
elif message.get("3DDISPLAYREQUEST", False):
eventservice = message.get("events", None)
eventcomms = None
if eventservice is not None:
eventcomms = self.addOutbox("eventsfeedback")
self.link((self, eventcomms), eventservice)
self.objects.append((message.get("object"), eventcomms))
elif message.get("WRAPPERREQUEST", False):
surface = message.get("surface")
self.wrappedsurfaces.append(str(id(surface)))
callbackservice = message["wrapcallback"]
callbackcomms = self.addOutbox("wrapfeedback")
pow2surface = self.surface_to_pow2surface[str(id(surface))]
#determine texture coordinates
tex_w = float(surface.get_width()) / float(
pow2surface.get_width())
tex_h = float(surface.get_height()) / float(
pow2surface.get_height())
# send display data
self.link((self, callbackcomms), callbackservice)
b = Bunch()
b.texname = self.surface_to_texnames[str(id(surface))]
b.tex_w = tex_w
b.tex_h = tex_h
b.width = surface.get_width()
b.height = surface.get_height()
try:
b.eventservice = self.surface_to_eventservice[str(
id(surface))]
except KeyError:
b.eventservice = None
self.send(b, callbackcomms)
#handle only events if wrapped components can receive them
try:
eventcomms = self.surface_to_eventcomms[str(id(surface))]
# save callback for event requests
eventrequestservice = message["eventrequests"]
eventrequestcomms = self.addOutbox("eventrequests")
self.link((self, eventrequestcomms), eventrequestservice)
self.surface_to_eventrequestcomms[str(
id(surface))] = eventrequestcomms
# transmit already requested eventtypes
for (etype,
wanted) in self.events_wanted[eventcomms].items():
if wanted == True:
self.send({"ADDLISTENEVENT": etype},
eventrequestcomms)
except KeyError:
pass
elif message.get("DISPLAYREQUEST", False):
self.needsRedrawing = True
callbackservice = message["callback"]
eventservice = message.get("events", None)
size = message["size"]
surface = pygame.Surface(size)
#create another surface, with dimensions a power of two
# this is needed because otherwise texturing is REALLY slow
pow2size = (int(2**(ceil(log(size[0], 2)))),
int(2**(ceil(log(size[1], 2)))))
pow2surface = pygame.Surface(pow2size)
alpha = message.get("alpha", 255)
surface.set_alpha(alpha)
if message.get("transparency", None):
surface.set_colorkey(message["transparency"])
position = message.get("position",
self.surfacePosition(surface))
callbackcomms = self.addOutbox("displayerfeedback")
eventcomms = None
if eventservice is not None:
eventcomms = self.addOutbox("eventsfeedback")
self.events_wanted[eventcomms] = {}
self.link((self, eventcomms), eventservice)
self.visibility[eventcomms] = (surface, size, position)
self.surface_to_eventcomms[str(id(surface))] = eventcomms
self.surface_to_eventservice[str(
id(surface))] = eventservice
self.link((self, callbackcomms), callbackservice)
self.send(surface, callbackcomms)
# generate texture name
texname = glGenTextures(1)
self.surface_to_texnames[str(id(surface))] = texname
self.surface_to_pow2surface[str(id(surface))] = pow2surface
self.surfaces.append((surface, position, size, callbackcomms,
eventcomms, pow2surface, texname))
elif message.get("ADDLISTENEVENT", None) is not None:
# test if surface is beeing wrapped
if str(id(surface)) in self.wrappedsurfaces:
self.send(
message,
self.surface_to_eventrequestcomms[str(id(surface))])
else:
eventcomms = self.surface_to_eventcomms[str(
id(message["surface"]))]
self.events_wanted[eventcomms][
message["ADDLISTENEVENT"]] = True
elif message.get("REMOVELISTENEVENT", None) is not None:
# test if surface is beeing wrapped
if str(id(surface)) in self.wrappedsurfaces:
self.send(
message,
self.surface_to_eventrequestcomms[str(id(surface))])
else:
eventcomms = self.surface_to_eventcomms[str(
id(message["surface"]))]
self.events_wanted[eventcomms][
message["REMOVELISTENEVENT"]] = False
elif message.get("CHANGEDISPLAYGEO", False):
try:
surface = message.get("surface", None)
if surface is not None:
self.needsRedrawing = True
c = 0
found = False
while c < len(self.surfaces) and not found:
if self.surfaces[c][0] == surface:
found = True
break
c += 1
if found:
(surface, position, size, callbackcomms,
eventcomms, pow2surface,
texname) = self.surfaces[c]
new_position = message.get("position", position)
# update texture
self.updatePygameTexture(surface, texname)
self.surfaces[c] = (surface, new_position,
callbackcomms, eventcomms,
texname)
except Exception, e:
print "It all went horribly wrong", e
elif message.get("OVERLAYREQUEST", False):
self.needsRedrawing = True
size = message["size"]
pixformat = message["pixformat"]
position = message.get("position", (0, 0))
overlay = pygame.Overlay(pixformat, size)
yuvdata = message.get("yuv", ("", "", ""))
# transform (y,u,v) to (y,v,u) because pygame seems to want that(!)
if len(yuvdata) == 3:
yuvdata = (yuvdata[0], yuvdata[2], yuvdata[1])
yuvservice = message.get("yuvservice", False)
if yuvservice:
yuvinbox = self.addInbox("overlay_yuv")
self.link(yuvservice, (self, yuvinbox))
yuvservice = (yuvinbox, yuvservice)
posservice = message.get("positionservice", False)
if posservice:
posinbox = self.addInbox("overlay_position")
self.link(posservice, (self, posinbox))
posservice = (posinbox, posservice)
self.overlays.append({
"overlay": overlay,
"yuv": yuvdata,
"position": position,
"size": size,
"yuvservice": yuvservice,
"posservice": posservice
})
frame_i = 0
# rtsp://192.168.0.88:8554
url = 'rtsp://*****:*****@10.0.1.67:554/'
# live555 only provides mechanism for streaming, meaning that it will take NAL packets
# from the network or file source and push it to the "DummySink", you still need to
# decode (transform the NAL units to bitmaps) and render (draw the bitmaps to the screen).
w = 1920
h = 1080
SR = (1920, 1080)
pygame.init()
pygame.display.set_mode(SR)
ovl = pygame.Overlay(pygame.YV12_OVERLAY, (w, h))
ovl.set_location(0, 0, w, h)
def decodeFrame(receiveBuf):
#av_packet_from_data(m_packet, receiveBuf, len(receiveBuf))
#avcodec_decode_video2(codecCtx, frame, &got_picture, m_packet)
global decoder
print ''
if frame_i == 0:
avcC = receiveBuf
#TODO get avcC to decode
decoder = h264decode.Decoder(avcC)
else:
yuv = decoder.decodeFrame(receiveBuf)
if yuv is not None:
dlen=0
while len( s )> 0:
dlen=dlen+len(s)
if nodecode==1:
print "demuxed %d " % dlen
for fr in r:
if fr[ 0 ]== v_id and nodecode==0:
try:
d= c.decode( fr[ 1 ] )
if d and d.data:
if video==1:
if w==0: w=d.size[0]
if h==0: h=d.size[1]
if not overlay:
overlay= pygame.Overlay( YV12,(w+1,h) )
overlay.display(d.data)
frcnt=frcnt+1
print "decoded %d\r" % frcnt,
except:
print "\ndecode error"
s=f.read(BufferSize)
try:
r=None
r= dm.parse( s ,pos)
pos=pos+BufferSize
except muxer.SeekRequired,reqpos:
f.seek( reqpos[0], 0 )
pos=reqpos[0]
r=dm.ReadyData()
print "seek to" % pos
size = ( int(round(size[0]*options.scaleWidth)),
int(round(size[1]*options.scaleHeight)) )
print('output resolution: %dx%d' % (size))
# setup pygame
pygame.init()
if options.fullscreen:
screen = pygame.display.set_mode(size, pygame.DOUBLEBUF|pygame.HWSURFACE|pygame.FULLSCREEN)
else:
screen = pygame.display.set_mode(size)
useYuv = False
if streamInfo['pixelFormat'] == 'yuv420p':
overlay = pygame.Overlay(pygame.YV12_OVERLAY, size)
overlay.set_location(0, 0, size[0], size[1])
useYuv = True
if overlay.get_hardware():
print('render: Hardware accelerated yuv overlay (fast)')
else:
print('render: Software yuv overlay (slow)')
else:
print('render: software rgb (very slow)')
# add scaler to convert to rgb
media.addScaler(vstream, *size)
#media.addScaler(vstream, *size, scaling='gauss')
decodedCount = 0
mainLoop = True