again changed videprocessing class and tab3

app.py

@@ -443,43 +443,60 @@ class VideoProcessor:
             height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             
-            # Create temporary output file
-            temp_output = tempfile.NamedTemporaryFile(suffix='.avi', delete=False)  # Changed to .avi
+            # Create temporary output file - always start with mp4
+            temp_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
             temp_output.close()
             
-            # Try different codecs in order of compatibility
+            # Try different codecs - prioritize MP4-compatible ones
             codecs_to_try = [
-                ('MJPG', '.avi'),   # Motion JPEG - most compatible
-                ('XVID', '.avi'),   # XVID
-                ('mp4v', '.mp4'),   # MPEG-4
-                ('DIV3', '.avi'),   # DivX
-                (0, '.avi')         # Uncompressed (fallback)
+                ('mp4v', '.mp4'),   # MPEG-4 - most compatible MP4 codec
+                ('MP4V', '.mp4'),   # Alternative case
+                ('FMP4', '.mp4'),   # Another MPEG-4 variant
+                ('DIVX', '.mp4'),   # DivX (sometimes works with MP4)
+                ('XVID', '.avi'),   # If MP4 fails, try AVI
+                ('MJPG', '.avi'),   # Motion JPEG - fallback
+                ('DIV3', '.avi'),   # DivX3
+                (0, '.avi')         # Uncompressed (last resort)
             ]
             
             out = None
             output_path = None
+            used_codec = None
             
             for codec_str, ext in codecs_to_try:
                 try:
                     # Update output filename with appropriate extension
-                    output_path = temp_output.name.replace('.avi', ext)
+                    if ext == '.mp4':
+                        output_path = temp_output.name
+                    else:
+                        output_path = temp_output.name.replace('.mp4', ext)
                     
                     if codec_str == 0:
-                        # Uncompressed fallback
                         fourcc = 0
                         print("Using uncompressed video (larger file size)")
                     else:
                         fourcc = cv2.VideoWriter_fourcc(*codec_str)
-                        print(f"Trying codec: {codec_str}")
+                        print(f"Trying codec: {codec_str} for {ext}")
                     
-                    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+                    # Create writer with specific parameters
+                    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height), isColor=True)
                     
                     if out.isOpened():
-                        print(f"Successfully opened video writer with codec: {codec_str}")
-                        break
-                    else:
+                        # Test write a black frame to ensure it really works
+                        test_frame = np.zeros((height, width, 3), dtype=np.uint8)
+                        out.write(test_frame)
                         out.release()
-                        out = None
+                        
+                        # Re-open for actual writing
+                        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height), isColor=True)
+                        if out.isOpened():
+                            used_codec = codec_str
+                            print(f"✓ Successfully using codec: {codec_str} with {ext}")
+                            break
+                    
+                    out.release()
+                    out = None
+                    
                 except Exception as e:
                     print(f"Failed with codec {codec_str}: {e}")
                     if out:
@@ -488,11 +505,12 @@ class VideoProcessor:
                     continue
             
             if out is None or not out.isOpened():
-                raise Exception("Could not open video writer with any codec")
+                # Last resort: save frames as images and create video differently
+                print("Standard codecs failed. Trying alternative approach...")
+                return self._process_with_frame_saving(cap, style_configs, blend_mode, fps, width, height, total_frames, progress_callback)
             
             # Process frames
             frame_count = 0
-            processed_frames = []
             
             while True:
                 ret, frame = cap.read()
@@ -510,13 +528,11 @@ class VideoProcessor:
                 styled_array = np.array(styled_frame)
                 bgr_frame = cv2.cvtColor(styled_array, cv2.COLOR_RGB2BGR)
                 
-                # Write frame
-                out.write(bgr_frame)
-                
-                # Also keep frames in memory for fallback
-                if len(processed_frames) < 300:  # Limit to prevent memory issues
-                    processed_frames.append(bgr_frame.copy())
+                # Ensure frame is correct size and type
+                if bgr_frame.shape[:2] != (height, width):
+                    bgr_frame = cv2.resize(bgr_frame, (width, height))
                 
+                out.write(bgr_frame)
                 frame_count += 1
                 
                 if progress_callback and frame_count % 10 == 0:
@@ -527,34 +543,17 @@ class VideoProcessor:
             out.release()
             
             # Verify the output file
-            if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
-                print("Output file is empty or doesn't exist")
-                
-                # Try to create a simple video from frames as fallback
-                if processed_frames:
-                    print("Attempting fallback: creating video from frames")
-                    fallback_path = tempfile.NamedTemporaryFile(suffix='_fallback.mp4', delete=False).name
-                    
-                    # Try creating with the most basic settings
-                    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-                    out_fallback = cv2.VideoWriter(fallback_path, fourcc, fps, (width, height))
-                    
-                    if out_fallback.isOpened():
-                        for frame in processed_frames:
-                            out_fallback.write(frame)
-                        out_fallback.release()
-                        
-                        if os.path.exists(fallback_path) and os.path.getsize(fallback_path) > 0:
-                            os.unlink(output_path)
-                            return fallback_path
-                
+            if not os.path.exists(output_path) or os.path.getsize(output_path) < 1000:
+                print(f"Output file is too small or doesn't exist (size: {os.path.getsize(output_path) if os.path.exists(output_path) else 0} bytes)")
                 return None
             
