def loadVideoFromPath(path):
decoder = Y4MDecoder()
parser = y4m.Reader(decoder.incorporateFrame, verbose=False)
with open(path, 'rb') as f:
data = f.read()
parser.decode(data.decode('latin-1', errors='replace').encode('latin-1'))
return decoder.getVideo()
def test_loop_simple(self):
def process_frame(frame):
generator.encode(frame)
parser = y4m.Reader(process_frame, verbose=False)
generator = y4m.Writer(open(os.devnull, 'wb'))
with zfd.open(sample, 'r') as f:
parser.decode(f.read())
def test_read_simple(self):
self.cpt = 0
def process_frame(frame):
self.cpt += 1
parser = y4m.Reader(process_frame, verbose=False)
with zfd.open(sample, 'r') as f:
parser.decode(f.read())
self.assertEqual(self.cpt, sample_num_frames)
def decodey4m(file_queue, dstPath, threadID):
while not file_queue.empty():
f = file_queue.get(1, 5)
print("thread " + str(threadID) + ' decode ' + f)
parser = y4m.Reader(sourcePath=f, dstPath=dstPath, verbose=False)
fp = open(f, 'rb')
try:
parser.decode(fp.read())
except:
print('error ' + f)
fp.close()
def main(args):
OPENING = 'Opening %s...'
BLOCK_SIZE = 4 * 1024 * 1024
ref_parser = y4m.Reader(process_ref)
recons_parser = y4m.Reader(process_recons)
print(OPENING % args[1])
with open(args[1], 'r') as ref:
print(OPENING % args[2])
with open(args[2], 'r') as recons:
try:
ref_buf, recons_buf = ref.buffer, recons.buffer
except:
ref_buf, recons_buf = ref, recons
while True:
data = ref_buf.read(BLOCK_SIZE)
if not data: break
ref_parser.decode(data)
data = recons_buf.read(BLOCK_SIZE)
if not data: break
recons_parser.decode(data)
print('Total: %2.4f' % np.array(scores).mean())
def read_video(videopath, max_frames=100000, PIL_Image_flag=True):
"""
:param videopath: the path to the video
:param PIL_Image_flag: whether return PIL.Image.Image list
:return: PIL.image frames list or numpy.ndarray list
"""
if videopath.endswith(".y4m"):
global y4m_frames
y4m_frames = []
parser = y4m.Reader(process_y4m_frame, verbose=False)
infd = open(videopath, "rb")
with infd as f:
while True:
data = f.read(1024 * 1024)
if not data:
break
parser.decode(data)
if len(y4m_frames) == max_frames:
break
if PIL_Image_flag:
return [Image.fromarray(f) for f in y4m_frames]
else:
return y4m_frames
else:
cap = cv2.VideoCapture(videopath)
frames = []
while True:
ret, frame = cap.read()
if ret:
frames.append(frame)
# cv2.imshow('frame', frame)
# cv2.waitKey(25)
else:
break
if len(frames) == max_frames:
break
cap.release() # close vapture
for i, bgr in enumerate(frames):
frames[i] = bgr[..., ::-1]
if PIL_Image_flag:
return [Image.fromarray(f) for f in frames]
else:
return frames
def test_read_simple_1k(self):
self.cpt = 0
def process_frame(frame):
self.cpt += 1
parser = y4m.Reader(process_frame, verbose=False)
with zfd.open(sample, 'r') as f:
while True:
data = f.read(1024)
if not data:
break
parser.decode(data)
self.assertEqual(self.cpt, sample_num_frames)
def readStandardSequence(filename):
# read y4m file from the
data = raw_input(filename)
reader = y4m.Reader(verbose=True)
reader.decode(data)
def _y4m():
f = 'E:/datasets/SR/youku/youku_00000_00049_l/Youku_00000_l.y4m'
img = y4m.Reader(f)
a = 0
