[fix] redundant functions discarded

Author: chyomin06

compressai_vision/codecs/encdec_utils/png_yuv.py

@@ -29,6 +29,7 @@
 
 import logging
 import math
+import shutil
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -93,6 +94,12 @@ def __call__(self, input: Dict, file_prefix: str):
                 "-i",
                 filename_pattern,
             ]
+
+            yuv_file = Path(f"{Path(file_names[0]).parent.parent}.yuv")
+            print(f"Checking if YUV is available: {yuv_file}")
+            if not yuv_file.is_file():
+                yuv_file = None
+
         else:
             nb_frames = 1
             input_info = ["-i", file_names[0]]
@@ -108,6 +115,25 @@ def __call__(self, input: Dict, file_prefix: str):
         pix_fmt_suffix = "10le" if input_bitdepth == 10 else ""
         chroma_format = "gray" if chroma_format == "400" else f"yuv{chroma_format}p"
 
+        # Use existing YUV (if found):
+        if yuv_file is not None:
+            size = yuv_file.stat().st_size
+            bytes_per_luma_sample = {"yuv420p": 1.5}[chroma_format]
+            bytes_per_sample = (input_bitdepth + 7) >> 3
+            expected_size = int(
+                frame_width
+                * frame_height
+                * bytes_per_luma_sample
+                * bytes_per_sample
+                * nb_frames
+            )
+            assert (
+                size == expected_size
+            ), f"YUV found for input but expected size of {expected_size} bytes differs from actual size of {size} bytes"
+            shutil.copy(yuv_file, yuv_in_path)
+            print(f"Using pre-existing YUV file: {yuv_file}")
+            return (yuv_in_path, nb_frames, frame_width, frame_height, file_prefix)
+
         # TODO (fracape)
         # we don't enable skipping frames (codec.skip_n_frames) nor use n_frames_to_be_encoded in video mode
 
