def getWriter(self, name, codec):
width = int(self.reader.get(cv2api_delegate.prop_frame_width))
height = int(self.reader.get(cv2api_delegate.prop_frame_height))
fourcc = cv2api_delegate.get_fourcc(codec) if codec != 'RAW' else 0
return VideoPluginWriter(cv2api_delegate.videoWriter(
name, fourcc, (self.reader.get(cv2api_delegate.prop_fps)),
(width, height)),
clip=self.use_16)
def createMovie(name, generator, size):
from maskgen.cv2api import cv2api_delegate
f = generator()
w = cv2api_delegate.videoWriter(name,
cv2api_delegate.get_fourcc('mp4v'),
10,
f.shape[0:2][::-1],
isColor=1)
try:
for i in range(size):
w.write(f)
f = generator()
finally:
w.release()
def createOutput(in_file, out_file, timeManager, codec=None):
"""
:param in_file:
:param out_file:
:param timeManager:
:param codec:
:return:
@type in_file: str
@type out_file: str
@type timeManager: VidTimeManager
"""
logger = logging.getLogger('maskgen')
cap = cv2api_delegate.videoCapture(in_file)
fourcc = cv2api_delegate.get_fourcc(
str(codec)) if codec is not None else cap.get(
cv2api_delegate.fourcc_prop)
fps = cap.get(cv2api_delegate.prop_fps)
height = int(np.rint(cap.get(cv2api_delegate.prop_frame_height)))
width = int(np.rint(cap.get(cv2api_delegate.prop_frame_width)))
out_video = cv2api_delegate.videoWriter(out_file,
fourcc,
fps, (width, height),
isColor=1)
if not out_video.isOpened():
err = out_file + " fourcc: " + str(fourcc) + " FPS: " + str(fps) + \
" H: " + str(height) + " W: " + str(width)
raise ValueError('Unable to create video ' + err)
try:
writecount = 0
dropcount = 0
while (cap.grab()):
ret, frame = cap.retrieve()
elapsed_time = float(cap.get(cv2api_delegate.prop_pos_msec))
timeManager.updateToNow(elapsed_time)
if timeManager.isBeforeTime() or timeManager.isPastTime():
out_video.write(frame)
writecount += 1
else:
dropcount += 1
logger.debug('Drop {} frames; Wrote {} frames'.format(
dropcount, writecount))
finally:
cap.release()
out_video.release()
return dropcount
def paste(self, video_file, object, codec):
vfi = cv2api_delegate.videoCapture(video_file)
width = int(vfi.get(cv2api_delegate.prop_frame_width))
height = int(vfi.get(cv2api_delegate.prop_frame_height))
fourcc = fourccs[codec]
video_prefix = video_file[:video_file.rfind('.')]
video_file_output = video_prefix + '_paste.' + suffices[codec]
video_file_output = os.path.split(video_file_output)[1]
vfo = cv2api_delegate.videoWriter(video_file_output, fourcc, (vfi.get(cv2api_delegate.prop_fps)), (width, height))
if not vfo.isOpened():
raise ValueError('VideoWriter failed to open.')
try:
while vfi.isOpened() and vfo.isOpened():
r,f = vfi.read()
if not r:
break
i = ImageWrapper(self.paste_in(f,object),mode='BGR')
vfo.write(i.image_array)
finally:
vfi.release()
vfo.release()
self.addFileToRemove(video_file_output)
return video_file_output
def copyFrames(in_file,
out_file,
start_time,
end_time,
paste_time,
codec=None):
"""
:param in_file: is the full path of the video file from which to drop frames
:param out_file: resulting video file
:param start_time: (milli,frame no) to start to fill
:param end_time: (milli,frame no) end fil
:param codec:
:return:
"""
import time
logger = logging.getLogger('maskgen')
frames_to_write = []
frames_to_copy = []
cap = cv2api_delegate.videoCapture(in_file)
fourcc = cv2api_delegate.get_fourcc(
str(codec)) if codec is not None else cap.get(
cv2api_delegate.fourcc_prop)
fps = cap.get(cv2api_delegate.prop_fps)
height = int(np.rint(cap.get(cv2api_delegate.prop_frame_height)))
width = int(np.rint(cap.get(cv2api_delegate.prop_frame_width)))
out_video = cv2api_delegate.videoWriter(out_file,
fourcc,
fps, (width, height),
isColor=1)
if not out_video.isOpened():
err = out_file + " fourcc: " + str(fourcc) + " FPS: " + str(fps) + \
" H: " + str(height) + " W: " + str(width)
raise ValueError('Unable to create video ' + err)
copy_time_manager = VidTimeManager(startTimeandFrame=start_time,
stopTimeandFrame=end_time)
paste_time_manager = VidTimeManager(startTimeandFrame=paste_time)
write_count = 0
try:
while (not copy_time_manager.isPastTime() and cap.grab()):
ret, frame = cap.retrieve()
elapsed_time = float(cap.get(cv2api_delegate.prop_pos_msec))
copy_time_manager.updateToNow(elapsed_time)
paste_time_manager.updateToNow(elapsed_time)
if not copy_time_manager.isBeforeTime(
) and not copy_time_manager.isPastTime():
frames_to_copy.append(frame)
if not paste_time_manager.isBeforeTime():
frames_to_write.append(frame)
else:
out_video.write(frame)
write_count += 1
if logger.isEnabledFor(logging.DEBUG):
logger.debug("First to copy {}".format(
hashlib.sha256(frames_to_copy[0]).hexdigest()))
logger.debug("Last to copy {}".format(
hashlib.sha256(frames_to_copy[-1]).hexdigest()))
ImageWrapper(frames_to_copy[0]).save('first_' + str(time.clock()) +
'.png')
ImageWrapper(frames_to_copy[-1]).save('last_' + str(time.clock()) +
'.png')
if len(frames_to_write) > 0:
# paste prior to copy
for copy_frame in frames_to_copy:
out_video.write(copy_frame)
for write_frame in frames_to_write:
out_video.write(write_frame)
else:
# paste after to copy
frame = None
while (paste_time_manager.isBeforeTime() and cap.grab()):
ret, frame = cap.retrieve()
elapsed_time = float(cap.get(cv2api_delegate.prop_pos_msec))
paste_time_manager.updateToNow(elapsed_time)
if paste_time_manager.isBeforeTime():
out_video.write(frame)
write_count += 1
for copy_frame in frames_to_copy:
out_video.write(copy_frame)
if frame is not None:
out_video.write(frame)
while (cap.grab()):
ret, frame = cap.retrieve()
out_video.write(frame)
finally:
cap.release()
out_video.release()
return write_count
def smartAddFrames(in_file,
out_file,
start_time,
end_time,
codec=None,
direction='forward',
audio=False):
"""
:param in_file: is the full path of the video file from which to drop frames
:param out_file: resulting video file
:param start_time: (milli,frame no) start to fill
:param end_time: (milli,frame no) end to fill
:param codec:
:return:
"""
logger = logging.getLogger('maskgen')
if audio:
audioProcessor = maskgen.maskgen_audio.SilenceProcessor(in_file)
#Potention Add strategy if you'd want
audio_file = audioProcessor.original
maskgen.maskgen_audio.export_audio(
audio_file,
os.path.splitext(out_file)[0] + '.wav')
import time
cap = cv2api_delegate.videoCapture(in_file)
fourcc = cv2api_delegate.get_fourcc(
str(codec)) if codec is not None else cap.get(
cv2api_delegate.fourcc_prop)
fps = cap.get(cv2api_delegate.prop_fps)
height = int(np.rint(cap.get(cv2api_delegate.prop_frame_height)))
width = int(np.rint(cap.get(cv2api_delegate.prop_frame_width)))
out_video = cv2api_delegate.videoWriter(out_file,
fourcc,
fps, (width, height),
isColor=1)
time_manager = VidTimeManager(startTimeandFrame=start_time,
stopTimeandFrame=end_time)
if not out_video.isOpened():
err = out_file + " fourcc: " + str(fourcc) + " FPS: " + str(fps) + \
" H: " + str(height) + " W: " + str(width)
raise ValueError('Unable to create video ' + err)
try:
last_frame = None
frame_analyzer = FrameAnalyzer(start_time, end_time, fps)
written_count = 0
while (cap.grab()):
ret, frame = cap.retrieve()
frame_analyzer.addFrame(frame)
elapsed_time = float(cap.get(cv2api_delegate.prop_pos_msec))
time_manager.updateToNow(elapsed_time)
if not time_manager.isBeforeTime():
break
out_video.write(frame)
written_count += 1
last_frame = frame
next_frame = frame
if logger.isEnabledFor(logging.DEBUG):
logger.debug('Written {} frames '.format(written_count))
logger.debug('Smart Add Frames ' + str(start_time) + ' to ' +
str(end_time))
logger.debug("Selected Before {}".format(
hashlib.sha256(last_frame).hexdigest()))
logger.debug("Selected After {}".format(
hashlib.sha256(next_frame).hexdigest()))
ImageWrapper(last_frame).save('before_' + str(time.clock()) +
'.png')
ImageWrapper(next_frame).save('after_' + str(time.clock()) +
'.png')
logger.debug("STD after and before {}".format(
np.std(last_frame - next_frame)))
frame_analyzer.updateFlow(last_frame, next_frame, direction)
opticalFlow = kdtreeOpticalFlow(last_frame, next_frame,
frame_analyzer.jump_flow,
frame_analyzer.back_flow)
frames_to_add = frame_analyzer.framesToAdd()
lf = last_frame
written_count = 0
for i in range(1, int(frames_to_add + 1)):
frame_scale = i / (1.0 + frames_to_add)
frame = opticalFlow.setTime(frame_scale)
if logger.isEnabledFor(logging.DEBUG):
logger.debug("frame {}".format(np.std(frame - lf)))
out_video.write(frame)
lf = frame
out_video.write(next_frame)
written_count += 1
while (cap.grab()):
ret, frame = cap.retrieve()
out_video.write(frame)
written_count += 1
logger.debug('Written additioning {} frames '.format(written_count))
finally:
cap.release()
out_video.release()
if audio:
logger.debug('Recombining Audio and Video')
import maskgen.ffmpeg_api as ffmpeg
tmpvid = os.path.splitext(out_file)[0] + 'tmp' + os.path.splitext(
out_file)[1]
os.rename(out_file, tmpvid)
ffmpeg.run_ffmpeg([
'-i', tmpvid, '-i',
os.path.splitext(out_file)[0] + '.wav', '-c:v', 'rawvideo', '-c:a',
'pcm_s32le', '-r',
str(fps), out_file, '-y'
])
os.remove(tmpvid)
os.remove(os.path.splitext(out_file)[0] + '.wav')
return frames_to_add, frames_to_add * (1000.0 / fps)