def write_video_frame(self, input_frame):
if not self.configured:
self.video_stream.height = input_frame.height
self.video_stream.width = input_frame.width
self.configured = True
packet = Packet()
packet.payload = input_frame.jpeg_buffer.view()
self.container.mux(packet)
def decode(self, encoded_frame):
try:
packet = Packet(encoded_frame.data)
packet.pts = encoded_frame.timestamp
frames = self.codec.decode(packet)
except AVError as e:
logger.warning('failed to decode, skipping package: ' + str(e))
return []
return list(map(video_frame_from_avframe, frames))
def write_video_frame(self, input_frame):
if not self.configured:
self.video_stream.height = input_frame.height
self.video_stream.width = input_frame.width
self.configured = True
packet = Packet()
packet.payload = input_frame.jpeg_buffer
packet.dts = self.frame_count * 10000
packet.pts = self.frame_count * 10000
self.frame_count += 1
self.container.mux(packet)
def write_video_frame(self, input_frame):
if not self.configured:
self.video_stream.height = input_frame.height
self.video_stream.width = input_frame.width
self.configured = True
packet = Packet()
packet.payload = input_frame.jpeg_buffer
packet.dts = self.frame_count*10000
packet.pts = self.frame_count*10000
self.frame_count +=1
self.container.mux(packet)
def write_video_frame(self, input_frame):
if not self.configured:
self.video_stream.height = input_frame.height
self.video_stream.width = input_frame.width
self.configured = True
packet = Packet()
packet.payload = input_frame.jpeg_buffer
#we are setting the packet pts manually this uses a different timebase av.frame!
packet.dts = int(self.frame_count/self.video_stream.time_base/self.fps)
packet.pts = int(self.frame_count/self.video_stream.time_base/self.fps)
self.frame_count +=1
self.container.mux(packet)
def iter_raw_frames(path, packet_sizes, ctx):
with open(path, 'rb') as f:
for i, size in enumerate(packet_sizes):
packet = Packet(size)
read_size = f.readinto(packet)
assert size
assert read_size == size
print(i + 1, size, read_size)
if not read_size:
break
for frame in ctx.decode(packet):
print(' ', frame)
yield frame
print('flushing...')
while True:
try:
frames = ctx.decode(None)
except AVError as e:
if e.errno != 541478725: # EOF
raise
break
for frame in frames:
print(' ', frame)
yield frame
if not frames:
break
def decode(self, data):
try:
packet = Packet(data)
frames = self.codec.decode(packet)
except AVError as e:
logger.warning('failed to decode, skipping package: ' + str(e))
return []
return list(map(frame_from_avframe, frames))
def image_sequence_encode(self, codec_name):
try:
codec = Codec(codec_name, 'w')
except UnknownCodecError:
raise SkipTest()
container = av.open(fate_suite('h264/interlaced_crop.mp4'))
video_stream = container.streams.video[0]
width = 640
height = 480
ctx = codec.create()
pix_fmt = ctx.codec.video_formats[0].name
ctx.width = width
ctx.height = height
ctx.time_base = video_stream.codec_context.time_base
ctx.pix_fmt = pix_fmt
ctx.open()
frame_count = 1
path_list = []
for frame in iter_frames(container, video_stream):
new_frame = frame.reformat(width, height, pix_fmt)
new_packets = ctx.encode(new_frame)
self.assertEqual(len(new_packets), 1)
new_packet = new_packets[0]
path = self.sandboxed('%s/encoder.%04d.%s' % (
codec_name,
frame_count,
codec_name if codec_name != 'mjpeg' else 'jpg',
))
path_list.append(path)
with open(path, 'wb') as f:
f.write(new_packet)
frame_count += 1
if frame_count > 5:
break
ctx = av.Codec(codec_name, 'r').create()
for path in path_list:
with open(path, 'rb') as f:
size = os.fstat(f.fileno()).st_size
packet = Packet(size)
size = f.readinto(packet)
frame = ctx.decode(packet)[0]
self.assertEqual(frame.width, width)
self.assertEqual(frame.height, height)
self.assertEqual(frame.format.name, pix_fmt)
def encode_frame(self, input_frame, pts: int) -> T.Iterator[Packet]:
# for JPEG we only get a single packet per frame
packet = Packet()
packet.stream = self.video_stream
packet.payload = input_frame.jpeg_buffer
packet.time_base = self.time_base
packet.pts = pts
# TODO: check if we still need dts here, as they were removed from MPEG_Writer
packet.dts = pts
yield packet
class XMEye:
def __init__(self, ip=None, port=None):
self.model = ''
self.ip = ip
self.port = port
self.login = None
self.password = None
self.channels_count = 0
self.status = None
self.Socket = None
self.Socket2 = None
self.conn = None
self.codec_264 = CodecContext.create("h264", "r")
self.status_enum = {
None: 0,
'Wrong password': -1,
'Banned': 2
}
set_level(1)
@match_typing
def auth(self, login: str, password: str):
self.Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.conn = DVRIPClient(self.Socket)
self.Socket.settimeout(4)
try:
log_in = self.conn.connect((self.ip, self.port), login, password)
self.status = self.status_enum[log_in]
except:
return -1
finally:
self.Socket.close()
if self.status is self.status_enum[None]:
self.login = login
self.password = password
self.sys_info()
print([self.ip, self.model])
@match_typing
def get_snapshot(self, ch: int):
while True:
try:
self.Socket2 = socket.create_connection((self.ip, self.port), 6)
h264 = self.conn.monitor(self.Socket2, channel=ch, stream=Stream.HD)
break
# баг в либе [TODO]
except DVRIPRequestError:
continue
data = b''
while True:
# Ln76 adds \xff\xd9 for each chunk / frame :c
# if len(data) > 54000: # ~ SD
# break
if chunk := h264.read(1024):
data += chunk
if len(chunk) < 1024:
break
frame = self.codec_264.decode(Packet(data))
jpeg = BytesIO()
frame[0].to_image().save(jpeg, format='JPEG')
self.Socket2.close()
# if ch == self.channels_count:
# self.conn.logout()
# self.Socket.close()
return jpeg.getvalue()