@@ -149,6 +175,7 @@ def __call__(
         dec_path: str,
         yuv_dec_path: Path,
         org_img_size: Optional[Dict] = None,
+        vcm_mode: bool = False,
     ):
         """Converts a YUV file to a series of PNG images using ffmpeg.
 
@@ -192,16 +219,39 @@ def __call__(
             f"{chroma_format}{pix_fmt_suffix}",
             "-s",
             f"{frame_width}x{frame_height}",
-            "-src_range",
-            "1",  # (fracape) assume dec yuv is full range for now
-            "-i",
-            f"{yuv_dec_path}",
-            "-pix_fmt",
-            "rgb24",
-            *cmd_suffix,
-            output_png,
         ]
 
+        if not vcm_mode:
+            convert_cmd.extend(
+                [
+                    "-src_range",
+                    "1",  # (fracape) assume dec yuv is full range for now
+                ]
+            )
+
+        convert_cmd.extend(
+            [
+                "-i",
+                f"{yuv_dec_path}",
+                "-pix_fmt",
+                "rgb24",
+            ]
+        )
+
+        if vcm_mode:
+            convert_cmd.extend(
+                [
+                    "-vsync",
+                    "1",
+                ]
+            )
+        convert_cmd.extend(
+            [
+                *cmd_suffix,
+                output_png,
+            ]
+        )
+
         run_cmdline(convert_cmd)
 
         if org_img_size is not None and (

compressai_vision/codecs/std_codecs.py

@@ -28,21 +28,18 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import configparser
-import errno
 import json
 import logging
 import math
 import os
-import shutil
 import sys
 import time
 from io import BytesIO
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Tuple, Union
 
 import torch
 import torch.nn as nn
-from torch import Tensor
 
 from compressai_vision.codecs.utils import FpnUtils
 from compressai_vision.model_wrappers import BaseWrapper
@@ -53,14 +50,7 @@
 
 from .encdec_utils import *
 from .encdec_utils.png_yuv import PngFilesToYuvFileConverter, YuvFileToPngFilesConverter
-from .utils import (
-    MIN_MAX_DATASET,
-    compute_frame_resolution,
-    min_max_inv_normalization,
-    min_max_normalization,
-    tensor_to_tiled,
-    tiled_to_tensor,
-)
+from .utils import MIN_MAX_DATASET, min_max_inv_normalization, min_max_normalization
 
 
 def get_filesize(filepath: Union[Path, str]) -> int:
@@ -405,231 +395,6 @@ def get_decode_cmd(
         self.logger.debug(cmd)
         return cmd
 
-    def convert_input_to_yuv(self, input: Dict, file_prefix: str):
-        """
-        Converts the input image or video to YUV format using ffmpeg, or use existing YUV if available.
-        Args:
-            input (Dict): A dictionary containing information about the input. It should have the following keys:
-                - file_names (List[str]): A list of file names for the input. If it contains more than one file, it is considered a video.
-                - last_frame (int): The last frame number of the video.
-                - frame_skip (int): The number of frames to skip in the video.
-                - org_input_size (Dict[str, int]): A dictionary containing the width and height of the input.
-            file_prefix (str): The prefix for the output file name.
-        Returns:
-            Tuple[str, int, int, int, str]: A tuple containing the following:
-                - yuv_in_path (str): The path to the converted YUV input file.
-                - nb_frames (int): The number of frames in the input.
-                - frame_width (int): The width of the frames in the input.
-                - frame_height (int): The height of the frames in the input.
-                - file_prefix (str): The updated file prefix.
-        Raises:
-            AssertionError: If the number of images in the input folder does not match the expected number of frames.
-        """
-        file_names = input["file_names"]
-        yuv_file = None
-        if len(file_names) > 1:  # video
-            # NOTE: using glob for now, should be more robust and look at skipped
-            # NOTE: somewhat rigid pattern (lowercase png)
-            filename_pattern = f"{str(Path(file_names[0]).parent)}/*.png"
-            nb_frames = input["last_frame"] - input["frame_skip"]
-            images_in_folder = len(
-                [file for file in Path(file_names[0]).parent.glob("*.png")]
-            )
-            assert (
-                images_in_folder == nb_frames
-            ), f"input folder contains {images_in_folder} images, {nb_frames} were expected"
-
-            input_info = [
-                "-pattern_type",
-                "glob",
-                "-i",
-                filename_pattern,
-            ]
-
-            yuv_file = Path(f"{Path(file_names[0]).parent.parent}.yuv")
-            print(f"Checking if YUV is available: {yuv_file}")
-            if not yuv_file.is_file():
-                yuv_file = None
-        else:
-            input_info = ["-i", file_names[0]]
-
-        chroma_format = self.enc_cfgs["chroma_format"]
-        input_bitdepth = self.enc_cfgs["input_bitdepth"]
-
-        frame_width = math.ceil(input["org_input_size"]["width"] / 2) * 2
-        frame_height = math.ceil(input["org_input_size"]["height"] / 2) * 2
-        file_prefix = f"{file_prefix}_{frame_width}x{frame_height}_{self.frame_rate}fps_{input_bitdepth}bit_p{chroma_format}"
-        yuv_in_path = f"{file_prefix}_input.yuv"
-
-        pix_fmt_suffix = "10le" if input_bitdepth == 10 else ""
-        chroma_format = "gray" if chroma_format == "400" else f"yuv{chroma_format}p"
-
-        # Use existing YUV (if found):
-        if yuv_file is not None:
-            size = yuv_file.stat().st_size
-            bytes_per_luma_sample = {"yuv420p": 1.5}[chroma_format]
-            bytes_per_sample = (input_bitdepth + 7) >> 3
-            expected_size = int(
-                frame_width
-                * frame_height
-                * bytes_per_luma_sample
-                * bytes_per_sample
-                * nb_frames
-            )
-            assert (
-                size == expected_size
-            ), f"YUV found for input but expected size of {expected_size} bytes differs from actual size of {size} bytes"
-            shutil.copy(yuv_file, yuv_in_path)
-            print(f"Using pre-existing YUV file: {yuv_file}")
-            return (yuv_in_path, nb_frames, frame_width, frame_height, file_prefix)
-
-        # TODO (fracape)
-        # we don't enable skipping frames (codec.skip_n_frames) nor use n_frames_to_be_encoded in video mode
-
-        convert_cmd = [
-            "ffmpeg",
-            "-y",
-            "-hide_banner",
-            "-loglevel",
-            f"{self.ffmpeg_loglevel}",
-        ]
-        convert_cmd += input_info
-        convert_cmd += [
-            "-vf",
-            "pad=ceil(iw/2)*2:ceil(ih/2)*2",
-            "-f",
-            "rawvideo",
-            "-pix_fmt",
-            f"{chroma_format}{pix_fmt_suffix}",
-            "-dst_range",
-            "1",  #  (fracape) convert to full range for now
-        ]
-
-        convert_cmd.append(yuv_in_path)
-        self.logger.debug(convert_cmd)
-
-        run_cmdline(convert_cmd)
-
-        return (yuv_in_path, nb_frames, frame_width, frame_height, file_prefix)
-
-    def convert_yuv_to_pngs(
-        self,
-        output_file_prefix: str,
-        dec_path: str,
-        yuv_dec_path: Path,
-        org_img_size: Dict = None,
-        vcm_mode: bool = False,
-    ):
-        """
-        Converts a YUV file to a series of PNG images using ffmpeg.
-        Args:
-            output_file_prefix (str): The prefix of the output file name.
-            dec_path (str): The path to the directory where the PNG images will be saved.
-            yuv_dec_path (Path): The path to the input YUV file.
-            org_img_size (Dict, optional): The original image size. Defaults to None.
-        Returns:
-            None
-        Raises:
-            AssertionError: If the video format is not YUV420.
-        """
-        video_info = get_raw_video_file_info(yuv_dec_path.split("qp")[-1])
-        frame_width = video_info["width"]
-        frame_height = video_info["height"]
-
-        assert (
-            "420" in video_info["format"].value
-        ), f"Only support yuv420, but got {video_info['format']}"
-        pix_fmt_suffix = "10le" if video_info["bitdepth"] == 10 else ""
-        chroma_format = f"yuv420p"
-
-        convert_cmd = [
-            "ffmpeg",
-            "-y",
-            "-hide_banner",
-            "-loglevel",
-            "error",
-            "-f",
-            "rawvideo",
-            "-pix_fmt",
-            f"{chroma_format}{pix_fmt_suffix}",
-            "-s",
-            f"{frame_width}x{frame_height}",
-        ]
-        if not vcm_mode:
-            convert_cmd.extend(
-                [
-                    "-src_range",
-                    "1",  # (fracape) assume dec yuv is full range for now
-                ]
-            )
-        convert_cmd.extend(
-            [
-                "-i",
-                f"{yuv_dec_path}",
-                "-pix_fmt",
-                "rgb24",
-            ]
-        )
-        if vcm_mode:
-            convert_cmd.extend(
-                [
-                    "-vsync",
-                    "1",
-                ]
-            )
-
-        # TODO (fracape) hacky, clean this
-        if self.datacatalog == "MPEGOIV6":
-            output_png = f"{dec_path}/{output_file_prefix}.png"
-        elif self.datacatalog == "SFUHW":
-            prefix = output_file_prefix.split("qp")[0]
-            output_png = f"{dec_path}/{prefix}%03d.png"
-            convert_cmd += ["-start_number", "0"]
-        elif self.datacatalog in ["MPEGHIEVE"]:
-            convert_cmd += ["-start_number", "0"]
-            output_png = f"{dec_path}/%06d.png"
-        elif self.datacatalog in ["MPEGTVDTRACKING"]:
-            convert_cmd += ["-start_number", "1"]
-            output_png = f"{dec_path}/%06d.png"
-        convert_cmd.append(output_png)
-
-        run_cmdline(convert_cmd)
-
-        if org_img_size is not None:
-            discrepancy = (
-                True
-                if frame_height != org_img_size["height"]
-                or frame_width != org_img_size["width"]
-                else False
-            )
-
-            if discrepancy:
-                self.logger.warning(
-                    f"Different original input size found. It must be {org_img_size['width']}x{org_img_size['height']}, but {frame_width}x{frame_height} are parsed from YUV"
-                )
-                self.logger.warning(
-                    f"Use {org_img_size['width']}x{org_img_size['height']}, instead of {frame_width}x{frame_height}"
-                )
-
-                final_png = f"{dec_path}/{Path(output_png).stem}_tmp.png"
-
-                convert_cmd = [
-                    "ffmpeg",
-                    "-y",
-                    "-hide_banner",
-                    "-loglevel",
-                    "error",
-                    "-i",
-                    output_png,
-                    "-vf",
-                    f"crop={org_img_size['width']}:{org_img_size['height']}",
-                    final_png,  # no name change
-                ]
-                run_cmdline(convert_cmd)
-
-                Path(output_png).unlink()
-                Path(final_png).rename(output_png)
-
     def encode(
         self,
         x: Dict,
@@ -849,7 +614,11 @@ def decode(
             self.logger.debug(f"dec_time:{dec_time}")
 
             self.convert_yuv_to_pngs(
-                output_file_prefix, dec_path, yuv_dec_path, org_img_size, vcm_mode
+                output_file_prefix,
+                dec_path,
+                yuv_dec_path,
+                org_img_size=org_img_size,
+                vcm_mode=vcm_mode,
             )
 
             # output the list of file paths for each frame

compressai_vision/pipelines/remote_inference/image_remote_inference.py

@@ -135,7 +135,7 @@ def __call__(
                 continue
 
             start = time_measure()
-            dec_seq = self._decompress(
+            dec_seq, dec_time_by_module, mac_computation = self._decompress(
                 codec,
                 res["bitstream"],
                 self.codec_output_dir,