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'))