batchmp 1.4__py3-none-any.whl

batchmp/ffmptools/ffcommands/convert.py

@@ -0,0 +1,130 @@
+# 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 Conversion of media files
+"""
+import shutil, sys, os, shlex
+from batchmp.commons.utils import temp_dir
+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 ConvertorTask(FFMPRunnerTask):
+    ''' Conversion TasksProcessor task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata,
+                                                            target_format):
+        self.target_format = target_format
+
+        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
+        elif self.ff_other_options == FFmpegCommands.CONVERT_LOSSLESS:
+            # see if lossless is appropriate
+            # TBD: video formats
+            if self.target_format == '.flac':
+                self.ff_other_options = FFmpegCommands.CONVERT_LOSSLESS_FLAC
+            elif self.target_format == '.m4a':
+                self.ff_other_options = FFmpegCommands.CONVERT_LOSSLESS_ALAC
+            else:
+                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 in (FFmpegCommands.CONVERT_COPY_VBR_QUALITY,
+                                         FFmpegCommands.CONVERT_LOSSLESS_FLAC,
+                                         FFmpegCommands.CONVERT_LOSSLESS_ALAC,
+                                         FFmpegCommands.CONVERT_CHANGE_CONTAINER):
+                self.ff_other_options += self._ff_cmd_exclude_artwork_streams()
+
+    def execute(self):
+        ''' builds and runs FFmpeg Conversion command in a subprocess
+        '''
+        # store tags if needed
+        self._store_tags()
+
+        task_result = TaskResult()
+
+        with temp_dir() as tmp_dir:
+            # prepare the tmp output path
+            conv_fname = ''.join((os.path.splitext(os.path.basename(self.fpath))[0], self.target_format))
+            conv_fpath = os.path.join(tmp_dir, conv_fname)
+
+            # build ffmpeg cmd string
+            p_in = ''.join((self.ff_cmd, ' {}'.format(shlex.quote(conv_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(conv_fpath)
+
+                # move converted file to target dir
+                shutil.move(conv_fpath, self.target_dir)
+
+                # all well
+                task_result.succeeded = True
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+
+class Convertor(FFMPRunner):
+    def convert(self, ff_entry_params):
+
+        ''' Converts media to specified format
+        '''
+        tasks = []
+        if ff_entry_params.target_format:
+            if ff_entry_params.target_format.startswith('.'):
+                target_dir_prefix = '{}'.format(ff_entry_params.target_format[1:])
+            else:
+                target_dir_prefix = '{}'.format(ff_entry_params.target_format)
+                target_format = '.{}'.format(ff_entry_params.target_format)
+            ff_entry_params.target_dir_prefix = target_dir_prefix
+
+            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,
+                                ff_entry_params.target_format)
+                                    for media_file, target_dir_path in zip(media_files, target_dirs)]
+            for task_param in tasks_params:
+                task = ConvertorTask(*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/cuesplit.py

@@ -0,0 +1,223 @@
+# 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 cue splitter
+"""
+import shutil, sys, os, shlex, re
+from datetime import timedelta
+from batchmp.commons.utils import temp_dir
+from batchmp.ffmptools.ffrunner import FFMPRunner, LogLevel
+from batchmp.commons.taskprocessor import TaskResult
+from batchmp.fstools.walker import DWalker
+from batchmp.ffmptools.utils.cueparse import CueParser, CueParseReadDataEncodingError
+from batchmp.tags.handlers.tagsholder import TagHolder
+from batchmp.ffmptools.ffcommands.convert import ConvertorTask
+from batchmp.commons.descriptors import PropertyDescriptor
+from batchmp.commons.utils import (
+    run_cmd,
+    CmdProcessingError
+)
+
+class CueSplitTagHolder(TagHolder):
+    ''' Need a few extra attributes for cue splitting
+    '''
+    cue_virt_fpath = PropertyDescriptor()
+    time_offset = PropertyDescriptor()
+
+
+class CueSplitterTask(ConvertorTask):
+    ''' Cue Slit TasksProcessor task
+    '''
+    def __init__(self, cue_tag_holder, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata,
+                                                target_format):
+
+        # unpack relevant properties due to pickle / multiprocessing
+        self.time_offset = cue_tag_holder.time_offset
+        self.duration = cue_tag_holder.length
+
+        self.track_number = cue_tag_holder.track
+        self.year = cue_tag_holder.year
+        self.genre = cue_tag_holder.genre
+        self.track_title = cue_tag_holder.title
+        self.albumartist = cue_tag_holder.albumartist
+        self.album = cue_tag_holder.album
+        self.composer = cue_tag_holder.composer
+        self.comments = cue_tag_holder.comments
+
+        super().__init__(cue_tag_holder.filepath, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata, target_format)
+
+    @property
+    def ff_cmd(self):
+        ''' Cue Split command builder
+        '''
+        return ''.join((super().ff_cmd,
+                            ' -ss {}'.format(self.time_offset),
+                            ' -t {}'.format(self.duration)
+                            ))
+
+    def _store_tags(self):
+        if self.tag_holder:
+            if self.track_title:
+                self.tag_holder.title = self.track_title
+            if self.album:
+                self.tag_holder.album = self.album
+            if self.albumartist:
+               self.tag_holder.albumartist  = self.albumartist
+            if self.composer:
+                self.tag_holder.composer = self.composer
+            if self.track_number:
+                self.tag_holder.track  = self.track_number
+            if self.comments:
+                self.tag_holder.comments = self.comments
+            if self.year:
+                self.tag_holder.year = self.year
+            if self.genre:
+                self.tag_holder.genre = self.genre
+
+
+    def execute(self):
+        ''' builds and runs FFmpeg Conversion command in a subprocess
+        '''
+        # store tags
+        self._store_tags()
+
+        task_result = TaskResult()
+
+        with temp_dir() as tmp_dir:
+            # prepare the tmp output path
+            conv_fname = '{0:02d} {1}'.format(self.track_number, self.track_title)
+            conv_fname = re.sub(r'[^\w\-_\. ]', '_', conv_fname)
+            conv_fname = ''.join((conv_fname, self.target_format))
+            conv_fpath = os.path.join(tmp_dir, conv_fname)
+
+            # build ffmpeg cmd string
+            p_in = ''.join((self.ff_cmd, ' {}'.format(shlex.quote(conv_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(conv_fpath)
+
+                # move converted file to target dir
+                shutil.move(conv_fpath, self.target_dir)
+
+                # all well
+                task_result.succeeded = True
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+
+class CueSplitter(FFMPRunner):
+    def cue_split(self, ff_entry_params, encoding = 'utf-8'):
+
+        ''' Converts media to specified format
+        '''
+        tasks = []
+        if ff_entry_params.target_format:
+            if not ff_entry_params.target_format.startswith('.'):
+                ff_entry_params.target_format = '.{}'.format(ff_entry_params.target_format)
+            ff_entry_params.target_dir_prefix = '{}'.format(ff_entry_params.target_format[1:])
+
+            cue_tagholders, target_dirs = self._prepare_cue_data(ff_entry_params, encoding = encoding)
+            # build tasks
+            tasks_params = [(cue_tag_holder, 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.target_format)
+                                    for cue_tag_holder, target_dir_path in zip(cue_tagholders, target_dirs)]
+            for task_param in tasks_params:
+                task = CueSplitterTask(*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 _prepare_cue_data(ff_entry_params,                        
+                        pass_filter = None,
+                        encoding = 'utf-8'):
+        ''' Builds a list of target media files and their tagholder attributes corresponding to found .cue files.
+            Prepares their respective target output dirs
+        '''
+        pass_filter = lambda fpath: fpath.endswith('.cue')
+
+        cue_fpaths = [entry.realpath for entry in DWalker.file_entries(ff_entry_params, pass_filter = pass_filter)]
+
+        cue_tagholders = CueSplitter._prepare_tagholders(cue_fpaths, encoding = encoding)
+
+        target_dirs = FFMPRunner._setup_target_dirs(ff_entry_params,
+                        fpathes = [cue_tagholder.cue_virt_fpath for cue_tagholder in cue_tagholders])
+
+        return cue_tagholders, target_dirs
+
+
+    @staticmethod
+    def _prepare_tagholders(cue_fpaths, encoding):
+        cue_tagholders = []
+        for cue_fpath in cue_fpaths:
+            cue_parser = CueParser()
+            try:
+                cue_sheet = cue_parser.parse(cue_fpath, encoding = encoding)
+            except CueParseReadDataEncodingError:
+                print('\nUnable to read data from the "{0}" file using encoding: {1}'.format(cue_fpath, encoding))
+                print('Use the \'-en\' encoding option to specify correct encoding, e.g.: -en \'latin-1\'\n')
+                exit(1)
+
+            for file in cue_sheet.files:
+                for track in file.tracks:
+                    tag_holder = CueSplitTagHolder()
+
+                    cue_virt_dir = os.path.dirname(cue_fpath) + os.path.sep + \
+                                                        os.path.splitext(os.path.basename(cue_fpath))[0]
+                    tag_holder.cue_virt_fpath = os.path.join(cue_virt_dir, file.name)
+                    tag_holder.filepath = os.path.join(os.path.dirname(cue_fpath), file.name)
+
+                    if cue_sheet.rem:
+                        for rem_item in cue_sheet.rem:
+                            if not tag_holder.year:
+                                match = re.match(r'DATE.+(\d{4})', rem_item)
+                                if match:
+                                    tag_holder.year = match.group(1)
+                                    continue
+                            if not tag_holder.genre:
+                                match = re.match(r'GENRE\s+(.+)$', rem_item)
+                                if match:
+                                    tag_holder.genre = match.group(1)
+                        tag_holder.comments = ', '.join(cue_sheet.rem)
+
+                    tag_holder.title = track.title or cue_sheet.title
+                    tag_holder.album = cue_sheet.title
+                    tag_holder.albumartist = track.performer or cue_sheet.performer
+                    tag_holder.composer = track.songwriter or cue_sheet.songwriter
+
+                    tag_holder.track = track.number
+                    tag_holder.time_offset = track.offset_in_seconds
+                    tag_holder.length = track.duration_in_seconds or timedelta(days = 30).total_seconds()
+
+                    cue_tagholders.append(tag_holder)
+
+        return cue_tagholders
+

batchmp/ffmptools/ffcommands/denoise.py

@@ -0,0 +1,173 @@
+# 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 Reduce of background audio noise in media files,
+    via filtering out highpass / low-pass frequencies
+    Supports multi-passes processing, e.g. 3 times for each media file
+"""
+import shutil, sys, os, datetime, math, shlex
+from batchmp.commons.utils import temp_dir
+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 DenoiserTask(FFMPRunnerTask):
+    ''' Denoise TasksProcessor task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                            ff_general_options, ff_other_options, preserve_metadata,
+                                                        highpass, lowpass, num_passes):
+        # build ffmpeg '-af' parameter
+        if highpass and lowpass:
+            af_str = 'highpass=f={0}, lowpass=f={1}'.format(highpass, lowpass)
+        elif lowpass:
+            af_str = 'lowpass=f={}'.format(lowpass)
+        elif highpass:
+            af_str = 'highpass=f={}'.format(highpass)
+        else:
+            raise ValueError('At least one of the highpass / lowpass values must be specified')
+
+        self.af_str = af_str
+        self.num_passes = num_passes
+        self.excluded_artwork_streams = False
+
+        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()
+                self.excluded_artwork_streams = True
+
+
+    def ff_denoise_cmd(self, fpath, pass_cnt):
+        ''' Denoise command builder
+        '''
+        # when implicitly excluding artwork streams, need to do this only for the first pass
+        apply_ff_other_options = (not self.excluded_artwork_streams) or (pass_cnt == 0)
+
+        return ''.join(('ffmpeg',
+                            FFmpegCommands.LOG_LEVEL_ERROR,
+                            ' -i {}'.format(shlex.quote(fpath)),
+                            self.ff_general_options,
+                            self.ff_other_options if apply_ff_other_options else '',
+                            ' -af {}'.format(shlex.quote(self.af_str))))
+
+    def execute(self):
+        ''' builds and runs Denoise command in a subprocess
+        '''
+        fname = os.path.basename(self.fpath)
+        fname_ext = os.path.splitext(fname)[1].strip().lower()
+
+        # ffmpeg initial input path
+        fpath_input = self.fpath
+
+        # store tags if needed
+        self._store_tags()
+        task_result = TaskResult()
+
+        with temp_dir() as tmp_dir:
+            # process the file in given number of passes
+            for pass_cnt in range(self.num_passes):
+
+                # compile intermediary output path
+                fpath_output = ''.join((os.path.splitext(fname)[0],
+                                        '_{}'.format(datetime.datetime.now().strftime("%H%M%S%f")),
+                                        fname_ext))
+                fpath_output = os.path.join(tmp_dir, fpath_output)
+
+                p_in = '{0} {1}'.format(self.ff_denoise_cmd(fpath_input, pass_cnt), shlex.quote(fpath_output))
+                self._log(p_in, LogLevel.FFMPEG)
+
+                # run ffmpeg command as a subprocess
+                try:
+                    _, pass_elapsed = run_cmd(p_in)
+                except CmdProcessingError as e:
+                    task_result.add_task_step_info_msg('\nA problem while processing media file:\n\t{0}' \
+                                  '\nSkipping further processing at pass {1} ...' \
+                                  '\nOriginal error message:\n\t{2}' \
+                                  .format(fpath_input, pass_cnt + 1, e.args[0]))
+                    break
+                else:
+                    task_result.add_task_step_duration(pass_elapsed)
+
+                if pass_cnt == self.num_passes - 1:
+                    # the last pass, rounding up
+
+                    # restore tags if needed
+                    self._restore_tags(fpath_output)
+
+                    # move denoised file to target dir
+                    shutil.move(fpath_output, os.path.join(self.target_dir, fname))
+
+                    # all well
+                    task_result.succeeded = True
+                else:
+                    # for the next pass, just make the intermediary output new input
+                    fpath_input = fpath_output
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+
+class Denoiser(FFMPRunner):
+    DEFAULT_HIGHPASS = 200
+    DEFAULT_LOWPASS = 3000
+    DEFAULT_NUM_PASSES = 1
+
+    def apply_af_filters(self, ff_entry_params,
+                            num_passes = None, highpass = None, lowpass = None):
+
+        ''' Reduce of background audio noise in media files
+            via filtering out highpass / low-pass frequencies
+        '''
+        if not highpass:
+            highpass = self.DEFAULT_HIGHPASS
+        if not lowpass:
+            lowpass = self.DEFAULT_LOWPASS
+        if not num_passes:
+            num_passes = self.DEFAULT_NUM_PASSES
+
+        ff_entry_params.target_dir_prefix = 'denoised'
+        media_files, target_dirs = self._prepare_files(ff_entry_params)
+
+        msg = None if len(media_files) == 0 else \
+                                '{0} media files to process, ({1} {2} each)'.format(
+                                                            len(media_files), num_passes,
+                                                            'passes' if num_passes > 1 else 'pass')
+        # 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,
+                            highpass, lowpass, num_passes)
+                                for media_file, target_dir_path in zip(media_files, target_dirs)]
+        for task_param in tasks_params:
+            task = DenoiserTask(*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/fragment.py

@@ -0,0 +1,121 @@
+# 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 Fragmentation of media files
+"""
+import shutil, sys, os, shlex
+from batchmp.commons.utils import temp_dir
+from batchmp.ffmptools.ffrunner import FFMPRunner, FFMPRunnerTask, LogLevel
+from batchmp.commons.taskprocessor import TaskResult
+from batchmp.ffmptools.ffcommands.cmdopt import FFmpegCommands, FFmpegBitMaskOptions
+from batchmp.ffmptools.ffcommands.segment import Segmenter
+from batchmp.commons.utils import (
+    timed,
+    run_cmd,
+    CmdProcessingError
+)
+
+class FragmenterTask(FFMPRunnerTask):
+    ''' Fragment TasksProcessor task
+    '''
+    def __init__(self, fpath, target_dir, log_level,
+                            ff_general_options, ff_other_options, preserve_metadata,
+                            fragment_starttime, fragment_duration, fragment_trim):
+
+        self.fragment_starttime = fragment_starttime
+        self.fragment_duration = fragment_duration
+        self.fragment_trim = fragment_trim
+
+        super().__init__(fpath, target_dir, log_level,
+                                ff_general_options, ff_other_options, preserve_metadata)
+
+    @property
+    def ff_cmd(self):
+        ''' Fragment command builder
+        '''
+        if self.fragment_trim:
+            media_duration = Segmenter._media_duration(self.fpath)
+            self.fragment_duration = media_duration - self.fragment_trim - self.fragment_starttime
+        return ''.join((super().ff_cmd,
+                            ' -ss {}'.format(self.fragment_starttime),
+                            ' -t {}'.format(self.fragment_duration)
+                            ))
+
+    def execute(self):
+        ''' builds and runs Fragment FFmpeg command in a subprocess
+        '''
+        # store tags if needed
+        self._store_tags()
+
+        task_result = TaskResult()
+
+        with temp_dir() as tmp_dir:
+            # prepare the tmp output path
+            fragmented_fpath = os.path.join(tmp_dir, os.path.basename(self.fpath))
+
+            # build ffmpeg cmd string
+            p_in = '{0} {1}'.format(self.ff_cmd, shlex.quote(fragmented_fpath))
+            self._log(p_in, LogLevel.FFMPEG)
+
+            # run ffmpeg command as a subprocess
+            try:
+                if self.fragment_duration < 0:
+                    raise CmdProcessingError('A problem while processing media file {0}: \
+                                            Negative media duration {1}s, check your input parameters to add up correctly'\
+                                            .format(self.fpath, int(self.fragment_duration)))                
+
+                _, 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(fragmented_fpath)
+
+                # move fragmented file to target dir
+                shutil.move(fragmented_fpath, self.target_dir)
+
+                # all well
+                task_result.succeeded = True
+
+        task_result.add_report_msg(self.fpath)
+        return task_result
+
+
+class Fragmenter(FFMPRunner):
+    def fragment(self, ff_entry_params,
+                    fragment_starttime = None, fragment_duration = None, fragment_trim = None):
+
+        ''' Fragment media file by specified starttime & duration
+        '''
+        tasks = []
+        if (fragment_starttime is not None) and (fragment_duration is not None):
+            ff_entry_params.target_dir_prefix = 'fragmented'
+            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,
+                                fragment_starttime, fragment_duration, fragment_trim)
+                                    for media_file, target_dir_path in zip(media_files, target_dirs)]
+            for task_param in tasks_params:
+                task = FragmenterTask(*task_param)
+                tasks.append(task)
+
+        # run tasks
+        self.run_tasks(tasks, serial_exec = ff_entry_params.serial_exec, quiet = ff_entry_params.quiet)
+
+