def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print("using LiveView grabber")
self.active = False
self.photomode = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
# Search for available camera
if options.debug:
print("searching for camera")
search = ControlPoint()
cameras = search.discover(1)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
return
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print("No camera found, aborting")
display.terminate_clicked()
self.event_terminated.set()
return
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if options.debug:
print("Versions: %s" % camera.getVersions())
print("API List: %s" % mode)
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len((camera.getAvailableLiveviewSize()['result'])[0]) > 1:
url = camera.liveview(["L"])
else:
url = camera.liveview()
else:
url = camera.liveview()
incoming_image = None
frame_info = None
# Ensure that we're in correct mode (movie by default)
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if options.still:
if (mode['result'])[0] != 'still':
if 'still' in (mode['result'])[1]:
camera.setShootMode(["still"])
self.photomode = True
else:
self.photomode = True
else:
if (mode['result'])[0] != 'movie':
if 'movie' in (mode['result'])[1]:
camera.setShootMode(["movie"])
else:
self.photomode = True
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
while not self.event_terminate.isSet():
# Handle events from the camera (record start/stop)
if self.frame_count % 50 == 0:
mode = camera.getEvent(["false"])
else:
mode = None
if mode and type(mode) == dict:
status = mode['result'][1]
if self.active == False and status['cameraStatus'] == 'MovieRecording':
self.frame_count = 0
self.start_time = datetime.datetime.now()
self.active = True
if options.debug:
print("started capture %s" % self.start_time)
elif self.active == True and status['cameraStatus'] == 'IDLE':
self.active = False
self.end_time = datetime.datetime.now()
if options.debug:
elapsed = self.end_time - self.start_time
'''
print("Stopped capture: frames = ", self.frame_count, \
", delta = ", elapsed.seconds + (float(elapsed.microseconds) / 1000000), \
", fps = ", self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000)))
'''
print("Stopped capture: frames = %d, delta = %d, fps = %d" % \
(self.frame_count, elapsed.seconds + (float(elapsed.microseconds) / 1000000), \
self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000))))
# read header, confirms image is also ready to read
header = lst.get_header()
if header:
image_file = io.BytesIO(lst.get_latest_view())
incoming_image = Image.open(image_file)
frame_info = lst.get_frameinfo()
if options.gui == True :
# Correct display size if changed
if incoming_image and ((incoming_image.size)[0] != display.width):
if options.debug:
print("adjusted width from %d to %d" % (display.width, (incoming_image.size)[0]))
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
display.width, display.height)
if incoming_image and ((incoming_image.size)[1] != display.height):
if options.debug:
print("adjusted height from %d to %d" % (display.height, (incoming_image.size)[1]))
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
display.width, display.height)
# copy image to the display
if incoming_image:
image_copy = incoming_image.convert("RGB")
# draw frame info to image
if frame_info:
for x in range(len(frame_info)):
left = frame_info[x]['left'] * display.width / 10000
top = frame_info[x]['top'] * display.height / 10000
right = frame_info[x]['right'] * display.width / 10000
bottom = frame_info[x]['bottom'] * display.height / 10000
dr = ImageDraw.Draw(image_copy)
dr.line((left, top, left, bottom), fill="white", width=3)
dr.line((right, top, right, bottom), fill="white", width=3)
dr.line((left, top, right, top), fill="white", width=3)
dr.line((left, bottom, right, bottom), fill="white", width=3)
display.copy_to_offscreen(image_copy)
if options.debug and header:
common = common_header(header)
print("Frame: %d, %d, %s" % (common['sequence_number'], common['time_stamp'], datetime.datetime.now()))
# count frames
self.frame_count = self.frame_count + 1
# handle events
if self.event_start_stream.isSet():
if self.photomode == True:
camera.actTakePicture()
else:
camera.startMovieRec()
self.event_start_stream.clear()
if self.event_stop_stream.isSet():
camera.stopMovieRec()
self.event_stop_stream.clear()
# give OS a breather
#time.sleep(0.01)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
print("No camera found, aborting")
quit()
mode = camera.getAvailableApiList()
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len(
(camera.getAvailableLiveviewSize()['result'])[0]) > 1:
url = camera.liveview(["L"])
else:
url = camera.liveview()
else:
url = camera.liveview()
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print("using LiveView grabber")
self.active = False
self.photomode = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
# Search for available camera
if options.debug:
print("searching for camera")
search = ControlPoint()
cameras = search.discover(1)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
return
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print("No camera found, aborting")
display.terminate_clicked()
self.event_terminated.set()
return
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if options.debug:
print("Versions: %s" % camera.getVersions())
print("API List: %s" % mode)
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len((camera.getAvailableLiveviewSize()['result'])[0]) > 1:
url = camera.liveview(["L"])
else:
url = camera.liveview()
else:
url = camera.liveview()
incoming_image = None
frame_info = None
# Ensure that we're in correct mode (movie by default)
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if options.still:
if (mode['result'])[0] != 'still':
if 'still' in (mode['result'])[1]:
camera.setShootMode(["still"])
self.photomode = True
else:
self.photomode = True
else:
if (mode['result'])[0] != 'movie':
if 'movie' in (mode['result'])[1]:
camera.setShootMode(["movie"])
else:
self.photomode = True
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
while not self.event_terminate.isSet():
# Handle events from the camera (record start/stop)
if self.frame_count % 50 == 0:
mode = camera.getEvent(["false"])
else:
mode = None
if mode and type(mode) == dict:
status = mode['result'][1]
if self.active == False and status['cameraStatus'] == 'MovieRecording':
self.frame_count = 0
self.start_time = datetime.datetime.now()
self.active = True
if options.debug:
print("started capture %s" % self.start_time)
elif self.active == True and status['cameraStatus'] == 'IDLE':
self.active = False
self.end_time = datetime.datetime.now()
if options.debug:
elapsed = self.end_time - self.start_time
'''
print("Stopped capture: frames = ", self.frame_count, \
", delta = ", elapsed.seconds + (float(elapsed.microseconds) / 1000000), \
", fps = ", self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000)))
'''
print("Stopped capture: frames = %d, delta = %d, fps = %d" % \
(self.frame_count, elapsed.seconds + (float(elapsed.microseconds) / 1000000), \
self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000))))
# read header, confirms image is also ready to read
header = lst.get_header()
if header:
image_file = io.BytesIO(lst.get_latest_view())
incoming_image = Image.open(image_file)
frame_info = lst.get_frameinfo()
if options.gui == True :
# Correct display size if changed
if incoming_image and ((incoming_image.size)[0] != display.width):
if options.debug:
print("adjusted width from %d to %d" % (display.width, (incoming_image.size)[0]))
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
display.width, display.height)
if incoming_image and ((incoming_image.size)[1] != display.height):
if options.debug:
print("adjusted height from %d to %d" % (display.height, (incoming_image.size)[1]))
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
display.width, display.height)
# copy image to the display
if incoming_image:
image_copy = incoming_image.convert("RGB")
# draw frame info to image
if frame_info:
for x in range(len(frame_info)):
left = frame_info[x]['left'] * display.width / 10000
top = frame_info[x]['top'] * display.height / 10000
right = frame_info[x]['right'] * display.width / 10000
bottom = frame_info[x]['bottom'] * display.height / 10000
dr = ImageDraw.Draw(image_copy)
dr.line((left, top, left, bottom), fill="white", width=3)
dr.line((right, top, right, bottom), fill="white", width=3)
dr.line((left, top, right, top), fill="white", width=3)
dr.line((left, bottom, right, bottom), fill="white", width=3)
display.copy_to_offscreen(image_copy)
if options.debug and header:
common = common_header(header)
print("Frame: %d, %d, %s" % (common['sequence_number'], common['time_stamp'], datetime.datetime.now()))
# count frames
self.frame_count = self.frame_count + 1
# handle events
if self.event_start_stream.isSet():
if self.photomode == True:
camera.actTakePicture()
else:
camera.startMovieRec()
self.event_start_stream.clear()
if self.event_stop_stream.isSet():
camera.stopMovieRec()
self.event_stop_stream.clear()
# give OS a breather
#time.sleep(0.01)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
class CameraHandler:
def __init__(self):
self.find_camera()
self.hdpic_seq = 0
self.hdpicture = None
self.hdpic_tstamp = Time(0, 0)
self.hdpic_msg = CompressedImage() # message to publish
self.cameras = None
self.cam = None
self.mode = None
self.hdpic_resp = None
self.polled_image_resp = None
self.hdpic_pub = None
self.incoming = None
self.img_msg = CompressedImage()
self.pub = None
self.success_liveview = False
def find_camera(self, duration=3):
"""
Uses the discover protocol and sets communication with one camera.
"""
# get available camera
search = ControlPoint()
self.cameras = search.discover(duration)
# use first found camera
if len(self.cameras):
self.cam = SonyAPI(self.cameras[0])
else:
self.cam = None
rospy.logerr("No camera found")
return
self.mode = self.cam.getAvailableApiList()
# some cameras need startRecMode call
# no needed in QX1
if 'starRecMode' in (self.mode['result'])[0]:
self.cam.startRecMode()
time.sleep(5)
else:
rospy.loginfo("No startRecMode available")
# re-read capabilities
self.mode = self.cam.getAvailableApiList()
rospy.loginfo("Found camera")
return
def polled_image_error(self, msg):
"""
Returns a failed GetPolledImageResponse.
:param msg: Error message to return with GetPolledImageResponse.
:return: GetPolledImageResponse.
"""
rospy.logerr(msg)
return GetPolledImageResponse(success=False,
status_message=msg,
stamp=Time(0))
def take_pic_thread(self):
"""
Takes one hd picture and saves it to polled_image_resp.
:return: None
"""
self.polled_image_resp = None
try:
self.cam.setShootMode(param=['still'])
# set timestamp for picture
now = time.time()
self.hdpic_tstamp = Time(now)
# get status snapshot of cam
event = self.cam.getEvent(param=[False])
if "error" in event:
self.polled_image_resp = self.polled_image_error(
str(event['error']))
return
# check if is available to take pic
if event['result'][1]['cameraStatus'] != 'IDLE':
rospy.loginfo("Camera is busy")
self.polled_image_resp = self.polled_image_error(
"Camera is busy")
return
# take pic
self.hdpic_resp = self.cam.actTakePicture()
if 'error' in self.hdpic_resp:
rospy.logerr(self.hdpic_resp['error'])
self.polled_image_resp = self.polled_image_error(
str(self.hdpic_resp['error']))
return
# download pic
url = self.hdpic_resp['result'][0][0].replace('\\', '')
self.hdpicture = urllib2.urlopen(url).read()
self.hdpic_seq += 1 # increment sequence counter
rospy.loginfo("Picture taken")
# publish one pic
self.pub_hdpic()
# service response
self.polled_image_resp = GetPolledImageResponse(
success=True,
status_message="Picture taken",
stamp=self.hdpic_tstamp)
return
except Exception as err:
rospy.logerr(str(err))
self.polled_image_resp = self.polled_image_error(
"Couldn't take picture")
return
def take_picture(self, req):
"""
Callback function to handle polled camera requests.
:return: None
"""
# starts take pic thread and waits TIMEOUT_TAKEPIC seconds to complete
t_takepic = Thread(target=self.take_pic_thread)
t_takepic.start()
t_takepic.join(TIMEOUT_TAKEPIC)
# checks if take picture action was succesf
if self.polled_image_resp:
return self.polled_image_resp
else:
return self.polled_image_error(
"Couldn't take picture, it took too long")
def set_serv_pic(self):
"""
Sets the service to take pictures.
:return: None
"""
# service setup
s = rospy.Service('sony_cam/request_image', GetPolledImage,
self.take_picture)
rospy.loginfo("Ready to take pictures")
# waits for requests
rospy.spin()
def prep_pub_hdpic(self):
"""
Set up of hd picture publisher.
"""
self.hdpic_pub = rospy.Publisher('hdpicture/compressed',
CompressedImage,
queue_size=1)
def pub_hdpic(self):
"""
Publishes one hdpicture message.
"""
# fill message fields
self.hdpic_msg.header.seq = self.hdpic_seq
self.hdpic_msg.header.stamp = self.hdpic_tstamp
self.hdpic_msg.header.frame_id = "right_sony_cam"
self.hdpic_msg.format = 'jpeg'
self.hdpic_msg.data = self.hdpicture
# end fill
self.hdpic_pub.publish(self.hdpic_msg)
def liveview_thread(self):
"""
Publishes one liveview frame.
:return: None
"""
try:
# read next image
self.success_liveview = False
data = self.incoming.read(8)
common = common_header(data)
data = self.incoming.read(128)
self.img_msg = CompressedImage() # message to publish
if common['payload_type'] == 1: # jpeg frame
payload = payload_header(data)
image_file = self.incoming.read(payload['jpeg_data_size'])
# fill message fields
self.img_msg.header.seq = common['sequence_number']
self.img_msg.header.stamp.secs = common['time_stamp'] / 1000.
self.img_msg.header.stamp.nsecs = common['time_stamp'] * 1000.
self.img_msg.header.frame_id = "right_sony_cam"
self.img_msg.format = 'jpeg'
self.img_msg.data = image_file
# end fill
self.pub.publish(self.img_msg)
self.success_liveview = True
except Exception as err:
rospy.logerr("Couldn't get liveview")
def reset_liveview(self):
"""
Executes necessary steps to begin a liveview.
:return: Boolean, True when there are no errors.
"""
# disables packets with liveview frame info(face detection frames, focus frames and tracking frames)
# supported in QX1
try:
if 'setLiveviewFrameInfo' in (self.mode['result'])[0]:
self.cam.setLiveviewFrameInfo([{"frameInfo": False}])
self.incoming = urllib2.urlopen(self.cam.liveview())
except Exception:
rospy.logerr("Couldn't reset liveview")
return False
else:
return True
def liveview(self):
"""
Begins liveview streaming.
"""
# publisher setup
self.pub = rospy.Publisher('liveview/compressed',
CompressedImage,
queue_size=10)
rospy.loginfo("Beginning liveview")
reset_f = True
while reset_f:
try:
reset_f = not self.reset_liveview()
except Exception:
rospy.logerr("Couldn't begin liveview set up")
time.sleep(3)
while not rospy.is_shutdown():
try:
t_getlive = Thread(target=self.liveview_thread)
t_getlive.start()
t_getlive.join(TIMEOUT_GETLIVEVIEW)
if not self.success_liveview:
rospy.logerr(
"Couldn't get liveview, it took too long or other errors"
)
t_getresetlive = Thread(target=self.reset_liveview)
t_getresetlive.start()
t_getresetlive.join(TIMEOUT_GETLIVEVIEW)
time.sleep(3)
except Exception as err:
rospy.logerr("Couldn't get liveview")
time.sleep(3)
print("No camera found, aborting")
quit()
mode = camera.getAvailableApiList()
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len((camera.getAvailableLiveviewSize()['result'])[0]) > 1:
url = camera.liveview(["L"])
else:
url = camera.liveview()
else:
url = camera.liveview()
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
# Use PyGame to display images full screen
def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print "using LiveView grabber"
self.active = False
self.photomode = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
# Search for available camera
if options.debug:
print "searching for camera"
search = ControlPoint()
cameras = search.discover(1)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print "No camera found, aborting"
return
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print "No camera found, aborting"
display.terminate_clicked()
self.event_terminated.set()
return
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if options.debug:
print "Versions:", camera.getVersions()
print "API List:", mode
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len(
(camera.getAvailableLiveviewSize()['result'])[0]) > 1:
incoming = camera.liveview(["L"])
else:
incoming = camera.liveview()
else:
incoming = camera.liveview()
incoming_image = None
frame_sequence = None
frame_info = None
frame_data = None
# Ensure that we're in correct mode (movie by default)
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if options.still:
if (mode['result'])[0] != 'still':
if 'still' in (mode['result'])[1]:
camera.setShootMode(["still"])
self.photomode = True
else:
self.photomode = True
else:
if (mode['result'])[0] != 'movie':
if 'movie' in (mode['result'])[1]:
camera.setShootMode(["movie"])
else:
self.photomode = True
while not self.event_terminate.isSet():
# Handle events from the camera (record start/stop)
if self.frame_count % 50 == 0:
mode = camera.getEvent(["false"])
else:
mode = None
if mode and type(mode) == dict:
status = mode['result'][1]
if self.active == False and status[
'cameraStatus'] == 'MovieRecording':
self.frame_count = 0
self.start_time = datetime.datetime.now()
self.active = True
if options.debug:
print "started capture", self.start_time
elif self.active == True and status['cameraStatus'] == 'IDLE':
self.active = False
self.end_time = datetime.datetime.now()
if options.debug:
elapsed = self.end_time - self.start_time
print "Stopped capture: frames = ", self.frame_count,
print ", delta = ", elapsed.seconds + (
float(elapsed.microseconds) / 1000000),
print ", fps = ", self.frame_count / (
elapsed.seconds +
(float(elapsed.microseconds) / 1000000))
# read next image
data = incoming.read(8)
common = common_header(data)
data = incoming.read(128)
if common['payload_type'] == 1:
payload = payload_header(data)
image_file = io.BytesIO(
incoming.read(payload['jpeg_data_size']))
incoming_image = Image.open(image_file)
incoming.read(payload['padding_size'])
elif common['payload_type'] == 2:
frame_info = payload_header(data, 2)
if frame_info['jpeg_data_size']:
frame_sequence = common['sequence_number']
frame_data = incoming.read(frame_info['jpeg_data_size'])
incoming.read(frame_info['padding_size'])
if options.gui == True:
# Correct display size if changed
if incoming_image and (
(incoming_image.size)[0] != display.width):
if options.debug:
print "adjusted width from", display.width, "to", (
incoming_image.size)[0]
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
if incoming_image and (
(incoming_image.size)[1] != display.height):
if options.debug:
print "adjusted height from", display.height, "to", (
incoming_image.size)[1]
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
# copy image to the display
if incoming_image:
image_copy = incoming_image.convert("RGB")
# only recent frame info to image
if frame_info and frame_sequence >= common['sequence_number']-1 \
and frame_info['jpeg_data_size']:
for x in range(frame_info['frame_count']):
x = x * frame_info['frame_size']
(left, top, right,
bottom) = struct.unpack(">HHHH",
frame_data[x:x + 8])
left = left * display.width / 10000
top = top * display.height / 10000
right = right * display.width / 10000
bottom = bottom * display.height / 10000
dr = ImageDraw.Draw(image_copy)
dr.line((left, top, left, bottom),
fill="white",
width=3)
dr.line((right, top, right, bottom),
fill="white",
width=3)
dr.line((left, top, right, top),
fill="white",
width=3)
dr.line((left, bottom, right, bottom),
fill="white",
width=3)
display.copy_to_offscreen(image_copy)
if options.debug:
print "Frame:", common['sequence_number'], common[
'time_stemp'], datetime.datetime.now()
# count frames
self.frame_count = self.frame_count + 1
# handle events
if self.event_start_stream.isSet():
if self.photomode == True:
camera.actTakePicture()
else:
camera.startMovieRec()
self.event_start_stream.clear()
if self.event_stop_stream.isSet():
camera.stopMovieRec()
self.event_stop_stream.clear()
# give OS a breather
#time.sleep(0.01)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print "using LiveView grabber"
self.active = False
self.photomode = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
# Search for available camera
if options.debug:
print "searching for camera"
search = ControlPoint()
cameras = search.discover(1)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print "No camera found, aborting"
return
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print "No camera found, aborting"
display.terminate_clicked()
self.event_terminated.set()
return
# For those cameras which need it
if "startRecMode" in (mode["result"])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if options.debug:
print "Versions:", camera.getVersions()
print "API List:", mode
if "setLiveviewFrameInfo" in (mode["result"])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if "getAvailableLiveviewSize" in (mode["result"])[0]:
if options.large and len((camera.getAvailableLiveviewSize()["result"])[0]) > 1:
incoming = camera.liveview(["L"])
else:
incoming = camera.liveview()
else:
incoming = camera.liveview()
incoming_image = None
frame_sequence = None
frame_info = None
frame_data = None
# Ensure that we're in correct mode (movie by default)
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if options.still:
if (mode["result"])[0] != "still":
if "still" in (mode["result"])[1]:
camera.setShootMode(["still"])
self.photomode = True
else:
self.photomode = True
else:
if (mode["result"])[0] != "movie":
if "movie" in (mode["result"])[1]:
camera.setShootMode(["movie"])
else:
self.photomode = True
while not self.event_terminate.isSet():
# Handle events from the camera (record start/stop)
if self.frame_count % 50 == 0:
mode = camera.getEvent(["false"])
else:
mode = None
if mode and type(mode) == dict:
status = mode["result"][1]
if self.active == False and status["cameraStatus"] == "MovieRecording":
self.frame_count = 0
self.start_time = datetime.datetime.now()
self.active = True
if options.debug:
print "started capture", self.start_time
elif self.active == True and status["cameraStatus"] == "IDLE":
self.active = False
self.end_time = datetime.datetime.now()
if options.debug:
elapsed = self.end_time - self.start_time
print "Stopped capture: frames = ", self.frame_count,
print ", delta = ", elapsed.seconds + (float(elapsed.microseconds) / 1000000),
print ", fps = ", self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000))
# read next image
data = incoming.read(8)
common = common_header(data)
data = incoming.read(128)
if common["payload_type"] == 1:
payload = payload_header(data)
image_file = io.BytesIO(incoming.read(payload["jpeg_data_size"]))
incoming_image = Image.open(image_file)
incoming.read(payload["padding_size"])
elif common["payload_type"] == 2:
frame_info = payload_header(data, 2)
if frame_info["jpeg_data_size"]:
frame_sequence = common["sequence_number"]
frame_data = incoming.read(frame_info["jpeg_data_size"])
incoming.read(frame_info["padding_size"])
if options.gui == True:
# Correct display size if changed
if incoming_image and ((incoming_image.size)[0] != display.width):
if options.debug:
print "adjusted width from", display.width, "to", (incoming_image.size)[0]
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, display.width, display.height)
if incoming_image and ((incoming_image.size)[1] != display.height):
if options.debug:
print "adjusted height from", display.height, "to", (incoming_image.size)[1]
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, display.width, display.height)
# copy image to the display
if incoming_image:
image_copy = incoming_image.convert("RGB")
# only recent frame info to image
if frame_info and frame_sequence >= common["sequence_number"] - 1 and frame_info["jpeg_data_size"]:
for x in range(frame_info["frame_count"]):
x = x * frame_info["frame_size"]
(left, top, right, bottom) = struct.unpack(">HHHH", frame_data[x : x + 8])
left = left * display.width / 10000
top = top * display.height / 10000
right = right * display.width / 10000
bottom = bottom * display.height / 10000
dr = ImageDraw.Draw(image_copy)
dr.line((left, top, left, bottom), fill="white", width=3)
dr.line((right, top, right, bottom), fill="white", width=3)
dr.line((left, top, right, top), fill="white", width=3)
dr.line((left, bottom, right, bottom), fill="white", width=3)
display.copy_to_offscreen(image_copy)
if options.debug:
print "Frame:", common["sequence_number"], common["time_stemp"], datetime.datetime.now()
# count frames
self.frame_count = self.frame_count + 1
# handle events
if self.event_start_stream.isSet():
if self.photomode == True:
camera.actTakePicture()
else:
camera.startMovieRec()
self.event_start_stream.clear()
if self.event_stop_stream.isSet():
camera.stopMovieRec()
self.event_stop_stream.clear()
# give OS a breather
# time.sleep(0.01)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
class Camera_sonywifi(Camera):
def __init__(self, picture_size, preview_size, zoom=30, ssid="DIRECT-LKE0:ILCE-6000", pw="UeyxbxAG",
iface="wlp2s0"):
Camera.__init__(self, picture_size, preview_size, zoom, type='sony_wifi')
self.live_stream = None
if not sony_enabled:
raise CameraException("pysony module not installed")
self.previous_wifi = \
subprocess.check_output(["nmcli", "--fields", "NAME", "c", "show", "--active"]).decode("utf-8").split("\n")[
1].strip()
self.sony_api_version = "1.0"
if self.previous_wifi == ssid:
self.previous_wifi = ""
else:
try:
wifi_list = subprocess.check_output(["nmcli", "--fields", "SSID", "device", "wifi"]).decode(
"utf-8").split("\n")
wifi_list = [wifi_list[i].strip() for i in range(len(wifi_list))]
if ssid in wifi_list:
subprocess.check_call(["nmcli", "con", "up", "id", ssid])
else:
raise CameraException("Sony Wifi not found")
except subprocess.CalledProcessError:
raise CameraException("Cannot connect to wifi")
search = ControlPoint()
cameras = search.discover()
self.last_preview_frame = Image.new('RGB', preview_size, (0, 0, 0))
if len(cameras):
self.camera = SonyAPI(QX_ADDR=cameras[0])
else:
raise CameraException("No camera found")
options = self.camera.getAvailableApiList()['result'][0]
logging.info(str(options))
def zoom_in(self):
self.camera.actZoom(["in", "1shot"])
def zoom_out(self):
self.camera.actZoom(["out", "1shot"])
def __del__(self):
self.teardown()
def teardown(self):
if sony_enabled:
if self.live_stream is not None:
self.stop_preview_stream()
if self.previous_wifi is not "":
try:
subprocess.check_call(["nmcli", "con", "up", "id", self.previous_wifi])
except subprocess.CalledProcessError:
raise CameraException("Cannot connect to previous wifi " + self.previous_wifi)
def start_preview_stream(self):
# For those cameras which need it
options = self.camera.getAvailableApiList()['result'][0]
logging.info("starting preview")
if 'startRecMode' in options:
self.camera.startRecMode()
time.sleep(1)
options = self.camera.getAvailableApiList()['result'][0]
print(str(options))
self.camera.setLiveviewFrameInfo([{"frameInfo": False}])
url = self.camera.liveview()
assert isinstance(url, str)
print(url)
self.live_stream = SonyAPI.LiveviewStreamThread(url)
self.live_stream.start()
self.preview_active = True
def stop_preview_stream(self):
logging.info("stopping preview")
if self.live_stream is not None:
self.live_stream.stop()
options = self.camera.getAvailableApiList()['result'][0]
# if self.preview_active and 'endRecMode' in (options):
# self.camera.stopRecMode()
# if self.live_stream.is_active():
# self.camera.stopLiveview() # todo: is this correct?
self.preview_active = False
def get_preview_frame(self, filename=None):
# read header, confirms image is also ready to read
header = False
while not header:
header = self.live_stream.get_header()
if header:
# image_file = io.BytesIO(self.live_stream.get_latest_view())
# incoming_image = Image.open(image_file)
# frame_info = self.live_stream.get_frameinfo()
data = self.live_stream.get_latest_view()
img = Image.open(io.BytesIO(data))
# img=img.resize(self.preview_size, Image.ANTIALIAS)
else:
img = self.last_preview_frame
if filename is not None:
img.save(filename)
return img
def take_picture(self, filename="/tmp/picture.jpg"):
options = self.camera.getAvailableApiList()['result'][0]
url = self.camera.actTakePicture()
logging.info(url)
response = requests.get(url['result'][0][0].replace('\\', ''))
img = Image.open(io.BytesIO(response.content))
if filename is not None:
img.save(filename)
return img