コード例 #1
0
    async def _concat(self, ctx, vstream, astream, kwargs):
        first_vid_filepath = kwargs['first_vid_filepath']
        second_vid_filepath = kwargs['input_filename']

        target_width = 640
        target_height = 480
        first_vid_metadata = FFProbe(first_vid_filepath)
        second_vid_metadata = FFProbe(second_vid_filepath)
        for stream in first_vid_metadata.streams + second_vid_metadata.streams:
            if(stream.is_video()):
                width, height = stream.frame_size()
                target_width = min(target_width, width)
                target_height = min(target_height, height)

        first_stream = ffmpeg.input(first_vid_filepath)
        vfirst = (
            first_stream.video
            .filter('scale', w=target_width, h=target_height)
            .filter('setsar', r='1:1')
        )
        afirst = first_stream.audio
        
        vstream = (
            vstream
            .filter('scale', w=target_width, h=target_height)
            .filter('setsar', r='1:1')
        )

        joined = ffmpeg.concat(vfirst, afirst, vstream, astream, v=1, a=1).node
        return (joined[0], joined[1], {'vsync':0})
コード例 #2
0
 def getFileLengthMs(self, fileName, isAudio=False):
     if not isAudio:
         ms = int(float(FFProbe(fileName).video[0].duration) *
                  1000)  # duration in milliseconds
     else:
         ms = int(float(FFProbe(fileName).audio[0].duration) *
                  1000)  # duration in milliseconds
     return ms
コード例 #3
0
 def test_bitrate(self):
     try:
         media = FFProbe(test_videos[0],
                         show_streams=True,
                         show_packets=True)
         packets_by_stream = media.get_packets_by_stream()
         for stream_index, packets in packets_by_stream.items():
             bytes = sum([packet.size() for packet in packets], 0)
             print(
                 'Stream bitrate:', bytes * 8 /
                 (media.streams()[stream_index].duration_seconds() * 1000))
     except Exception as e:
         raise e
コード例 #4
0
ファイル: ffprobe-test.py プロジェクト: jacobzelek/ffprobe
	def test_sample_media(self):
		samples = [ f for f in listdir(self.tmp_dir) if isfile(join(self.tmp_dir,f)) ]
		for sample in samples:
			print "Probing " + sample
			metadata = FFProbe(self.tmp_dir + "/" + sample)
			print "HTML5 Media Source Type: " + metadata.html5SourceType()
			self.assertNotEqual(metadata.durationSeconds(), 0.0)
			self.assertNotEqual(metadata.bitrate(), 0.0)
			for stream in metadata.streams:
				if stream.isAudio() or stream.isVideo():
					self.assertNotEqual(stream.durationSeconds(), 0.0)

				if stream.isVideo():
					self.assertNotEqual(stream.frameSize(), (0,0))
コード例 #5
0
def main(video):

    if not video.exists():
        video = SOURCE / video.name
    if not DEBUG:
        folder = DEST / video.stem
        folder.mkdir(exist_ok=True)
        name = folder / video.name

    # read file, get time, framerate and duration
    try:
        stream = FFProbe(str(video)).streams[0]
        start_time = get_time(stream.start_time)
        framerate = stream.framerate
        duration = get_time(stream.duration_seconds())

    except:
        stream = VideoFileClip(str(video))
        start_time = get_time(stream.start)
        framerate = stream.fps
        duration = get_time(stream.duration)

    # get scene timestamps
    scenes = find_scenes(video, framerate)
    if get_time(scenes[0][0]) != start_time:
        scenes.insert(0, (start_time, scenes[0][0]))
    [print(scene) for scene in scenes]

    # get individual clips
    for num, (start, end) in enumerate(scenes, start=1):

        if num == 1:
            start, end = start_time, get_time(end)

        elif num == len(scenes) + 1:
            start, end = get_time(start), duration

        else:
            start, end = get_time(start), get_time(end)

        if start > end: start, end = end, start
        if start == end: continue

        if DEBUG:
            print(start, end)
            continue

        file = name.with_name(f'{name.stem} - {num:03}.mp4')
        trim(str(video), str(file), start, end)
コード例 #6
0
def test_video(video, complexity):
    
    metadata=FFProbe(video)
    coding_res = int(metadata.video[0].height)*int(metadata.video[0].width)
    bitrate = int(re.search(r'\d+', metadata.metadata['bitrate']).group());
    framerate = int(metadata.video[0].framerate);
    test_model(bitrate, coding_res, framerate, complexity)
