files

.gitignore

@@ -0,0 +1,27 @@
+.env
+/data/
+shortsai-469312-ab95bf92b7fb.json
+
+/env
+
+/__pycache__
+
+/whisperenv
+
+temp_audio.wav
+
+test_audio.wav
+
+/16_aug
+/21_aug
+
+/data_flood
+resources_info.json
+
+/metadata
+
+.gradio/
+
+.DS_Store
+
+ /edited_videos/

extract_metadata.py

@@ -0,0 +1,134 @@
+from scenedetect import VideoManager, SceneManager
+from scenedetect.detectors import ContentDetector
+import cv2
+import os
+import numpy as np
+import ffmpeg
+from moviepy.editor import VideoFileClip
+import time
+from utils import read_files
+from grok_analyze import analyze_image_with_grok_f
+import json
+import random
+import string
+def extract_scenes_scenedetect(video_path, threshold=30.0, min_scene_duration=5.0):
+    
+    vid_obj={"type":"video", "path":video_path}
+
+    vid_obj["scenes"]=[ ]
+    
+    # Initialize video and scene manager
+    video = VideoManager([video_path])
+    scene_manager = SceneManager()
+    scene_manager.add_detector(ContentDetector(threshold=threshold))
+    
+    # Detect scenes
+    video.start()
+    scene_manager.detect_scenes(video)
+    scene_list = scene_manager.get_scene_list()
+    
+    # Get video FPS for time calculations
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    min_frames = int(min_scene_duration * fps)  # Convert 25 seconds to frames
+    
+    # Filter scenes to ensure at least 25 seconds (min_frames) between them
+    filtered_scenes = []
+    last_frame = -min_frames  # Allow the first scene to start at frame 0
+    for scene in scene_list:
+        print(scene)
+        start_frame = scene[0].get_frames()
+        if start_frame >= last_frame + min_frames:
+            filtered_scenes.append(scene)
+            last_frame = start_frame
+    
+    print(f"Total scenes detected: {len(scene_list)}")
+    print(f"Filtered scenes (at least {min_scene_duration} seconds apart): {len(filtered_scenes)}")
+    
+    if not filtered_scenes:
+            print("No scenes detected; extracting the first frame of the video.")
+            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            ret, frame = cap.read()
+            if ret:
+                # Calculate timestamp for frame 0
+                timestamp = 0 / fps
+                minutes = int(timestamp // 60)
+                seconds = int(timestamp % 60)
+                milliseconds = int((timestamp % 1) * 1000)
+                print(f"First Frame - Timestamp: {minutes:02d}:{seconds:02d}.{milliseconds:03d}")
+                                
+                # Analyze frame and store scene info
+                description = analyze_image_with_grok_f(frame)
+                scene_info = {
+                    "timestamp": f"{minutes:02d}:{seconds:02d}.{milliseconds:03d}",
+                    "description": description
+                }
+                vid_obj["scenes"].append(scene_info)
+            else:
+                print("Failed to read the first frame of the video.")
+            cap.release()
+            video.release()
+            return vid_obj
+    else:
+        # Extract frames from filtered scenes
+        for i, scene in enumerate(filtered_scenes):
+            # Calculate and format timestamp
+            start_frame = scene[0].get_frames()
+            timestamp = start_frame / fps
+            minutes = int(timestamp // 60)
+            seconds = int(timestamp % 60)
+            milliseconds = int((timestamp % 1) * 1000)
+            print(f"Scene {i:04d} - Timestamp: {minutes:02d}:{seconds:02d}.{milliseconds:03d}")
+            
+            # Seek to the start of the scene
+            cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+            ret, frame = cap.read()
+            description=analyze_image_with_grok_f(frame)
+            scene={"timestamp":f"{minutes:02d}:{seconds:02d}.{milliseconds:03d}", "description":description}
+            vid_obj["scenes"].append(scene)
+
+            # if ret:
+            #     output_path = os.path.join(output_folder, f"scene_{i:04d}.jpg")
+            #     cv2.imwrite(output_path, frame)
+        print(vid_obj)
+        cap.release()
+        video.release()
+
+        return vid_obj
+
+
+def get_metadata(all_files):
+
+    all_files_info=[]
+    for file_path in all_files:
+        print(file_path)
+        if file_path.split(".")[-1] in ["MOV","mp4"]:
+            vid_info=extract_scenes_scenedetect(file_path)
+            all_files_info.append(vid_info)
+
+    random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
+    file_name = f"all_files_info_{random_string}.json"
+
+    with open(file_name, "w") as file:
+        json.dump(all_files_info, file, indent=4)
+    
+    return all_files_info,file_name
+
+
+
+
+if __name__ == "__main__":
+    all_files_info=[]
+    dir_path="/Users/georgia.bucea/products/ShortsAI/21_aug"
+    all_files=read_files(dir_path)
+
+    for file in all_files:
+        file_path=dir_path+"/"+file
+        if file_path.split(".")[-1] in ["MOV","mp4"]:
+            vid_info=extract_scenes_scenedetect(file_path)
+            all_files_info.append(vid_info)
+
+    with open("all_files_info.json", "w") as file:
+        json.dump(all_files_info, file, indent=4)
+    
+

find_steps.py

@@ -0,0 +1,124 @@
+from sentence_transformers import SentenceTransformer, util
+
+import json
+from datetime import datetime
+# Function to read and parse the JSON file
+def find_next_step(data, current_context):
+    try:
+        # Read the JSON file
+        # with open(file_path, 'r') as file:
+        #     data = json.load(file)
+        
+        # Initialize counters
+        total_videos = len(data)
+        total_scenes = 0
+        max_score=0.0
+        step={
+            "path" :"",
+            "start":"",
+            "end": "",
+            }
+        # Iterate through each video entry
+        print(f"Processing {total_videos} videos...\n")
+        for index, video in enumerate(data, 1):
+            video_type = video.get('type', 'Unknown')
+            video_path = video.get('path', 'No path provided')
+            scenes = video.get('scenes', [])
+            scene_count = len(scenes)
+            total_scenes += scene_count
+            
+
+            # Iterate through each scene in the video
+            for scene_index, scene in enumerate(scenes, 1):
+                timestamp = scene.get('timestamp', 'No timestamp')
+                description = scene.get('description', 'No description')
+
+                time_obj = datetime.strptime(timestamp, "%M:%S.%f")
+                start = time_obj.minute * 60 + time_obj.second + time_obj.microsecond / 1_000_000               
+                score=compare_phrases(description,current_context)
+
+                if score > max_score:
+                    if scene_index+1<len(scenes):
+                        next_scene=scenes[scene_index+1]
+                        next_timestamp=next_scene.get('timestamp', 'No timestamp')
+                        time_obj = datetime.strptime(next_timestamp, "%M:%S.%f")
+
+                        stop = time_obj.minute * 60 + time_obj.second + time_obj.microsecond / 1_000_000  
+                        step={
+                        "path" :video_path,
+                        "start":start,
+                        "end": stop,
+                        "description":description
+                        }
+                    else:
+                        step={
+                        "path" :video_path,
+                        "start":start,
+                        "end": "",
+                        "description":description
+                        }
+
+                    max_score=score
+
+                if "Error" in description:
+                    print("[Note: This scene contains an error]")
+        
+        # Print overall summary
+        print(f"Summary:")
+        print(f"  Total Videos: {total_videos}")
+        print(f"  Total Scenes: {total_scenes}")
+        
+    except FileNotFoundError:
+        print(f"Error: File '{file_path}' not found.")
+    except json.JSONDecodeError:
+        print("Error: Invalid JSON format.")
+    except Exception as e:
+        print(f"Error: An unexpected error occurred: {str(e)}")
+
+    return step
+
+
+
+def compare_phrases(phrase1,phrase2="Passing around a dj mixing a song"):
+    model = SentenceTransformer('all-MiniLM-L6-v2',local_files_only=True)
+    # Get embeddings
+    embedding1 = model.encode(phrase1, convert_to_tensor=True)
+    embedding2 = model.encode(phrase2, convert_to_tensor=True)
+
+    # Compute cosine similarity
+    similarity_score = util.cos_sim(embedding1, embedding2)[0][0]
+
+
+    # print(f"Similarity score: {similarity_score:.4f}")
+    # print(phrase1)
+    return similarity_score
+
+
+
+def find_all_steps(data, context):
+
+    context = context.replace("\n", "").lower()
+    all_actions=context.split(".")
+    steps=[]
+    for action in all_actions:
+        step=find_next_step(data,action)
+        steps.append(step)
+    return steps
+
+
+    
+
+
+if __name__ == "__main__":
+    file_path = '/Users/georgia.bucea/products/ShortsAI/all_files_metadata.json'  # Update this with the actual file path
+
+    context = """I am walking around San Francisco and passing around the big white building. I am walking around a music band and DJ mixing a song. I am showing a demo on the phone, I am explaining the demo on the mobile phone"""
+    # Read the JSON file
+    with open(file_path, 'r') as file:
+         data = json.load(file)
+
+    steps=find_all_steps(data,context)
+    print(steps)
+
+    
+

grok_analyze.py

@@ -0,0 +1,135 @@
+import os
+import base64
+from xai_sdk import Client
+from xai_sdk.chat import user, image
+from dotenv import load_dotenv
+import cv2
+import json
+load_dotenv()
+
+def encode_image_to_base64_f(frame):
+    """
+    Encode an OpenCV frame (NumPy array) to a base64 string.
+    
+    Args:
+        frame (np.ndarray): OpenCV frame in BGR format.
+        
+    Returns:
+        str: Base64-encoded string of the image with data URL prefix, or None if encoding fails.
+    """
+    try:
+        # Convert BGR frame to JPEG-encoded bytes
+        _, buffer = cv2.imencode('.jpg', frame)
+        # Encode to base64 and convert to string
+        encoded_string = base64.b64encode(buffer).decode('utf-8')
+        # Prefix with data URL format for JPEG images
+        return f"data:image/jpeg;base64,{encoded_string}"
+    except Exception as e:
+        print(f"Error encoding frame to base64: {str(e)}")
+        return None
+
+def analyze_image_with_grok_f( frame):
+    """
+    Analyze an image using Grok via xAI API.
+    
+    Args:
+        api_key (str): xAI API key.
+        image_path (str): Path to the local image file.
+        
+    Returns:
+        str: Grok's analysis of the image or error message.
+    """
+    # Initialize xAI client
+    api_key = os.getenv("X_AI")
+    client = Client(
+        api_key=api_key,
+    )
+    
+    # Encode image to base64
+    base64_image = encode_image_to_base64_f(frame)
+    if not base64_image:
+        return "Error: Could not encode image. Check if the file exists and is valid."
+    
+    # Create chat session
+    chat = client.chat.create(model="grok-4-0709")  # Use vision-capable model
+    
+    # Append user message with base64-encoded image
+    chat.append(
+        user(
+            "Write a short and concise description of the image",
+            image(base64_image)  # Pass base64-encoded string
+        )
+    )
+    
+    try:
+        response = chat.sample()
+        return response.content
+    except Exception as e:
+        return f"Error during API call: {str(e)}"
+
+def get_story_with_grok(context,current_context):
+        # Initialize xAI client
+    api_key = os.getenv("X_AI")
+    client = Client(
+        api_key=api_key,
+    )
+    
+    # Create chat session
+    chat = client.chat.create(model="grok-4-0709")  # Use vision-capable model
+    print(current_context)
+    if current_context!="":
+    # Append user message with base64-encoded image
+        chat.append(
+            user(
+                "Based on the following context, and the phrase: "+current_context+ " generate a random story with no more than 4 scenes. The story should be given as JSON, with the scenes in the following format: path:file_path,start:,end:mdescription. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. " + str(context),
+            )
+        )
+    else:
+        chat.append(
+            user(
+                "Based on the following context, generate a random story with no more than 4 scenes. The story should be given as JSON, with the scenes in the following format: path:file_path,start:,end:mdescription. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. " + str(context),
+            )
+        )
+        
+    try:
+        response = chat.sample()
+        data= response.content
+        video_data = json.loads(data)
+        return video_data
+    except Exception as e:
+        return f"Error during API call: {str(e)}"
+
+
+def main():
+    # Your xAI API key    
+    # Path to your image
+    # image_path = "/Users/georgia.bucea/products/ShortsAI/frames_scenesdetect/scene_0000.jpg"
+    
+    # # Verify image path exists
+    # if not os.path.exists(image_path):
+    #     print(f"Error: Image file not found at {image_path}")
+    #     return
+    
+    # print("Analyzing image...")
+    # analysis = analyze_image_with_grok_f( image_path)
+    # print("Grok's Analysis:")
+    # print(analysis)
+
+    context_path="/Users/georgia.bucea/products/ShortsAI/all_files_metadata.json"
+    with open(context_path, 'r') as file:
+
+        data = json.load(file)
+        print("here we are")
+        print(get_story_with_grok(data))
+        
+    
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+
+
+

requirements.txt

@@ -0,0 +1,98 @@
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+annotated-types==0.7.0
+anyio==4.10.0
+attrs==25.3.0
+Brotli==1.1.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
+click==8.2.1
+decorator==4.4.2
+fastapi==0.116.1
+ffmpeg==1.4
+ffmpeg-python==0.2.0
+ffmpy==0.6.1
+filelock==3.19.1
+frozenlist==1.7.0
+fsspec==2025.9.0
+future==1.0.0
+gradio==5.44.1
+gradio_client==1.12.1
+groovy==0.1.2
+grpcio==1.74.0
+h11==0.16.0
+hf-xet==1.1.9
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+imageio-ffmpeg==0.6.0
+importlib_metadata==8.7.0
+Jinja2==3.1.6
+joblib==1.5.2
+markdown-it-py==4.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+moviepy==1.0.3
+mpmath==1.3.0
+multidict==6.6.4
+networkx==3.5
+numpy==2.2.6
+opencv-python==4.12.0.88
+opentelemetry-api==1.36.0
+opentelemetry-sdk==1.36.0
+opentelemetry-semantic-conventions==0.57b0
+orjson==3.11.3
+packaging==25.0
+pandas==2.3.2
+pillow==11.3.0
+pillow_heif==1.1.0
+platformdirs==4.4.0
+proglog==0.1.12
+propcache==0.3.2
+protobuf==6.32.0
+pydantic==2.11.7
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+regex==2025.9.1
+requests==2.32.5
+rich==14.1.0
+ruff==0.12.11
+safehttpx==0.1.6
+safetensors==0.6.2
+scenedetect==0.6.7
+scikit-learn==1.7.1
+scipy==1.16.1
+semantic-version==2.10.0
+sentence-transformers==5.1.0
+setuptools==80.9.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.47.3
+sympy==1.14.0
+threadpoolctl==3.6.0
+tokenizers==0.22.0
+tomlkit==0.13.3
+torch==2.8.0
+tqdm==4.67.1
+transformers==4.56.0
+typer==0.17.3
+typing-inspection==0.4.1
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+websockets==15.0.1
+xai-sdk==1.1.0
+yarl==1.20.1
+zipp==3.23.0

video_editing.py

@@ -0,0 +1,138 @@
+from moviepy.editor import VideoFileClip, concatenate_videoclips,ColorClip,CompositeVideoClip
+from find_steps import find_all_steps
+import json
+import random
+import string
+step={
+   "path" :"/Users/georgia.bucea/products/ShortsAI/21_aug/IMG_8299.MOV",
+   "start":0.0,
+   "end": '',
+}
+        
+def crop_video(step, target_resolution=(1080, 1920), target_fps=30):
+    """
+    Crop a video clip to the specified start and end times, and resize to target resolution
+    while maintaining the original aspect ratio with padding if necessary.
+    
+    Args:
+        step (dict): Dictionary with 'path', 'start', and 'end' keys.
+        target_resolution (tuple): Desired output resolution (width, height).
+        target_fps (int): Desired frame rate for the output video.
+    
+    Returns:
+        VideoClip: Cropped and resized video clip with preserved audio.
+    """
+    video = VideoFileClip(step["path"])
+    
+    # Crop the video based on start and end times
+    if step.get("end"):
+        video = video.subclip(step["start"], step["end"])
+    else:
+        video = video.subclip(step["start"])
+    
+    # Set consistent frame rate
+    video = video.set_fps(target_fps)
+    
+    # Calculate target aspect ratio
+    target_width, target_height = target_resolution
+    target_aspect = target_width / target_height
+    video_aspect = video.w / video.h
+    
+    # Resize or pad to match target resolution while preserving aspect ratio
+    if abs(video_aspect - target_aspect) > 0.01:  # Allow small tolerance
+        print("I'm here in abs")
+        if video_aspect > target_aspect:
+            # Video is wider than target: scale to match height, add black bars on sides
+            print("I'm here in video aspect >")
+            new_width = int(target_height * video_aspect)
+            video = video.resize(height=target_height)
+            # Create a background clip with black padding
+            background = ColorClip(size=(target_width, target_height), color=(0, 0, 0))
+            video = video.set_position(("center", "center")).on_color(size=(target_width, target_height), color=(0, 0, 0))
+        else:
+            print("I'm here in video aspect")
+            # Video is taller than target: scale to match width, add black bars on top/bottom
+            new_height = int(target_width / video_aspect)
+            video = video.resize(width=target_width)
+            # Create a background clip with black padding
+            background = ColorClip(size=(target_width, target_height), color=(0, 0, 0))
+            video = video.set_position(("center", "center")).on_color(size=(target_width, target_height), color=(0, 0, 0))
+    else:
+        print("I'm here in video aspect")
+        # Aspect ratio matches, resize directly
+        video = video.resize(target_resolution)
+    
+    # Ensure audio is preserved
+    if video.audio is None:
+        print(f"Warning: No audio in {step['path']}")
+    
+    return video
+
+def get_final_video(subclips, aspect_ratio="9:16"):
+    """
+    Concatenate video clips and save the final video with consistent resolution and audio.
+    
+    Args:
+        subclips (list): List of VideoClip objects.
+        aspect_ratio (str): Desired aspect ratio (e.g., '9:16').
+    
+    Returns:
+        str: Path to the saved video file.
+    """
+    # Parse aspect ratio
+    width_ratio, height_ratio = map(int, aspect_ratio.split(":"))
+    target_aspect = width_ratio / height_ratio
+    
+    # Set target resolution (e.g., 1080x1920 for 9:16)
+    target_height = 1920  # Standard for vertical videos
+    target_width = int(target_height * target_aspect)
+    target_resolution = (target_width, target_height)
+    
+    # Concatenate clips
+    final_clip = concatenate_videoclips(subclips, method="compose")
+    
+    # Generate unique filename
+    random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
+    file_name = f"edited_videos/video_edited{random_string}.mp4"  # Changed to .mp4 for compatibility
+    
+    # Write the final video file
+    final_clip.write_videofile(
+        file_name,
+        codec='libx264',
+        audio_codec='aac',
+        fps=30,  # Consistent frame rate
+        preset='medium',
+        ffmpeg_params=['-pix_fmt', 'yuv420p', '-aspect', aspect_ratio],  # Ensure compatibility with most players
+        verbose=False,
+        temp_audiofile=f"temp_audio_{random_string}.m4a",  # Explicit temp audio file
+    )
+    
+    # Close clips to free memory
+    final_clip.close()
+    # for clip in sub:
+    #     clip.close()
+    
+    return file_name
+
+
+
+
+
+if __name__ == "__main__":
+    file_path = '/Users/georgia.bucea/products/ShortsAI/all_files_metadata.json'  # Update this with the actual file path
+
+    context = """I am putting stuff in a car, with pipes and a guy in a red shirt. I am walking past a band with a DJ. I am explaining something on the phone"""
+ 
+    with open(file_path, 'r') as file:
+         data = json.load(file)
+
+    steps=find_all_steps(data,context)
+    all_videos=[]
+    for step in steps:
+        v=crop_video(step)
+        all_videos.append(v)
+
+    # v=crop_video(step)
+
+    get_final_video(all_videos)
+

video_editing_ffmpeg.py

@@ -0,0 +1,90 @@
+import ffmpeg
+import random
+import string
+# Define target resolution
+target_width = 1080
+target_height = 1920
+
+
+
+def concatenate_videos(files_timestamps):
+    processed_streams = []
+    for file_info in files_timestamps:
+        file_path = file_info["path"]
+        start_time = file_info["start"]
+        end_time = file_info["end"]
+        
+        try:
+            if end_time == "":
+            # Create input stream from start_time to end of video
+                stream = ffmpeg.input(file_path, ss=start_time)
+            else:
+            # Create input stream with trimming
+                stream = ffmpeg.input(file_path, ss=start_time, t=end_time - start_time)
+            video = stream.video
+            audio = stream.audio
+            
+            # Get video metadata to calculate aspect ratio
+            probe = ffmpeg.probe(file_path)
+            video_stream = next(s for s in probe['streams'] if s['codec_type'] == 'video')
+            video_width = int(video_stream['width'])
+            video_height = int(video_stream['height'])
+            video_aspect = video_width / video_height
+            target_aspect = target_width / target_height
+            
+            print(f"Processing {file_path}: resolution={video_width}x{video_height}, aspect={video_aspect:.2f}, trimmed from {start_time}s to {end_time}s")
+            
+            # Scale the video to fit within target resolution while preserving aspect ratio
+            if abs(video_aspect - target_aspect) > 0.01:  # Allow small tolerance
+                if video_aspect > target_aspect:
+                    # Video is wider: scale to target height, ensure width <= target_width
+                    video = video.filter('scale', f'min({target_width},iw*({target_height}/ih))', target_height, force_original_aspect_ratio='decrease')
+                    # Pad to target resolution, align to left for right-side padding
+                    video = video.filter('pad', target_width, target_height, 0, '(oh-ih)/2', color='black')
+                else:
+                    # Video is taller: scale to target width, ensure height <= target_height
+                    video = video.filter('scale', target_width, f'min({target_height},ih*({target_width}/iw))', force_original_aspect_ratio='decrease')
+                    # Pad to target resolution, center vertically
+                    video = video.filter('pad', target_width, target_height, '(ow-iw)/2', '(oh-ih)/2', color='black')
+            else:
+                # Aspect ratio matches: scale directly to target resolution
+                video = video.filter('scale', target_width, target_height, force_original_aspect_ratio='decrease')
+            
+            # Ensure consistent frame rate
+            video = video.filter('fps', fps=30)
+            
+            print(f"After scaling {file_path}: target resolution={target_width}x{target_height}")
+            
+            processed_streams.append(video)
+            processed_streams.append(audio)
+        
+        except ffmpeg.Error as e:
+            print(f"Error processing {file_path}: {e.stderr.decode()}")
+            continue
+        except StopIteration:
+            print(f"Error: No video stream found in {file_path}")
+            continue
+        except Exception as e:
+            print(f"Unexpected error processing {file_path}: {str(e)}")
+            continue
+
+    # Check if we have valid streams to concatenate
+    if not processed_streams:
+        print("Error: No valid streams to concatenate")
+        exit(1)
+
+    # Concatenate all video and audio streams
+    joined = ffmpeg.concat(*processed_streams, v=1, a=1).node
+
+    # Output the final video
+    try:
+        random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
+        file_name = f"edited_videos/video_edited{random_string}.mp4"  # Changed to .mp4 for compatibility
+    
+        ffmpeg.output(joined[0], joined[1], file_name, **{'c:v': 'libx264', 'c:a': 'aac'}, preset='fast').run(overwrite_output=True)
+        print("Video concatenation successful")
+        return file_name
+    except ffmpeg.Error as e:
+        print(f"Error during concatenation: {e.stderr.decode()}")
+
+