Update app.py

app.py

@@ -595,6 +595,11 @@ class ProfessionalCartoonFilmGenerator:
                     else:
                         print(f"❌ Open-Sora failed for scene {scene_num}, trying fallback...")
                         video_path = self._create_professional_static_video(scene, background_images)
+                    
+                    # If professional video fails, try simple video
+                    if not video_path:
+                        print(f"🔄 Professional video failed, trying simple video for scene {scene_num}...")
+                        video_path = self._create_simple_static_video(scene, background_images)
                 else:
                     print(f"🎬 Using static video fallback for scene {scene_num}...")
                     # Fallback to enhanced static video
@@ -721,7 +726,12 @@ class ProfessionalCartoonFilmGenerator:
                 return None
             
             # Advanced animation effects based on scene mood and type
+            print(f"🎬 Generating {total_frames} frames...")
+            
             for i in range(total_frames):
+                if i % 100 == 0:  # Progress update every 100 frames
+                    print(f"   Frame {i}/{total_frames} ({i/total_frames*100:.1f}%)")
+                
                 frame = img_array.copy()
                 progress = i / total_frames
                 
@@ -729,6 +739,8 @@ class ProfessionalCartoonFilmGenerator:
                 frame = self._apply_cinematic_effects(frame, scene, progress)
                 out.write(frame)
             
+            print(f"✅ All {total_frames} frames generated")
+            
             out.release()
             
             if os.path.exists(video_path):
@@ -747,48 +759,128 @@ class ProfessionalCartoonFilmGenerator:
     
     def _apply_cinematic_effects(self, frame, scene, progress):
         """Apply professional cinematic effects"""
-        h, w = frame.shape[:2]
-        
-        # Choose effect based on scene mood and type
-        mood = scene.get('mood', 'heartwarming')
-        shot_type = scene.get('shot_type', 'medium shot')
+        try:
+            h, w = frame.shape[:2]
+            
+            # Choose effect based on scene mood and type
+            mood = scene.get('mood', 'heartwarming')
+            shot_type = scene.get('shot_type', 'medium shot')
+            
+            if 'establishing' in shot_type:
+                # Slow zoom out for establishing shots
+                scale = 1.15 - progress * 0.1
+                center_x, center_y = w // 2, h // 2
+                M = cv2.getRotationMatrix2D((center_x, center_y), 0, scale)
+                frame = cv2.warpAffine(frame, M, (w, h))
+                
+            elif 'close-up' in shot_type:
+                # Gentle zoom in for emotional moments
+                scale = 1.0 + progress * 0.08
+                center_x, center_y = w // 2, h // 2
+                M = cv2.getRotationMatrix2D((center_x, center_y), 0, scale)
+                frame = cv2.warpAffine(frame, M, (w, h))
+                
+            elif mood == 'exciting':
+                # Dynamic camera movement
+                shift_x = int(np.sin(progress * 4 * np.pi) * 8)
+                shift_y = int(np.cos(progress * 2 * np.pi) * 4)
+                M = np.float32([[1, 0, shift_x], [0, 1, shift_y]])
+                frame = cv2.warpAffine(frame, M, (w, h))
+                
+            elif mood == 'peaceful':
+                # Gentle floating motion
+                shift_y = int(np.sin(progress * 2 * np.pi) * 6)
+                M = np.float32([[1, 0, 0], [0, 1, shift_y]])
+                frame = cv2.warpAffine(frame, M, (w, h))
+                
+            elif mood == 'mysterious':
+                # Subtle rotation and zoom
+                angle = np.sin(progress * np.pi) * 2
+                scale = 1.0 + np.sin(progress * np.pi) * 0.05
+                center_x, center_y = w // 2, h // 2
+                M = cv2.getRotationMatrix2D((center_x, center_y), angle, scale)
+                frame = cv2.warpAffine(frame, M, (w, h))
+            else:
+                # Default: gentle zoom for heartwarming scenes
+                scale = 1.0 + progress * 0.03
+                center_x, center_y = w // 2, h // 2
+                M = cv2.getRotationMatrix2D((center_x, center_y), 0, scale)
+                frame = cv2.warpAffine(frame, M, (w, h))
+            
+            return frame
+            
+        except Exception as e:
+            print(f"⚠️ Cinematic effect failed: {e}, using original frame")
+            return frame
+    
+    def _create_simple_static_video(self, scene: Dict, background_images: Dict) -> str:
+        """Create a simple static video without complex effects"""
+        scene_num = scene['scene_number']
         
