browsertime 19.1.0 → 19.3.0

package/browsertime/visualmetrics-portable.py

@@ -1,1969 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copyright (c) 2014, Google Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-    * Neither the name of the company nor the names of its contributors may be
-      used to endorse or promote products derived from this software without
-      specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."""
-#
-# The original script from Google was heavily modified for the Browsertime
-# project.
-#
-import gc
-import glob
-import gzip
-import json
-import logging
-import math
-import os
-import re
-import sys
-import shutil
-import subprocess
-import tempfile
-
-
-GZIP_TEXT = "wt"
-GZIP_READ_TEXT = "rt"
-
-# Globals
-options = None
-client_viewport = None
-frame_cache = {}
-
-
-# #################################################################################################
-# Replacement methods for ImageMagick to Python conversion
-# #################################################################################################
-
-
-def compare(img1, img2, fuzz=0.10):
-    """Calculate the Absolute Error count between given images."""
-    try:
-        import numpy as np
-
-        img1_data = np.array(img1)
-        img2_data = np.array(img2)
-
-        inds = np.argwhere(
-            np.isclose(img1_data[:, :, 0], img2_data[:, :, 0], atol=fuzz * 255)
-            & np.isclose(img1_data[:, :, 1], img2_data[:, :, 1], atol=fuzz * 255)
-            & np.isclose(img1_data[:, :, 2], img2_data[:, :, 2], atol=fuzz * 255)
-        )
-
-        return (img1_data.shape[0] * img1_data.shape[1]) - len(inds)
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def crop_im(img, crop_x, crop_y, crop_x_offset, crop_y_offset, gravity=None):
-    """Crop an image.
-
-    If gravity is equal to "center", the crop region will
-    first be centered before applying the crop.
-    """
-    try:
-        import numpy as np
-        from PIL import Image
-
-        img = np.array(img)
-
-        base_x = 0
-        base_y = 0
-
-        height, width, _ = img.shape
-        if gravity == "center":
-            base_x = width // 2
-            base_y = height // 2
-
-            base_x -= crop_x // 2
-            base_y -= crop_y // 2
-
-        # Handle the boundaries of the crop using max to prevent
-        # negatives, and min to prevent going over the othersde of
-        # the image
-        start_x = min(width - 1, max(base_x + crop_x_offset, 0))
-        start_y = min(height - 1, max(base_y + crop_y_offset, 0))
-
-        end_x = min(width - 1, max(start_x + crop_x, 0))
-        end_y = min(height - 1, max(start_y + crop_y, 0))
-
-        if len(img[start_y:end_y, start_x:end_x, :]) == 0:
-            raise Exception(
-                f"Cropped image is empty. Image dimensions: {img.shape}, "
-                f"Crop Region: {crop_x}, {crop_y}, {crop_x_offset}, {crop_y_offset}"
-            )
-
-        return Image.fromarray(img[start_y:end_y, start_x:end_x, :])
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def resize(img, width, height):
-    """Resize an image to the given width, and height."""
-
-    try:
-        from PIL import Image
-
-        try:
-            # If it's a numpy array, convert it first
-            img = Image.fromarray(img)
-        except:
-            pass
-
-        return img.resize((width, height), resample=Image.LANCZOS)
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def scale(img, maxsize):
-    """Scale an image to the given max size."""
-    width, height = img.size
-    ratio = min(float(maxsize) / width, float(maxsize) / height)
-    return resize(img, int(width * ratio), int(height * ratio))
-
-
-def mask(
-    img, x_mask, y_mask, x_offset, y_offset, color=(255, 255, 255), insert_img=None
-):
-    """Mask an image.
-
-    If insert_img is provided, the image given will mask the region
-    specified. Otherwise, by default, the region specified will be covered
-    in white - change color to change the mask color.
-    """
-    try:
-        import numpy as np
-        from PIL import Image
-
-        img_data = np.array(img)
-        if insert_img is not None:
-            insert_img_data = np.array(insert_img)
-            img_data[
-                y_offset : y_offset + y_mask, x_offset : x_offset + x_mask, :
-            ] = insert_img
-        else:
-            img_data[
-                y_offset : y_offset + y_mask, x_offset : x_offset + x_mask, :
-            ] = color
-
-        return Image.fromarray(img_data)
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def blank_frame(file, color="white"):
-    """Return a new blank frame that has the same dimensions as file."""
-    try:
-        from PIL import Image
-
-        with Image.open(file) as im:
-            width, height = im.size
-        return Image.new("RGB", (width, height), color=color)
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def edges_im(img):
-    """Find the edges of the given image.
-
-    First, we apply a gaussian filter using a kernal of radius=13,
-    and sigma=1 to a grayscale version of the image. Then we apply
-    CED to find the edges.
-
-    We calculate the hysterisis thresholds for the CED using the min and max
-    vaues of the blurred image. We use 10% as the lower threshold,
-    and 30% as the upper threshold.
-    """
-    try:
-        import cv2
-        import numpy as np
-        from PIL import Image, ImageOps
-
-        gs_img = np.array(ImageOps.grayscale(img))
-        blurred_img = cv2.GaussianBlur(gs_img, (13, 13), 1)
-
-        # Calculate the threshold values for double-thresholding
-        min_g = np.min(blurred_img[:])
-        max_g = np.max(blurred_img[:])
-        edge_img = cv2.Canny(
-            blurred_img, 0.10 * (max_g - min_g) + min_g, 0.30 * (max_g - min_g) + min_g
-        )
-
-        return Image.fromarray(edge_img)
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def contentful_value(img):
-    """
-    Get the contentful value by counting the number of
-    defined pixels in the image of the edges.
-    """
-    try:
-        import numpy as np
-
-        edge_img = np.array(edges_im(img))
-        white_pixels = np.where(edge_img != 0)
-
-        return len(white_pixels[0])
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def build_edge_video(video_path, viewport):
-    """Compute, and highlight the edges of a given video.
-
-    Makes use of the same technique as the contentful value
-    calculation. However, it crops, and scales the image using
-    our own method rather than FFMPEG. This creates two videos
-    suffixed with `-edges` and `-edges-overlay` that contain
-    the raw edges, and a video with the edges overlaid. They will
-    be found in the same location as the original video.
-
-    These videos will only be produced when --contentful-video is
-    used.
-    """
-    logging.debug("Creating edge video for {0}".format(video_path))
-
-    output_dir, video_name = os.path.split(video_path)
-    video_name, _ = os.path.splitext(video_name)
-
-    try:
-        import cv2
-        import numpy as np
-        from PIL import Image, ImageOps
-
-        # Get the edges of all frames
-        edge_video = []
-        resized_video = []
-        video = cv2.VideoCapture(video_path)
-        frame_count = video.get(cv2.CAP_PROP_FPS)
-        while video.isOpened():
-            ret, frame = video.read()
-            if ret:
-                cropped_im = frame
-                if viewport:
-                    cropped_im = crop_im(
-                        frame,
-                        viewport["width"],
-                        viewport["height"],
-                        viewport["x"],
-                        viewport["y"],
-                    )
-                resized_video.append(scale(cropped_im, options.thumbsize))
-                edge_video.append(np.array(edges_im(resized_video[-1])))
-            else:
-                video.release()
-                break
-
-        out_size = edge_video[-1].shape
-        out_edges = cv2.VideoWriter(
-            os.path.join(output_dir, video_name + "-edges.mp4"),
-            cv2.VideoWriter_fourcc(*"MP4V"),
-            frame_count,
-            (out_size[1], out_size[0]),
-            1,
-        )
-        out_edges_overlay = cv2.VideoWriter(
-            os.path.join(output_dir, video_name + "-edges-overlay.mp4"),
-            cv2.VideoWriter_fourcc(*"MP4V"),
-            frame_count,
-            (out_size[1], out_size[0]),
-            1,
-        )
-        for i, frame in enumerate(edge_video):
-            cframe = np.zeros((out_size[0], out_size[1], 3))
-            overlayframe = np.array(resized_video[i])
-            for x in range(cframe.shape[0]):
-                for y in range(cframe.shape[1]):
-                    if frame[x, y] != 0:
-                        cframe[x, y, :] = (0, 0, 255)
-                        overlayframe[x, y, :] = (0, 0, 255)
-            out_edges.write(np.uint8(cframe))
-            out_edges_overlay.write(np.uint8(overlayframe))
-
-        out_edges.release()
-        out_edges_overlay.release()
-
-        logging.debug("Finished creating edge videos for {0}".format(video_path))
-    except BaseException as e:
-        logging.exception(e)
-        return
-
-
-def convert_to_srgb(img):
-    """Convert PIL image to sRGB color space (if possible)"""
-    try:
-        import io
-        from PIL import Image, ImageCms
-
-        icc = img.info.get("icc_profile", "")
-
-        if icc:
-            return ImageCms.profileToProfile(
-                img,
-                ImageCms.ImageCmsProfile(io.BytesIO(icc)),
-                ImageCms.createProfile("sRGB"),
-            )
-
-        logging.debug(
-            "Unable to convert image to sRGB as there is no color "
-            "profile to transform from."
-        )
-        return img
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-
-def convert_img_to_jpeg(src, dest, quality=30):
-    """Convert an image to a JPEG with the given quality."""
-    try:
-        from PIL import Image
-
-        with Image.open(src) as img:
-            img = convert_to_srgb(img)
-            img.save(dest, quality=quality)
-    except BaseException as e:
-        logging.exception(e)
-        return
-
-
-# #################################################################################################
-# Frame Extraction and de-duplication
-# #################################################################################################
-
-
-def video_to_frames(
-    video,
-    directory,
-    force,
-    orange_file,
-    find_viewport,
-    viewport_retries,
-    viewport_min_height,
-    viewport_min_width,
-    full_resolution,
-):
-    """Extract the video frames"""
-    global client_viewport
-    first_frame = os.path.join(directory, "ms_000000")
-    if (
-        not os.path.isfile(first_frame + ".png")
-        and not os.path.isfile(first_frame + ".jpg")
-    ) or force:
-        if os.path.isfile(video):
-            video = os.path.realpath(video)
-            logging.info("Processing frames from video " + video + " to " + directory)
-            is_mobile = find_recording_platform(video)
-            if os.path.isdir(directory):
-                shutil.rmtree(directory, True)
-            if not os.path.isdir(directory):
-                os.mkdir(directory, 0o755)
-            if os.path.isdir(directory):
-                directory = os.path.realpath(directory)
-                viewport, cropped = find_video_viewport(
-                    video,
-                    directory,
-                    find_viewport,
-                    viewport_retries,
-                    viewport_min_height,
-                    viewport_min_width,
-                    is_mobile,
-                )
-
-                if options.contentful_video:
-                    # Create some videos with the edges
-                    build_edge_video(video, viewport)
-
-                gc.collect()
-                if extract_frames(video, directory, full_resolution, viewport):
-                    client_viewport = None
-                    directories = [directory]
-                    for dir in directories:
-                        if orange_file is not None:
-                            remove_frames_before_orange(dir, orange_file)
-                            remove_orange_frames(dir, orange_file)
-                        find_render_start(dir, orange_file, cropped, is_mobile)
-                        adjust_frame_times(dir)
-                        eliminate_duplicate_frames(dir, cropped, is_mobile)
-                        crop_viewport(dir)
-                        gc.collect()
-                else:
-                    logging.critical("Error extracting the video frames from %s", video)
-            else:
-                logging.critical("Error creating output directory: %s", directory)
-        else:
-            logging.critical("Input video file %s does not exist", video)
-    else:
-        logging.info("Extracted video already exists in %s", directory)
-
-
-def extract_frames(video, directory, full_resolution, viewport):
-    """Extract and number the video frames"""
-    ret = False
-    logging.info("Extracting frames from " + video + " to " + directory)
-    decimate = get_decimate_filter()
-    if decimate is not None:
-        crop = ""
-        if viewport is not None:
-            crop = "crop={0}:{1}:{2}:{3},".format(
-                viewport["width"], viewport["height"], viewport["x"], viewport["y"]
-            )
-        scale = "scale=iw*min({0:d}/iw\\,{0:d}/ih):ih*min({0:d}/iw\\,{0:d}/ih),".format(
-            options.thumbsize
-        )
-        if full_resolution:
-            scale = ""
-        # escape directory name
-        # see https://en.wikibooks.org/wiki/FFMPEG_An_Intermediate_Guide/image_sequence#Percent_in_filename
-        dir_escaped = directory.replace("%", "%%")
-        command = [
-            "ffmpeg",
-            "-v",
-            "debug",
-            "-i",
-            video,
-            "-vsync",
-            "0",
-            "-vf",
-            crop + scale + decimate + "=0:64:640:0.001",
-            os.path.join(dir_escaped, "img-%d.png"),
-        ]
-        logging.debug(" ".join(command))
-        lines = []
-
-        proc = subprocess.Popen(command, stderr=subprocess.PIPE, encoding="UTF-8")
-        while proc.poll() is None:
-            lines.extend(iter(proc.stderr.readline, ""))
-
-        pattern = re.compile(r"keep pts:[0-9]+ pts_time:(?P<timecode>[0-9\.]+)")
-        frame_count = 0
-        for line in lines:
-            match = re.search(pattern, line)
-            if match:
-                frame_count += 1
-                frame_time = int(
-                    math.floor(float(match.groupdict().get("timecode")) * 1000)
-                )
-                src = os.path.join(directory, "img-{0:d}.png".format(frame_count))
-                dest = os.path.join(directory, "video-{0:06d}.png".format(frame_time))
-                logging.debug("Renaming " + src + " to " + dest)
-                os.rename(src, dest)
-                ret = True
-    return ret
-
-
-def find_recording_platform(video):
-    """Find the platform that this video was recorded on.
-
-    We can make use of a field called `com.android.version` to
-    determine if we've recorded on mobile or not.
-    """
-    command = ["ffprobe", video]
-    logging.debug(command)
-
-    lines = []
-    proc = subprocess.Popen(command, stderr=subprocess.PIPE, encoding="UTF-8")
-
-    while proc.poll() is None:
-        lines.extend(iter(proc.stderr.readline, ""))
-
-    is_mobile = False
-    matcher = re.compile(".*com\.android\.version.*")
-    for line in lines:
-        if matcher.search(line):
-            is_mobile = True
-
-    return is_mobile
-
-
-def remove_frames_before_orange(directory, orange_file):
-    """Remove stray frames from the start of the video"""
-    frames = sorted(glob.glob(os.path.join(directory, "video-*.png")))
-    if len(frames):
-        # go through the first 20 frames and remove any that come before the first orange frame.
-        # iOS video capture starts with a blank white frame and then flips to
-        # orange before starting.
-        logging.debug("Scanning for non-orange frames...")
-        found_orange = False
-        remove_frames = []
-        frame_count = 0
-        for frame in frames:
-            frame_count += 1
-            if is_color_frame(frame, orange_file):
-                found_orange = True
-                break
-            if frame_count > 20:
-                break
-            remove_frames.append(frame)
-
-        if found_orange and len(remove_frames):
-            for frame in remove_frames:
-                logging.debug("Removing pre-orange frame %s", frame)
-                os.remove(frame)
-
-
-def remove_orange_frames(directory, orange_file):
-    """Remove orange frames from the beginning of the video"""
-    frames = sorted(glob.glob(os.path.join(directory, "video-*.png")))
-    if len(frames):
-        logging.debug("Scanning for orange frames...")
-        for frame in frames:
-            if is_color_frame(frame, orange_file):
-                logging.debug("Removing Orange frame: %s", frame)
-                os.remove(frame)
-            else:
-                break
-        for frame in reversed(frames):
-            if is_color_frame(frame, orange_file):
-                logging.debug("Removing orange frame %s from the end", frame)
-                os.remove(frame)
-            else:
-                break
-
-
-def find_image_viewport(file, is_mobile):
-    logging.debug("Finding the viewport for %s", file)
-    try:
-        from PIL import Image
-
-        im = Image.open(file)
-        width, height = im.size
-        x = int(math.floor(width / 2))
-        y = int(math.floor(height / 2))
-        pixels = im.load()
-        background = pixels[x, y]
-
-        # Find the left edge
-        left = None
-        while left is None and x >= 0:
-            if not colors_are_similar(background, pixels[x, y]):
-                left = x + 1
-            else:
-                x -= 1
-        if left is None:
-            left = 0
-        logging.debug("Viewport left edge is %d", left)
-
-        # Find the right edge
-        x = int(math.floor(width / 2))
-        right = None
-        while right is None and x < width:
-            if not colors_are_similar(background, pixels[x, y]):
-                right = x - 1
-            else:
-                x += 1
-        if right is None:
-            right = width
-        logging.debug("Viewport right edge is {0:d}".format(right))
-
-        # Find the top edge
-        x = int(math.floor(width / 2))
-        top = None
-        while top is None and y >= 0:
-            if not colors_are_similar(background, pixels[x, y]):
-                top = y + 1
-            else:
-                y -= 1
-        if top is None:
-            top = 0
-        logging.debug("Viewport top edge is {0:d}".format(top))
-
-        # Find the bottom edge
-        y = int(math.floor(height / 2))
-        bottom = None
-        while bottom is None and y < height:
-            if not colors_are_similar(background, pixels[x, y]):
-                bottom = y - 1
-            else:
-                y += 1
-        if bottom is None:
-            bottom = height
-        logging.debug("Viewport bottom edge is {0:d}".format(bottom))
-
-        viewport = {
-            "x": left,
-            "y": top,
-            "width": (right - left),
-            "height": (bottom - top),
-        }
-
-        if is_mobile:
-            # On mobile we need to ignore the top ~10 pixels because
-            # there is a visible progress bar there on some browsers.
-            viewport["y"] += 10
-            viewport["height"] -= 10
-
-    except Exception:
-        viewport = None
-
-    return viewport
-
-
-def find_video_viewport(
-    video,
-    directory,
-    find_viewport,
-    viewport_retries,
-    viewport_min_height,
-    viewport_min_width,
-    is_mobile,
-):
-    logging.debug("Finding Video Viewport...")
-    viewport = None
-
-    # cropped will be True if the viewport setting changes
-    # the original frame
-    cropped = False
-
-    try:
-        from PIL import Image
-
-        retries = -1
-
-        while (
-            viewport is None
-            or viewport["height"] <= viewport_min_height
-            or viewport["width"] <= viewport_min_width
-        ):
-            retries += 1
-            if retries >= 1:
-                # In some cases, the first frame is not an orange screen or a screen
-                # with a solid color. In this case, we need to try finding the viewport
-                # using the next frame. The `viewport_retries` dictates the maximum number
-                # of frames to check.
-                if retries >= viewport_retries:
-                    logging.exception(
-                        "Could not calculate a viewport after %s tries.",
-                        viewport_retries,
-                    )
-                    break
-                logging.info("Failed to find a good viewport. Retrying...")
-
-            logging.debug("Using frame " + str(retries))
-
-            frame = os.path.join(directory, "viewport.png")
-            if os.path.isfile(frame):
-                os.remove(frame)
-
-            command = ["ffmpeg", "-i", video]
-
-            # Pull one frame from the video starting with the frame at
-            # the `retries` index
-            command.extend(["-vf", "select=gte(n\\,%s)" % retries])
-            command.extend(["-frames:v", "1", frame])
-            subprocess.check_output(command)
-
-            if os.path.isfile(frame):
-                with Image.open(frame) as im:
-                    width, height = im.size
-                    logging.debug("%s is %dx%d", frame, width, height)
-                if find_viewport:
-                    viewport = find_image_viewport(frame, is_mobile)
-                else:
-                    viewport = {"x": 0, "y": 0, "width": width, "height": height}
-
-                os.remove(frame)
-
-        if viewport is not None and viewport != {
-            "x": 0,
-            "y": 0,
-            "width": width,
-            "height": height,
-        }:
-            cropped = True
-
-    except Exception as e:
-        viewport = None
-
-    return viewport, cropped
-
-
-def adjust_frame_times(directory):
-    offset = None
-    frames = sorted(glob.glob(os.path.join(directory, "video-*.png")))
-    # Special hack to the the video start
-    # Let us tune this in the future to skip using a global
-    global videoRecordingStart
-    match = re.compile(r"video-(?P<ms>[0-9]+)\.png")
-    if len(frames):
-        for frame in frames:
-            m = re.search(match, frame)
-            if m is not None:
-                frame_time = int(m.groupdict().get("ms"))
-                if offset is None:
-                    # This is the first frame.
-                    videoRecordingStart = frame_time
-                    offset = frame_time
-                new_time = frame_time - offset
-                dest = os.path.join(directory, "ms_{0:06d}.png".format(new_time))
-                os.rename(frame, dest)
-
-
-def find_render_start(directory, orange_file, cropped, is_mobile):
-    logging.debug("Finding Render Start...")
-    try:
-        if (
-            client_viewport is not None
-            or options.viewport is not None
-            or (options.renderignore > 0 and options.renderignore <= 100)
-        ):
-            files = sorted(glob.glob(os.path.join(directory, "video-*.png")))
-            count = len(files)
-            if count > 1:
-                from PIL import Image
-
-                first = files[0]
-                with Image.open(first) as im:
-                    width, height = im.size
-                if options.renderignore > 0 and options.renderignore <= 100:
-                    mask = {}
-                    mask["width"] = int(math.floor(width * options.renderignore / 100))
-                    mask["height"] = int(
-                        math.floor(height * options.renderignore / 100)
-                    )
-                    mask["x"] = int(math.floor(width / 2 - mask["width"] / 2))
-                    mask["y"] = int(math.floor(height / 2 - mask["height"] / 2))
-                else:
-                    mask = None
-
-                im_width = width
-                im_height = height
-
-                top = 10
-                right_margin = 10
-                bottom_margin = 24
-                if height > 400 or width > 400:
-                    top = max(top, int(math.ceil(float(height) * 0.03)))
-                    right_margin = max(
-                        right_margin, int(math.ceil(float(width) * 0.04))
-                    )
-                    bottom_margin = max(
-                        bottom_margin, int(math.ceil(float(width) * 0.04))
-                    )
-                height = max(height - top - bottom_margin, 1)
-                left = 0
-                width = max(width - right_margin, 1)
-                if client_viewport is not None:
-                    height = max(client_viewport["height"] - top - bottom_margin, 1)
-                    width = max(client_viewport["width"] - right_margin, 1)
-                    left += client_viewport["x"]
-                    top += client_viewport["y"]
-                elif cropped:
-                    # The image was already cropped, so only cutout the bottom
-                    # to get rid of the network request/etc. information for
-                    # desktop videos, and nothing extra on mobile.
-                    top = 0
-                    left = 0
-                    width = im_width
-
-                    if is_mobile:
-                        height = im_height
-                    else:
-                        height = im_height - bottom_margin
-
-                crop = (width, height, left, top)
-
-                for i in range(1, count):
-                    if frames_match(first, files[i], 10, 0, crop, mask):
-                        logging.debug("Removing pre-render frame %s", files[i])
-                        os.remove(files[i])
-                    elif orange_file is not None and is_color_frame(
-                        files[i], orange_file
-                    ):
-                        logging.debug("Removing orange frame %s", files[i])
-                        os.remove(files[i])
-                    else:
-                        break
-    except BaseException:
-        logging.exception("Error getting render start")
-
-
-def eliminate_duplicate_frames(directory, cropped, is_mobile):
-    logging.debug("Eliminating Duplicate Frames...")
-    global client_viewport
-    try:
-        files = sorted(glob.glob(os.path.join(directory, "ms_*.png")))
-        if len(files) > 1:
-            from PIL import Image
-
-            blank = files[0]
-            with Image.open(blank) as im:
-                width, height = im.size
-            im_width = width
-            im_height = height
-
-            # Figure out the region of the image that we care about
-            top = 40
-            right_margin = 10
-            bottom_margin = 10
-            if height > 400 or width > 400:
-                top = int(math.ceil(float(height) * 0.04))
-                right_margin = int(math.ceil(float(width) * 0.04))
-                bottom_margin = int(math.ceil(float(width) * 0.06))
-            height = max(height - top - bottom_margin, 1)
-            left = 0
-            width = max(width - right_margin, 1)
-
-            if client_viewport is not None:
-                height = max(client_viewport["height"] - top - bottom_margin, 1)
-                width = max(client_viewport["width"] - right_margin, 1)
-                left += client_viewport["x"]
-                top += client_viewport["y"]
-            elif cropped:
-                # The image was already cropped, so only cutout the bottom
-                # to get rid of the network request/etc. information for
-                # desktop videos, and nothing extra on mobile.
-                top = 0
-                left = 0
-                width = im_width
-
-                if is_mobile:
-                    height = im_height
-                else:
-                    height = im_height - bottom_margin
-
-            crop = (width, height, left, top)
-            logging.debug("Viewport cropping set to (W, H, L, T): " + str(crop))
-
-            # Do a pass looking for the first non-blank frame with an allowance
-            # for up to a 10% per-pixel difference for noise in the white
-            # field.
-            count = len(files)
-            for i in range(1, count):
-                if frames_match(blank, files[i], 10, 0, crop, None):
-                    logging.debug(
-                        "Removing duplicate frame {0} from the beginning".format(
-                            files[i]
-                        )
-                    )
-                    os.remove(files[i])
-                else:
-                    break
-
-            # Do another pass looking for the last frame but with an allowance for up
-            # to a 15% difference in individual pixels to deal with noise
-            # around text.
-            files = sorted(glob.glob(os.path.join(directory, "ms_*.png")))
-            count = len(files)
-            duplicates = []
-            if count > 2:
-                files.reverse()
-                baseline = files[0]
-                previous_frame = baseline
-                for i in range(1, count):
-                    if frames_match(baseline, files[i], 15, 5, crop, None):
-                        if previous_frame is baseline:
-                            duplicates.append(previous_frame)
-                        else:
-                            logging.debug(
-                                "Removing duplicate frame {0} from the end".format(
-                                    previous_frame
-                                )
-                            )
-                            os.remove(previous_frame)
-                        previous_frame = files[i]
-                    else:
-                        break
-            for duplicate in duplicates:
-                logging.debug(
-                    "Removing duplicate frame {0} from the end".format(duplicate)
-                )
-                os.remove(duplicate)
-
-    except BaseException:
-        logging.exception("Error processing frames for duplicates")
-
-
-def crop_viewport(directory):
-    if client_viewport is not None:
-        try:
-            from PIL import Image
-
-            files = sorted(glob.glob(os.path.join(directory, "ms_*.png")))
-            count = len(files)
-            if count > 0:
-                for i in range(count):
-                    with Image.open(files[i]) as im:
-                        new_img = crop_im(
-                            im,
-                            client_viewport["width"],
-                            client_viewport["height"],
-                            client_viewport["x"],
-                            client_viewport["y"],
-                        )
-                        new_img.save(files[i])
-
-        except BaseException:
-            logging.exception("Error cropping to viewport")
-
-
-def get_decimate_filter():
-    decimate = None
-    try:
-        filters = subprocess.check_output(
-            ["ffmpeg", "-filters"], stderr=subprocess.STDOUT, encoding="UTF-8"
-        )
-        lines = filters.split("\n")
-        match = re.compile(
-            r"(?P<filter>[\w]*decimate).*V->V.*Remove near-duplicate frames"
-        )
-        for line in lines:
-            m = re.search(match, line)
-            if m is not None:
-                decimate = m.groupdict().get("filter")
-                break
-    except BaseException:
-        logging.critical("Error checking ffmpeg filters for decimate")
-        decimate = None
-    return decimate
-
-
-def clean_directory(directory):
-    files = glob.glob(os.path.join(directory, "*.png"))
-    for file in files:
-        os.remove(file)
-    files = glob.glob(os.path.join(directory, "*.jpg"))
-    for file in files:
-        os.remove(file)
-    files = glob.glob(os.path.join(directory, "*.json"))
-    for file in files:
-        os.remove(file)
-
-
-def is_color_frame(file, color_file):
-    """Check a section from the middle, top and bottom of the viewport to see if it matches"""
-    global frame_cache
-    if file in frame_cache and color_file in frame_cache[file]:
-        return bool(frame_cache[file][color_file])
-    match = False
-    if os.path.isfile(color_file):
-        try:
-            from PIL import Image
-
-            with Image.open(file) as img:
-                width, height = img.size
-            crops = []
-
-            # Middle
-            crops.append(
-                (int(width / 2), int(height / 3), int(width / 4), int(height / 3))
-            )
-            # Top
-            crops.append((int(width / 2), int(height / 5), int(width / 4), 50))
-            # Bottom
-            crops.append(
-                (
-                    int(width / 2),
-                    int(height / 5),
-                    int(width / 4),
-                    height - int(height / 5),
-                )
-            )
-
-            for crop in crops:
-                with Image.open(file) as im:
-                    crop_i = crop_im(im, crop[0], crop[1], crop[2], crop[3])
-                    resized_im = resize(crop_i, 200, 200)
-
-                    with Image.open(color_file) as color_im:
-                        different_pixels = compare(resized_im, color_im, fuzz=0.15)
-
-                if different_pixels < 10000:
-                    match = True
-                    break
-        except Exception as e:
-            logging.debug(e)
-            pass
-    if file not in frame_cache:
-        frame_cache[file] = {}
-    frame_cache[file][color_file] = bool(match)
-    return match
-
-
-def colors_are_similar(a, b, threshold=15):
-    similar = True
-    sum = 0
-    for x in range(3):
-        delta = abs(a[x] - b[x])
-        sum += delta
-        if delta > threshold:
-            similar = False
-    if sum > threshold:
-        similar = False
-
-    return similar
-
-
-def frames_match(image1, image2, fuzz_percent, max_differences, crop_region, mask_rect):
-    match = False
-
-    try:
-        from PIL import Image
-
-        with Image.open(image1) as i1, Image.open(image2) as i2:
-            if mask_rect:
-                i1 = mask(
-                    i1,
-                    mask_rect["width"],
-                    mask_rect["height"],
-                    mask_rect["x"],
-                    mask_rect["y"],
-                )
-                i2 = mask(
-                    i2,
-                    mask_rect["width"],
-                    mask_rect["height"],
-                    mask_rect["x"],
-                    mask_rect["y"],
-                )
-
-            if crop_region:
-                i1 = crop_im(
-                    i1, crop_region[0], crop_region[1], crop_region[2], crop_region[3]
-                )
-                i2 = crop_im(
-                    i2, crop_region[0], crop_region[1], crop_region[2], crop_region[3]
-                )
-
-            different_pixels = compare(i1, i2, fuzz=fuzz_percent / 100)
-            if different_pixels <= max_differences:
-                match = True
-
-    except BaseException as e:
-        logging.exception(e)
-        return None
-
-    return match
-
-
-def generate_orange_png(orange_file):
-    try:
-        from PIL import Image, ImageDraw
-
-        im = Image.new("RGB", (200, 200))
-        draw = ImageDraw.Draw(im)
-        draw.rectangle([0, 0, 200, 200], fill=(222, 100, 13))
-        del draw
-        im.save(orange_file, "PNG")
-    except BaseException:
-        logging.exception("Error generating orange png " + orange_file)
-
-
-##########################################################################
-#   Histogram calculations
-##########################################################################
-
-
-def calculate_histograms(directory, histograms_file, force):
-    logging.debug("Calculating image histograms")
-    if not os.path.isfile(histograms_file) or force:
-        try:
-            extension = None
-            directory = os.path.realpath(directory)
-            first_frame = os.path.join(directory, "ms_000000")
-            if os.path.isfile(first_frame + ".png"):
-                extension = ".png"
-            elif os.path.isfile(first_frame + ".jpg"):
-                extension = ".jpg"
-            if extension is not None:
-                histograms = []
-                frames = sorted(glob.glob(os.path.join(directory, "ms_*" + extension)))
-                match = re.compile(r"ms_(?P<ms>[0-9]+)\.")
-                for frame in frames:
-                    m = re.search(match, frame)
-                    if m is not None:
-                        frame_time = int(m.groupdict().get("ms"))
-                        histogram = calculate_image_histogram(frame)
-                        gc.collect()
-                        if histogram is not None:
-                            histograms.append(
-                                {
-                                    "time": frame_time,
-                                    "file": os.path.basename(frame),
-                                    "histogram": histogram,
-                                }
-                            )
-                if os.path.isfile(histograms_file):
-                    os.remove(histograms_file)
-                f = gzip.open(histograms_file, GZIP_TEXT)
-                json.dump(histograms, f)
-                f.close()
-            else:
-                logging.critical("No video frames found in " + directory)
-        except BaseException:
-            logging.exception("Error calculating histograms")
-    else:
-        logging.debug("Histograms file {0} already exists".format(histograms_file))
-    logging.debug("Done calculating histograms")
-
-
-def calculate_image_histogram(file):
-    logging.debug("Calculating histogram for " + file)
-    try:
-        from PIL import Image
-
-        im = Image.open(file)
-        width, height = im.size
-        colors = im.getcolors(width * height)
-        histogram = {
-            "r": [0 for i in range(256)],
-            "g": [0 for i in range(256)],
-            "b": [0 for i in range(256)],
-        }
-        for entry in colors:
-            try:
-                count = entry[0]
-                pixel = entry[1]
-                # Don't include White pixels (with a tiny bit of slop for
-                # compression artifacts)
-                if pixel[0] < 250 or pixel[1] < 250 or pixel[2] < 250:
-                    histogram["r"][pixel[0]] += count
-                    histogram["g"][pixel[1]] += count
-                    histogram["b"][pixel[2]] += count
-            except Exception:
-                pass
-        colors = None
-    except Exception:
-        histogram = None
-        logging.exception("Error calculating histogram for " + file)
-    return histogram
-
-
-##########################################################################
-#   Screen Shots
-##########################################################################
-
-
-def save_screenshot(directory, dest, quality):
-    directory = os.path.realpath(directory)
-    files = sorted(glob.glob(os.path.join(directory, "ms_*.png")))
-    if files is not None and len(files) >= 1:
-        src = files[-1]
-        if dest[-4:] == ".jpg":
-            convert_img_to_jpeg(src, dest, quality=quality)
-        else:
-            shutil.copy(src, dest)
-
-
-##########################################################################
-#   JPEG conversion
-##########################################################################
-
-
-def convert_to_jpeg(directory, quality):
-    logging.debug("Converting video frames to JPEG")
-    directory = os.path.realpath(directory)
-    pattern = os.path.join(directory, "ms_*.png")
-
-    files = sorted(glob.glob(pattern))
-    for file in files:
-        _, filename = os.path.split(file)
-        filen, ext = os.path.splitext(filename)
-        convert_img_to_jpeg(
-            file, os.path.join(directory, filen + ".jpg"), quality=quality
-        )
-        os.remove(file)
-
-    logging.debug("Done converting video frames to JPEG")
-
-
-##########################################################################
-#   Visual Metrics
-##########################################################################
-
-
-def calculate_visual_metrics(
-    histograms_file,
-    start,
-    end,
-    perceptual,
-    contentful,
-    dirs,
-    progress_file,
-    hero_elements_file,
-):
-    metrics = None
-    histograms = load_histograms(histograms_file, start, end)
-    if histograms is not None and len(histograms) > 0:
-        progress = calculate_visual_progress(histograms)
-        if progress and progress_file is not None:
-            file_name, ext = os.path.splitext(progress_file)
-            if ext.lower() == ".gz":
-                f = gzip.open(progress_file, GZIP_TEXT, 7)
-            else:
-                f = open(progress_file, "w")
-            json.dump(progress, f)
-            f.close()
-        if len(histograms) > 1:
-            metrics = [
-                {"name": "First Visual Change", "value": histograms[1]["time"]},
-                {"name": "Last Visual Change", "value": histograms[-1]["time"]},
-                {"name": "Speed Index", "value": calculate_speed_index(progress)},
-            ]
-            if perceptual:
-                value, value_progress = calculate_perceptual_speed_index(progress, dirs)
-                metrics.extend(
-                    (
-                        {"name": "Perceptual Speed Index", "value": value},
-                        {
-                            "name": "Perceptual Speed Index Progress",
-                            "value": value_progress,
-                        },
-                    )
-                )
-            if contentful:
-                value, value_progress = calculate_contentful_speed_index(progress, dirs)
-
-                metrics.extend(
-                    (
-                        {"name": "Contentful Speed Index", "value": value},
-                        {
-                            "name": "Contentful Speed Index Progress",
-                            "value": value_progress,
-                        },
-                    )
-                )
-            if hero_elements_file is not None and os.path.isfile(hero_elements_file):
-                logging.debug("Calculating hero element times")
-                hero_data = None
-                hero_f_in = gzip.open(hero_elements_file, GZIP_READ_TEXT)
-                try:
-                    hero_data = json.load(hero_f_in)
-                except Exception as e:
-                    logging.exception("Could not load hero elements data")
-                    logging.exception(e)
-                hero_f_in.close()
-
-                if (
-                    hero_data is not None
-                    and hero_data["heroes"] is not None
-                    and hero_data["viewport"] is not None
-                    and len(hero_data["heroes"]) > 0
-                ):
-                    viewport = hero_data["viewport"]
-                    hero_timings = []
-                    for hero in hero_data["heroes"]:
-                        hero_time = calculate_hero_time(progress, dirs, hero, viewport)
-                        if hero_time is not None:
-                            hero_timings.append(
-                                {
-                                    "name": hero["name"],
-                                    "value": hero_time,
-                                }
-                            )
-                    hero_timings_sorted = sorted(
-                        hero_timings, key=lambda timing: timing["value"]
-                    )
-                    # hero_timings.append({'name': 'FirstPaintedHero',
-                    #                     'value': hero_timings_sorted[0]['value']})
-                    if (len(hero_timings_sorted) > 0):
-                        hero_timings.append(
-                            {
-                                "name": "LastMeaningfulPaint",
-                                "value": hero_timings_sorted[-1]["value"],
-                            }
-                        )
-                    hero_data["timings"] = hero_timings
-                    metrics += hero_timings
-
-                    hero_f_out = gzip.open(hero_elements_file, GZIP_TEXT, 7)
-                    json.dump(hero_data, hero_f_out)
-                    hero_f_out.close()
-            else:
-                logging.warn(
-                    "Hero elements file is not valid: " + str(hero_elements_file)
-                )
-        else:
-            metrics = [
-                {"name": "First Visual Change", "value": histograms[0]["time"]},
-                {"name": "Last Visual Change", "value": histograms[0]["time"]},
-                {"name": "Visually Complete", "value": histograms[0]["time"]},
-                {"name": "Speed Index", "value": 0},
-            ]
-            if perceptual:
-                metrics.append({"name": "Perceptual Speed Index", "value": 0})
-            if contentful:
-                metrics.append({"name": "Contentful Speed Index", "value": 0})
-        prog = ""
-        for p in progress:
-            if len(prog):
-                prog += ", "
-            prog += "{0:d}={1:d}".format(p["time"], int(p["progress"]))
-        metrics.append({"name": "Visual Progress", "value": prog})
-
-    return metrics
-
-
-def load_histograms(histograms_file, start, end):
-    histograms = None
-    if os.path.isfile(histograms_file):
-        f = gzip.open(histograms_file)
-        original = json.load(f)
-        f.close()
-        if start != 0 or end != 0:
-            histograms = []
-            for histogram in original:
-                if histogram["time"] <= start:
-                    histogram["time"] = start
-                    histograms = [histogram]
-                elif histogram["time"] <= end:
-                    histograms.append(histogram)
-                else:
-                    break
-        else:
-            histograms = original
-    return histograms
-
-
-def calculate_visual_progress(histograms):
-    progress = []
-    first = histograms[0]["histogram"]
-    last = histograms[-1]["histogram"]
-    for index, histogram in enumerate(histograms):
-        p = calculate_frame_progress(histogram["histogram"], first, last)
-        file_name, ext = os.path.splitext(histogram["file"])
-        progress.append({"time": histogram["time"], "file": file_name, "progress": p})
-        logging.debug("{0:d}ms - {1:d}% Complete".format(histogram["time"], int(p)))
-    return progress
-
-
-def calculate_frame_progress(histogram, start, final):
-    """Calculate the progress percentage of a given frame histogram.
-
-    This method finds the visually-complete progress by taking a sum of
-    all the differences in the histogram between the current frame, and the
-    final frame. The initial/first frame is used to remove values that are
-    consitent between the first, and final frame (i.e. it's a baseline).
-
-    Note that this method should not be using a slop/fuzz because we aren't
-    looking at individual pixel intensities which is where the fuzz can be
-    found. Within individual channels, we hit an issue where we cannot tell
-    if a value in the red channel is purely from a red colour in the image, or
-    if it's mixed with other colours such as grey (e.g. red with rbg(240,0,0),
-    and light grey with rgb(245,245,245)).
-    """
-    total = 0
-    matched = 0
-    for channel in ("r", "g", "b"):
-        for pixel_ind in range(256):
-            curr = histogram[channel][pixel_ind]
-            init = start[channel][pixel_ind]
-            target = final[channel][pixel_ind]
-
-            curr_diff = abs(curr - init)
-            target_diff = abs(target - init)
-
-            matched += min(curr_diff, target_diff)
-            total += target_diff
-
-    progress = (float(matched) / float(total)) if total else 1
-    return math.floor(progress * 100)
-
-
-def find_visually_complete(progress):
-    time = 0
-    for p in progress:
-        if int(p["progress"]) == 100:
-            time = p["time"]
-            break
-        elif time == 0:
-            time = p["time"]
-    return time
-
-
-def calculate_speed_index(progress):
-    si = 0
-    last_ms = progress[0]["time"]
-    last_progress = progress[0]["progress"]
-    for p in progress:
-        elapsed = p["time"] - last_ms
-        si += elapsed * (1.0 - last_progress)
-        last_ms = p["time"]
-        last_progress = p["progress"] / 100.0
-    return int(si)
-
-
-def calculate_contentful_speed_index(progress, directory):
-    # convert output comes out with lines that have this format:
-    # <pixel count>: <rgb color> #<hex color> <gray color>
-    # This is CLI dependant and very fragile
-    matcher = re.compile(r"(\d+?):")
-
-    try:
-        from PIL import Image
-
-        dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), directory)
-        content = []
-        maxContent = 0
-        for p in progress[1:]:
-            # Full Path of the Current Frame
-            current_frame = os.path.join(dir, "ms_{0:06d}.png".format(p["time"]))
-            logging.debug("contentfulSpeedIndex: Current frame is %s" % current_frame)
-
-            value = 0
-            with Image.open(current_frame) as current_frame_img:
-                value = contentful_value(current_frame_img)
-
-            logging.debug("contentfulSpeedIndex: Contentful value {0}".format(value))
-
-            if value > maxContent:
-                maxContent = value
-            content.append(value)
-
-        for i, value in enumerate(content):
-            if maxContent > 0:
-                content[i] = float(content[i]) / float(maxContent)
-            else:
-                content[i] = 0.0
-
-        # Assume 0 content for first frame
-        cont_si = 1 * (progress[1]["time"] - progress[0]["time"])
-        completeness_value = [(progress[1]["time"], int(cont_si))]
-        for i in range(1, len(progress) - 1):
-            elapsed = progress[i + 1]["time"] - progress[i]["time"]
-            # print i,' time =',p['time'],'elapsed =',elapsed,'content = ',content[i]
-            cont_si += elapsed * (1.0 - content[i])
-            completeness_value.append((progress[i + 1]["time"], int(cont_si)))
-
-        cont_si = int(cont_si)
-        raw_progress_value = ["0=0"]
-        for timestamp, percent in completeness_value:
-            p = int(100 * float(percent) / float(cont_si))
-            raw_progress_value.append("%d=%d" % (timestamp, p))
-
-        return cont_si, ", ".join(raw_progress_value)
-    except Exception as e:
-        logging.exception(e)
-        return None, None
-
-
-def calculate_perceptual_speed_index(progress, directory):
-    from ssim import compute_ssim
-
-    x = len(progress)
-    dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), directory)
-    first_paint_frame = os.path.join(dir, "ms_{0:06d}.png".format(progress[1]["time"]))
-    target_frame = os.path.join(dir, "ms_{0:06d}.png".format(progress[x - 1]["time"]))
-    ssim_1 = compute_ssim(first_paint_frame, target_frame)
-    per_si = float(progress[1]["time"])
-    last_ms = progress[1]["time"]
-    # Full Path of the Target Frame
-    logging.debug("Target image for perSI is %s" % target_frame)
-    ssim = ssim_1
-    completeness_value = []
-    for p in progress[1:]:
-        elapsed = p["time"] - last_ms
-        # print '*******elapsed %f'%elapsed
-        # Full Path of the Current Frame
-        current_frame = os.path.join(dir, "ms_{0:06d}.png".format(p["time"]))
-        logging.debug("Current Image is %s" % current_frame)
-        # Takes full path of PNG frames to compute SSIM value
-        per_si += elapsed * (1.0 - ssim)
-        ssim = compute_ssim(current_frame, target_frame)
-        gc.collect()
-        last_ms = p["time"]
-        completeness_value.append((p["time"], int(per_si)))
-
-    per_si = int(per_si)
-    raw_progress_value = ["0=0"]
-    for timestamp, percent in completeness_value:
-        p = int(100 * float(percent) / float(per_si))
-        raw_progress_value.append("%d=%d" % (timestamp, p))
-
-    return per_si, ", ".join(raw_progress_value)
-
-
-def calculate_hero_time(progress, directory, hero, viewport):
-    try:
-        dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), directory)
-        n = len(progress)
-        target_frame = os.path.join(dir, "ms_{0:06d}".format(progress[n - 1]["time"]))
-
-        extension = None
-        if os.path.isfile(target_frame + ".png"):
-            extension = ".png"
-        elif os.path.isfile(target_frame + ".jpg"):
-            extension = ".jpg"
-        if extension is not None:
-            hero_width = int(hero["width"])
-            hero_height = int(hero["height"])
-            hero_x = int(hero["x"])
-            hero_y = int(hero["y"])
-            target_frame = target_frame + extension
-            logging.debug(
-                "Target image for hero %s is %s" % (hero["name"], target_frame)
-            )
-
-            from PIL import Image
-
-            with Image.open(target_frame) as im:
-                width, height = im.size
-            if width != viewport["width"]:
-                scale = float(width) / float(viewport["width"])
-                logging.debug(
-                    "Frames are %dpx wide but viewport was %dpx. Scaling by %f"
-                    % (width, viewport["width"], scale)
-                )
-                hero_width = int(hero["width"] * scale)
-                hero_height = int(hero["height"] * scale)
-                hero_x = int(hero["x"] * scale)
-                hero_y = int(hero["y"] * scale)
-
-            logging.debug(
-                'Calculating render time for hero element "%s" at position [%d, %d, %d, %d]'
-                % (hero["name"], hero_x, hero_y, hero_width, hero_height)
-            )
-
-            # Apply the mask to the target frame to create the reference frame
-            target_mask_path = os.path.join(
-                dir,
-                "hero_{0}_ms_{1:06d}.png".format(hero["name"], progress[n - 1]["time"]),
-            )
-
-            def __apply_hero_mask(cur_frame):
-                """Helper method for re-applying the same mask."""
-                cropped_frame = None
-                with Image.open(cur_frame) as im:
-                    cropped_frame = crop_im(im, hero_width, hero_height, hero_x, hero_y)
-                return cropped_frame
-
-            target_mask = __apply_hero_mask(target_frame)
-            target_mask.save(target_mask_path)
-
-            def cleanup():
-                if os.path.isfile(target_mask_path):
-                    os.remove(target_mask_path)
-
-            # Allow for small differences like scrollbars and overlaid UI elements
-            # by applying a 10% fuzz and allowing for up to 2% of the pixels to be
-            # different.
-            fuzz = 10
-            max_pixel_diff = math.ceil(hero_width * hero_height * 0.02)
-
-            for p in progress:
-                current_frame = os.path.join(dir, "ms_{0:06d}".format(p["time"]))
-                extension = None
-                if os.path.isfile(current_frame + ".png"):
-                    extension = ".png"
-                elif os.path.isfile(current_frame + ".jpg"):
-                    extension = ".jpg"
-                if extension is not None:
-                    current_mask_path = os.path.join(
-                        dir, "hero_{0}_ms_{1:06d}.png".format(hero["name"], p["time"])
-                    )
-
-                    current_mask = __apply_hero_mask(current_frame + extension)
-                    current_mask.save(current_mask_path)
-
-                    match = frames_match(
-                        target_mask_path,
-                        current_mask_path,
-                        fuzz,
-                        max_pixel_diff,
-                        None,
-                        None,
-                    )
-
-                    # Remove each mask after using it
-                    os.remove(current_mask_path)
-
-                    if match:
-                        # Clean up masks as soon as a match is found
-                        cleanup()
-                        return p["time"]
-
-            # No matches found; clean up masks
-            cleanup()
-
-        return None
-    except Exception as e:
-        logging.exception(e)
-        return None
-
-
-##########################################################################
-#   Check any dependencies
-##########################################################################
-
-
-def check_config():
-    ok = True
-
-    if get_decimate_filter() is not None:
-        logging.debug("FFMPEG found")
-    else:
-        print("ffmpeg: FAIL")
-        ok = False
-
-    if sys.version_info >= (3, 6):
-        logging.debug("Python 3.6+ found")
-    else:
-        print("Python 3.6+: FAIL")
-        ok = False
-
-    try:
-        import numpy as np
-
-        logging.debug("Numpy found")
-    except BaseException:
-        print("Numpy: FAIL")
-        ok = False
-
-    try:
-        import cv2
-
-        logging.debug("OpenCV-Python found")
-    except BaseException:
-        print("OpenCV-Python: FAIL")
-        ok = False
-
-    try:
-        from PIL import Image, ImageCms, ImageDraw, ImageOps  # noqa
-
-        logging.debug("Pillow found")
-    except BaseException:
-        print("Pillow: FAIL")
-        ok = False
-
-    try:
-        from ssim import compute_ssim  # noqa
-
-        logging.debug("SSIM found")
-    except BaseException:
-        print("SSIM: FAIL")
-        ok = False
-
-    return ok
-
-
-def check_process(command, output):
-    ok = False
-    try:
-        out = subprocess.check_output(
-            command, stderr=subprocess.STDOUT, shell=True, encoding="UTF-8"
-        )
-        if out.find(output) > -1:
-            ok = True
-    except BaseException:
-        ok = False
-    return ok
-
-
-##########################################################################
-#   Main Entry Point
-##########################################################################
-
-
-def main():
-    import argparse
-
-    global options
-
-    parser = argparse.ArgumentParser(
-        description="Calculate visual performance metrics from a video.",
-        prog="visualmetrics",
-    )
-    parser.add_argument("--version", action="version", version="%(prog)s 0.1")
-    parser.add_argument(
-        "-c",
-        "--check",
-        action="store_true",
-        default=False,
-        help="Check dependencies (ffmpeg, Numpy, OpenCV-Python, PIL, SSIM).",
-    )
-    parser.add_argument(
-        "-v",
-        "--verbose",
-        action="count",
-        help="Increase verbosity (specify multiple times for more).",
-    )
-    parser.add_argument(
-        "--logfile", help="Write log messages to given file instead of stdout"
-    )
-    parser.add_argument(
-        "--logformat",
-        help="Formatting for the log messages",
-        default="%(asctime)s.%(msecs)03d - %(message)s",
-    )
-    parser.add_argument("-i", "--video", help="Input video file.")
-    parser.add_argument(
-        "-d",
-        "--dir",
-        help="Directory of video frames "
-        "(as input if exists or as output if a video file is specified).",
-    )
-    parser.add_argument(
-        "--render", help="Render the video frames to the given mp4 video file."
-    )
-    parser.add_argument(
-        "--screenshot",
-        help="Save the last frame of video as an image to the path provided.",
-    )
-    parser.add_argument(
-        "-q",
-        "--quality",
-        type=int,
-        help="JPEG Quality " "(if specified, frames will be converted to JPEG).",
-    )
-    parser.add_argument(
-        "-l",
-        "--full",
-        action="store_true",
-        default=False,
-        help="Keep full-resolution images instead of resizing to 400x400 pixels",
-    )
-    parser.add_argument(
-        "--thumbsize", type=int, default=400, help="Thumbnail size (defaults to 400)."
-    )
-    parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        help="Force processing of a video file (overwrite existing directory).",
-    )
-    parser.add_argument(
-        "-o",
-        "--orange",
-        action="store_true",
-        default=False,
-        help="Remove orange-colored frames from the beginning of the video.",
-    )
-    parser.add_argument(
-        "-p",
-        "--viewport",
-        action="store_true",
-        default=False,
-        help="Locate and use the viewport from the first video frame.",
-    )
-    parser.add_argument(
-        "--viewportretries",
-        type=int,
-        default=5,
-        help="Number of times to attempt to obtain a viewport. Analagous to the "
-        "number of frames to try to find a viewport with. By default, up to the "
-        "first 5 frames are used.",
-    )
-    parser.add_argument(
-        "--viewportminheight",
-        type=int,
-        default=0,
-        help="The minimum possible height (in pixels) for the viewport. Used when "
-        "attempting to find the viewport size. Defaults to 0.",
-    )
-    parser.add_argument(
-        "--viewportminwidth",
-        type=int,
-        default=0,
-        help="The minimum possible width (in pixels) for the viewport. Used when "
-        "attempting to find the viewport size. Defaults to 0.",
-    )
-    parser.add_argument(
-        "-s",
-        "--start",
-        type=int,
-        default=0,
-        help="Start time (in milliseconds) for calculating visual metrics.",
-    )
-    parser.add_argument(
-        "-e",
-        "--end",
-        type=int,
-        default=0,
-        help="End time (in milliseconds) for calculating visual metrics.",
-    )
-    parser.add_argument(
-        "--renderignore",
-        type=int,
-        default=0,
-        help="Ignore the center X%% of the frame when looking for "
-        "the first rendered frame (useful for Opera mini).",
-    )
-    parser.add_argument(
-        "-k",
-        "--perceptual",
-        action="store_true",
-        default=False,
-        help="Calculate perceptual Speed Index",
-    )
-    parser.add_argument(
-        "--contentful",
-        action="store_true",
-        default=False,
-        help="Calculate contentful Speed Index",
-    )
-    parser.add_argument(
-        "--contentful-video",
-        action="store_true",
-        default=False,
-        help="Produce a video of the edges used in the ContentfulSpeedIndex "
-        "calculation. The resulting videos are suffixed with -edge and "
-        "-edge-overlay.",
-    )
-    parser.add_argument(
-        "-j",
-        "--json",
-        action="store_true",
-        default=False,
-        help="Set output format to JSON",
-    )
-    parser.add_argument("--progress", help="Visual progress output file.")
-    parser.add_argument("--herodata", help="Hero elements data file.")
-
-    options = parser.parse_args()
-
-    if not options.check and not options.dir and not options.video:
-        parser.error(
-            "A video, Directory of images or histograms file needs to be provided.\n\n"
-            "Use -h to see available options"
-        )
-
-    if options.perceptual or options.contentful:
-        if not options.video:
-            parser.error(
-                "A video file needs to be provided.\n\n"
-                "Use -h to see available options"
-            )
-
-    temp_dir = tempfile.mkdtemp(prefix="vis-")
-    colors_temp_dir = tempfile.mkdtemp(prefix="vis-color-")
-    directory = temp_dir
-    if options.dir is not None:
-        directory = options.dir
-    histogram_file = os.path.join(temp_dir, "histograms.json.gz")
-
-    # Set up logging
-    log_level = logging.CRITICAL
-    if options.verbose == 1:
-        log_level = logging.ERROR
-    elif options.verbose == 2:
-        log_level = logging.WARNING
-    elif options.verbose == 3:
-        log_level = logging.INFO
-    elif options.verbose == 4:
-        log_level = logging.DEBUG
-    if options.logfile is not None:
-        logging.basicConfig(
-            filename=options.logfile,
-            level=log_level,
-            format=options.logformat,
-            datefmt="%H:%M:%S",
-        )
-    else:
-        logging.basicConfig(
-            level=log_level, format=options.logformat, datefmt="%H:%M:%S"
-        )
-
-    ok = False
-    try:
-        if not options.check:
-            # Run a quick check to make sure all requirements exist,
-            # otherwise failures might be silent due to how this code is
-            # structured.
-            ok = check_config()
-            if not ok:
-                raise Exception("Please install requirements before running.")
-
-            if options.video:
-                orange_file = None
-                if options.orange:
-                    orange_file = os.path.join(
-                        os.path.dirname(os.path.realpath(__file__)), "orange.png"
-                    )
-                    if not os.path.isfile(orange_file):
-                        orange_file = os.path.join(colors_temp_dir, "orange.png")
-                        generate_orange_png(orange_file)
-                video_to_frames(
-                    options.video,
-                    directory,
-                    options.force,
-                    orange_file,
-                    options.viewport,
-                    options.viewportretries,
-                    options.viewportminheight,
-                    options.viewportminwidth,
-                    options.full,
-                )
-
-            # Calculate the histograms and visual metrics
-            calculate_histograms(directory, histogram_file, options.force)
-            metrics = calculate_visual_metrics(
-                histogram_file,
-                options.start,
-                options.end,
-                options.perceptual,
-                options.contentful,
-                directory,
-                options.progress,
-                options.herodata,
-            )
-
-            if options.screenshot is not None:
-                quality = 30
-                if options.quality is not None:
-                    quality = options.quality
-                save_screenshot(directory, options.screenshot, quality)
-            # JPEG conversion
-            if options.dir is not None and options.quality is not None:
-                convert_to_jpeg(directory, options.quality)
-
-            if metrics is not None:
-                ok = True
-                if options.json:
-                    data = dict()
-                    for metric in metrics:
-                        data[metric["name"].replace(" ", "")] = metric["value"]
-                    if "videoRecordingStart" in globals():
-                        data["videoRecordingStart"] = videoRecordingStart
-                    print(json.dumps(data))
-                else:
-                    for metric in metrics:
-                        print("{0}: {1}".format(metric["name"], metric["value"]))
-        else:
-            ok = check_config()
-    except Exception as e:
-        logging.exception(e)
-        ok = False
-
-    # Clean up
-    shutil.rmtree(temp_dir)
-    shutil.rmtree(colors_temp_dir)
-    if ok:
-        exit(0)
-    else:
-        exit(1)
-
-
-if "__main__" == __name__:
-    main()