コード例 #7
0
    def test_sample_media(self):
        samples = [
            f for f in listdir(self.tmp_dir) if isfile(join(self.tmp_dir, f))
        ]
        for sample in samples:
            print("Probing " + sample)
            metadata = FFProbe(self.tmp_dir + "/" + sample)
            print("HTML5 Media Source Type: " + metadata.html5SourceType())
            self.assertNotEqual(metadata.durationSeconds(), 0.0)
            self.assertNotEqual(metadata.bitrate(), 0.0)
            for stream in metadata.streams:
                if stream.isAudio() or stream.isVideo():
                    self.assertNotEqual(stream.durationSeconds(), 0.0)

                if stream.isVideo():
                    self.assertNotEqual(stream.frameSize(), (0, 0))
コード例 #8
0
def get_tags(driver, path, filter=False):

    tags = set()
    frames = []
    video = path.suffix in ('.gif', '.webm', '.mp4')

    if video:

        tags.add('animated')
        if path.suffix in ('.webm', '.mp4'):
            try:
                for stream in FFProbe(str(path)).streams:
                    if stream.codec_type == 'audio':
                        tags.add('audio')
                        break
            except:
                pass
        temp_dir = tempfile.TemporaryDirectory()
        vidcap = VideoCapture(str(path))
        success, frame = vidcap.read()

        while success:

            temp = ROOT.parent / temp_dir.name / f'{next(tempfile._get_candidate_names())}.jpg'
            temp.write_bytes(imencode('.jpg', frame)[-1])
            frames.append(temp)
            success, frame = vidcap.read()

        else:
            step = 90 * log((len(frames) * .002) + 1) + 1
            frames = frames[::round(step)]

    else:
        frames.append(path)

    for frame in frames:

        driver.get('http://dev.kanotype.net:8003/deepdanbooru/')
        driver.find('//*[@id="exampleFormControlFile1"]', str(frame))
        driver.find('//button[@type="submit"]', click=True)

        for _ in range(4):
            html = bs4.BeautifulSoup(driver.page_source(), 'lxml')
            try:
                tags.update([
                    tag.text for tag in html.find('tbody').findAll(href=True)
                ])
                break
            except AttributeError:
                if driver.current_url().endswith('deepdanbooru/'):
                    driver.find('//*[@id="exampleFormControlFile1"]',
                                str(frame))
                    driver.find('//button[@type="submit"]', click=True)
                driver.refresh()

    else:
        if video: temp_dir.cleanup()
        if filter: tags.difference_update(REMOVE)

    return ' '.join(tags)
コード例 #9
0
def test_ff():
    if len(sys.argv[1:]) != 1:
        logging.error("Wrong number of input arguments!")
        sys.exit()

    inputfile = sys.argv[1]
    m = FFProbe(inputfile)
    v_num = len(m.video)
    a_num = len(m.audio)
    #assert v_num==1 and a_num==1
    vst = m.video
    ast = m.audio
    #vcodec=vst.codec()
    #acodec=ast.codec()
    fmt = m.format
    print 'format:'
    print '\tformat_name=%s' % fmt.formatName()
    for a in vst:
        print 'video:'
        print '\tcodec_name=%s description=%s' % (a.codecName(),
                                                  a.codecDescription())
    for a in ast:
        print 'audio:'
        print '\tcodec_name=%s description=%s language=%s' % (
            a.codecName(), a.codecDescription(), a.language())
コード例 #10
0
def fetchStimuli(count = None, modality = None, forceImport = False):
	if forceImport:
		from os import path, listdir
		from ffprobe import FFProbe

		# TODO: Expand to support audio-only modality.
		stimLocation = path.relpath(path.dirname(__file__)) + "/" + app.config["stim_base"]
		stimFiles = listdir(stimLocation)
		stimObjs = []
		for stimFile in stimFiles:
			# Only look at .mp4 files
			# Check if a stimulus with this filename already exists, and add it if not.
			if stimFile.endswith(".mp4") and models.Stimulus.query.filter_by(filename = stimFile).first() is None:
				durationStr = FFProbe(stimLocation + stimFile).video[0].duration
				duration = int(round(float(durationStr)))
				stimObj = models.Stimulus(filename = stimFile, modality = "video", duration = duration)
				stimObjs.append(stimObj)
		try:
			db.session.add_all(stimObjs)
			db.session.commit()
		except Exception as error:
			print("Error adding stimuli to database", error)
	
	query = models.Stimulus.query.order_by(models.Stimulus.id)
	if modality:
		query = query.filter_by(modality = modality)
	if app.config.get("tags"):
		query = query.filter_by(tags = app.config["tags"])
	if count:
		query = query.limit(count)
	results = query.all()
	return results
