def __init__(self, file_path, container_format, container_format_profile): self._path = file_path self._tracks_by_type = None self._ffmpeg = Ffmpeg() # TODO singleton if File._format_signatures is None: formats = {} for file_format, (_, _, signatures) in self._FORMATS_INFO.iteritems(): for signature in signatures: formats[signature] = file_format File._format_signatures = formats self._format = File._format_signatures[(container_format, container_format_profile)]
def __init__(self): QObject.__init__(self) self.app_running = True self.ff = Ffmpeg() self.folders = set(Folders) self.files = files_list.Files self.filesPrevCount = 0 self.now_crawling = True self.prop = 0 self.has_booted = False self._sub_files = [] self._prep_file = "" self.prep_file_index = 0 self._prep_folder = "" self._supported_ext = ('.mp3', '.aac', '.wav', '.m4a', '.ogg')
def __init__(self): """ """ QObject.__init__(self) self.file = '' self.file_size = 0 self.app_running = True self._not_paused = True self._not_stopped = False self.t_size = 0 self.tt_played = 0 self.volume_val = 1.4 self.ff = Ffmpeg() print(threading.enumerate())
def __init__(self, parent_path, parent_format, ffm_data, codec_props): self._parent_path = parent_path self._parent_format = parent_format self._ffm_data = ffm_data self._ffmpeg = Ffmpeg() # TODO pass from outside self._duration = None self._codec_enums = {} self._codec_ids = {} self._codec_names = {} self._codec_file_extensions = {} for codec_enum, (codec_id, codec_name, codec_file_extension) in codec_props.iteritems(): self._codec_enums[codec_id] = codec_enum self._codec_ids[codec_enum] = codec_id self._codec_names[codec_enum] = codec_name self._codec_file_extensions[codec_enum] = codec_file_extension
def run(self): """ Main controller for Video2X This function controls the flow of video conversion and handles all necessary functions. """ # parse arguments for waifu2x # check argument sanity self._check_arguments() # convert paths to absolute paths self.input_video = self.input_video.absolute() self.output_video = self.output_video.absolute() # initialize objects for ffmpeg and waifu2x-caffe fm = Ffmpeg(self.ffmpeg_settings, self.image_format) # extract frames from video fm.extract_frames(self.input_video, self.extracted_frames) Avalon.info('Reading video information') video_info = fm.get_video_info(self.input_video) # analyze original video with ffprobe and retrieve framerate # width, height = info['streams'][0]['width'], info['streams'][0]['height'] # find index of video stream video_stream_index = None for stream in video_info['streams']: if stream['codec_type'] == 'video': video_stream_index = stream['index'] break # exit if no video stream found if video_stream_index is None: Avalon.error('Aborting: No video stream found') raise StreamNotFoundError('no video stream found') # get average frame rate of video stream framerate = float( Fraction( video_info['streams'][video_stream_index]['avg_frame_rate'])) fm.pixel_format = video_info['streams'][video_stream_index]['pix_fmt'] # get a dict of all pixel formats and corresponding bit depth pixel_formats = fm.get_pixel_formats() # try getting pixel format's corresponding bti depth try: self.bit_depth = pixel_formats[fm.pixel_format] except KeyError: Avalon.error(f'Unsupported pixel format: {fm.pixel_format}') raise UnsupportedPixelError( f'unsupported pixel format {fm.pixel_format}') Avalon.info(f'Framerate: {framerate}') # width/height will be coded width/height x upscale factor if self.scale_ratio: original_width = video_info['streams'][video_stream_index]['width'] original_height = video_info['streams'][video_stream_index][ 'height'] self.scale_width = int(self.scale_ratio * original_width) self.scale_height = int(self.scale_ratio * original_height) # upscale images one by one using waifu2x Avalon.info('Starting to upscale extracted images') self._upscale_frames() Avalon.info('Upscaling completed') # frames to Video Avalon.info('Converting extracted frames into video') # use user defined output size fm.convert_video(framerate, f'{self.scale_width}x{self.scale_height}', self.upscaled_frames) Avalon.info('Conversion completed') # migrate audio tracks and subtitles Avalon.info('Migrating audio tracks and subtitles to upscaled video') fm.migrate_audio_tracks_subtitles(self.input_video, self.output_video, self.upscaled_frames)
def run(self): """Main controller for Video2X This function controls the flow of video conversion and handles all necessary functions. """ # parse arguments for waifu2x # check argument sanity self._check_arguments() # convert paths to absolute paths self.input_video = os.path.abspath(self.input_video) self.output_video = os.path.abspath(self.output_video) # initialize objects for ffmpeg and waifu2x-caffe fm = Ffmpeg(self.ffmpeg_settings, self.image_format) # initialize waifu2x driver if self.waifu2x_driver == 'waifu2x_caffe': w2 = Waifu2xCaffe(self.waifu2x_settings, self.method, self.model_dir) elif self.waifu2x_driver == 'waifu2x_converter': w2 = Waifu2xConverter(self.waifu2x_settings, self.model_dir) else: raise Exception(f'Unrecognized waifu2x driver: {self.waifu2x_driver}') # extract frames from video fm.extract_frames(self.input_video, self.extracted_frames) Avalon.info('Reading video information') video_info = fm.get_video_info(self.input_video) # analyze original video with ffprobe and retrieve framerate # width, height = info['streams'][0]['width'], info['streams'][0]['height'] # find index of video stream video_stream_index = None for stream in video_info['streams']: if stream['codec_type'] == 'video': video_stream_index = stream['index'] break # exit if no video stream found if video_stream_index is None: Avalon.error('Aborting: No video stream found') exit(1) # get average frame rate of video stream framerate = float(Fraction(video_info['streams'][video_stream_index]['avg_frame_rate'])) Avalon.info(f'Framerate: {framerate}') # width/height will be coded width/height x upscale factor if self.scale_ratio: original_width = video_info['streams'][video_stream_index]['width'] original_height = video_info['streams'][video_stream_index]['height'] self.scale_width = int(self.scale_ratio * original_width) self.scale_height = int(self.scale_ratio * original_height) # upscale images one by one using waifu2x Avalon.info('Starting to upscale extracted images') self._upscale_frames(w2) Avalon.info('Upscaling completed') # frames to Video Avalon.info('Converting extracted frames into video') # use user defined output size fm.convert_video(framerate, f'{self.scale_width}x{self.scale_height}', self.upscaled_frames) Avalon.info('Conversion completed') # migrate audio tracks and subtitles Avalon.info('Migrating audio tracks and subtitles to upscaled video') fm.migrate_audio_tracks_subtitles(self.input_video, self.output_video, self.upscaled_frames)
def video2x(): """Main controller for Video2X This function controls the flow of video conversion and handles all necessary functions. """ check_model_type(args) # Parse arguments for waifu2x if args.cpu: method = 'cpu' elif args.gpu: method = 'gpu' ffmpeg_arguments.append('-hwaccel {}'.format(ffmpeg_hwaccel)) elif args.cudnn: method = 'cudnn' ffmpeg_arguments.append('-hwaccel {}'.format(ffmpeg_hwaccel)) # Initialize objects for ffmpeg and waifu2x-caffe fm = Ffmpeg(ffmpeg_path, args.output, ffmpeg_arguments) w2 = Waifu2x(waifu2x_path, method, args.model_type) # Clear and create directories if os.path.isdir(FRAMES): shutil.rmtree(FRAMES) if os.path.isdir(UPSCALED): shutil.rmtree(UPSCALED) os.mkdir(FRAMES) os.mkdir(UPSCALED) # Extract frames from video fm.extract_frames(args.video, FRAMES) Avalon.info('Reading video information') info = get_video_info() # Analyze original video with ffprobe and retrieve framerate # width, height = info['streams'][0]['width'], info['streams'][0]['height'] # Find index of video stream video_stream_index = None for stream in info['streams']: if stream['codec_type'] == 'video': video_stream_index = stream['index'] break # Exit if no video stream found if video_stream_index is None: Avalon.error('Aborting: No video stream found') # Get average frame rate of video stream framerate = float( Fraction(info['streams'][video_stream_index]['avg_frame_rate'])) Avalon.info('Framerate: {}'.format(framerate)) # Upscale images one by one using waifu2x Avalon.info('Starting to upscale extracted images') upscale_frames(w2) Avalon.info('Upscaling completed') # Frames to Video Avalon.info('Converting extracted frames into video') # Width/height will be coded width/height x upscale factor if args.factor: coded_width = info['streams'][video_stream_index]['coded_width'] coded_height = info['streams'][video_stream_index]['coded_height'] fm.convert_video( framerate, '{}x{}'.format(args.factor * coded_width, args.factor * coded_height), UPSCALED) # Use user defined output size else: fm.convert_video(framerate, '{}x{}'.format(args.width, args.height), UPSCALED) Avalon.info('Conversion completed') # Extract and press audio in Avalon.info('Stripping audio track from original video') fm.extract_audio(args.video, UPSCALED) Avalon.info('Inserting audio track into new video') fm.insert_audio_track(UPSCALED)
def __init__(self, w, h, standard, ffm_data): self._width = w self._height = h self._standard = standard self._ffm_data = ffm_data self._ffmpeg = Ffmpeg()
def run(self): """Main controller for Video2X This function controls the flow of video conversion and handles all necessary functions. """ # Parse arguments for waifu2x # Check argument sanity self._check_model_type(self.model_type) self._check_arguments() # Convert paths to absolute paths self.input_video = os.path.abspath(self.input_video) self.output_video = os.path.abspath(self.output_video) # Add a forward slash to directory if not present # otherwise there will be a format error if self.ffmpeg_path[-1] != '/' and self.ffmpeg_path[-1] != '\\': self.ffmpeg_path = '{}/'.format(self.ffmpeg_path) # Check if FFMPEG and waifu2x are present if not os.path.isdir(self.ffmpeg_path): raise FileNotFoundError(self.ffmpeg_path) if not os.path.isfile(self.waifu2x_path) and not os.path.isdir(self.waifu2x_path): raise FileNotFoundError(self.waifu2x_path) # Initialize objects for ffmpeg and waifu2x-caffe fm = Ffmpeg(self.ffmpeg_path, self.ffmpeg_arguments) # Initialize waifu2x driver if self.waifu2x_driver == 'waifu2x_caffe': w2 = Waifu2xCaffe(self.waifu2x_path, self.method, self.model_type) elif self.waifu2x_driver == 'waifu2x_converter': w2 = Waifu2xConverter(self.waifu2x_path) else: raise Exception('Unrecognized waifu2x driver: {}'.format(self.waifu2x_driver)) # Extract frames from video fm.extract_frames(self.input_video, self.extracted_frames) Avalon.info('Reading video information') video_info = fm.get_video_info(self.input_video) # Analyze original video with ffprobe and retrieve framerate # width, height = info['streams'][0]['width'], info['streams'][0]['height'] # Find index of video stream video_stream_index = None for stream in video_info['streams']: if stream['codec_type'] == 'video': video_stream_index = stream['index'] break # Exit if no video stream found if video_stream_index is None: Avalon.error('Aborting: No video stream found') exit(1) # Get average frame rate of video stream framerate = float(Fraction(video_info['streams'][video_stream_index]['avg_frame_rate'])) Avalon.info('Framerate: {}'.format(framerate)) # Width/height will be coded width/height x upscale factor if self.ratio: coded_width = video_info['streams'][video_stream_index]['coded_width'] coded_height = video_info['streams'][video_stream_index]['coded_height'] self.output_width = self.ratio * coded_width self.output_height = self.ratio * coded_height # Upscale images one by one using waifu2x Avalon.info('Starting to upscale extracted images') self._upscale_frames(w2) Avalon.info('Upscaling completed') # Frames to Video Avalon.info('Converting extracted frames into video') # Use user defined output size fm.convert_video(framerate, '{}x{}'.format(self.output_width, self.output_height), self.upscaled_frames) Avalon.info('Conversion completed') # Migrate audio tracks and subtitles Avalon.info('Migrating audio tracks and subtitles to upscaled video') fm.migrate_audio_tracks_subtitles(self.input_video, self.output_video, self.upscaled_frames)