batchmp 1.4__py3-none-any.whl

batchmp/ffmptools/ffcommands/normalize_peak.py

@@ -0,0 +1,135 @@
+# coding=utf8
+## Copyright (c) 2014 Arseniy Kuznetsov
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+
+""" Batch Peak Normalization of media files
+"""
+import shutil, sys, os, shlex
+from batchmp.commons.utils import temp_dir
+from batchmp.ffmptools.ffutils import FFH
+from batchmp.ffmptools.ffrunner import FFMPRunner, FFMPRunnerTask, LogLevel
+from batchmp.commons.taskprocessor import TaskResult
+from batchmp.ffmptools.ffcommands.cmdopt import FFmpegCommands, FFmpegBitMaskOptions
+from batchmp.commons.utils import (
+    timed,
+    run_cmd,
+    CmdProcessingError
+)
+
+class PeakNormalizerTask(FFMPRunnerTask):
+    ''' Peak Normalizer TasksProcessor task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                            ff_general_options, ff_other_options, preserve_metadata):
+
+        super().__init__(fpath, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata)
+
+    def _check_defaults(self):
+        if not self.ff_other_options:
+            self.ff_other_options = FFmpegCommands.CONVERT_COPY_VBR_QUALITY
+
+        if not self.ff_general_options:
+            self.ff_general_options = FFmpegBitMaskOptions.ff_general_options(
+                                                          FFmpegBitMaskOptions.MAP_ALL_STREAMS)
+
+            if self.ff_other_options == FFmpegCommands.CONVERT_COPY_VBR_QUALITY:
+                self.ff_other_options += self._ff_cmd_exclude_artwork_streams()
+
+    def ff_normalize_cmd(self, volume_gain):
+        ''' Peak Normalize command builder
+        '''
+        return ''.join((super().ff_cmd,
+                            ' -af "volume=volume={}dB"'.format(volume_gain)))
+                            #'' if True else ' -c:a pcm_s16le'))
+
+    def execute(self):
+        ''' builds and runs Peak Normalization command in a subprocess
+        '''
+        task_result = TaskResult()
+
+        volume_entry, task_elapsed = self._detect_volumes()
+        task_result.add_task_step_duration(task_elapsed)
+
+        if not volume_entry:
+            task_result.add_task_step_info_msg('A problem analyzing volume in media file:\n\t{}' \
+                                                                                .format(self.fpath))
+        elif not volume_entry.max_volume:
+            task_result.add_task_step_info_msg( \
+                                        'Already normalized:\n\t{0}'.format(self.fpath))
+            # copy source file to target dir
+            shutil.copy(self.fpath, self.target_dir)
+
+            # all well
+            task_result.succeeded = True
+        else:
+            # store tags if needed
+            self._store_tags()
+
+            with temp_dir() as tmp_dir:
+                # prepare the tmp output path
+                norm_fname = os.path.basename(self.fpath)
+                norm_fpath = os.path.join(tmp_dir, norm_fname)
+
+                # build ffmpeg cmd string
+                p_in = ''.join((self.ff_normalize_cmd(volume_entry.max_volume), \
+                                                ' {}'.format(shlex.quote(norm_fpath))))
+                self._log(p_in, LogLevel.FFMPEG)
+
+                # run ffmpeg command as a subprocess
+                try:
+                    _, task_elapsed = run_cmd(p_in)
+                    task_result.add_task_step_duration(task_elapsed)
+                except CmdProcessingError as e:
+                    task_result.add_task_step_info_msg('A problem while processing media file:\n\t{0}' \
+                                                       '\nOriginal error message:\n\t{1}' \
+                                                            .format(self.fpath, e.args[0]))
+                else:
+                    # restore tags if needed
+                    self._restore_tags(norm_fpath)
+
+                    # move converted file to target dir
+                    shutil.move(norm_fpath, self.target_dir)
+
+                    # all well
+                    task_result.succeeded = True
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+    @timed
+    def _detect_volumes(self):
+        return FFH.volume_detector(self.fpath)
+
+
+class PeakNormalizer(FFMPRunner):
+    def peak_normalize(self, ff_entry_params):
+
+        ''' Peak Normalization of media files
+        '''
+        ff_entry_params.target_dir_prefix = 'peak_normalized'
+        media_files, target_dirs = self._prepare_files(ff_entry_params)
+
+        # build tasks
+        tasks = []
+        tasks_params = [(media_file, target_dir_path, ff_entry_params.log_level,
+                            ff_entry_params.ff_general_options, ff_entry_params.ff_other_options, ff_entry_params.preserve_metadata)
+                                for media_file, target_dir_path in zip(media_files, target_dirs)]
+        for task_param in tasks_params:
+            task = PeakNormalizerTask(*task_param)
+            tasks.append(task)
+
+        # run tasks
+        self.run_tasks(tasks, serial_exec = ff_entry_params.serial_exec, quiet = ff_entry_params.quiet)
+
+

batchmp/ffmptools/ffcommands/segment.py

@@ -0,0 +1,157 @@
+# coding=utf8
+## Copyright (c) 2014 Arseniy Kuznetsov
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+
+""" Batch splitting of media files
+"""
+import shutil, sys, os, math, fnmatch, shlex
+from batchmp.commons.utils import temp_dir
+from batchmp.ffmptools.ffrunner import FFMPRunner, FFMPRunnerTask, LogLevel
+from batchmp.commons.taskprocessor import TaskResult
+from batchmp.tags.handlers.ffmphandler import FFmpegTagHandler
+from batchmp.tags.handlers.mtghandler import MutagenTagHandler
+from batchmp.ffmptools.ffcommands.cmdopt import FFmpegCommands, FFmpegBitMaskOptions
+from batchmp.ffmptools.ffutils import FFH
+from batchmp.commons.utils import (
+    timed,
+    run_cmd,
+    CmdProcessingError,
+    MiscHelpers
+)
+
+class SegmenterTask(FFMPRunnerTask):
+    ''' Segment TasksProcessor task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                            ff_general_options, ff_other_options, preserve_metadata,
+                            reset_timestamps, segment_size_MB, segment_length_secs):
+
+        super().__init__(fpath, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata)
+
+        # calculate number of segments and, if needed, the segment length in secs
+        if segment_length_secs:
+            self.segment_length_secs = segment_length_secs
+            self.num_segments = math.ceil(Segmenter._media_duration(self.fpath) / segment_length_secs)
+        elif segment_size_MB:
+            num_segments = Segmenter._media_size_MB(self.fpath) / segment_size_MB
+            self.segment_length_secs = Segmenter._media_duration(self.fpath) / num_segments
+            self.num_segments = math.ceil(num_segments)
+        else:
+            # should not really get there, but just in case
+            raise ValueError('One of the command parameters needs to be specified: '\
+                                                    '<segment_size_MB | segment_length_secs>')
+        self.reset_timestamps = reset_timestamps
+
+    @property
+    def ff_cmd(self):
+        ''' Fragment command builder
+        '''
+        return ''.join((super().ff_cmd,
+                            FFmpegCommands.SEGMENT,
+                            ' {0} {1}'.format(FFmpegCommands.SEGMENT_TIME, self.segment_length_secs),
+                            FFmpegCommands.SEGMENT_RESET_TIMESTAMPS if self.reset_timestamps else ''))
+
+    def execute(self):
+        ''' builds and runs Segment FFmpeg command in a subprocess
+        '''
+        # store tags if needed
+        self._store_tags()
+
+        task_result = TaskResult()
+
+        with temp_dir() as tmp_dir:
+            # compile intermediary output path
+            fn_parts = os.path.splitext(os.path.basename(self.fpath))
+            fname_ext = fn_parts[1].strip().lower()
+            fpath_output = ''.join((fn_parts[0],
+                                   '_%{}d'.format(MiscHelpers.int_num_digits(self.num_segments)),
+                                   fname_ext))
+            fpath_output = os.path.join(tmp_dir, fpath_output)
+
+            # build ffmpeg cmd string
+            p_in = ''.join((self.ff_cmd, ' {}'.format(shlex.quote(fpath_output))))
+            self._log(p_in, LogLevel.FFMPEG)
+
+            # run ffmpeg command as a subprocess
+            try:
+                _, task_elapsed = run_cmd(p_in)
+                task_result.add_task_step_duration(task_elapsed)
+            except CmdProcessingError as e:
+                task_result.add_task_step_info_msg('A problem while processing media file:\n\t{0}' \
+                                                                    '\nOriginal error message:\n\t{1}' \
+                                                                            .format(self.fpath, e.args[0]))
+            else:
+                # move split files to target directory
+                for segmented_fname in os.listdir(tmp_dir):
+                    if fnmatch.fnmatch(segmented_fname, '*{}'.format(fname_ext)):
+                        segmented_fpath = os.path.join(tmp_dir, segmented_fname)
+
+                        # restore tags if needed
+                        self._restore_tags(segmented_fpath)
+
+                        # move fragmented file to target dir
+                        shutil.move(segmented_fpath, self.target_dir)
+
+                # all well
+                task_result.succeeded = True
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+
+class Segmenter(FFMPRunner):
+    def segment(self, ff_entry_params, 
+                    segment_size_MB = 0.0, 
+                    segment_length_secs = 0.0,
+                    reset_timestamps = False):
+
+        ''' Segment media file by specified size | duration
+        '''
+        tasks = []
+        if segment_size_MB or segment_length_secs:
+#           if segment_length_secs:
+#               # here need to determine media length
+#               pass_filter = lambda fpath: self._media_duration(fpath) > segment_length_secs
+#           elif segment_size_MB:
+#               # simple media selection by size
+#               pass_filter = lambda fpath: FFH.ffmpeg_supported_media(fpath) and (self._media_size_MB(fpath) > segment_size_MB)
+
+            ff_entry_params.target_dir_prefix = 'segmented'
+            media_files, target_dirs = self._prepare_files(ff_entry_params)
+
+            # build tasks
+            tasks_params = [(media_file, target_dir_path, ff_entry_params.log_level,
+                                ff_entry_params.ff_general_options, ff_entry_params.ff_other_options, ff_entry_params.preserve_metadata,
+                                reset_timestamps, segment_size_MB, segment_length_secs)
+                                    for media_file, target_dir_path in zip(media_files, target_dirs)]
+            for task_param in tasks_params:
+                task = SegmenterTask(*task_param)
+                tasks.append(task)
+
+        # run tasks
+        self.run_tasks(tasks, serial_exec = ff_entry_params.serial_exec, quiet = ff_entry_params.quiet)
+
+
+    # Internal Helpers
+    @staticmethod
+    def _media_duration(fpath):
+        handler = MutagenTagHandler() + FFmpegTagHandler()
+        if handler.can_handle(fpath):
+            return handler.tag_holder.length
+        else:
+            return 0.0
+
+    @staticmethod
+    def _media_size_MB(fpath):
+        return os.path.getsize(fpath) / 1000**2

