def test_WriteGear_customFFmpeg(ffmpeg_command_to_save_audio, logging):
"""
Testing WriteGear Compression-Mode(FFmpeg) custom FFmpeg Pipeline by seperating audio from video
"""
try:
# define writer
writer = WriteGear(
output_filename="Output.mp4",
compression_mode=(True if ffmpeg_command_to_save_audio else False),
logging=logging,
) # Define writer
# execute FFmpeg command
writer.execute_ffmpeg_cmd(ffmpeg_command_to_save_audio)
# assert audio file is created successfully
if ffmpeg_command_to_save_audio and isinstance(
ffmpeg_command_to_save_audio, list):
assert os.path.isfile("input_audio.aac")
except Exception as e:
if isinstance(e, AssertionError):
pytest.fail(str(e))
elif isinstance(e, ValueError):
pytest.xfail("Test Passed!")
else:
logger.exception(str(e))
def record_btn_press(self, instance):
if not self.state:
self.state_label.text = 'Record'
self.record_btn.text = 'Stop Record'
self.start_time = datetime.datetime.now()
self.stream = ScreenGear(monitor=1,
**{
'THREADED_QUEUE_MODE': False
}).start()
output_params = {
'-vcodec': 'libx264',
'-crf': 0,
'-preset': 'fast'
}
self.video_path = get_path('video', parent=True) + '/' + \
self.start_time.strftime("%Y-%m-%d %H_%M_%S.mp4")
self.writer = WriteGear(output_filename=self.video_path,
compression_mode=True,
**output_params)
self.count = 0
self.count_frames = 0
self.timer = TimerThread(self.interval, self.record_image)
self.timer.start()
else:
self.timer.stopped.set()
self.state_label.text = 'Idle'
self.record_btn.text = 'Start Record'
self.stream.stop()
self.stream = None
self.writer.close()
self.writer = None
self.start_time = None
self.state = not self.state
def start_rec_callback(self):
"""Allows the user to record a video which is saved to the `calibration
videos` folder of the data output directory."""
if not self.streaming:
self.config['CameraSettings']['num_cams'] = int(self.num_cams.get())
self.config['CameraSettings']['fps'] = int(self.fps.get())
self.config['CameraSettings']['exposure'] = int(self.exposure.get())
self.config['CameraSettings']['gain'] = float(self.gain.get())
self.config['CameraSettings']['trigger_source'] = self.trigger_source.get()
self.config['CameraSettings']['gpo_mode'] = self.gpo_mode.get()
self.config['CameraSettings']['img_width'] = int(self.img_width.get())
self.config['CameraSettings']['img_height'] = int(self.img_height.get())
self.config['CameraSettings']['offset_x'] = int(self.offset_x.get())
self.config['CameraSettings']['offset_y'] = int(self.offset_y.get())
self.output_params = (self.config['CameraSettings']['num_cams']*
self.config['CameraSettings']['img_width'],self.config['CameraSettings']['img_height'])
self.config['CameraSettings']['output_params'] = self.output_params
self.cams = camint.start_interface(self.config)
self.cams_connected = True
self.img = camint.init_image()
self.calibration_path = self.config['ReachMaster']['data_dir'] + "/calibration_videos/"
if not os.path.isdir(self.calibration_path):
os.makedirs(self.calibration_path)
self.vid_fn = self.calibration_path + str(datetime.datetime.now()) + '.mp4'
self.video = WriteGear(
output_filename = self.vid_fn,
compression_mode = True,
logging=False,
**self.output_params)
self.delay = int(np.round(1.0/float(self.config['CameraSettings']['fps'])*1000.0))
self.record = True
self._rec()
else:
tkMessageBox.showinfo("Warning", "Shouldn't record while streaming. Bad framerates!")
class VideoBuilder:
def __init__(self, filename, width, height, fps):
self.closed = False
self.filepath = '{}.mp4'.format(filename)
output_parameters = {
"-vcodec":"libx264",
"-movflags": "+dash",
"-input_framerate": fps,
"-output_dimensions": (width, height)
}
self._writer = WriteGear(output_filename=self.filepath,
**output_parameters)
self._frame_count = 0
self.fps = fps
def add_frame(self, frame):
assert not self.closed, "Can't add frame to closed VideoBuilder!"
self._writer.write(frame)
self._frame_count += 1
def duration(self):
return round(self._frame_count / self.fps, 3)
def close(self):
self.closed = True
self._writer.close()
def _init_special_protocol(self):
if self.config['Protocol']['type'] == 'CONTINUOUS':
self.vid_fn = self.video_data_path + str(datetime.datetime.now()) + '.mp4'
self.video = WriteGear(
output_filename = self.vid_fn,
compression_mode = True,
logging=False,
**self.output_params)
self.video_open = True
elif self.config['Protocol']['type'] == 'TRIALS':
self.img_buffer = deque()
def test_fail_framechannels(compression_mode):
"""
IO Test - made to fail with multiple frame channels
"""
np.random.seed(0)
# generate random data for 10 frames
random_data1 = np.random.random(size=(480, 640, 3)) * 255
input_data1 = random_data1.astype(np.uint8)
np.random.seed(0)
random_data2 = np.random.random(size=(480, 640, 4)) * 255
input_data2 = random_data2.astype(np.uint8)
writer = None
try:
writer = WriteGear("output.mp4", compression_mode=compression_mode)
writer.write(None)
writer.write(input_data1)
writer.write(input_data2)
except Exception as e:
if isinstance(e, ValueError):
pytest.xfail("Test Passed!")
else:
pytest.fail(str(e))
finally:
if not writer is None:
writer.close()
def test_write(conversion):
"""
Testing WriteGear Compression-Mode(FFmpeg) Writer capabilties in different colorspace
"""
#Open stream
stream = CamGear(source=return_testvideo_path(), colorspace = conversion, logging=True).start()
writer = WriteGear(output_filename = 'Output_tw.mp4', custom_ffmpeg = return_static_ffmpeg()) #Define writer
while True:
frame = stream.read()
# check if frame is None
if frame is None:
#if True break the infinite loop
break
if conversion in ['COLOR_BGR2RGB', 'COLOR_BGR2RGBA']:
writer.write(frame, rgb_mode = True)
else:
writer.write(frame)
stream.stop()
writer.close()
basepath, _ = os.path.split(return_static_ffmpeg())
ffprobe_path = os.path.join(basepath,'ffprobe.exe' if os.name == 'nt' else 'ffprobe')
result = check_output([ffprobe_path, "-v", "error", "-count_frames", "-i", os.path.abspath('Output_tw.mp4')])
if result:
if not isinstance(result, string_types):
result = result.decode()
logger.debug('Result: {}'.format(result))
for i in ["Error", "Invalid", "error", "invalid"]:
assert not(i in result)
os.remove(os.path.abspath('Output_tw.mp4'))
def test_write(conversion):
"""
Testing Compression Mode(FFmpeg) Writer capabilties in different colorspace
"""
stream = cv2.VideoCapture(return_testvideo_path(
)) #Open live webcam video stream on first index(i.e. 0) device
writer = WriteGear(output_filename='Output_tw.mp4',
custom_ffmpeg=return_static_ffmpeg()) #Define writer
while True:
(grabbed, frame) = stream.read()
if not grabbed:
break
if conversion:
frame = cv2.cvtColor(frame, capPropId(conversion))
if conversion in ['COLOR_BGR2RGB', 'COLOR_BGR2RGBA']:
writer.write(frame, rgb_mode=True)
else:
writer.write(frame)
stream.release()
writer.close()
basepath, _ = os.path.split(return_static_ffmpeg())
ffprobe_path = os.path.join(
basepath, 'ffprobe.exe' if os.name == 'nt' else 'ffprobe')
result = check_output([
ffprobe_path, "-v", "error", "-count_frames", "-i",
os.path.abspath('Output_tw.mp4')
])
if result:
if not isinstance(result, string_types):
result = result.decode()
print('Result: {}'.format(result))
for i in ["Error", "Invalid", "error", "invalid"]:
assert not (i in result)
os.remove(os.path.abspath('Output_tw.mp4'))
def test_paths(compression_mode, path):
"""
Paths Test - Test various paths/urls supported by WriteGear.
"""
writer = None
try:
writer = WriteGear(path, compression_mode=compression_mode)
except Exception as e:
if isinstance(e, ValueError):
pytest.xfail("Test Passed!")
else:
pytest.fail(str(e))
finally:
if not writer is None:
writer.close()
def __init__(self, filename, width, height, fps):
self.closed = False
self.filepath = '{}.mp4'.format(filename)
output_parameters = {
"-vcodec":"libx264",
"-movflags": "+dash",
"-input_framerate": fps,
"-output_dimensions": (width, height)
}
self._writer = WriteGear(output_filename=self.filepath,
**output_parameters)
self._frame_count = 0
self.fps = fps
def test_WriteGear_customFFmpeg(): """ Testing WriteGear Compression-Mode(FFmpeg) custom FFmpeg Pipeline by seperating audio from video """ output_audio_filename = 'input_audio.aac' #define writer writer = WriteGear(output_filename = 'Output.mp4', logging = True) #Define writer #save stream audio as 'input_audio.aac' ffmpeg_command_to_save_audio = ['-y', '-i', return_testvideo_path(), '-vn', '-acodec', 'copy', output_audio_filename] # `-y` parameter is to overwrite outputfile if exists #execute FFmpeg command writer.execute_ffmpeg_cmd(ffmpeg_command_to_save_audio) #assert audio file is created successfully assert os.path.isfile(output_audio_filename)
def mainrun(input):
"""
Main video splitting function w/ VideoGear (uses ffmpeg conversions)
Parameters
----------
input : input filename or filepath
Returns
-------
"""
intput_filename = input
no_of_cam = 3
crf = '25'
pix_Format = 'yuv420p'
cap = cv2.VideoCapture(intput_filename)
if (cap.isOpened() == False):
print("Error opening video file")
fps = int(cap.get(5))
width = int(cap.get(3) / no_of_cam)
height = int(cap.get(4))
output_params = {'-c:v': 'h264', '-crf': crf, '-input_framerate': fps, '-pix_fmt': pix_Format, \
'-preset': 'fast', '-tune': 'zerolatency', '-output_dimensions': (width, height)}
print('Start converting... ', end='', flush=True)
writers = []
for i in range(no_of_cam):
output_filename = intput_filename.split('.')[0] + '_cam' + str(
i + 1) + '.mp4'
writers.append(WriteGear(output_filename=output_filename, compression_mode=True, \
logging=False, **output_params))
while (cap.isOpened()):
ret, frame = cap.read()
if ret == True:
for i, w in enumerate(writers):
index = range(width * i, width * i + width)
frame_ = frame[:, index]
frame_ = conver2bgr(frame_)
frame_ = enhanceImage(frame_)
w.write(frame_)
else:
break
for w in writers:
w.close()
cap.release()
cv2.destroyAllWindows()
print('[DONE]')
def videowriter(self, frame, date = None):
if self.lasttriggercount == 0 and self.triggercounter > 0:
path = 'C:/Users/Pat/.spyder-py3/ImageData/videos/'
output_params = {"-vcodec":"libx264", "-input_framerate":3} #"-crf": 0, "-preset": "fast", "-tune": "zerolatency",
self.writer = WriteGear(output_filename = os.path.join(path , '{}.mp4'.format(date)), **output_params)
self.writer.write(frame)
#start video recording
return None
elif self.lasttriggercount > 0 and self.triggercounter > 0:
self.writer.write(frame)
#keep recording
return None
elif self.lasttriggercount > 0 and self.triggercounter ==0:
self.writer.write(frame)
self.writer.close()
self.writer = None
#close recording
return None
else:
return None
def test_WriteGear_compression(f_name, output_params, result):
"""
Testing VidGear Non-Compression(OpenCV) Mode with different parameters
"""
try:
stream = cv2.VideoCapture(return_testvideo_path())
writer = WriteGear(
output_filename=f_name,
compression_mode=False,
logging=True,
**output_params
)
while True:
(grabbed, frame) = stream.read()
if not grabbed:
break
writer.write(frame)
stream.release()
writer.close()
remove_file_safe(f_name)
except Exception as e:
if result:
pytest.fail(str(e))
else:
logger.exception(str(e))
def test_output_dimensions():
"""
Testing "-output_dimensions" special parameter provided by WriteGear(in Compression Mode)
"""
dimensions = (640, 480)
stream = cv2.VideoCapture(return_testvideo_path())
output_params = {"-output_dimensions": dimensions}
writer = WriteGear(output_filename='Output_tod.mp4',
custom_ffmpeg=return_static_ffmpeg(),
logging=True,
**output_params) #Define writer
while True:
(grabbed, frame) = stream.read()
if not grabbed:
break
writer.write(frame)
stream.release()
writer.close()
output = cv2.VideoCapture(os.path.abspath('Output_tod.mp4'))
output_dim = (output.get(cv2.CAP_PROP_FRAME_WIDTH),
output.get(cv2.CAP_PROP_FRAME_HEIGHT))
assert output_dim[0] == 640 and output_dim[1] == 480
output.release()
os.remove(os.path.abspath('Output_tod.mp4'))
def test_WriteGear_customFFmpeg(ffmpeg_cmd, logging, output_params):
"""
Testing WriteGear Compression-Mode(FFmpeg) custom FFmpeg Pipeline by seperating audio from video
"""
writer = None
try:
# define writer
writer = WriteGear(
output_filename="Output.mp4",
compression_mode=(True if ffmpeg_cmd != ["invalid"] else False),
logging=logging,
**output_params) # Define writer
# execute FFmpeg command
writer.execute_ffmpeg_cmd(ffmpeg_cmd)
writer.close()
# assert audio file is created successfully
if ffmpeg_cmd and isinstance(ffmpeg_cmd,
list) and "-acodec" in ffmpeg_cmd:
assert os.path.isfile("input_audio.aac")
except Exception as e:
if isinstance(e, AssertionError):
pytest.fail(str(e))
elif isinstance(e, (ValueError, RuntimeError)):
pytest.xfail("Test Passed!")
else:
logger.exception(str(e))
def test_output_dimensions():
"""
Testing "-output_dimensions" special parameter provided by WriteGear(in Compression Mode)
"""
dimensions = (640, 480)
stream = cv2.VideoCapture(return_testvideo_path())
output_params = {}
if platform.system() == "Windows":
output_params = {
"-output_dimensions": dimensions,
"-ffmpeg_download_path": tempfile.gettempdir(),
}
else:
output_params = {"-output_dimensions": dimensions}
writer = WriteGear(output_filename="Output_tod.mp4",
custom_ffmpeg=return_static_ffmpeg(),
logging=True,
**output_params) # Define writer
while True:
(grabbed, frame) = stream.read()
if not grabbed:
break
writer.write(frame)
stream.release()
writer.close()
output = cv2.VideoCapture(os.path.abspath("Output_tod.mp4"))
output_dim = (
output.get(cv2.CAP_PROP_FRAME_WIDTH),
output.get(cv2.CAP_PROP_FRAME_HEIGHT),
)
assert output_dim[0] == 640 and output_dim[1] == 480
output.release()
remove_file_safe("Output_tod.mp4")
def beginRecording(button):
global fileNameList
global writer1
global writer2
global video_streams
# start streams
stream1 = video_streams[len(video_streams) - 2] # penultimate stream
stream2 = video_streams[len(video_streams) - 1] # ultimate stream
stream1.start()
stream2.start()
fileNameList = compute.getNewFileNames()
print(fileNameList)
writer1 = WriteGear(output_filename=fileNameList[0], **output_params1)
writer2 = WriteGear(output_filename=fileNameList[1], **output_params2)
change_LED(255, 0, 0) # Red LED to indicate recording
while True:
frameA = stream1.read()
# read frames from stream1
frameB = stream2.read()
# read frames from stream2
print("stream1.framerate:" + str(stream1.framerate))
print("stream2.framerate:" + str(stream2.framerate))
# check if any of two frame is None
if frameA is None or frameB is None:
#if True break the infinite loop
break
#cv2.imshow("Output Frame1", frameA)
#cv2.imshow("Output Frame2", frameB)
# Show output window of stream1 and stream 2 seperately
writer1.write(frameA)
writer2.write(frameB)
# If button is pressed, exit recording
if button.is_pressed:
time.sleep(0.5)
print("Stop Recording!")
change_LED(255, 165, 0)
global endTime
endTime = time.time()
break
def test_input_framerate(c_ffmpeg):
"""
Testing "-input_framerate" parameter provided by WriteGear(in Compression Mode)
"""
stream = cv2.VideoCapture(return_testvideo_path()) # Open stream
test_video_framerate = stream.get(cv2.CAP_PROP_FPS)
output_params = (
{"-input_framerate": test_video_framerate}
if (c_ffmpeg != "wrong_path")
else {"-input_framerate": "wrong_input"}
)
writer = WriteGear(
output_filename="Output_tif.mp4",
custom_ffmpeg=c_ffmpeg,
logging=True,
**output_params
) # Define writer
while True:
(grabbed, frame) = stream.read()
if not grabbed:
break
writer.write(frame)
stream.release()
writer.close()
output_video_framerate = getFrameRate(os.path.abspath("Output_tif.mp4"))
assert test_video_framerate == output_video_framerate
os.remove(os.path.abspath("Output_tif.mp4"))
def test_write(conversion):
"""
Testing VidGear Non-Compression(OpenCV) Mode Writer
"""
stream = cv2.VideoCapture(return_testvideo_path())
writer = WriteGear(output_filename = 'Output_twc.avi', compression_mode = False) #Define writer
while True:
(grabbed, frame) = stream.read()
# read frames
# check if frame empty
if not grabbed:
#if True break the infinite loop
break
if conversion:
frame = cv2.cvtColor(frame, capPropId(conversion))
writer.write(frame)
stream.release()
writer.close()
basepath, _ = os.path.split(return_static_ffmpeg())
ffprobe_path = os.path.join(basepath,'ffprobe.exe' if os.name == 'nt' else 'ffprobe')
result = check_output([ffprobe_path, "-v", "error", "-count_frames", "-i", os.path.abspath('Output_twc.avi')])
if result:
if not isinstance(result, string_types):
result = result.decode()
print('Result: {}'.format(result))
for i in ["Error", "Invalid", "error", "invalid"]:
assert not(i in result)
os.remove(os.path.abspath('Output_twc.avi'))
def test_failedextension():
"""
IO Test - made to fail with filename with wrong extention
"""
np.random.seed(0)
# generate random data for 10 frames
random_data = np.random.random(size=(10, 1080, 1920, 3)) * 255
input_data = random_data.astype(np.uint8)
# 'garbage' extension does not exist
with pytest.raises(ValueError):
writer = WriteGear("garbage.garbage")
writer.write(input_data)
writer.close()
def test_assertfailedwrite():
"""
IO Test - made to fail with Wrong Output file path
"""
np.random.seed(0)
# generate random data for 10 frames
random_data = np.random.random(size=(10, 1080, 1920, 3)) * 255
input_data = random_data.astype(np.uint8)
with pytest.raises(AssertionError):
# wrong folder path does not exist
writer = WriteGear("wrong_path/output.mp4")
writer.write(input_data)
writer.close()
def test_failedchannels():
"""
IO Test - made to fail with invalid channel length
"""
np.random.seed(0)
# generate random data for 10 frames
random_data = np.random.random(size=(480, 640, 5)) * 255
input_data = random_data.astype(np.uint8)
# 'garbage' extension does not exist
with pytest.raises(ValueError):
writer = WriteGear("output.mp4")
writer.write(input_data)
writer.close()
def test_invalid_params():
"""
Invalid parameter Failure Test - Made to fail by calling invalid parameters
"""
np.random.seed(0)
# generate random data for 10 frames
random_data = np.random.random(size=(480, 640, 3)) * 255
input_data = random_data.astype(np.uint8)
with pytest.raises(ValueError):
output_params = {"-vcodec": "unknown"}
writer = WriteGear(
"output.mp4", compression_mode=True, logging=True, **output_params
)
writer.write(input_data)
writer.write(input_data)
writer.close()
def capture():
global capture_state
global del_it
global start
# while in not_exit mode
while capture_state != 2:
out_file = str(start)
# capture mode
if capture_state == 1:
log_scripts.log_msg('capturing : '+out_file)
out_file = 'data\\'+out_file
vid_out = WriteGear(out_file+'.avi',compression_mode=False,
custom_ffmpeg='C:\Program Files (x86)\ffmpeg\bin',**output_params)
txt_out = open(out_file+'.txt', 'w')
# capture 512 frames, or stop if altered
cnt = 0
while cnt <= 512 and not del_it:
vid_out.write(video_scripts.get_state())
txt_out.write(key_scripts.get_state())
cnt = cnt + 1
vid_out.close()
txt_out.close()
# if delete
if del_it:
os.remove(out_file+'.avi')
os.remove(out_file+'.txt')
del_it = 0
capture_state = 0
log_scripts.log_msg('deleting : '+out_file)
log_scripts.log_msg('state : False')
log_scripts.log_msg('Capturing : Stop')
else:
log_scripts.log_msg('saving : '+out_file)
start = start + 1
else:
log_scripts.log_msg('at hold')
time.sleep(2)
log_scripts.log_msg('capture thread exited')
exit()
def test_input_framerate():
"""
Testing "-input_framerate" parameter provided by WriteGear(in Compression Mode)
"""
stream = cv2.VideoCapture(return_testvideo_path()) #Open stream
test_video_framerate = stream.get(cv2.CAP_PROP_FPS)
output_params = {"-input_framerate":test_video_framerate}
writer = WriteGear(output_filename = 'Output_tif.mp4', custom_ffmpeg = return_static_ffmpeg(), **output_params) #Define writer
while True:
(grabbed, frame) = stream.read()
if not grabbed:
break
writer.write(frame)
stream.release()
writer.close()
output_video_framerate = getFrameRate(os.path.abspath('Output_tif.mp4'))
assert test_video_framerate == output_video_framerate
os.remove(os.path.abspath('Output_tif.mp4'))
def test_WriteGear_compression(f_name, c_ffmpeg, output_params, result): """ Testing WriteGear Compression-Mode(FFmpeg) with different parameters """ try: stream = cv2.VideoCapture(return_testvideo_path()) #Open stream writer = WriteGear(output_filename = f_name, compression_mode = True, **output_params) while True: (grabbed, frame) = stream.read() if not grabbed: break writer.write(frame) stream.release() writer.close() if f_name and f_name != tempfile.gettempdir(): os.remove(os.path.abspath(f_name)) except Exception as e: if result: pytest.fail(str(e))
def test_invalid_encoder(v_codec):
"""
Invalid encoder Failure Test
"""
np.random.seed(0)
# generate random data for 10 frames
random_data = np.random.random(size=(480, 640, 3)) * 255
input_data = random_data.astype(np.uint8)
try:
output_params = {"-vcodec": v_codec}
writer = WriteGear("output.mp4",
compression_mode=True,
logging=True,
**output_params)
writer.write(input_data)
writer.write(input_data)
writer.close()
except Exception as e:
pytest.fail(str(e))
def Videowriter_compression_mode(path):
"""
Function to Benchmark VidGearwriter - (Compression Mode: FFmpeg)
"""
stream = VideoGear(source=path).start()
writer = WriteGear(output_filename = 'Output_vc.mp4', custom_ffmpeg = return_static_ffmpeg())
fps_Vid = FPS().start()
while True:
frame = stream.read()
if frame is None:
break
writer.write(frame)
fps_Vid.update()
fps_Vid.stop()
stream.stop()
writer.close()
print("FFmpeg Writer")
print("[LOG] total elasped time: {:.2f}".format(fps_Vid.total_time_elapsed()))
print("[LOG] approx. FPS: {:.2f}".format(fps_Vid.fps()))
os.remove(os.path.abspath('Output_vc.mp4'))
def Videowriter_non_compression_mode(path):
"""
Function to Benchmark VidGearwriter - (Non-Compression Mode: OpenCV)
"""
stream = VideoGear(source=path).start()
writer = WriteGear(output_filename = 'Output_vnc.mp4', compression_mode = False )
fps_CV = FPS().start()
while True:
frame = stream.read()
if frame is None:
break
writer.write(frame)
fps_CV.update()
fps_CV.stop()
stream.stop()
writer.close()
print("OpenCV Writer")
print("[LOG] total elasped time: {:.2f}".format(fps_CV.total_time_elapsed()))
print("[LOG] approx. FPS: {:.2f}".format(fps_CV.fps()))
os.remove(os.path.abspath('Output_vnc.mp4'))