-            print(f"Video saved to: {output_path}")
+            print(f"Video successfully saved to: {output_path}")
             print(f"File size: {os.path.getsize(output_path) / 1024 / 1024:.2f} MB")
+            print(f"Format: {os.path.splitext(output_path)[1]}")
+            print(f"Codec used: {used_codec}")
             
-            # Clean up original temp file if we used a different extension
-            if output_path != temp_output.name:
+            # Clean up original temp file if different
+            if output_path != temp_output.name and os.path.exists(temp_output.name):
                 try:
                     os.unlink(temp_output.name)
                 except:
@@ -566,6 +565,74 @@ class VideoProcessor:
             print(f"Error processing video: {e}")
             traceback.print_exc()
             return None
+    
+    def _process_with_frame_saving(self, cap, style_configs, blend_mode, fps, width, height, total_frames, progress_callback):
+        """Alternative processing method: save frames then combine"""
+        try:
+            print("Using frame-saving fallback method...")
+            temp_dir = tempfile.mkdtemp()
+            frame_count = 0
+            frame_paths = []
+            
+            # Process and save frames
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                # Process frame
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                pil_frame = Image.fromarray(rgb_frame)
+                styled_frame = self.system.blend_styles(pil_frame, style_configs, blend_mode)
+                
+                # Save frame
+                frame_path = os.path.join(temp_dir, f"frame_{frame_count:06d}.png")
+                styled_frame.save(frame_path)
+                frame_paths.append(frame_path)
+                
+                frame_count += 1
+                if progress_callback and frame_count % 10 == 0:
+                    progress = frame_count / total_frames
+                    progress_callback(progress, f"Processing frame {frame_count}/{total_frames}")
+            
+            cap.release()
+            
+            if not frame_paths:
+                return None
+            
+            # Try to create video from frames
+            output_path = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
+            
+            # Read first frame to get size
+            first_frame = cv2.imread(frame_paths[0])
+            h, w = first_frame.shape[:2]
+            
+            # Try simple mp4v codec
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
+            
+            if out.isOpened():
+                for frame_path in frame_paths:
+                    frame = cv2.imread(frame_path)
+                    out.write(frame)
+                out.release()
+                
+                # Clean up frames
+                shutil.rmtree(temp_dir)
+                
+                if os.path.exists(output_path) and os.path.getsize(output_path) > 1000:
+                    print(f"Successfully created video using frame-saving method")
+                    return output_path
+            
+            # Clean up
+            shutil.rmtree(temp_dir)
+            return None
+            
+        except Exception as e:
+            print(f"Frame-saving method failed: {e}")
+            if 'temp_dir' in locals() and os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+            return None
 
 # ===========================
 # MAIN STYLE TRANSFER SYSTEM
@@ -1911,6 +1978,7 @@ with tab2:
 # TAB 3: Video Processing
 # TAB 3: Video Processing
 # TAB 3: Video Processing
+# TAB 3: Video Processing
 with tab3:
     st.header("🎬 Video Processing")
     
@@ -1971,29 +2039,23 @@ with tab3:
                             )
                             
                             if output_path and os.path.exists(output_path):
-                                # Read the video file immediately and store bytes in session state
+                                # Read the video file immediately
                                 try:
                                     with open(output_path, 'rb') as f:
                                         video_bytes = f.read()
                                     
                                     # Determine file extension
-                                    file_ext = os.path.splitext(output_path)[1]
+                                    file_ext = os.path.splitext(output_path)[1].lower()
                                     
                                     # Store in session state
                                     st.session_state['video_result_bytes'] = video_bytes
                                     st.session_state['video_result_ext'] = file_ext
                                     st.session_state['video_result_available'] = True
+                                    st.session_state['video_is_mp4'] = (file_ext == '.mp4')
                                     
-                                    # Convert to MP4 if needed for web playback
-                                    if file_ext.lower() != '.mp4':
-                                        st.info(f"Video saved as {file_ext} format. Converting for web playback...")
-                                        
-                                        # For non-MP4, we'll provide download but may have playback issues
-                                        st.warning("Note: Video playback may not work for non-MP4 formats. Use the download button to save the file.")
-                                    
-                                    st.success("Video processing complete!")
+                                    st.success(f"✅ Video processing complete! Format: {file_ext.upper()}")
                                     
-                                    # Clean up the output file after reading
+                                    # Clean up files
                                     try:
                                         os.unlink(output_path)
                                     except:
@@ -2002,7 +2064,7 @@ with tab3:
                                     st.error(f"Failed to read processed video: {str(e)}")
                                     st.session_state['video_result_available'] = False
                             else:
