              self._rename_tmp_file()
              return
  
          exe = im_ffm.get_ffmpeg_exe()
          inputs = OrderedDict([(self.video_tmp_file, None), (self.source_video, None)])
          outputs = {self.video_file: "-map 0:v:0 -map 1:a:0 -c: copy"}
          ffm = FFmpeg(executable=exe,
                       global_options="-hide_banner -nostats -v 0 -y",
                       inputs=inputs,
                       outputs=outputs)
          logger.debug("Executing: %s", ffm.cmd)
 
</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: </s> remove         self.source_video = source_video
        self.frame_ranges = frame_ranges
        self.frame_order = self.set_frame_order(total_count)
        self.output_dimensions = None  # Fix dims of 1st frame in case of different sized images
        self.writer = None  # Need to know dimensions of first frame, so set writer then

    @property
    def video_file(self):
        """ Return full path to video output """
        filename = os.path.basename(self.source_video)
        filename = os.path.splitext(filename)[0]
        filename = "{}_converted.{}".format(filename, self.config["container"])
        retval = os.path.join(self.output_folder, filename)
        logger.debug(retval)
        return retval
 </s> add         self._source_video: str = source_video
        self._output_filename: str = self._get_output_filename()
        self._frame_ranges: Optional[List[int]] = frame_ranges
        self._frame_order: List[int] = self._set_frame_order(total_count)
        self._output_dimensions: Optional[str] = None  # Fix dims on 1st received frame
        # Need to know dimensions of first frame, so set writer then
        self._writer: Optional[imageio.plugins.ffmpeg.FfmpegFormat.Writer] = None </s> remove         self.output_folder = output_folder
        self.output_dimensions = None
 </s> add         self.output_folder: str = output_folder </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         self.config = get_config(".".join(self.__module__.split(".")[-2:]), configfile=configfile)
 </s> add         self.config: dict = get_config(".".join(self.__module__.split(".")[-2:]),
                                       configfile=configfile)
        inputs = OrderedDict([(self._video_tmp_file, None), (self._source_video, None)])
        outputs = {self._output_filename: "-map 0:v:0 -map 1:a:0 -c: copy"}
              self._rename_tmp_file()
              return
  
          exe = im_ffm.get_ffmpeg_exe()
        inputs = OrderedDict([(self._video_tmp_file, None), (self._source_video, None)])
        outputs = {self._output_filename: "-map 0:v:0 -map 1:a:0 -c: copy"}
        inputs = OrderedDict([(self._video_tmp_file, None), (self._source_video, None)])
        outputs = {self._output_filename: "-map 0:v:0 -map 1:a:0 -c: copy"}
          ffm = FFmpeg(executable=exe,
                       global_options="-hide_banner -nostats -v 0 -y",
                       inputs=inputs,
                       outputs=outputs)
          logger.debug("Executing: %s", ffm.cmd)
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