コード例 #11
0
    def is_video(self):

        if os.path.exists(self.video_path):
            metadata = FFProbe(self.video_path)
            if len(metadata.streams) > 0:
                if metadata.streams[0].is_video():
                    return True
        return False
コード例 #12
0
def get_video_duration(video_file):
    """Get video duration in seconds"""
    try:
        return float(FFProbe(video_file).video[0].duration)
    except Exception as e:
        print("could not extract duration from video {} due to {}".format(
            video_file, e))
        return None
コード例 #13
0
ファイル: utils.py プロジェクト: Rayos1/Software
def get_tags(driver, path, filter=False):

    tags = set()
    frames = []
    video = path.suffix in ('.gif', '.webm', '.mp4')

    if video:

        tags.add('animated')

        if path.suffix in ('.webm', '.mp4'):
            try:
                for stream in FFProbe(str(path)).streams:
                    if stream.codec_type == 'audio':
                        tags.add('audio')
                        break
            except:
                pass

            vidcap = VideoCapture(str(path))
            frame_count = int(vidcap.get(CAP_PROP_FRAME_COUNT))
            vidcap.release()

        elif path.suffix in ('.gif'):

            gifcap = GifImagePlugin.GifImageFile(str(path))
            frame_count = gifcap.n_frames
            gifcap.close()

        step = 90 * log((frame_count * .002) + 1) + 1
        frames = video_generator(path, round(step))

    else:
        frames.append(path)

    for frame in frames:

        driver.get('http://dev.kanotype.net:8003/deepdanbooru/')
        driver.find('//*[@id="exampleFormControlFile1"]', str(frame))
        driver.find('//button[@type="submit"]', click=True)

        for _ in range(4):
            html = bs4.BeautifulSoup(driver.page_source(), 'lxml')
            try:
                tags.update([
                    tag.text for tag in html.find('tbody').findAll(href=True)
                ])
                break
            except AttributeError:
                if driver.current_url().endswith('deepdanbooru/'):
                    driver.find('//*[@id="exampleFormControlFile1"]',
                                str(frame))
                    driver.find('//button[@type="submit"]', click=True)
                driver.refresh()

    if filter: tags.difference_update(REMOVE)

    return ' '.join(tags)
コード例 #14
0
def get_stream(files, text):
        
    new = DEST / files[0].with_suffix('.mp4').name

    if text and text in ('y', 'ye', 'yes'):

        stream = [
            ffmpeg.input(str(file)).drawtext(
                text=file.stem, fontsize=45, 
                x=int(FFProbe(file).streams[0].width) * .70, 
                y=int(FFProbe(file).streams[0].height) * .85,
                shadowcolor='white', shadowx=2, shadowy=2
                ) 
            for file in files
            ]
    else: stream = [ffmpeg.input(str(file)) for file in files]
    
    return new, stream
コード例 #15
0
def detect_file(input_file):
    m = FFProbe(input_file)
    vst = m.video
    assert len(vst) == 1
    ast = m.audio
    sst = m.subtitle
    fmt = m.format

    return fmt, vst, ast, sst
コード例 #16
0
def get_codec(path: str):
    try:
        metadata = FFProbe(path)
    except:
        return None

    if 'video' in metadata.streams:
        return metadata.video[0].codec_name

    return metadata.audio[0].codec_name
