| from __future__ import unicode_literals |
|
|
| from past.builtins import basestring |
| from .dag import KwargReprNode |
| from ._utils import escape_chars, get_hash_int |
| from builtins import object |
| import os |
|
|
|
|
| def _is_of_types(obj, types): |
| valid = False |
| for stream_type in types: |
| if isinstance(obj, stream_type): |
| valid = True |
| break |
| return valid |
|
|
|
|
| def _get_types_str(types): |
| return ', '.join(['{}.{}'.format(x.__module__, x.__name__) for x in types]) |
|
|
|
|
| class Stream(object): |
| """Represents the outgoing edge of an upstream node; may be used to create more downstream nodes.""" |
|
|
| def __init__( |
| self, upstream_node, upstream_label, node_types, upstream_selector=None |
| ): |
| if not _is_of_types(upstream_node, node_types): |
| raise TypeError( |
| 'Expected upstream node to be of one of the following type(s): {}; got {}'.format( |
| _get_types_str(node_types), type(upstream_node) |
| ) |
| ) |
| self.node = upstream_node |
| self.label = upstream_label |
| self.selector = upstream_selector |
|
|
| def __hash__(self): |
| return get_hash_int([hash(self.node), hash(self.label)]) |
|
|
| def __eq__(self, other): |
| return hash(self) == hash(other) |
|
|
| def __repr__(self): |
| node_repr = self.node.long_repr(include_hash=False) |
| selector = '' |
| if self.selector: |
| selector = ':{}'.format(self.selector) |
| out = '{}[{!r}{}] <{}>'.format( |
| node_repr, self.label, selector, self.node.short_hash |
| ) |
| return out |
|
|
| def __getitem__(self, index): |
| """ |
| Select a component (audio, video) of the stream. |
| |
| Example: |
| Process the audio and video portions of a stream independently:: |
| |
| input = ffmpeg.input('in.mp4') |
| audio = input['a'].filter("aecho", 0.8, 0.9, 1000, 0.3) |
| video = input['v'].hflip() |
| out = ffmpeg.output(audio, video, 'out.mp4') |
| """ |
| if self.selector is not None: |
| raise ValueError('Stream already has a selector: {}'.format(self)) |
| elif not isinstance(index, basestring): |
| raise TypeError("Expected string index (e.g. 'a'); got {!r}".format(index)) |
| return self.node.stream(label=self.label, selector=index) |
|
|
| @property |
| def audio(self): |
| """Select the audio-portion of a stream. |
| |
| Some ffmpeg filters drop audio streams, and care must be taken |
| to preserve the audio in the final output. The ``.audio`` and |
| ``.video`` operators can be used to reference the audio/video |
| portions of a stream so that they can be processed separately |
| and then re-combined later in the pipeline. This dilemma is |
| intrinsic to ffmpeg, and ffmpeg-python tries to stay out of the |
| way while users may refer to the official ffmpeg documentation |
| as to why certain filters drop audio. |
| |
| ``stream.audio`` is a shorthand for ``stream['a']``. |
| |
| Example: |
| Process the audio and video portions of a stream independently:: |
| |
| input = ffmpeg.input('in.mp4') |
| audio = input.audio.filter("aecho", 0.8, 0.9, 1000, 0.3) |
| video = input.video.hflip() |
| out = ffmpeg.output(audio, video, 'out.mp4') |
| """ |
| return self['a'] |
|
|
| @property |
| def video(self): |
| """Select the video-portion of a stream. |
| |
| Some ffmpeg filters drop audio streams, and care must be taken |
| to preserve the audio in the final output. The ``.audio`` and |
| ``.video`` operators can be used to reference the audio/video |
| portions of a stream so that they can be processed separately |
| and then re-combined later in the pipeline. This dilemma is |
| intrinsic to ffmpeg, and ffmpeg-python tries to stay out of the |
| way while users may refer to the official ffmpeg documentation |
| as to why certain filters drop audio. |
| |
| ``stream.video`` is a shorthand for ``stream['v']``. |
| |
| Example: |
| Process the audio and video portions of a stream independently:: |
| |
| input = ffmpeg.input('in.mp4') |
| audio = input.audio.filter("aecho", 0.8, 0.9, 1000, 0.3) |
| video = input.video.hflip() |
| out = ffmpeg.output(audio, video, 'out.mp4') |
| """ |
| return self['v'] |
|
|
|
|
| def get_stream_map(stream_spec): |
| if stream_spec is None: |
| stream_map = {} |
| elif isinstance(stream_spec, Stream): |
| stream_map = {None: stream_spec} |
| elif isinstance(stream_spec, (list, tuple)): |
| stream_map = dict(enumerate(stream_spec)) |
| elif isinstance(stream_spec, dict): |
| stream_map = stream_spec |
| return stream_map |
|
|
|
|
| def get_stream_map_nodes(stream_map): |
| nodes = [] |
| for stream in list(stream_map.values()): |
| if not isinstance(stream, Stream): |
| raise TypeError('Expected Stream; got {}'.format(type(stream))) |
| nodes.append(stream.node) |
| return nodes |
|
|
|
|
| def get_stream_spec_nodes(stream_spec): |
| stream_map = get_stream_map(stream_spec) |
| return get_stream_map_nodes(stream_map) |
|
|
|
|
| class Node(KwargReprNode): |
| """Node base""" |
|
|
| @classmethod |
| def __check_input_len(cls, stream_map, min_inputs, max_inputs): |
| if min_inputs is not None and len(stream_map) < min_inputs: |
| raise ValueError( |
| 'Expected at least {} input stream(s); got {}'.format( |
| min_inputs, len(stream_map) |
| ) |
| ) |
| elif max_inputs is not None and len(stream_map) > max_inputs: |
| raise ValueError( |
| 'Expected at most {} input stream(s); got {}'.format( |
| max_inputs, len(stream_map) |
| ) |
| ) |
|
|
| @classmethod |
| def __check_input_types(cls, stream_map, incoming_stream_types): |
| for stream in list(stream_map.values()): |
| if not _is_of_types(stream, incoming_stream_types): |
| raise TypeError( |
| 'Expected incoming stream(s) to be of one of the following types: {}; got {}'.format( |
| _get_types_str(incoming_stream_types), type(stream) |
| ) |
| ) |
|
|
| @classmethod |
| def __get_incoming_edge_map(cls, stream_map): |
| incoming_edge_map = {} |
| for downstream_label, upstream in list(stream_map.items()): |
| incoming_edge_map[downstream_label] = ( |
| upstream.node, |
| upstream.label, |
| upstream.selector, |
| ) |
| return incoming_edge_map |
|
|
| def __init__( |
| self, |
| stream_spec, |
| name, |
| incoming_stream_types, |
| outgoing_stream_type, |
| min_inputs, |
| max_inputs, |
| args=[], |
| kwargs={}, |
| ): |
| stream_map = get_stream_map(stream_spec) |
| self.__check_input_len(stream_map, min_inputs, max_inputs) |
| self.__check_input_types(stream_map, incoming_stream_types) |
| incoming_edge_map = self.__get_incoming_edge_map(stream_map) |
|
|
| super(Node, self).__init__(incoming_edge_map, name, args, kwargs) |
| self.__outgoing_stream_type = outgoing_stream_type |
| self.__incoming_stream_types = incoming_stream_types |
|
|
| def stream(self, label=None, selector=None): |
| """Create an outgoing stream originating from this node. |
| |
| More nodes may be attached onto the outgoing stream. |
| """ |
| return self.__outgoing_stream_type(self, label, upstream_selector=selector) |
|
|
| def __getitem__(self, item): |
| """Create an outgoing stream originating from this node; syntactic sugar for ``self.stream(label)``. |
| It can also be used to apply a selector: e.g. ``node[0:'a']`` returns a stream with label 0 and |
| selector ``'a'``, which is the same as ``node.stream(label=0, selector='a')``. |
| |
| Example: |
| Process the audio and video portions of a stream independently:: |
| |
| input = ffmpeg.input('in.mp4') |
| audio = input[:'a'].filter("aecho", 0.8, 0.9, 1000, 0.3) |
| video = input[:'v'].hflip() |
| out = ffmpeg.output(audio, video, 'out.mp4') |
| """ |
| if isinstance(item, slice): |
| return self.stream(label=item.start, selector=item.stop) |
| else: |
| return self.stream(label=item) |
|
|
|
|
| class FilterableStream(Stream): |
| def __init__(self, upstream_node, upstream_label, upstream_selector=None): |
| super(FilterableStream, self).__init__( |
| upstream_node, upstream_label, {InputNode, FilterNode}, upstream_selector |
| ) |
|
|
|
|
| |
| class InputNode(Node): |
| """InputNode type""" |
|
|
| def __init__(self, name, args=[], kwargs={}): |
| super(InputNode, self).__init__( |
| stream_spec=None, |
| name=name, |
| incoming_stream_types={}, |
| outgoing_stream_type=FilterableStream, |
| min_inputs=0, |
| max_inputs=0, |
| args=args, |
| kwargs=kwargs, |
| ) |
|
|
| @property |
| def short_repr(self): |
| return os.path.basename(self.kwargs['filename']) |
|
|
|
|
| |
| class FilterNode(Node): |
| def __init__(self, stream_spec, name, max_inputs=1, args=[], kwargs={}): |
| super(FilterNode, self).__init__( |
| stream_spec=stream_spec, |
| name=name, |
| incoming_stream_types={FilterableStream}, |
| outgoing_stream_type=FilterableStream, |
| min_inputs=1, |
| max_inputs=max_inputs, |
| args=args, |
| kwargs=kwargs, |
| ) |
|
|
| """FilterNode""" |
|
|
| def _get_filter(self, outgoing_edges): |
| args = self.args |
| kwargs = self.kwargs |
| if self.name in ('split', 'asplit'): |
| args = [len(outgoing_edges)] |
|
|
| out_args = [escape_chars(x, '\\\'=:') for x in args] |
| out_kwargs = {} |
| for k, v in list(kwargs.items()): |
| k = escape_chars(k, '\\\'=:') |
| v = escape_chars(v, '\\\'=:') |
| out_kwargs[k] = v |
|
|
| arg_params = [escape_chars(v, '\\\'=:') for v in out_args] |
| kwarg_params = ['{}={}'.format(k, out_kwargs[k]) for k in sorted(out_kwargs)] |
| params = arg_params + kwarg_params |
|
|
| params_text = escape_chars(self.name, '\\\'=:') |
|
|
| if params: |
| params_text += '={}'.format(':'.join(params)) |
| return escape_chars(params_text, '\\\'[],;') |
|
|
|
|
| |
| class OutputNode(Node): |
| def __init__(self, stream, name, args=[], kwargs={}): |
| super(OutputNode, self).__init__( |
| stream_spec=stream, |
| name=name, |
| incoming_stream_types={FilterableStream}, |
| outgoing_stream_type=OutputStream, |
| min_inputs=1, |
| max_inputs=None, |
| args=args, |
| kwargs=kwargs, |
| ) |
|
|
| @property |
| def short_repr(self): |
| return os.path.basename(self.kwargs['filename']) |
|
|
|
|
| class OutputStream(Stream): |
| def __init__(self, upstream_node, upstream_label, upstream_selector=None): |
| super(OutputStream, self).__init__( |
| upstream_node, |
| upstream_label, |
| {OutputNode, GlobalNode, MergeOutputsNode}, |
| upstream_selector=upstream_selector, |
| ) |
|
|
|
|
| |
| class MergeOutputsNode(Node): |
| def __init__(self, streams, name): |
| super(MergeOutputsNode, self).__init__( |
| stream_spec=streams, |
| name=name, |
| incoming_stream_types={OutputStream}, |
| outgoing_stream_type=OutputStream, |
| min_inputs=1, |
| max_inputs=None, |
| ) |
|
|
|
|
| |
| class GlobalNode(Node): |
| def __init__(self, stream, name, args=[], kwargs={}): |
| super(GlobalNode, self).__init__( |
| stream_spec=stream, |
| name=name, |
| incoming_stream_types={OutputStream}, |
| outgoing_stream_type=OutputStream, |
| min_inputs=1, |
| max_inputs=1, |
| args=args, |
| kwargs=kwargs, |
| ) |
|
|
|
|
| def stream_operator(stream_classes={Stream}, name=None): |
| def decorator(func): |
| func_name = name or func.__name__ |
| [setattr(stream_class, func_name, func) for stream_class in stream_classes] |
| return func |
|
|
| return decorator |
|
|
|
|
| def filter_operator(name=None): |
| return stream_operator(stream_classes={FilterableStream}, name=name) |
|
|
|
|
| def output_operator(name=None): |
| return stream_operator(stream_classes={OutputStream}, name=name) |
|
|
|
|
| __all__ = ['Stream'] |
|
|