batchmp/ffmptools/ffcommands/silencesplit.py

@@ -0,0 +1,159 @@
+# coding=utf8
+## Copyright (c) 2014 Arseniy Kuznetsov
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+
+""" Batch split on silence
+"""
+import shutil, sys, os, fnmatch, shlex
+from batchmp.commons.utils import temp_dir
+from batchmp.ffmptools.ffrunner import FFMPRunner, FFMPRunnerTask, LogLevel
+from batchmp.commons.taskprocessor import TaskResult
+from batchmp.tags.handlers.ffmphandler import FFmpegTagHandler
+from batchmp.tags.handlers.mtghandler import MutagenTagHandler
+from batchmp.ffmptools.ffcommands.cmdopt import FFmpegCommands, FFmpegBitMaskOptions
+from batchmp.ffmptools.ffutils import FFH
+from batchmp.commons.utils import (
+    timed,
+    run_cmd,
+    CmdProcessingError,
+    MiscHelpers
+)
+
+class SilenceSplitterTask(FFMPRunnerTask):
+    ''' Segment TasksProcessor task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                            ff_general_options, ff_other_options, preserve_metadata,
+                            reset_timestamps, silence_min_duration, silence_noise_tolerance_amplitude_ratio, 
+                            silence_auto_duration, silence_target_trimmed_duration):
+
+        super().__init__(fpath, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata)
+
+        self.reset_timestamps = reset_timestamps
+        self.silence_min_duration = silence_min_duration
+        self.silence_noise_tolerance_amplitude_ratio = silence_noise_tolerance_amplitude_ratio
+        self.silence_auto_duration = silence_auto_duration
+        self.silence_target_trimmed_duration = silence_target_trimmed_duration
+
+    def ff_cmd(self, segment_start_times):
+        ''' Silence Splitter command builder
+        '''
+        return ''.join((super().ff_cmd,
+                            FFmpegCommands.SEGMENT,
+                            ' {0} {1}'.format(FFmpegCommands.SEGMENT_TIMES, ','.join(segment_start_times)),
+                            FFmpegCommands.SEGMENT_RESET_TIMESTAMPS if self.reset_timestamps else ''))
+
+    def execute(self):
+        ''' builds and runs Segment FFmpeg command in a subprocess
+        '''
+
+        task_result = TaskResult()
+
+        segment_start_times, task_elapsed = self._segment_start_times()
+        task_result.add_task_step_duration(task_elapsed)
+        if not segment_start_times:
+            task_result.add_task_step_info_msg( \
+                                        'No silence detected in media file:\n\t{0}'.format(self.fpath))
+        else:
+            # store tags if needed
+            self._store_tags()
+
+            with temp_dir() as tmp_dir:
+                # compile intermediary output path
+                fn_parts = os.path.splitext(os.path.basename(self.fpath))
+                fname_ext = fn_parts[1].strip().lower()
+                fpath_output = ''.join((fn_parts[0],
+                                       '_%{}d'.format(MiscHelpers.int_num_digits(len(segment_start_times))),
+                                       fname_ext))
+                fpath_output = os.path.join(tmp_dir, fpath_output)
+
+                # build ffmpeg cmd string
+                p_in = ''.join((self.ff_cmd(segment_start_times), ' {}'.format(shlex.quote(fpath_output))))
+                self._log(p_in, LogLevel.FFMPEG)
+
+                # run ffmpeg command as a subprocess
+                try:
+                    _, task_elapsed = run_cmd(p_in)
+                    task_result.add_task_step_duration(task_elapsed)
+                except CmdProcessingError as e:
+                    task_result.add_task_step_info_msg('A problem while processing media file:\n\t{0}' \
+                                                                        '\nOriginal error message:\n\t{1}' \
+                                                                                .format(self.fpath, e.args[0]))
+                else:
+                    # move split files to target directory
+                    for segmented_fname in os.listdir(tmp_dir):
+                        if fnmatch.fnmatch(segmented_fname, '*{}'.format(fname_ext)):
+                            segmented_fpath = os.path.join(tmp_dir, segmented_fname)
+
+                            # restore tags if needed
+                            self._restore_tags(segmented_fpath)
+
+                            # move fragmented file to target dir
+                            shutil.move(segmented_fpath, self.target_dir)
+
+                    # all well
+                    task_result.succeeded = True
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+    @timed
+    def _segment_start_times(self):
+        silence_entries = FFH.silence_detector(self.fpath,
+                         min_duration = self.silence_min_duration,
+                         noise_tolerance_amplitude_ratio = self.silence_noise_tolerance_amplitude_ratio)        
+        
+        # silence entry duration
+        duration = lambda silence_entry: silence_entry.silence_end - silence_entry.silence_start
+        
+        # auto-duration filter
+        if self.silence_auto_duration:            
+            durations = [duration(silence_entry) for silence_entry in silence_entries]
+            min_duration = MiscHelpers.percentile(durations, 25)        
+            silence_entries = [silence_entry for silence_entry in silence_entries if duration(silence_entry) > min_duration]
+
+        segment_start_times = []
+        for silence_entry in silence_entries:
+            # trim silences start duration
+            silence_start = lambda silence_entry : silence_entry.silence_start \
+                    if duration(silence_entry) < self.silence_target_trimmed_duration \
+                                              else silence_entry.silence_end - self.silence_target_trimmed_duration
+            segment_start_times.append(str(silence_start(silence_entry)))
+
+        return segment_start_times
+
+
+class SilenceSplitter(FFMPRunner):
+    def silence_split(self, ff_entry_params):
+        ''' Segment media file by specified silence
+        '''
+
+        ff_entry_params.target_dir_prefix = 'silence_split'
+        media_files, target_dirs = self._prepare_files(ff_entry_params)
+
+        # build tasks
+        tasks = []        
+        tasks_params = [(media_file, target_dir_path, ff_entry_params.log_level, ff_entry_params.ff_general_options, 
+                            ff_entry_params.ff_other_options, ff_entry_params.preserve_metadata, ff_entry_params.reset_timestamps, 
+                            ff_entry_params.silence_min_duration, ff_entry_params.silence_noise_tolerance_amplitude_ratio, 
+                            ff_entry_params.silence_auto_duration, ff_entry_params.silence_target_trimmed_duration)
+                                for media_file, target_dir_path in zip(media_files, target_dirs)]
+
+        for task_param in tasks_params:
+            task = SilenceSplitterTask(*task_param)
+            tasks.append(task)
+
+        # run tasks
+        self.run_tasks(tasks, serial_exec = ff_entry_params.serial_exec, quiet = ff_entry_params.quiet)
+

batchmp/ffmptools/ffrunner.py

@@ -0,0 +1,189 @@
+# coding=utf8
+## Copyright (c) 2014 Arseniy Kuznetsov
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+
+import os, sys, shlex
+from enum import IntEnum
+from batchmp.fstools.walker import DWalker
+from batchmp.commons.utils import MiscHelpers
+from batchmp.commons.taskprocessor import Task, TasksProcessor
+from batchmp.ffmptools.ffutils import FFH, FFmpegNotInstalled
+from batchmp.tags.handlers.mtghandler import MutagenTagHandler
+from batchmp.tags.handlers.ffmphandler import FFmpegTagHandler
+from batchmp.tags.handlers.tagsholder import TagHolder
+from batchmp.fstools.fsutils import UniqueDirNamesChecker
+from batchmp.ffmptools.ffcommands.cmdopt import FFmpegCommands, FFmpegBitMaskOptions
+
+
+class FFMPRunnerTask(Task):
+    ''' Represents an abstract FFMP Runner task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                        ff_general_options, ff_other_options, preserve_metadata):
+        self.fpath = fpath
+        self.target_dir = target_dir
+        self.log_level = log_level
+
+        self.ff_general_options = FFmpegBitMaskOptions.ff_general_options(ff_general_options)
+        self.ff_other_options = ff_other_options
+
+        self.tag_holder = TagHolder() if preserve_metadata else None
+
+        self._check_defaults()
+
+    @property
+    def ff_cmd(self):
+        ''' Base FFmpeg command builder
+        '''
+        return ''.join(('ffmpeg',
+                            FFmpegCommands.LOG_LEVEL_ERROR,
+                            ' -i {}'.format(shlex.quote(self.fpath)),
+                            self.ff_general_options,
+                            self.ff_other_options))
+
+    # Helpers
+    def _check_defaults(self):
+        if not self.ff_other_options:
+            self.ff_other_options = FFmpegCommands.CONVERT_COPY_VBR_QUALITY
+
+        if not self.ff_general_options:
+            self.ff_general_options = FFmpegBitMaskOptions.ff_general_options(
+                                  FFmpegBitMaskOptions.COPY_CODECS | FFmpegBitMaskOptions.MAP_ALL_STREAMS)
+
+            if self.ff_other_options == FFmpegCommands.CONVERT_COPY_VBR_QUALITY:
+                self.ff_other_options += self._ff_cmd_exclude_artwork_streams()
+
+    def _store_tags(self):
+        if self.tag_holder:
+            handler = MutagenTagHandler() + FFmpegTagHandler()
+            if handler.can_handle(self.fpath):
+                self.tag_holder.copy_tags(handler.tag_holder)
+
+    def _restore_tags(self, fpath):
+        if self.tag_holder:
+            handler = MutagenTagHandler() + FFmpegTagHandler()
+            if handler.can_handle(fpath):
+                handler.tag_holder.copy_tags(self.tag_holder)
+                handler.save()
+
+    def _log(self, msg, type):
+        if self.log_level and self.log_level >= type:
+            # quick log
+            print(msg)
+
+    # FFmpeg command parts builders
+    def _ff_cmd_exclude_artwork_streams(self):
+        media_entry = FFH.media_file_info_full(self.fpath)
+        exclude_artworks_cmd = ''
+        if media_entry:
+            for artwork_stream in media_entry.artwork_streams:
+                idx = artwork_stream.get('index')
+                if idx is not None:
+                    exclude_artworks_cmd = '{0} {1}'.format(exclude_artworks_cmd,
+                                                            FFmpegCommands.exclude_input_stream(idx))
+        return exclude_artworks_cmd
+
+
+class LogLevel(IntEnum):
+    QUIET = 0
+    FFMPEG = 1
+    VERBOSE = 2
+
+
+class FFMPRunner:
+    ''' Base FFMPRunner
+    '''
+    def __init__(self):
+        if not FFH.ffmpeg_installed():
+            print(FFmpegNotInstalled().default_message)
+            sys.exit(0)
+
+    def run_tasks(self, tasks, msg = None, serial_exec = False, quiet = False):
+        if tasks and len(tasks) > 0:
+            print('{0} media files to process'.format(len(tasks)) if msg is None else msg)
+
+            (tasks_results, cpu_core_time), total_elapsed = TasksProcessor().process_tasks(tasks,
+                                                                            serial_exec = serial_exec,
+                                                                            quiet = quiet)
+            # print run report
+            if not quiet:
+                self.run_report(tasks_results, cpu_core_time, total_elapsed)
+        else:
+            print('No media files to process')
+
+
+    def run_report(self, tasks_results, cpu_core_time, total_elapsed):
+        ''' Info summary on executed FFMP commands
+        '''
+        succeeded = sum(1 for result in tasks_results if result.succeeded)
+        failed = sum(1 for result in tasks_results if not result.succeeded)
+
+        total_elapsed_str = MiscHelpers.time_delta_str(total_elapsed)
+        cpu_core_time_str = MiscHelpers.time_delta_str(cpu_core_time)
+
+        num_tasks = len(tasks_results)
+        print('Finished running {0} task{1} '\
+                        '(Succeeded: {2}, Failed: {3})'.format(num_tasks,
+                                                            '' if num_tasks == 1 else 's',
+                                                            succeeded, failed))
+        print('Cumulative FFmpeg CPU Cores time: {}'.format(cpu_core_time_str))
+        print('Total running time: {}'.format(total_elapsed_str))
+
+
+    ## Internal helpers
+    @staticmethod
+    def _prepare_files(ff_entry_params, pass_filter = None):
+        ''' Builds a list of matching media files to process,
+            along with their respective target out dirs
+        '''
+        if not pass_filter:
+            pass_filter = lambda fpath: FFH.ffmpeg_supported_media(fpath)
+        
+        media_files = [entry.realpath for entry in DWalker.file_entries(ff_entry_params, pass_filter = pass_filter)]
+
+        target_dirs = FFMPRunner._setup_target_dirs(ff_entry_params, fpathes = media_files)
+
+        return media_files, target_dirs
+
+    @staticmethod
+    def _setup_target_dirs(ff_entry_params, fpathes = None):
+        # check inputs
+        # target dir prefix
+        DEFAULT_TARGET_DIR_PREFIX = 'processed'
+        if ff_entry_params.target_dir_prefix is None:
+            ff_entry_params.target_dir_prefix = DEFAULT_TARGET_DIR_PREFIX
+        # target dir
+        if ff_entry_params.target_dir is None:
+            ff_entry_params.target_dir = os.path.dirname(ff_entry_params.src_dir)
+
+        # target path (within the target dir)
+        target_dir_name = '{0}_{1}'.format(os.path.basename(ff_entry_params.src_dir), ff_entry_params.target_dir_prefix)
+        target_dir_name = UniqueDirNamesChecker(ff_entry_params.target_dir).unique_name(target_dir_name)
+        target_path_dir = os.path.join(ff_entry_params.target_dir, target_dir_name)
+
+        # target dirs
+        target_dirs = []
+        for fpath in fpathes:
+            relpath = os.path.relpath(os.path.dirname(fpath), ff_entry_params.src_dir)
+            if relpath.startswith(os.pardir):
+                raise ValueError('File not in specified source directory or its subfolders')
+            elif relpath.endswith('{}'.format(os.path.curdir)):
+                relpath = relpath[:-1]
+
+            target_path = os.path.join(target_path_dir, relpath)
+            if not os.path.exists(target_path):
+                os.makedirs(target_path)
+            target_dirs.append(target_path)
+
+        return target_dirs
+