コード例 #17
0
    def stab_file(self, input_path, output_path):

        zoomed_file_name = "zoomed.mp4"
        metadata = FFProbe(input_path)
        if len(metadata.video) > 1:
            raise VideoBrokenException(
                "Video may not contain multiple video streams")
        if len(metadata.video) < 1:
            raise VideoBrokenException("No video streams found in file")

        could_check_dur_initially = self.check_vid_duration(input_path)

        try:
            # zoom by the size of the zoom in the stabilization, the total output file is bigger,
            # but no resolution is lost to the crop
            subprocess.check_output(
                [
                    self.ffmpeg_full_path,
                    "-y",
                    "-i",
                    input_path,
                    "-vf",
                    "scale=trunc((iw*" + self.video_scale_factor +
                    ")/2)*2:trunc(ow/a/2)*2",
                    "-pix_fmt",
                    "yuv420p",  # workaround for https://github.com/georgmartius/vid.stab/issues/36
                    zoomed_file_name
                ],
                stderr=subprocess.STDOUT)

            if not could_check_dur_initially:
                # sometimes metadata on original vids were broken,
                # so we need to re-check after fixing it during the first ffmpeg-pass
                self.check_vid_duration(zoomed_file_name)

            subprocess.check_output([
                self.ffmpeg_full_path, "-y", "-i", zoomed_file_name, "-vf",
                "vidstabdetect", "-f", "null", "-"
            ],
                                    stderr=subprocess.STDOUT)

            subprocess.check_output([
                self.ffmpeg_full_path, "-y", "-i", zoomed_file_name, "-vf",
                "vidstabtransform=smoothing=20:crop=black:zoom=" +
                self.video_zoom_factor +
                ":optzoom=0:interpol=linear,unsharp=5:5:0.8:3:3:0.4",
                output_path
            ],
                                    stderr=subprocess.STDOUT)
        except subprocess.CalledProcessError as cpe:
            print "cpe.returncode", cpe.returncode
            print "cpe.cmd", cpe.cmd
            print "cpe.output", cpe.output

            raise VideoStabilisingException, "ffmpeg could't compute file", cpe
コード例 #18
0
 def test_video(self):
     for test_video in test_videos:
         try:
             media = FFProbe(test_video)
             self.assertIsNotNone(media)
             print('File:', test_video)
             print_ffprobe(media)
         except FFProbeError as e:
             raise e
         except Exception as e:
             raise e
コード例 #19
0
 def test_stream(self):
     for test_stream in test_streams:
         try:
             media = FFProbe(test_stream)
             self.assertIsNotNone(media)
             print('Stream URL:', test_stream)
             print_ffprobe(media)
         except FFProbeError as e:
             raise e
         except Exception as e:
             raise e
コード例 #20
0
ファイル: videoutils.py プロジェクト: urlordjames/musicserver
def getmediainfo(location):
    metadata = FFProbe(location)
    isvideo = False
    if len(metadata.streams) < 1:
        return None
    for stream in metadata.streams:
        if stream.is_video():
            isvideo = True
    if isvideo:
        return "video"
    else:
        return "audio"
コード例 #21
0
def walk_tree(path):
    for root, dirs, files in os.walk(path):
        for file in files:
            if check_extension(file):
                pathname = os.path.join(root, file)
                metadata = FFProbe(pathname)
                try:
                    length = metadata.streams[0].durationSeconds()
                except (IndexError):
                    print os.path.join(root, file) + " was a problem file. skipped."
                    continue
                output_table.append((pathname, length))
コード例 #22
0
def get_video_start_time(video_file):
    """Get video start time in seconds"""
    try:
        time_string = FFProbe(video_file).video[0].creation_time
        try:
            creation_time = datetime.datetime.strptime(time_string,
                                                       TIME_FORMAT)
        except:
            creation_time = datetime.datetime.strptime(time_string,
                                                       TIME_FORMAT_2)
    except:
        return None
    return creation_time
コード例 #23
0
 def check_vid_duration(self, path):
     metadata = FFProbe(path)
     if hasattr(metadata.video[0], "duration") \
             and is_number(metadata.video[0].duration):
         if float(metadata.video[0].duration
                  ) > self.max_video_length_seconds:
             raise VideoBrokenException("Video too long. Video duration: " +
                                        metadata.video[0].duration +
                                        ", Maximum duration: " +
                                        str(self.max_video_length_seconds) +
                                        ". ")
         else:
             return True
     return False
コード例 #24
0
def transcribe_file(speech_file):

    client = speech.SpeechClient()

    with io.open(speech_file, 'rb') as audio_file:
        content = audio_file.read()
    metadata = FFProbe(speech_file)
    sample_rate = int(metadata.audio[0].sample_rate)
    audio = types.RecognitionAudio(content=content)
    config = types.RecognitionConfig(
        encoding=enums.RecognitionConfig.AudioEncoding.OGG_OPUS,
        language_code='ru-RU',
        sample_rate_hertz=sample_rate)
    response = client.recognize(config, audio)
    for result in response.results:
        return result.alternatives[-1].transcript