-                                st.error("Failed to process video. Please check the format and try again.")
+                                st.error("Failed to process video. Please try a different video or reduce the resolution.")
                                 st.session_state['video_result_available'] = False
                             
                             # Cleanup input file
@@ -2021,12 +2083,37 @@ with tab3:
             if st.session_state.get('video_result_available', False) and 'video_result_bytes' in st.session_state:
                 try:
                     file_ext = st.session_state.get('video_result_ext', '.mp4')
+                    video_bytes = st.session_state['video_result_bytes']
                     
-                    # Try to display video if it's MP4
-                    if file_ext.lower() == '.mp4':
-                        st.video(st.session_state['video_result_bytes'])
+                    # File info
+                    file_size_mb = len(video_bytes) / (1024 * 1024)
+                    
+                    # Try to display video
+                    if st.session_state.get('video_is_mp4', False):
+                        # For MP4, should work in browser
+                        st.video(video_bytes)
+                        st.success(f"✅ Video ready! Size: {file_size_mb:.2f} MB")
                     else:
-                        st.info(f"Video format ({file_ext}) may not be playable in browser. Please download the file.")
+                        # For non-MP4, show info and download
+                        st.info(f"Video format ({file_ext}) may not play in browser. Please download to view.")
+                        
+                        # Show preview image if possible
+                        try:
+                            # Try to extract a frame for preview
+                            temp_preview = tempfile.NamedTemporaryFile(delete=False, suffix=file_ext)
+                            temp_preview.write(video_bytes)
+                            temp_preview.close()
+                            
+                            cap = cv2.VideoCapture(temp_preview.name)
+                            ret, frame = cap.read()
+                            if ret:
+                                # Convert frame to RGB and display
+                                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                                st.image(rgb_frame, caption="Video Preview (First Frame)", use_column_width=True)
+                            cap.release()
+                            os.unlink(temp_preview.name)
+                        except:
+                            pass
                     
                     # Always provide download button
                     mime_types = {
@@ -2034,47 +2121,47 @@ with tab3:
                         '.avi': 'video/x-msvideo',
                         '.mov': 'video/quicktime'
                     }
-                    mime_type = mime_types.get(file_ext.lower(), 'video/mp4')
+                    mime_type = mime_types.get(file_ext, 'application/octet-stream')
                     
-                    st.download_button(
-                        label="📥 Download Processed Video",
-                        data=st.session_state['video_result_bytes'],
-                        file_name=f"styled_video_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}{file_ext}",
-                        mime=mime_type
-                    )
+                    col_dl1, col_dl2 = st.columns(2)
                     
-                    # Info about the video
-                    file_size_mb = len(st.session_state['video_result_bytes']) / (1024 * 1024)
-                    st.info(f"Video size: {file_size_mb:.2f} MB ({file_ext} format)")
+                    with col_dl1:
+                        st.download_button(
+                            label=f"📥 Download Video ({file_ext.upper()})",
+                            data=video_bytes,
+                            file_name=f"styled_video_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}{file_ext}",
+                            mime=mime_type,
+                            use_container_width=True
+                        )
                     
-                    # Codec info
-                    st.caption("💡 If video doesn't play, download it and use a local video player.")
+                    with col_dl2:
+                        if st.button("🗑️ Clear Result", use_container_width=True):
+                            del st.session_state['video_result_bytes']
+                            st.session_state['video_result_available'] = False
+                            if 'video_result_ext' in st.session_state:
+                                del st.session_state['video_result_ext']
+                            if 'video_is_mp4' in st.session_state:
+                                del st.session_state['video_is_mp4']
+                            st.rerun()
                     
-                    # Clear button to free memory
-                    if st.button("🗑️ Clear Result", key="clear_video_result"):
-                        del st.session_state['video_result_bytes']
-                        if 'video_result_ext' in st.session_state:
-                            del st.session_state['video_result_ext']
-                        st.session_state['video_result_available'] = False
-                        st.rerun()
+                    # Info about playback
+                    if not st.session_state.get('video_is_mp4', False):
+                        st.caption("💡 For best compatibility, download and use VLC or another video player.")
                     
                 except Exception as e:
                     st.error(f"Error displaying video: {str(e)}")
                     
-                    # Fallback: just provide download if display fails
+                    # Emergency download button
                     if 'video_result_bytes' in st.session_state:
-                        file_ext = st.session_state.get('video_result_ext', '.mp4')
                         st.download_button(
-                            label="📥 Download Processed Video (Display Error)",
+                            label="📥 Download Video (Error occurred)",
                             data=st.session_state['video_result_bytes'],
-                            file_name=f"styled_video_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}{file_ext}",
+                            file_name=f"styled_video_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4",
                             mime="application/octet-stream"
                         )
-                    else:
-                        st.error("Video data not available")
             
             elif st.session_state.get('video_result_available', False):
-                st.warning("Video data not found in session. Please process the video again.")
+                st.warning("Video data not found. Please process the video again.")
                 if st.button("Clear State"):
                     st.session_state['video_result_available'] = False
                     st.rerun()