def getAudioDuration(path): matedata = FFProbe(path) adur = 0 for stream in matedata.streams: if stream.is_audio(): adur = stream.duration_seconds() return adur
def checkFile(vid): try: fileInfo = FFProbe(vid) except: return False, [] size = os.stat(vid).st_size print(size) if size < 10000000: return False, [] filename, ext = os.path.splitext(vid) index = [] for item in fileInfo.streams: index.append(item.__dict__) for stream in fileInfo.streams: if stream.is_video(): my_stream = dict(stream.__dict__) print(my_stream) if (('TAG:DURATION' in my_stream and my_stream['TAG:DURATION'] > '00:10:00.000000000') or ('codec_type' in my_stream and my_stream['codec_type'] == 'video')) and my_stream['codec_name'] != 'ansi': return True, index return False, []
def Transcoding(self): destination = self.file_path print(destination) for file in glob.glob(destination): if file.split('.')[-1] not in self.extension_allowed: continue print(file) output_file = os.getcwd() + "/" + ((file.split('/')[-1]).split('.')[0]) + ".mxf" print(output_file) duration = self.get_duration(file) metadata = FFProbe(file) streams_metadata = metadata.streams field_order_scan = "" audio_channels = "" video_index = "" audio_indexes = [] audio_stream_channel_map = {} audio_codec_name = "" file_profile = "" file_processing_status = "" command = self.get_command_stub(file) for stream_name in streams_metadata: if stream_name.codec_type == "video": profile,command, field_order_scan, video_index= self.video_metatdata(stream_name, command, field_order_scan, video_index) file_profile = file_profile + profile.split('_')[2] + "_" + profile.split('_')[3] + "_" elif stream_name.codec_type == "audio": profile, audio_stream_channel_map, audio_channels, audio_indexes, audio_codec_name = self.audio_metadata(stream_name, audio_stream_channel_map, audio_channels, audio_indexes, audio_codec_name ) file_profile = file_profile + "_" + str(audio_channels) elif stream_name.codec_type == "data": profile = self.data_metadata(stream_name) print(profile) if audio_channels == "": command, video_index = self.no_audio(command, video_index, output_file) elif ((type(audio_channels) is int) and (audio_channels >= 1)) : command = self.audio_present(command, video_index, audio_indexes, audio_stream_channel_map,audio_codec_name, output_file) command = self.get_audiocodec_output(command, audio_channels, audio_codec_name, output_file) print(field_order_scan) command = self.command_type_check(field_order_scan,command) print(1) print(command) try: self.file_processing_status = "DONE" # command = self.command_type_check(field_order_scan) # print(command) retcode = subprocess.call(command) self.Move_To_Dest(output_file, retcode) except: # print(command) self.file_processing_status = "ERROR" print("Cannot process file, Error logged.") self.add_fileprofile(file,file_profile,duration)
def getVideoFrames(self): # Split video into it corresponding parts based on self.desiredFrames print(self.inputVideo) metadata = FFProbe(self.inputVideo) print(metadata) # if len(metadata.streams) != 2: # # continue #duration = metadata.audio[0].duration_seconds() duration = self.getLength() self.duration = duration print(duration) # try: # duration = metadata.audio[0].duration_seconds() # except: # pass timestep = float(duration) / self.desiredFrames print(duration, timestep) print(self.inputVideo) cmd = 'ffmpeg -i ' + self.inputVideo + ' ' + self.outputPath + '$filename%04d.jpg' os.system(cmd) if os.path.exists(self.outputAudio + 'audio.wav'): os.remove(self.outputAudio + 'audio.wav') cmd2 = 'ffmpeg -i ' + self.inputVideo + ' ' + self.outputAudio + 'audio.wav' os.system(cmd2) #import pdb; pdb.set_trace() # os.system("ffmpeg -i %s %s" % (self.inputVideo, self.outputPath)) return True
def getLength(self, mediaPath): metadata=FFProbe(mediaPath) length = 0.0 for stream in metadata.streams: if (stream.is_video()) or (stream.is_audio()): length = stream.duration_seconds() #print(" -> Length: " + str(length)) return length
def getVideoDuration(path): matedata = FFProbe(path) # print("streams",len(matedata))matedata videoDuration = 0 for stream in matedata.streams: if stream.is_video(): videoDuration = stream.duration_seconds() return videoDuration
def extractThumbnail(originalPath, thumbnailPath): time = 0.0 metadata = FFProbe(originalPath) for stream in metadata.streams: if stream.is_video(): time = stream.duration_seconds() / 2 thumbnailTask = ffmpy3.FFmpeg( inputs={originalPath: None}, outputs={thumbnailPath: '-y -ss %d -vframes 1 ' % (time)}) thumbnailTask.run()
def aws_stuff(index): table = dynamodb.Table('Videos') metadata = FFProbe('./resources/{}'.format(index)) is_video = False for stream in metadata.streams: if stream.is_video(): is_video = True video_length = int(stream.duration_seconds()) table.update_item( Key= {'id': index}, UpdateExpression = "SET video_length = :video_length", ExpressionAttributeValues={':video_length': video_length} ) break if not is_video: table.update_item( Key= {'id': index}, UpdateExpression = "SET job_status = :job_status", ExpressionAttributeValues={':job_status': 'Invalid Video File'} ) #TODO delete file return table.update_item( Key= {'id': index}, UpdateExpression = "SET job_status = :job_status", ExpressionAttributeValues={':job_status': 'Extracting Audio'} ) audio_file = AudioExtract.extractFLAC(index) bucket = 'orbitalphase1' s3 = boto3.client('s3') s3.upload_file(audio_file, bucket, audio_file) transcribe = boto3.client('transcribe') result = transcribe.start_transcription_job( TranscriptionJobName=index, LanguageCode='en-US', MediaSampleRateHertz=44100, MediaFormat='flac', Media={ 'MediaFileUri': 'https://s3-us-east-2.amazonaws.com/{}/{}'.format(bucket,audio_file) } ) table.update_item( Key= {'id': index}, UpdateExpression = "SET job_status = :job_status", ExpressionAttributeValues={':job_status': 'Sent Audio For Transcription'} )
def stream_aspect_ratio(file): # Returns the aspect ratio expressed as a string, e.g. "4:3" file_metadata = FFProbe(file) ratio = None for stream in file_metadata.streams: if stream.is_video(): width, height = stream.frame_size() for resolution in RESOLUTIONS: if RESOLUTIONS[resolution]["width"] == width: ratio = RESOLUTIONS[resolution]["aspect_ratio"] return ratio if not ratio: print("Incompatible input dimensions.") sys.exit()
def getARandRes(path): inputfile = FFProbe(path) for stream in inputfile.streams: if stream.is_video(): width, height = stream.frame_size() ratio = "" for aspect in aspects: if aspect[0] == width: ratio = aspect[1] break if ratio == "": print("Incompatible input dimensions.") sys.exit() return ratio, [width, height]
def computeResolution(inputPath, outputPath, videoName, videoExtension): metadata = FFProbe(inputPath) videoRes = 0 videoMaxResolution = 0 for stream in metadata.streams: if stream.is_video(): (width, height) = stream.frame_size() videoRes = width * height for res in resolutions: if videoRes >= res: videoMaxResolution = res fmpg = ffmpy3.FFmpeg( inputs={inputPath: None}, outputs={ outputPath + '/' + videoName + '_' + resolutionNames[res] + '.' + videoExtension: resolutionComputing[res] }) fmpg.run() if videoMaxResolution == 0: return videoMaxResolution return "_" + resolutionNames[videoMaxResolution]
def calculate_length_and_upload_to_s3(sender, instance, **kwargs): post_save.disconnect(calculate_length_and_upload_to_s3, sender=sender) ffprobe = FFProbe(str(instance.audiofile.file.name)) print(str(instance.audiofile.file.name)) print(ffprobe.duration) if ffprobe.duration is not None: instance.length = ffprobe.duration else: instance.length = 0 # try: # ffprobe_out = subprocess.Popen( # "ffprobe " + str(instance.audiofile.file.name), # shell=True, # stdout=subprocess.PIPE, # stderr=subprocess.STDOUT, # close_fds=True # ) # for line in ffprobe_out.stdout.readlines(): # line = line.decode() # if "Duration" in line: # values = line.split(",")[0].split("Duration:")[1].split(":") # duration = 3600 * float(values[0]) + 60 * float(values[1]) + float(values[2]) # ffprobe_out.stdout.close() # ffprobe_out() # ffprobe_out.wait() # print(duration) # instance.length = duration # # ffprobe_out.stdout.close() # ffprobe_out.pipe_cloexec() # except IOError: # print("0") # instance.length = 0 instance.save() upload_to_s3(instance) post_save.connect(calculate_length_and_upload_to_s3, sender=sender)
def checkDir(dirname): global total_duration global cnt global verbose global only_errors for f in os.scandir(dirname): if f.is_dir(): checkDir(f.path) else: if f.name[-3:] in ['mp4', 'mov', 'avi']: cnt += 1 try: metadata = FFProbe(f.path) except: if verbose or only_errors: print('Error in file', f.path) continue duration_vs = 0.0 for stream in metadata.streams: if stream.is_video(): duration_vs += stream.duration_seconds() if verbose: print(f.name, "duration by video streams:", duration_vs) total_duration += duration_vs
action='store_true', help='filter results that are low bit rate') args = parser.parse_args() file_mask = "*." + args.extension if args.recursive: file_mask = "**/*." + args.extension print( f"Starting directory scan path={args.path} recursive={args.recursive} file_mask={file_mask}" ) for filename in glob.iglob(args.path + file_mask, recursive=args.recursive): metadata = FFProbe(filename) pass_filter = True if args.find_stereo_only: pass_filter = is_stereo_only(metadata) if pass_filter and args.find_single_audio_only: pass_filter = is_single_audio_only(metadata) if pass_filter and args.find_fullscreen: pass_filter = is_fullscreen(metadata) if pass_filter and args.find_low_bit_rate: pass_filter = is_low_bit_rate(metadata, args.min_bit_rate)
help="never use previous encoding from ffmpeg if available") group.add_argument( "-n", action="store_false", dest="overwrite", help="always use previous encoding from ffmpeg if available") args = parser.parse_args() print(version) print(args) input_filepath = args.source # probe metadata input_metadata = FFProbe(input_filepath) for stream in input_metadata.streams: if stream.is_video(): input_framerate = stream.frames() / stream.duration_seconds() output_keyinput_framerate = round( (args.segment_duration * input_framerate) / (1000 * args.i_factor)) dir_dashed = "video_dashed" dir_encoded = "video_encoded" ### SETUP FOLDERS ### # Set up folders if first run def makeFolder(folderpath): if not os.path.exists(folderpath):
def getLength(filename): """Returns length of file to the microsecond using ffprobe""" return FFProbe(filename).streams[0].duration_seconds()
def main(): '''Populate video info file.''' from argparse import ArgumentParser # for some reason pylint complains about members being undefined :( # pylint: disable=E1101 parser = ArgumentParser( description='Run ffprobe on file to find video FPS. Load and restore to videoname.mp4.info') show_default = ' (default %(default)s)' parser.add_argument('-V', dest='video_in', default=None, help='Input video') parser.add_argument('-F', '--family-preset', dest='familyPreset', help='Family preset: detect "inv" at the end of the name to set both "family" and "inverse"') parser.add_argument('-fps', dest='fps', default=20.0, type=float, help='video codec FPS, may be different to actual fps for broken encoders '+ show_default) options = parser.parse_args() if (options.video_in == None): print('No video provided') return -1 if (not os.path.isfile(options.video_in)): print('Videofile {} not found'.format(options.video_in)) return -1 jsonfile = options.video_in+'.info' jsonfileout=jsonfile #+'_out.txt' print("jsonfile="+jsonfile) print("jsonfileout="+jsonfileout) if (os.path.isfile(jsonfile)): with open(jsonfile) as infile: try: data_orig = json.load(infile) data = copy.deepcopy(data_orig) except ValueError as err: print('Error parsing JSON file {}'.format(jsonfile)) print(err) return 1 print("Loaded old JSON file: {}".format(jsonfile)) print(data) else: data = {'place': 'Gurabo'} print("No preexisting JSON file: {}".format(jsonfile)) print(data) metadata=FFProbe(options.video_in) #FFStream.frame_rate = get_frame_rate def get_field(self, name): """ Returns named parameter using ffprobe. Returns none is it is not a video stream. """ f = None if self.is_video(): if self.__dict__[name]: f = self.__dict__[name] return f for stream in metadata.streams: if stream.is_video(): #print(stream.__dict__.keys()) data["nframes"]=stream.frames() data["duration"]=stream.duration_seconds() r_frame_rate=get_field(stream,'r_frame_rate') ratio = r_frame_rate.split('/') if (len(ratio)==1): fps = float(ratio[0]) elif (len(ratio)==2): fps = float(ratio[0])/float(ratio[1]) else: print('Error, could not parse r_frame_rate={}'.format(r_frame_rate)) data["r_frame_rate"]=r_frame_rate data["videofps"]=fps #data["ffprobe"] = stream.__dict__ print("### Original JSON:") pp(data_orig) print("### Updated JSON:") pp(data) if (not user_yes_no_query('Update file {} ?'.format(jsonfileout))): return 0 with open(jsonfileout, 'w') as outfile: json.dump(data, outfile, indent=2, sort_keys=False) outfile.write('\n') return 0
def extract_files(): """After we have all of our videos split between train and test, and all nested within folders representing their classes, we need to make a data file that we can reference when training our RNN(s). This will let us keep track of image sequences and other parts of the training process. We'll first need to extract images from each of the videos. We'll need to record the following data in the file: [train|test], class, filename, nb frames Extracting can be done with ffmpeg: `ffmpeg -i video.mpg image-%04d.jpg` """ data_file = [] folders = ['./train/', './test/'] seq_len = 40 def rescale_list(input_list, size): """Given a list and a size, return a rescaled/samples list. For example, if we want a list of size 5 and we have a list of size 25, return a new list of size five which is every 5th element of the origina list.""" #import pdb;pdb.set_trace() try: assert len(input_list) >= size except: return [] # Get the number to skip between iterations. skip = len(input_list) // size # Build our new output. output = [input_list[i] for i in range(0, len(input_list), skip)] # Cut off the last one if needed. return output[:size] f = open('failedfiles.csv','w') for folder in folders: class_folders = glob.glob(folder + 'vids/%s'%sys.argv[1]) #class_folders = glob.glob(folder + 'vids/ApplyEyeMakeup') #class_folders = glob.glob(folder + 'vids/test') for vid_class in class_folders: class_files = glob.glob(vid_class + '/*.mp4') #class_files = glob.glob('./train/vids/ApplyEyeMakeup/v_ApplyEyeMakeup_g09_c01.avi') #class_files = glob.glob('./train/vids/test/2013DisneysTwilightZoneTowerofTerror-.mp4') for video_path in class_files: # Get the parts of the file. #import pdb; pdb.set_trace() video_parts = get_video_parts(video_path) train_or_test, srctype, classname, filename_no_ext, filename = video_parts #import pdb;pdb.set_trace() # Check if this class exists. for t in ['imgs','wavs','wavsfull','specs','imgsmerge','imgsrescale']: if not os.path.exists(train_or_test + '/'+t+'/' + classname): print("Creating folder for %s/%s" % (train_or_test, classname)) os.makedirs(train_or_test + '/'+t+'/' + classname) # Only extract if we haven't done it yet. Otherwise, just get # the info. if not check_already_extracted(video_parts): # Now extract it. src = train_or_test + '/vids/' + classname + '/' + \ filename dest = train_or_test + '/imgs/' + classname + '/' + \ filename_no_ext + '-%04d.jpg' dest1 = train_or_test + '/imgsrescale/' + classname + '/' + \ filename_no_ext dest2 = train_or_test + '/wavsfull/' + classname + '/' + \ filename_no_ext + '.wav' dest3 = train_or_test + '/wavs/' + classname + '/' + \ filename_no_ext #+ '-%04d.wav' dest4 = train_or_test + '/specs/' + classname + '/' dest5 = train_or_test + '/imgsrescale/' +classname + '/' dest6 = train_or_test + '/imgsmerge/' +classname + '/' from ffprobe3 import FFProbe metadata = FFProbe(src) if len(metadata.streams) != 2: continue try: duration = metadata.audio[0].duration_seconds() except: continue timestep = float(duration)/seq_len print (duration,timestep) os.system("ffmpeg -i %s %s" %(src, dest)) #import pdb; pdb.set_trace() os.system("ffmpeg -i %s %s" % (src, dest2)) imgs = glob.glob(train_or_test + '/imgs/' + classname + '/' + \ filename_no_ext+'*.jpg') rescale_imgs = rescale_list(sorted(imgs),seq_len) if rescale_imgs == []: f.write("glob,%s\n"%filename_no_ext) continue for i,im in enumerate(rescale_imgs): os.system("cp %s %s-%04d.jpg"%(im,dest1,i)) # from ffprobe3 import FFProbe # metadata = FFProbe(src) # duration = metadata.streams[0].duration_seconds() # timestep = float(duration)/seq_len # print (duration,timestep) import split_audio as spa spa.split(dest2,dest3,timestep=timestep*1000) import audio2spec_scipy2 as a2s import img_concat as imcat #from glob import glob names = glob.glob(dest3+'*.wav') if len(names) == 0: continue try: assert len(rescale_imgs)==len(names) except: f.write("audio,%s\n"%filename_no_ext) continue #for t in [('imgs','.jpg'),('wavs','.wav'),('wavsfull','.wav'),('specs','.png'),('imgsmerge','.jpg'),('imgsrescale','.jpg')]: # if os.path.exists(train_or_test + '/'+t[0]+'/' + classname+'/'+filename_no_ext+'*'): # os.system("rm -f %s"%(train_or_test + '/'+t[0]+'/' + classname+'/'+filename_no_ext+'*')) #os.remove(train_or_test + '/'+t[0]+'/' + classname+'/'+filename_no_ext+t[1]) for wf in names: #a2s.graph_spectrogram(wf,dest4+os.path.basename(wf).split('.')[0]) a2s.plotstft(wf, plotpath=dest4+os.path.basename(wf).split('.')[0]) imcat.concat(dest5+os.path.basename(wf).split('.')[0]+'.jpg',\ dest4+os.path.basename(wf).split('.')[0]+'.png',\ dest6+os.path.basename(wf).split('.')[0]) #os.system("ffmpeg -t 60 -acodec copy -i %s %s" % (src, dest3)) #call(["ffmpeg", "-r", '1', "-i", src, dest]) #call(["ffmpeg", "-vn", "-acodec", "pcm_s16le", "-ar", '44100', "-ac", '2', "-i", src, dest2]) #call(["ffmpeg", "-t", '60', "-acodec", "copy", "-i", dest2, dest3]) # Now get how many frames it is. nb_frames = get_nb_frames_for_video(video_parts) data_file.append([train_or_test, classname, filename_no_ext, nb_frames]) print("Generated %d frames for %s" % (nb_frames, filename_no_ext)) f.close() with open('data_file.csv', 'w') as fout: writer = csv.writer(fout) writer.writerows(data_file) print("Extracted and wrote %d video files." % (len(data_file)))
import os from ffprobe3 import FFProbe from ffprobe3.exceptions import FFProbeError test_dir = os.path.dirname(os.path.abspath(__file__)) test_videos = [ os.path.join(test_dir, './data/SampleVideo_720x480_5mb.mp4'), os.path.join(test_dir, './data/SampleVideo_1280x720_1mb.mp4'), os.path.join(test_dir, './data/SampleVideo_360x240_50mb.mp4'), os.path.join(test_dir, './data/SampleVideo_1280x720_50mb.mp4'), ] for test_video in test_videos: media = FFProbe(test_video) print('File:', test_video) print('\tStreams:', len(media.streams)) for index, stream in enumerate(media.streams, 1): print('\tStream: ', index) try: if stream.is_video(): frame_rate = stream.frames() / stream.duration_seconds() print('\t\tFrame Rate:', frame_rate) print('\t\tFrame Size:', stream.frame_size()) print('\t\tDuration:', stream.duration_seconds()) print('\t\tFrames:', stream.frames()) print('\t\tIs video:', stream.is_video()) except FFProbeError as e: print(e) except Exception as e:
import os from ffprobe3 import FFProbe from ffprobe3.exceptions import FFProbeError test_dir = os.path.dirname(os.path.abspath(__file__)) test_videos = [ os.path.join(test_dir, './data/SampleVideo_720x480_5mb.mp4'), os.path.join(test_dir, './data/SampleVideo_1280x720_1mb.mp4'), os.path.join(test_dir, './data/SampleVideo_360x240_50mb.mp4'), os.path.join(test_dir, './data/SampleVideo_1280x720_50mb.mp4'), ] for test_video in test_videos: media = FFProbe(test_video) print('File:', test_video) print('\tStreams:', len(media.streams)) for index, stream in enumerate(media.streams, 1): print('\tStream: ', index) try: if stream.is_video(): frame_rate = stream.frames() / stream.duration_seconds() print('\t\tFrame Rate:', frame_rate) print('\t\tFrame Size:', stream.frame_size()) print('\t\tDuration:', stream.duration_seconds()) print('\t\tFrames:', stream.frames()) print('\t\tIs video:', stream.is_video()) except FFProbeError as e: print(e) except Exception as e: