cleanups

1 files changed, 32 insertions, 37 deletions

diff --git a/src/flufigut.py b/src/flufigut.py
index 6882299..8841727 100755
--- a/src/flufigut.py
+++ b/src/flufigut.py
@@ -126,11 +126,11 @@ class Planet:
         source = mux['audio'].split(':')[0]
         input_samplerate = inputs[source]['properties']['samplerate']
         if 'samplerate' not in globals['formats'][format]:
-            return
+            return None
 
         target_samplerate = globals['formats'][format]['samplerate']
         if target_samplerate == input_samplerate:
-            return
+            return None
 
         feeder = 'input-%s' % (mux['audio'])
         comp_name = 'resample-%s-%s' % (source, target_samplerate)
@@ -144,19 +144,20 @@ class Planet:
                 'samplerate': target_samplerate,
             },
         }
+        return comp_name
 
     def __generate_video_resizer(self, mux, format, profile, inputs, globals):
         source = mux['video'].split(':')[0]
         input_resolution = inputs[source]['properties']['resolution']
         if 'video' not in globals['profiles'][profile]:
-            return
+            return None
 
         if input_resolution == "":
             raise Exception("format definition needs video but no video input given")
 
         target_resolution = globals['profiles'][profile]['video']
         if target_resolution == input_resolution:
-            return
+            return None
 
         if globals['resolutions'][target_resolution]['rate'] != globals['resolutions'][input_resolution]['rate']:
             raise Exception("ERROR: video rate conversion is not yet supported!!!")
@@ -175,27 +176,24 @@ class Planet:
                 'height': globals['resolutions'][target_resolution]['height'],
             },
         }
+        return comp_name
 
-    def __generate_audio_encoder(self, mux, format, profile, inputs, globals):
+    def __generate_audio_encoder(self, mux, format, profile, inputs, globals, feeder):
+        source = mux['audio'].split(':')[0]
         encoder = globals['formats'][format]['audio']
         bitrate = globals['profiles'][profile]['audio']
-
-        source = mux['audio'].split(':')[0]
-        input_samplerate = inputs[source]['properties']['samplerate']
-
-        target_samplerate = input_samplerate
+        samplerate = inputs[source]['properties']['samplerate']
         if 'samplerate' in globals['formats'][format]:
-            target_samplerate = globals['formats'][format]['samplerate']
+            samplerate = globals['formats'][format]['samplerate']
 
-        feeder = 'input-%s' % (mux['audio'])
-        if target_samplerate != input_samplerate:
-            feeder = 'resample-%s-%s' % (source, target_samplerate)
+        if not feeder:
+            feeder = 'input-%s' % (mux['audio'])
 
-        comp_name = 'encode-%s-%s-%i-%i' % (source, encoder, bitrate, target_samplerate)
-        comp_desc = '%s encoder for %i kbit/s @ %i Hz, from %s' % (encoder, bitrate, target_samplerate, source),
+        comp_name = 'encode-%s-%s-%i-%i' % (source, encoder, bitrate, samplerate)
+        comp_desc = '%s encoder for %i kbit/s @ %i Hz, from %s' % (encoder, bitrate, samplerate, source),
         if bitrate == 0:
-            comp_name = 'encode-%s-%s-%i' % (source, encoder, target_samplerate)
-            comp_desc = '%s encoder @ %i Hz, from %s' % (encoder, target_samplerate, source),
+            comp_name = 'encode-%s-%s-%i' % (source, encoder, samplerate)
+            comp_desc = '%s encoder @ %i Hz, from %s' % (encoder, samplerate, source),
 
         if comp_name in self.flow['encoders_audio']:
             return comp_name
@@ -211,21 +209,18 @@ class Planet:
         }
         return comp_name
 
-    def __generate_video_encoder(self, mux, format, profile, inputs, globals):
-        encoder = globals['formats'][format]['video']
-        target_resolution = globals['profiles'][profile]['video']
-        bitrate = globals['bitrates'][encoder][target_resolution]
-
+    def __generate_video_encoder(self, mux, format, profile, inputs, globals, feeder):
         source = mux['video'].split(':')[0]
-        input_resolution = inputs[source]['properties']['resolution']
+        encoder = globals['formats'][format]['video']
+        resolution = globals['profiles'][profile]['video']
+        bitrate = globals['bitrates'][encoder][resolution]
 
-        feeder = 'input-%s' % (mux['video'])
-        if target_resolution != input_resolution:
-            feeder = 'resize-%s-%s' % (source, target_resolution)
+        if not feeder:
+            feeder = 'input-%s' % (mux['video'])
 
-        comp_name = 'encode-%s-%s-%s' % (source, encoder, target_resolution)
-        comp_desc = '%s encoder for %sx%s, from %s' % (encoder, globals['resolutions'][target_resolution]['width'],
-                                                       globals['resolutions'][target_resolution]['height'], source),
+        comp_name = 'encode-%s-%s-%s' % (source, encoder, resolution)
+        comp_desc = '%s encoder for %sx%s, from %s' % (encoder, globals['resolutions'][resolution]['width'],
+                                                       globals['resolutions'][resolution]['height'], source),
 
         if comp_name in self.flow['encoders_video']:
             return comp_name
@@ -241,7 +236,7 @@ class Planet:
         }
         return comp_name
 
-    def __generate_muxer(self, mux_name, format, profile, globals, audio_encoder, video_encoder):
+    def __generate_muxer(self, mux_name, format, profile, globals, feeder_audio, feeder_video):
         muxer = globals['formats'][format]['muxer']
 
         comp_name = 'mux-%s-%s-%s' % (mux_name, format, profile)
@@ -250,8 +245,8 @@ class Planet:
             'type': '%s-mux' % muxer,
             'desc': comp_desc,
             'worker': None,
-            'feeder_audio': audio_encoder,
-            'feeder_video': video_encoder,
+            'feeder_audio': feeder_audio,
+            'feeder_video': feeder_video,
             'properties': {},
         }
 
@@ -266,11 +261,11 @@ class Planet:
                     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)
+                        resampler = self.__generate_audio_resampler(mux, format, profile, inputs, globals)
+                        audio_encoder = self.__generate_audio_encoder(mux, format, profile, inputs, globals, resampler)
                     if 'video' in mux:
-                        self.__generate_video_resizer(mux, format, profile, inputs, globals)
-                        video_encoder = self.__generate_video_encoder(mux, format, profile, inputs, globals)
+                        resizer = self.__generate_video_resizer(mux, format, profile, inputs, globals)
+                        video_encoder = self.__generate_video_encoder(mux, format, profile, inputs, globals, resizer)
 
                     self.__generate_muxer(mux_name, format, profile, globals, audio_encoder, video_encoder)