          logger.debug(retval)
          return retval
  
      @property
      def valid_tune(self):
          """ Return whether selected tune is valid for selected codec """
          return {"libx264": ["film", "animation", "grain", "stillimage", "fastdecode",
                              "zerolatency"],
                  "libx265": ["grain", "fastdecode", "zerolatency"]}
  
      @property
 
</s> remove     def video_fps(self):
        """ Return the fps of source video """
        reader = imageio.get_reader(self.source_video, "ffmpeg")
 </s> add     def _video_fps(self) -> float:
        """ float: The fps of the source video. """
        reader = imageio.get_reader(self._source_video, "ffmpeg") </s> remove     def video_tmp_file(self):
        """ Temporary video file, prior to muxing final audio """
        path, filename = os.path.split(self.video_file)
        retval = os.path.join(path, "__tmp_{}".format(filename))
 </s> add     def _video_tmp_file(self) -> str:
        """ str: Full path to the temporary video file that is generated prior to muxing final
        audio. """
        path, filename = os.path.split(self._output_filename)
        retval = os.path.join(path, f"__tmp_{filename}") </s> remove     def output_params(self):
        """ FFMPEG Output parameters """
 </s> add     def _output_params(self) -> List[str]:
        """ list: The FFMPEG Output parameters """ </s> remove     def is_stream(self):
        """ Return whether the writer is a stream or images
            Writers that write to a stream have a frame_order paramater to dictate
            the order in which frames should be written out (eg. gif/ffmpeg) """
 </s> add     def is_stream(self) -> bool:
        """ bool: Whether the writer outputs a stream or a series images.

        Writers that write to a stream have a frame_order paramater to dictate
        the order in which frames should be written out (eg. gif/ffmpeg) """ </s> remove     def set_frame_order(self, total_count):
        """ Return the full list of frames to be converted in order """
        if self.frame_ranges is None:
 </s> add     def _get_output_filename(self) -> str:
        """ Return full path to video output file.

        The filename is the same as the input video with `"_converted"` appended to the end. The
        file extension is as selected in the plugin settings. If a file already exists with the
        given filename, then `"_1"` is appended to the end of the filename. This number iterates
        until a valid filename that does not exist is found.

        Returns
        -------
        str
            The full path to the output video filename
        """
        filename = os.path.basename(self._source_video)
        filename = os.path.splitext(filename)[0]
        ext = self.config["container"]
        idx = 0
        while True:
            out_file = f"{filename}_converted{'' if idx == 0 else f'_{idx}'}.{ext}"
            retval = os.path.join(self.output_folder, out_file)
            if not os.path.exists(retval):
                break
            idx += 1
        logger.info("Outputting to: '%s'", retval)
        return retval

    def _set_frame_order(self, total_count: int) -> List[int]:
        """ Obtain the full list of frames to be converted in order.

        Parameters
        ----------
        total_count: int
            The total number of frames to be converted

        Returns
        -------
        list
            Full list of all frame indices to be converted
        """
        if self._frame_ranges is None:
    def _valid_tunes(self) -> dict:
        """ dict: Valid tune selections for libx264 and libx265 codecs. """
          logger.debug(retval)
          return retval
  
      @property
    def _valid_tunes(self) -> dict:
        """ dict: Valid tune selections for libx264 and libx265 codecs. """
    def _valid_tunes(self) -> dict:
        """ dict: Valid tune selections for libx264 and libx265 codecs. """
          return {"libx264": ["film", "animation", "grain", "stillimage", "fastdecode",
                              "zerolatency"],
                  "libx265": ["grain", "fastdecode", "zerolatency"]}
  
      @property
keep keep keep keep replace replace keep keep keep keep keep
 ffmpeg writer: Create new filename if output pre-exists 
plugins/convert/writer/ffmpeg.py