コード例 #25
0
def get_video_start_time(video_file):
    """Get video start time in seconds"""
    if not os.path.isfile(video_file):
        print("Error, video file {} does not exist".format(video_file))
        return None
    try:
        time_string = FFProbe(video_file).video[0].creation_time
        try:
            creation_time = datetime.datetime.strptime(time_string,
                                                       TIME_FORMAT)
        except:
            creation_time = datetime.datetime.strptime(time_string,
                                                       TIME_FORMAT_2)
    except:
        return None
    return creation_time
コード例 #26
0
def get_media_params(file_path):
    m = Metadata()

    try:
        metadata = FFProbe(file_path)

        if metadata.html5SourceType() != "":
            m.add("html5_source_type", metadata.html5SourceType())

        if metadata.bitrate() != 0.0:
            m.add("bit_rate", metadata.bitrate())

        if metadata.durationSeconds() != 0.0:
            m.add("duration", metadata.durationSeconds())

        for stream in metadata.streams:
            if stream.isVideo():
                (width, height) = stream.frameSize()
                if int(width) != 0 and int(height) != 0:
                    m.add("width", width)
                    m.add("height", height)

                if int(stream.frames()) != 0:
                    m.add("frames", stream.frames())
    except Exception as e:
        pass
    """Fallback and calculate bit rate or duration if missing using available data"""
    if m.exists("bit_rate") and m.exists("duration") is False:
        size = os.path.getsize(full_path)
        m.add("duration", (m.get("bit_rate") / 8) * size)

    if m.exists("duration") and m.exists("bit_rate") is False:
        size = os.path.getsize(full_path)
        m.add("bit_rate", (size / m.get("duration")) * 8)

    if m.exists("frames") and m.exists(
            "duration") and m.exists("frame_rate") is False:
        m.add("frame_rate", int(m.get("frames") / m.get("duration")))
    """If we have some values then return them if not then return False"""
    if m.empty() is False:
        return m

    return False
コード例 #27
0
ファイル: optimizer.py プロジェクト: kimarudg/video-squeezing
def ffmpeg(file_input, root_output='output'):
    """
    Transcode files
    :param file_input: Name of the file to transcode.
    :return:
    """

    # output_dir = os.path.join(source_dir, '/', os.path.dirname(file_input))
    output_dir = os.path.join(
        root_output,
        os.path.normpath(
            os.path.relpath(os.path.dirname(file_input), source_dir)))
    click.echo("Folders: " + output_dir)

    if os.path.exists(output_dir):
        click.echo("Folder " + output_dir + " already exists.")
    else:
        os.makedirs(output_dir)

    duration = 0
    start_time = current_milli_time()
    metadata = FFProbe(file_input)
    for stream in metadata.streams:
        click.echo(
            str(stream.durationSeconds()) + " seconds for " +
            os.path.basename(file_input))
        duration = stream.durationSeconds()

    try:
        ff = ffmpy.FF(inputs={file_input: None},
                      outputs={
                          os.path.abspath(
                              os.path.join(output_dir,
                                           os.path.basename(file_input))):
                          FFMPEG_OPTIONS
                      })
        click.echo(ff.cmd_str)
        ff.run()
    except:
        return "Problem with " + file_input

    end_time = current_milli_time()
    return "Converted " + str(duration) + " in ~" + str(
        round((end_time - start_time) / 1000 / 60))
コード例 #28
0
def generateScreenshot(file_):

    m = FFProbe(file_)
    for s in m.streams:
        if s.isVideo():
            framerate = s.frames() / s.durationSeconds()
            print "framerate " + str(framerate)
            print "frameSize " + str(s.frameSize())
        print "durationSeconds " + str(s.durationSeconds())
        print "frames " + str(s.frames())
        print "isVideo " + str(s.isVideo())
        print "sec2time " + str(sec2time(s.durationSeconds()))
        minutes = getMinutes(s.durationSeconds())
        print "minutes " + str(minutes)
    #return

    for i in range(5, int(minutes), 5):
        print "minutes = " + str(i)
        hms = min2time(i)
        print "hms = " + hms
        longtime = hms.replace(':', '')
        print "longtime = " + longtime
        timeasstring = hms
        image = file_ + '_' + longtime + '.jpg'
        print "target img= " + image
        inFile = file_
        outFile = image

        if os.path.isfile(outFile):
            print "skipping existing file " + outFile
            continue

        ff = FFmpeg(inputs={inFile: '-y -ss ' + timeasstring},
                    outputs={outFile: '-vframes 1 -q:v 2'})

        #         ffmpeg -y -ss 00:${i}:00 -i \""$file"\" -vframes 1 -q:v 2 \""${file}_00${i}00"\".jpg

        # -y = overwrite output file
        # -ss = seek to this time so not every frame is parsed

        print ff.cmd

        ff.run()
