added audio/video encoder and muxer

1 files changed, 127 insertions, 38 deletions

diff --git a/src/flufigut.py b/src/flufigut.py
index d7b4836..c533a08 100755
--- a/src/flufigut.py
+++ b/src/flufigut.py
@@ -127,7 +127,7 @@ class Planet:
 
     #
     # muxes
-    def __generate_audio_resampler(self, mux, format, inputs, globals):
+    def __generate_audio_resampler(self, mux, format, profile, inputs, globals):
         source = mux['audio'].split(':')[0]
         input_samplerate = inputs[source]['properties']['samplerate']
         if 'samplerate' not in globals['formats'][format]:
@@ -142,6 +142,7 @@ class Planet:
             self._components[comp_name] = -1
         else:
             self._components[comp_name] = 1
+
         feeder = 'input-%s' % (mux['audio'])
         self.flow['inputs']['resample-%s-%s' % (source, samplerate)] = {
             'type': 'audio-resample',
@@ -153,56 +154,144 @@ class Planet:
             },
         }
 
-    def __generate_video_resizer(self, mux, format, inputs, globals):
+    def __generate_video_resizer(self, mux, format, profile, inputs, globals):
         source = mux['video'].split(':')[0]
         input_resolution = inputs[source]['properties']['resolution']
-        for profile in mux['formats'][format]:
-            if 'video' not in globals['profiles'][profile]:
-                continue
+        if 'video' not in globals['profiles'][profile]:
+            return
 
-            if input_resolution == "":
-                raise exception("format definition needs video but no video input given")
-            resolution = globals['profiles'][profile]['video']
+        if input_resolution == "":
+            raise exception("format definition needs video but no video input given")
+        resolution = globals['profiles'][profile]['video']
 
-            if input_resolution == resolution:
-                continue
+        if input_resolution == resolution:
+            return
 
-            if globals['resolutions'][resolution]['rate'] != globals['resolutions'][input_resolution]['rate']:
-                raise exception("ERROR: video rate conversion is not yet supported!!!")
+        if globals['resolutions'][resolution]['rate'] != globals['resolutions'][input_resolution]['rate']:
+            raise exception("ERROR: video rate conversion is not yet supported!!!")
 
