def __init__(
self,
path: typing.Union[str, os.PathLike],
pre_load: bool = None,
fps: int = None,
*_,
**__,
):
assert os.path.isfile(path), f"video [{path}] not existed"
self.path: str = str(path)
self.data: typing.Optional[typing.Tuple[VideoFrame]] = tuple()
self._hook_list: typing.List["BaseHook"] = []
self.fps: int = fps
if fps:
video_path = os.path.join(tempfile.mkdtemp(), f"tmp_{fps}.mp4")
logger.debug(f"convert video, and bind path to {video_path}")
toolbox.fps_convert(fps, self.path, video_path, constants.FFMPEG)
self.path = video_path
with toolbox.video_capture(self.path) as cap:
self.frame_count = toolbox.get_frame_count(cap)
self.frame_size = toolbox.get_frame_size(cap)
if pre_load:
self.load_frames()
logger.info(
f"video object generated, length: {self.frame_count}, size: {self.frame_size}"
)
def __init__(self, path: typing.Union[bytes, str, os.PathLike], *_, **__):
assert os.path.isfile(path), f"video [{path}] not existed"
self.path: str = str(path)
self.data: typing.Optional[typing.Tuple[VideoFrame]] = tuple()
with toolbox.video_capture(path) as cap:
self.frame_count = toolbox.get_frame_count(cap)
self.frame_size = toolbox.get_frame_size(cap)
def __init__(self, path: str = None, *_, **__):
assert os.path.isfile(path), f"video [{path}] not existed"
self.path = path
self.data: typing.Tuple[VideoFrame] = tuple()
with toolbox.video_capture(path) as cap:
self.frame_count = toolbox.get_frame_count(cap)
self.frame_size = toolbox.get_frame_size(cap)
def __init__(self,
path: str = None,
*_, **__):
assert os.path.isfile(path), f'video [{path}] not existed'
self.path = path
with toolbox.video_capture(path) as cap:
self.frame_count = toolbox.get_frame_count(cap)
self.frame_size = toolbox.get_frame_size(cap)
def convert_video_into_ssim_list(
self, video_path: str) -> typing.List[VideoCutRange]:
ssim_list = list()
with toolbox.video_capture(video_path) as cap:
# get video info
frame_count = toolbox.get_frame_count(cap)
frame_size = toolbox.get_frame_size(cap)
logger.debug(
f'total frame count: {frame_count}, size: {frame_size}')
# load the first two frames
_, start = cap.read()
start_frame_id = toolbox.get_current_frame_id(cap)
toolbox.video_jump(cap, self.step)
ret, end = cap.read()
end_frame_id = toolbox.get_current_frame_id(cap)
# compress
start = toolbox.compress_frame(start,
compress_rate=self.compress_rate)
while ret:
end = toolbox.compress_frame(end,
compress_rate=self.compress_rate)
ssim = toolbox.compare_ssim(start, end)
logger.debug(
f'ssim between {start_frame_id} & {end_frame_id}: {ssim}')
ssim_list.append(
VideoCutRange(
video_path,
start=start_frame_id,
end=end_frame_id,
ssim=ssim,
))
# load the next one
start = end
start_frame_id, end_frame_id = end_frame_id, end_frame_id + self.step
toolbox.video_jump(cap, end_frame_id)
ret, end = cap.read()
return ssim_list
def convert_video_into_ssim_list(self, video_path: str, block: int = None, **kwargs) -> typing.List[VideoCutRange]:
if not block:
block = 1
ssim_list = list()
with toolbox.video_capture(video_path) as cap:
# get video info
frame_count = toolbox.get_frame_count(cap)
frame_size = toolbox.get_frame_size(cap)
logger.debug(f'total frame count: {frame_count}, size: {frame_size}')
# load the first two frames
_, start = cap.read()
start_frame_id = toolbox.get_current_frame_id(cap)
start_frame_time = toolbox.get_current_frame_time(cap)
toolbox.video_jump(cap, self.step + 1)
ret, end = cap.read()
end_frame_id = toolbox.get_current_frame_id(cap)
end_frame_time = toolbox.get_current_frame_time(cap)
# compress
start = toolbox.compress_frame(start, **kwargs)
# split func
# width > height
if frame_size[0] > frame_size[1]:
split_func = np.hsplit
else:
split_func = np.vsplit
logger.debug(f'split function: {split_func.__name__}')
while ret:
end = toolbox.compress_frame(end, **kwargs)
ssim = 0
start_part_list = split_func(start, block)
end_part_list = split_func(end, block)
for part_index, (each_start, each_end) in enumerate(zip(start_part_list, end_part_list)):
part_ssim = toolbox.compare_ssim(each_start, each_end)
ssim += part_ssim
logger.debug(f'part {part_index}: {part_ssim}')
ssim = ssim / block
logger.debug(f'ssim between {start_frame_id} & {end_frame_id}: {ssim}')
ssim_list.append(
VideoCutRange(
video_path,
start=start_frame_id,
end=end_frame_id,
ssim=[ssim],
start_time=start_frame_time,
end_time=end_frame_time,
)
)
# load the next one
start = end
start_frame_id, end_frame_id = end_frame_id, end_frame_id + self.step
start_frame_time = end_frame_time
toolbox.video_jump(cap, end_frame_id)
ret, end = cap.read()
end_frame_time = toolbox.get_current_frame_time(cap)
return ssim_list