コード例 #29
0
    def _get_stats(self):
        # TODO refactor to consume path on event, potentially from queue
        stats = list()
        for path in self.watch_path.glob("*.mkv"):
            metadata = FFProbe(path.name)
            video_stream_id = 0
            audio_tracks = list()
            has_dts = False
            dts_tracks = 0
            sub_tracks = 0
            has_lang = False
            for idx, stream in enumerate(metadata.streams):
                if stream.is_video():
                    video_stream_id = idx
                if stream.is_audio():
                    audio_tracks.append({
                        "codec":
                        stream.codec(),
                        "stream_id":
                        idx,
                        "stream_name":
                        stream.__dict__.get("TAG:title", None),
                    })
                    if stream.codec() == "dts":
                        dts_tracks += 1
                        has_dts = True
                if stream.is_subtitle():
                    sub_tracks += 1
                    if stream.language() == "rum":
                        has_lang = True

            fstat = {
                "file_path": path,
                "video_stream_id": video_stream_id,
                "audio_tracks": audio_tracks,
                "has_dts": has_dts,
                "dts_tracks": dts_tracks,
                "sub_tracks": sub_tracks,
                "has_lang": has_lang,
            }
            stats.append(fstat)

        return stats
コード例 #30
0
def test_stream():
    for test_stream in test_streams:
        media = FFProbe(test_stream)
        print('File:', test_stream)
        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:
                print(e)
コード例 #31
0
    def get_video_startime(self, video_file):
        """Estimate start date of video file using its metadata.
        Note that this method might give incorrect results depending on the recording device. Only tested
        for videos recorded on Android."""
        metadata = FFProbe(video_file)
        start_time_str = metadata.metadata['creation_time']
        duration_str = metadata.metadata['Duration']
        if 'Z' not in start_time_str:
            print("Warning: Video timestamp not in UTC")
        start_time = dateutil.parser.isoparse(
            start_time_str)  # Start time of video in UTC
        duration_t = dateutil.parser.parse(
            duration_str)  # Start time of video in UTC
        duration = datetime.timedelta(hours=duration_t.hour,
                                      minutes=duration_t.minute,
                                      seconds=duration_t.second)
        start_time_in_secs = start_time.timestamp() - duration.total_seconds()

        return start_time_in_secs
コード例 #32
0
ファイル: media_parsing.py プロジェクト: jacobzelek/BitTroll
def get_media_params(file_path):
    m = Metadata()

    try:
        metadata = FFProbe(file_path)

        if metadata.html5SourceType() != "":
            m.add("html5_source_type", metadata.html5SourceType())

        if metadata.bitrate() != 0.0:
            m.add("bit_rate", metadata.bitrate())

        if metadata.durationSeconds() != 0.0:
            m.add("duration", metadata.durationSeconds())

        for stream in metadata.streams:
            if stream.isVideo():
                (width,height) = stream.frameSize()
                if int(width) != 0 and int(height) != 0:
                    m.add("width",width)
                    m.add("height",height)

                if int(stream.frames()) != 0:
                    m.add("frames",stream.frames())
    except Exception as e:
        pass

    """Fallback and calculate bit rate or duration if missing using available data"""
    if m.exists("bit_rate") and m.exists("duration") is False:
        size = os.path.getsize(full_path)
        m.add("duration", (m.get("bit_rate")/8) * size)

    if m.exists("duration") and m.exists("bit_rate") is False:
        size = os.path.getsize(full_path)
        m.add("bit_rate", (size / m.get("duration"))*8)

    if m.exists("frames") and m.exists("duration") and m.exists("frame_rate") is False:
        m.add("frame_rate", int(m.get("frames")/m.get("duration")))

    """If we have some values then return them if not then return False"""
    if m.empty() is False:
        return m

    return False