Upload 3 files

llm_script_generator.py

@@ -215,17 +215,17 @@ Make it authentic to 1980s TV commercials with the energy and style of that era.
         inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
         
         # Generate
-        with self.model.eval():
-            outputs = self.model.generate(
-                **inputs,
-                max_new_tokens=self.model_config.get("max_tokens", 256),
-                temperature=self.model_config.get("temperature", 0.7),
-                top_p=self.model_config.get("top_p", 0.9),
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id,
-                eos_token_id=self.tokenizer.eos_token_id,
-                num_return_sequences=1
-            )
+        self.model.eval()
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=self.model_config.get("max_tokens", 256),
+            temperature=self.model_config.get("temperature", 0.7),
+            top_p=self.model_config.get("top_p", 0.9),
+            do_sample=True,
+            pad_token_id=self.tokenizer.eos_token_id,
+            eos_token_id=self.tokenizer.eos_token_id,
+            num_return_sequences=1
+        )
         
         # Decode response
         response = self.tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
@@ -386,3 +386,4 @@ Make it authentic to 1980s TV commercials with the energy and style of that era.
 def create_script_generator() -> LLMScriptGenerator:
     """Factory function to create a script generator."""
     return LLMScriptGenerator()
+

utils_audio.py

@@ -75,11 +75,16 @@ def _load_standard_tts(model_name: str, device: str):
     """Load standard TTS model."""
     try:
         from transformers import pipeline
+        import torch
+        
+        # Fix device string - convert "auto" to proper device
+        if device == "auto":
+            device = "cuda" if torch.cuda.is_available() else "cpu"
         
         pipe = pipeline(
             "text-to-speech",
             model=model_name,
-            torch_dtype="auto"
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32
         )
         
         if device == "cuda":
@@ -290,3 +295,4 @@ def write_wav(path: str, sr: int, wav: np.ndarray):
         except ImportError:
             logger.error("No audio writing library available (soundfile or scipy)")
             raise RuntimeError("Cannot write audio file - no audio library available")
+

utils_video.py

@@ -77,10 +77,15 @@ def _load_standard_t2v(model_name: str, device: str):
     """Load standard T2V model."""
     try:
         from diffusers import TextToVideoSDPipeline
+        import torch
+        
+        # Fix device string - convert "auto" to proper device
+        if device == "auto":
+            device = "cuda" if torch.cuda.is_available() else "cpu"
         
         pipe = TextToVideoSDPipeline.from_pretrained(
             model_name,
-            torch_dtype="auto"
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32
         )
         
         if device == "cuda":
@@ -153,21 +158,11 @@ def synth_t2v(prompt: str, seed: int, num_frames: int = 32, fps: int = 8,
 def _create_fallback_clip(prompt: str, num_frames: int, fps: int):
     """Create a simple fallback clip when video generation fails."""
     try:
-        from moviepy.editor import ColorClip, TextClip, CompositeVideoClip
-        
-        # Create a simple colored background
-        background = ColorClip(size=(640, 480), color=(100, 50, 200), duration=num_frames/fps)
-        
-        # Add text overlay
-        text = TextClip(
-            prompt[:50] + "..." if len(prompt) > 50 else prompt,
-            fontsize=24,
-            color='white',
-            font='Arial-Bold'
-        ).set_position('center').set_duration(num_frames/fps)
+        from moviepy.editor import ColorClip
         
-        # Composite the clips
-        clip = CompositeVideoClip([background, text])
+        # Create a simple colored background without text (avoids ImageMagick issues)
+        duration = num_frames / fps
+        clip = ColorClip(size=(640, 480), color=(100, 50, 200), duration=duration)
         
         logger.info(f"Created fallback clip: {clip.duration:.2f}s")
         return clip
@@ -219,10 +214,30 @@ def apply_retro_filters(input_path: str, output_path: str, intensity: float = VH
         
         stream = ffmpeg.input(input_path)
         
-        # Apply filter chain
+        # Apply filter chain - use simple filters to avoid filter_complex issues
         if len(filters) > 1:
-            filter_string = ','.join(filters)
-            stream = stream.filter_complex(filter_string)
+            # Apply filters one by one to avoid filter_complex issues
+            for filter_str in filters:
+                if filter_str == 'format=yuv420p':
+                    stream = stream.filter('format', 'yuv420p')
+                elif 'hue=' in filter_str:
+                    s_val = filter_str.split('s=')[1]
+                    stream = stream.filter('hue', s=float(s_val))
+                elif 'eq=' in filter_str:
+                    # Extract eq parameters
+                    eq_params = filter_str.split('eq=')[1]
+                    parts = eq_params.split(':')
+                    brightness = float(parts[0].split('=')[1]) if 'brightness=' in parts[0] else 0
+                    contrast = float(parts[1].split('=')[1]) if 'contrast=' in parts[1] else 1
+                    saturation = float(parts[2].split('=')[1]) if 'saturation=' in parts[2] else 1
+                    stream = stream.filter('eq', brightness=brightness, contrast=contrast, saturation=saturation)
+                elif 'noise=' in filter_str:
+                    alls_val = int(filter_str.split('alls=')[1].split(':')[0])
+                    stream = stream.filter('noise', alls=alls_val)
+                elif 'vignette=' in filter_str:
+                    angle = float(filter_str.split('vignette=')[1].split(':')[0])
+                    strength = float(filter_str.split(':')[1])
+                    stream = stream.filter('vignette', angle=angle, strength=strength)
         else:
             stream = stream.filter('format', 'yuv420p')
         
@@ -334,3 +349,4 @@ def _mux_with_moviepy(video_in: str, audio_in: str, out_path: str):
     video.close()
     audio.close()
     final_video.close()
+