-            comp_name = 'resize-%s' % (source)
-            if comp_name not in self._components:
-                self._components[comp_name] = -1
-            else:
-                self._components[comp_name] = 1
-            feeder = 'input-%s' % (mux['video'])
-            self.flow['inputs']['resize-%s-%s' % (source, resolution)] = {
-                'type': 'video-resize',
-                'desc': "resize video from %s to %sx%s" % (source, globals['resolutions'][resolution]['width'],
-                                                           globals['resolutions'][resolution]['height']),
-                'worker': comp_name,
-                'feeder': feeder,
-                'properties': {
-                    'width': globals['resolutions'][resolution]['width'],
-                    'height': globals['resolutions'][resolution]['height'],
-                },
-            }
+        comp_name = 'resize-%s' % (source)
+        if comp_name not in self._components:
+            self._components[comp_name] = -1
+        else:
+            self._components[comp_name] = 1
+
+        feeder = 'input-%s' % (mux['video'])
+        self.flow['inputs']['resize-%s-%s' % (source, resolution)] = {
+            'type': 'video-resize',
+            'desc': "resize video from %s to %sx%s" % (source, globals['resolutions'][resolution]['width'],
+                                                       globals['resolutions'][resolution]['height']),
+            'worker': comp_name,
+            'feeder': feeder,
+            'properties': {
+                'width': globals['resolutions'][resolution]['width'],
+                'height': globals['resolutions'][resolution]['height'],
+            },
+        }
+
+    def __generate_audio_encoder(self, mux, format, profile, inputs, globals):
+        encoder = globals['formats'][format]['audio']
+        bitrate = globals['profiles'][profile]['audio']
+        source = mux['audio'].split(':')[0]
+        input_samplerate = inputs[source]['properties']['samplerate']
+
+        samplerate = input_samplerate
+        if 'samplerate' in globals['formats'][format]:
+            samplerate = globals['formats'][format]['samplerate']
+
+        feeder = 'input-%s' % (mux['audio'])
+        if samplerate != input_samplerate:
+            feeder = 'resample-%s-%s' % (source, samplerate)
+
+        audio_encoder = 'encode-%s-%s-%i-%i' % (source, encoder, bitrate, samplerate)
+        if audio_encoder in self.flow['encoders_audio']:
+            return audio_encoder
+
+        comp_name = 'encoder-%s-%s-%s' % (source, encoder, bitrate)
+        if comp_name not in self._components:
+            self._components[comp_name] = -1
+        else:
+            self._components[comp_name] = 1
+
+        self.flow['encoders_audio'][audio_encoder] = {
+            'type': '%s-encode' % encoder,
+            'desc': "%s encoder for %i kbit/s @ %i Hz, from %s" % (encoder, bitrate, samplerate, source),
+            'worker': comp_name,
+            'feeder': feeder,
+            'properties': {
+                'bitrate': bitrate,
+            },
+        }
+        return audio_encoder
+
+    def __generate_video_encoder(self, mux, format, profile, inputs, globals):
+        encoder = globals['formats'][format]['video']
+        resolution = globals['profiles'][profile]['video']
+        bitrate = globals['bitrates'][encoder][resolution]
+        source = mux['video'].split(':')[0]
+        input_resolution = inputs[source]['properties']['resolution']
+
+        feeder = 'input-%s' % (mux['video'])
+        if resolution != input_resolution:
+            feeder = 'resize-%s-%s' % (source, resolution)
+
+        video_encoder = 'encode-%s-%s-%s' % (source, encoder, resolution)
+        if video_encoder in self.flow['encoders_video']:
+            return video_encoder
+
+        comp_name = 'encoder-%s-%s-%s' % (source, encoder, resolution)
+        if comp_name not in self._components:
+            self._components[comp_name] = -1
+        else:
+            self._components[comp_name] = 1
+
+        self.flow['encoders_video'][video_encoder] = {
+            'type': '%s-encode' % encoder,
+            'desc': "%s encoder for %sx%s, from %s" % (encoder, globals['resolutions'][resolution]['width'], globals['resolutions'][resolution]['height'], source),
+            'worker': comp_name,
+            'feeder': feeder,
+            'properties': {
+                'bitrate': bitrate,
+            },
+        }
+        return video_encoder
+
+    def __generate_muxer(self, mux_name, format, profile, globals, audio_encoder, video_encoder):
+        muxer = globals['formats'][format]['muxer']
+
+        comp_name = 'muxer-%s-%s-%s' % (mux_name, format, profile)
+        if comp_name not in self._components:
+            self._components[comp_name] = -1
+        else:
+            self._components[comp_name] = 1
+
+        self.flow['muxers']['muxer-%s-%s-%s' % (mux_name, format, profile)] = {
+            'type': '%s-mux' % muxer,
+            'desc': "%s muxer for %s, profile %s" % (format, mux_name, profile),
+            'worker': comp_name,
+            'feeder_audio': audio_encoder,
+            'feeder_video': video_encoder,
+            'properties': {},
+        }
 
     def _generate_muxes(self, muxes, inputs, globals):
         self.flow['encoders_audio'] = {}
         self.flow['encoders_video'] = {}
         self.flow['muxers'] = {}
 
-        for _, mux in muxes.items():
+        for mux_name, mux in muxes.items():
             for format in mux['formats'].keys():
-                audio_encoder = 'none'
-                video_encoder = 'none'
-                if 'audio' in mux:
-                    self.__generate_audio_resampler(mux, format, inputs, globals)
-                if 'video' in mux:
-                    self.__generate_video_resizer(mux, format, inputs, globals)
-
-        # TODO: add encoder and muxer
+                for profile in mux['formats'][format]:
+                    audio_encoder = 'none'
+                    video_encoder = 'none'
+                    if 'audio' in mux:
+                        self.__generate_audio_resampler(mux, format, profile, inputs, globals)
+                        audio_encoder = self.__generate_audio_encoder(mux, format, profile, inputs, globals)
+                    if 'video' in mux:
+                        self.__generate_video_resizer(mux, format, profile, inputs, globals)
+                        video_encoder = self.__generate_video_encoder(mux, format, profile, inputs, globals)
+
+                    self.__generate_muxer(mux_name, format, profile, globals, audio_encoder, video_encoder)
 
     #
     # all