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_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 __init__( # pylint: disable = too-many-arguments, too-many-locals, too-many-branches, too-many-statements self, source=0, y_tube=False, backend=0, colorspace=None, logging=False, time_delay=0, transform=None, downsample=None, buffer_size=96, **options ): if downsample is None: downsample = 1 self.downsample = downsample self.buffer_size = buffer_size # enable logging if specified self.__logging = False self.transform = transform if logging: self.__logging = logging # check if Youtube Mode is ON (True) if y_tube: try: # import pafy and parse youtube stream url import pafy #pylint: disable = import-outside-toplevel # validate video_url = youtube_url_validator(source) if video_url: source_object = pafy.new(video_url) vo_source = source_object.getbestvideo("webm", ftypestrict=True) va_source = source_object.getbest("webm", ftypestrict=False) # select the best quality if vo_source is None or ( va_source.dimensions >= vo_source.dimensions ): source = va_source.url else: source = vo_source.url if self.__logging: LOGGER.debug( "YouTube source ID: %s, Title: %s", video_url, source_object.title ) else: raise RuntimeError( "Invalid `{}` Youtube URL cannot be processed!".format(source) ) except Exception as exc: if self.__logging: LOGGER.exception(str(exc)) raise ValueError( "[CamGear:ERROR] :: YouTube Mode is enabled and the input YouTube URL is " "incorrect!" ) # youtube mode variable initialization self.__youtube_mode = y_tube # assigns special parameter to global variable and clear self.__threaded_queue_mode = options.pop("THREADED_QUEUE_MODE", True) if not isinstance(self.__threaded_queue_mode, bool): # reset improper values self.__threaded_queue_mode = True self.__queue = None # initialize deque for video files only if self.__threaded_queue_mode and isinstance(source, str): # import deque from collections import deque #pylint: disable = import-outside-toplevel # define deque and assign it to global var # max len self.buffer_size to check overflow self.__queue = deque(maxlen=self.buffer_size) # log it if self.__logging: LOGGER.debug( "Enabling Threaded Queue Mode for the current video source!" ) else: # otherwise disable it self.__threaded_queue_mode = False # log it if self.__logging: LOGGER.warning( "Threaded Queue Mode is disabled for the current video source!" ) # stream variable initialization self.stream = None if backend and isinstance(backend, int): # add backend if specified and initialize the camera stream if check_CV_version() == 3: # Different OpenCV 3.4.x statement self.stream = cv2.VideoCapture(source + backend) else: # Two parameters are available since OpenCV 4+ (master branch) self.stream = cv2.VideoCapture(source, backend) LOGGER.debug("Setting backend %s for this source.", backend) else: # initialize the camera stream self.stream = cv2.VideoCapture(source) # initializing colorspace variable self.color_space = None # apply attributes to source if specified options = {str(k).strip(): v for k, v in options.items()} for key, value in options.items(): propty = capPropId(key) if not (propty is None): self.stream.set(propty, value) # handle colorspace value if not (colorspace is None): self.color_space = capPropId(colorspace.strip()) if self.__logging and not (self.color_space is None): LOGGER.debug( "Enabling %s colorspace for this video stream!", colorspace.strip() ) # initialize and assign frame-rate variable self.framerate = 0.0 _fps = self.stream.get(cv2.CAP_PROP_FPS) if _fps > 1.0: self.framerate = _fps # applying time delay to warm-up webcam only if specified if time_delay: time.sleep(time_delay) # frame variable initialization (grabbed, self.frame) = self.stream.read() # check if valid stream if grabbed: # render colorspace if defined if not (self.color_space is None): self.frame = cv2.cvtColor(self.frame, self.color_space) if self.__threaded_queue_mode: if self.transform: try: self.frame = self.transform(self.frame) except AttributeError: LOGGER.error( "[slave thread] Failed to transform the input video frame. " "Setting stop state of reader.", exc_info=True) self.__terminate = True return # initialize and append to queue self.__queue.append(self.frame) else: raise RuntimeError( "[CamGear:ERROR] :: Source is invalid, CamGear failed to intitialize stream on " "this source!" ) # thread initialization self.__thread = None # initialize termination flag self.__terminate = False