-        if 'establishing' in shot_type:
-            # Slow zoom out for establishing shots
-            scale = 1.15 - progress * 0.1
-            center_x, center_y = w // 2, h // 2
-            M = cv2.getRotationMatrix2D((center_x, center_y), 0, scale)
-            frame = cv2.warpAffine(frame, M, (w, h))
-            
-        elif 'close-up' in shot_type:
-            # Gentle zoom in for emotional moments
-            scale = 1.0 + progress * 0.08
-            center_x, center_y = w // 2, h // 2
-            M = cv2.getRotationMatrix2D((center_x, center_y), 0, scale)
-            frame = cv2.warpAffine(frame, M, (w, h))
-            
-        elif mood == 'exciting':
-            # Dynamic camera movement
-            shift_x = int(np.sin(progress * 4 * np.pi) * 8)
-            shift_y = int(np.cos(progress * 2 * np.pi) * 4)
-            M = np.float32([[1, 0, shift_x], [0, 1, shift_y]])
-            frame = cv2.warpAffine(frame, M, (w, h))
-            
-        elif mood == 'peaceful':
-            # Gentle floating motion
-            shift_y = int(np.sin(progress * 2 * np.pi) * 6)
-            M = np.float32([[1, 0, 0], [0, 1, shift_y]])
-            frame = cv2.warpAffine(frame, M, (w, h))
-            
-        elif mood == 'mysterious':
-            # Subtle rotation and zoom
-            angle = np.sin(progress * np.pi) * 2
-            scale = 1.0 + np.sin(progress * np.pi) * 0.05
-            center_x, center_y = w // 2, h // 2
-            M = cv2.getRotationMatrix2D((center_x, center_y), angle, scale)
-            frame = cv2.warpAffine(frame, M, (w, h))
+        if scene_num not in background_images:
+            print(f"❌ No background image for scene {scene_num}")
+            return None
+            
+        video_path = f"{self.temp_dir}/simple_scene_{scene_num}.mp4"
         
-        return frame
+        try:
+            print(f"🎬 Creating simple video for scene {scene_num}...")
+            
+            # Load background image
+            bg_path = background_images[scene_num]
+            print(f"📁 Loading background from: {bg_path}")
+            
+            if not os.path.exists(bg_path):
+                print(f"❌ Background file not found: {bg_path}")
+                return None
+                
+            image = Image.open(bg_path)
+            img_array = np.array(image.resize((1024, 768)))  # 4:3 aspect ratio
+            img_array = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+            
+            print(f"📐 Image size: {img_array.shape}")
+            
+            # Simple video settings
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            fps = 24
+            duration = 10  # Shorter duration for simple video
+            total_frames = duration * fps
+            
+            print(f"🎬 Simple video settings: {fps}fps, {duration}s duration, {total_frames} frames")
+            
+            out = cv2.VideoWriter(video_path, fourcc, fps, (1024, 768))
+            
+            if not out.isOpened():
+                print(f"❌ Failed to open simple video writer for {video_path}")
+                return None
+            
+            # Simple static video - just repeat the same frame
+            print(f"🎬 Generating {total_frames} simple frames...")
+            
+            for i in range(total_frames):
+                if i % 50 == 0:  # Progress update every 50 frames
+                    print(f"   Frame {i}/{total_frames} ({i/total_frames*100:.1f}%)")
+                
+                # Just use the same frame without effects
+                out.write(img_array)
+            
+            print(f"✅ All {total_frames} simple frames generated")
+            
+            out.release()
+            
+            if os.path.exists(video_path):
+                file_size = os.path.getsize(video_path)
+                print(f"✅ Simple video created: {video_path} ({file_size / (1024*1024):.1f} MB)")
+                return video_path
+            else:
+                print(f"❌ Simple video file not created: {video_path}")
+                return None
+            
+        except Exception as e:
+            print(f"❌ Simple video creation failed for scene {scene_num}: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
     
     def _create_emergency_fallback_video(self, script_data: Dict) -> str:
         """Create a simple emergency fallback video when everything else fails"""