feat(core): Implement multi-audio file processing and complex numbering

This major update refactors the application to support processing multiple audio files into a single, continuous spectrogram video. The previous single-file workflow has been replaced with a robust batch processing pipeline.

This introduces a more powerful and flexible user experience, allowing for the creation of long-form videos from multiple sources, such as album tracks or podcast segments.

Key Changes:

Multi-File Upload:
The Gradio UI has been updated from `gr.Audio` to `gr.Files`, enabling users to upload and process multiple audio files in a single job.

Audio Processing Pipeline:
The backend now concatenates all uploaded audio files into a single, temporary WAV file.
It automatically handles resampling to a consistent sample rate if the source files differ.

Complex Title Numbering Logic:
Implemented a sophisticated system for numbering tracks and files based on the context of the upload:
1. **Single File with CUE:** Tracks are numbered sequentially (e.g., `01.`, `02.`).
2. **Single File without CUE:** The filename is used as the title, with no number.
3. **Multiple Files without CUE:** Files are numbered sequentially (e.g., `01.`, `02.`).
4. **Multiple Files (Mixed):** Files with CUE sheets have their tracks numbered with a composite scheme (e.g., `File 1, Track 1` -> `01-01.`). Files without CUE sheets are numbered by their position in the upload list.

UI Enhancements:
Added a new checkbox in the UI ("Format track numbers as double digits") to allow users to toggle zero-padding for all generated numbers.

Image Distribution:
The logic for background images has been adapted to distribute them evenly across the *total combined duration* of all uploaded audio files.

app.py

@@ -6,7 +6,9 @@ import os
 import time
 import struct
 import subprocess
+import soundfile as sf
 import matplotlib.font_manager as fm
+from PIL import ImageFont
 from typing import Tuple, List, Dict
 from mutagen.flac import FLAC
 from moviepy import CompositeVideoClip, TextClip, VideoClip, AudioFileClip, ImageClip
@@ -178,12 +180,12 @@ def increase_video_framerate(input_path: str, output_path: str, target_fps: int
         'ffmpeg',
         '-y',  # Overwrite output file if exists
         '-i', input_path,
-        '-map', '0',            # Map all streams (video, audio, subtitles)
-        '-vf', 'fps=24',        # Use fps filter to convert framerate to 24
-        '-c:v', 'libx264',      # Re-encode video with H.264 codec
-        '-preset', 'fast',      # Encoding speed/quality tradeoff
-        '-crf', '18',           # Quality (lower is better)
-        '-c:a', 'copy',         # Copy audio without re-encoding
+        '-map', '0',                # Map all streams (video, audio, subtitles)
+        '-vf', f'fps={target_fps}', # Use fps filter to convert framerate to 24
+        '-c:v', 'libx264',          # Re-encode video with H.264 codec
+        '-preset', 'fast',          # Encoding speed/quality tradeoff
+        '-crf', '18',               # Quality (lower is better)
+        '-c:a', 'copy',             # Copy audio without re-encoding
         output_path
     ]
     
@@ -203,19 +205,26 @@ def increase_video_framerate(input_path: str, output_path: str, target_fps: int
 
 # --- Main Processing Function ---
 def process_audio_to_video(
-    audio_path: str, image_paths: List[str],
+    audio_files: List[str], image_paths: List[str],
+    format_double_digits: bool,
     video_width: int, video_height: int,
     spec_fg_color: str, spec_bg_color: str, 
     font_name: str, font_size: int, font_color: str,
     font_bg_color: str, font_bg_alpha: float,
-    pos_h: str, pos_v: str
+    pos_h: str, pos_v: str,
+    progress=gr.Progress(track_tqdm=True)
 ) -> str:
-    if not audio_path: raise gr.Error("Please upload an audio file first.")
-    if not font_name: raise gr.Error("Please select a font from the list.")
+    if not audio_files:
+        raise gr.Error("Please upload at least one audio file.")
+    if not font_name:
+        raise gr.Error("Please select a font from the list.")
     
+    progress(0, desc="Initializing...")
+
     # Define paths for temporary and final files
     timestamp = int(time.time())
     temp_fps1_path = f"temp_{timestamp}_fps1.mp4"
+    temp_audio_path = f"temp_combined_audio_{timestamp}.wav"
     final_output_path = f"final_video_{timestamp}_fps24.mp4"
 
     WIDTH, HEIGHT = int(video_width), int(video_height)
@@ -252,90 +261,214 @@ def process_audio_to_video(
     
     # Wrap the entire process in a try...finally block to ensure cleanup
     try:
-        y, sr = librosa.load(audio_path, sr=None, mono=True)
-        duration = librosa.get_duration(y=y, sr=sr)
+        # --- Define total steps for the progress bar ---
+        TOTAL_STEPS = 5
         
-        # --- Image Processing Logic ---
-        image_clips = []
-        # Check if any images were uploaded.
-        if image_paths and len(image_paths) > 0:
-            print(f"Found {len(image_paths)} images to process.")
+        # --- 1. Audio Processing & Track Info Aggregation ---
+        all_tracks_info = []
+        total_duration = 0.0
+        y_accumulator = []
+        current_sr = None
+        
+        # --- Use `progress.tqdm` to create a progress bar for this loop ---
+        for file_idx, audio_path in enumerate(progress.tqdm(audio_files, desc=f"Stage 1/{TOTAL_STEPS}: Analyzing Audio Files")):
+            # --- Load audio as stereo (or its original channel count) ---
+            y, sr = librosa.load(audio_path, sr=None, mono=False)
+            # If loaded audio is mono (1D array), convert it to a 2D stereo array
+            # by duplicating the channel. This ensures all arrays can be concatenated.
+            if y.ndim == 1:
+                print(f"  - Converting mono file to stereo: {os.path.basename(audio_path)}")
+                y = np.stack([y, y])
+            
+            if current_sr is None:
+                current_sr = sr
+            if current_sr != sr:
+                print(f"Warning: Sample rate mismatch for {os.path.basename(audio_path)}. Expected {current_sr}Hz, found {sr}Hz.")
+                print(f"Resampling from {sr}Hz to {current_sr}Hz...")
+                y = librosa.resample(y, orig_sr=sr, target_sr=current_sr)
+            
+            y_accumulator.append(y)
+            # Use the first channel (y[0]) for duration calculation, which is standard practice
+            file_duration = librosa.get_duration(y=y[0], sr=current_sr)
             
             # First, try to parse the CUE sheet from the audio file.
-            tracks = []
+            cue_tracks = []
             if audio_path.lower().endswith('.flac'):
                 try:
                     audio_meta = FLAC(audio_path)
                     if 'cuesheet' in audio_meta.tags:
-                        tracks = parse_cue_sheet_manually(audio_meta.tags['cuesheet'][0])
-                        print(f"Successfully parsed {len(tracks)} tracks from CUE sheet.")
-                except Exception as e: print(f"Warning: Could not read or parse CUE sheet: {e}")
-
-            # --- HELPER FUNCTION FOR ROBUST IMAGE CLIPS ---
-            def create_image_layer(img_path, start, dur):
-                """
-                Creates an image layer that fits entirely within the video frame.
-                It scales the image down to fit and centers it on a transparent background.
-                """
-                # This function implements a "cover" scaling mode to ensure the image
-                # fills the entire video frame without leaving black bars.
-                try:
-                    img_clip_raw = ImageClip(img_path)
-                    
-                    # 1. Calculate scaling factor to "contain" the image (fit inside).
-                    #    We use min() to find the ratio that requires the most shrinkage,
-                    #    ensuring the whole image fits without being cropped.
-                    scale_factor = min(WIDTH / img_clip_raw.w, HEIGHT / img_clip_raw.h)
-                    
-                    # 2. Resize the image so it fits perfectly within the video dimensions.
-                    resized_image_clip = img_clip_raw.resized(scale_factor)
-                    
-                    # 3. Create a composite clip to position the resized image on a
-                    #    correctly-sized transparent canvas. This is the key to preventing overflow.
-                    final_layer = CompositeVideoClip(
-                        [resized_image_clip.with_position("center")],
-                        size=(WIDTH, HEIGHT)
-                    )
-                    
-                    # 4. Set the timing on the final composite layer.
-                    return final_layer.with_duration(dur).with_start(start)
+                        cue_tracks = parse_cue_sheet_manually(audio_meta.tags['cuesheet'][0])
+                        
+                        print(f"Successfully parsed {len(cue_tracks)} tracks from CUE sheet.")
                 except Exception as e:
-                    print(f"Warning: Failed to process image '{img_path}'. Skipping. Error: {e}")
-                    return None
-            # --- END OF HELPER FUNCTION ---
+                    print(f"Warning: Could not read or parse CUE sheet for {os.path.basename(audio_path)}: {e}")
+                    
+            # --- Apply New Numbering Logic ---
+            file_num = file_idx + 1 # File numbering starts from 1
+            if len(audio_files) > 1:
+                if cue_tracks: # Scenario 3: Multiple files, this one has CUE
+                    for track_idx, track in enumerate(cue_tracks):
+                        track_num = track_idx + 1 # Track numbering starts from 1
+                        number_str = f"{file_num:02d}-{track_num:02d}" if format_double_digits else f"{file_num}-{track_num}"
+                        all_tracks_info.append({
+                            "title": track.get('title', 'Unknown Track'),
+                            "start_time": total_duration + track.get('start_time', 0),
+                            "end_time": total_duration + (cue_tracks[track_idx+1].get('start_time', file_duration) if track_idx + 1 < len(cue_tracks) else file_duration),
+                            "number_str": number_str
+                        })
+                else: # Scenario 2: Multiple files, this one has NO CUE
+                    number_str = f"{file_num:02d}" if format_double_digits else str(file_num)
+                    all_tracks_info.append({
+                        "title": os.path.splitext(os.path.basename(audio_path))[0],
+                        "start_time": total_duration, "end_time": total_duration + file_duration,
+                        "number_str": number_str
+                    })
+            else: # Scenario 1: Single file upload
+                if cue_tracks: # With CUE
+                    for track_idx, track in enumerate(cue_tracks):
+                        track_num = track_idx + 1
+                        number_str = f"{track_num:02d}" if format_double_digits else str(track_num)
+                        all_tracks_info.append({
+                            "title": track.get('title', 'Unknown Track'),
+                            "start_time": total_duration + track.get('start_time', 0),
+                            "end_time": total_duration + (cue_tracks[track_idx+1].get('start_time', file_duration) if track_idx + 1 < len(cue_tracks) else file_duration),
+                            "number_str": f"{number_str}." # Add a dot for single file CUE tracks
+                        })
+                else: # No CUE
+                    all_tracks_info.append({
+                        "title": os.path.splitext(os.path.basename(audio_path))[0],
+                        "start_time": total_duration, "end_time": total_duration + file_duration,
+                        "number_str": None # Signal to not show any number
+                    })
+
+            total_duration += file_duration
+
+        # --- Concatenate along the time axis (axis=1) for stereo arrays ---
+        y_combined = np.concatenate(y_accumulator, axis=1)
+        duration = total_duration
+        
+        # --- Transpose the array for soundfile to write stereo correctly ---
+        sf.write(temp_audio_path, y_combined.T, current_sr)
+        print(f"Combined all audio files into one. Total duration: {duration:.2f}s")
+
+        # --- Update progress to the next stage, use fractional progress (current/total) ---
+        progress(1 / TOTAL_STEPS, desc=f"Stage 2/{TOTAL_STEPS}: Generating Text Overlays")
+        
+        # --- 2. Text Overlay Logic using the aggregated track info
+        text_clips = []
+        if all_tracks_info:
+            font_path = SYSTEM_FONTS_MAP.get(font_name)
+            if not font_path: raise gr.Error(f"Font path for '{font_name}' not found!")
+            
+            # Use the robust parser for text colors as well
+            font_bg_rgb = parse_color_to_rgb(font_bg_color)
+
+            position = (pos_h.lower(), pos_v.lower())
+
+            print(f"Using font: {font_name}, Size: {font_size}, Position: {position}")
+
+            # Create the RGBA tuple for the background color.
+            # The alpha value is converted from a 0.0-1.0 float to a 0-255 integer.
+            bg_color_tuple = (font_bg_rgb[0], font_bg_rgb[1], font_bg_rgb[2], int(font_bg_alpha * 255))
+            
+            # 1. Define a maximum width for the caption. 90% of the video width is a good choice.
+            caption_width = int(WIDTH * 0.9)
+            
+            # --- Get font metrics to calculate dynamic padding ---
+            try:
+                # Load the font with Pillow to access its metrics
+                pil_font = ImageFont.truetype(font_path, size=font_size)
+                _, descent = pil_font.getmetrics()
+                # Calculate a bottom margin to compensate for the font's descent.
+                # A small constant is added as a safety buffer.
+                # This prevents clipping on fonts with large descenders (like 'g', 'p').
+                bottom_margin = int(descent * 0.5) + 2
+                print(f"Font '{font_name}' descent: {descent}. Applying dynamic bottom margin of {bottom_margin}px.")
+            except Exception as e:
+                # Fallback in case of any font loading error
+                print(f"Warning: Could not get font metrics for '{font_name}'. Using fixed margin. Error: {e}")
+                bottom_margin = int(WIDTH * 0.01) # A small fixed fallback
+            
+            for track in all_tracks_info:
+                text_duration = track['end_time'] - track['start_time']
+                if text_duration <= 0:
+                    continue
+                
+                # Construct display text based on pre-formatted number string
+                display_text = f"{track['number_str']} {track['title']}" if track['number_str'] else track['title']
+                
+
+                # 1. Create the TextClip first without positioning to get its size
+                txt_clip = TextClip(
+                    text=display_text.strip(),
+                    font_size=font_size,
+                    color=font_color,
+                    font=font_path,
+                    bg_color=bg_color_tuple,
+                    method='caption', # <-- Set method to caption
+                    size=(caption_width, None), # <-- Provide size for wrapping
+                    margin=(0, 0, 0, bottom_margin)
+                ).with_position(position).with_duration(text_duration).with_start(track['start_time'])
+
+                text_clips.append(txt_clip)
+        
+        # --- Update progress to the next stage, use fractional progress (current/total) ---
+        progress(2 / TOTAL_STEPS, desc=f"Stage 3/{TOTAL_STEPS}: Generating Visual Layers")
+
+        # --- 3. Image and Spectrogram Logic ---
+        image_clips = []
+        if image_paths and len(image_paths) > 0:
+            print(f"Found {len(image_paths)} images to process.")
             
-            # Mode 1: If CUE tracks match the number of images, align them.
-            if tracks and len(tracks) == len(image_paths):
-                print("Image count matches track count. Aligning images with tracks.")
-                for i, (track, img_path) in enumerate(zip(tracks, image_paths)):
-                    start_time = track.get('start_time', 0)
-                    # The end time of a track is the start time of the next, or the total duration for the last track.
-                    end_time = tracks[i+1].get('start_time', duration) if i + 1 < len(tracks) else duration
-                    img_duration = end_time - start_time
-                    if img_duration <= 0: continue
+            # Simplified logic: calculate time per image, max 3 mins, and loop.
+            img_duration = duration / len(image_paths)
+            for i, img_path in enumerate(image_paths):
+
+                # --- HELPER FUNCTION FOR ROBUST IMAGE CLIPS ---
+                def create_image_layer(img_path, start, dur):
+                    """
+                    Creates an image layer that fits entirely within the video frame.
+                    It scales the image down to fit and centers it on a transparent background.
+                    """
+                    # This function implements a "cover" scaling mode to ensure the image
+                    # fills the entire video frame without leaving black bars.
+                    try:
+                        img_clip_raw = ImageClip(img_path)
+                    
+                        # 1. Calculate scaling factor to "contain" the image (fit inside).
+                        #    We use min() to find the ratio that requires the most shrinkage,
+                        #    ensuring the whole image fits without being cropped.
+                        scale_factor = min(WIDTH / img_clip_raw.w, HEIGHT / img_clip_raw.h)
+                        
+                        # 2. Resize the image so it fits perfectly within the video dimensions.
+                        resized_clip = img_clip_raw.resized(scale_factor)
+                        
+                        # 3. Create a composite clip to position the resized image on a
+                        #    correctly-sized transparent canvas. This is the key to preventing overflow.
+                        final_layer = CompositeVideoClip(
+                            [resized_clip.with_position("center")],
+                            size=(WIDTH, HEIGHT)
+                        )
+
+                        # 4. Set the timing on the final composite layer.
+                        return final_layer.with_duration(dur).with_start(start)
+                    except Exception as e:
+                        print(f"Warning: Failed to process image '{img_path}'. Skipping. Error: {e}")
+                        return None
                     
-                    # Create an ImageClip for the duration of the track.
-                    clip = create_image_layer(img_path, start_time, img_duration)
-                    if clip:
-                        image_clips.append(clip)
-
-            # Mode 2: If no CUE or mismatch, distribute images evenly across the audio duration.
-            else:
-                if tracks: print("Image count does not match track count. Distributing images evenly.")
-                else: print("No CUE sheet found. Distributing images evenly.")
-
-                img_duration = duration / len(image_paths)
-                for i, img_path in enumerate(image_paths):
-                    start_time = i * img_duration
-                    # Create an ImageClip for a calculated segment of time.                    
-                    clip = create_image_layer(img_path, start_time, img_duration)
-                    if clip:
-                        image_clips.append(clip)
-
-        # Spectrogram calculation
+                # Create an ImageClip for the duration of the track.
+                clip = create_image_layer(img_path, i * img_duration, img_duration)
+                if clip:
+                    image_clips.append(clip)
+        
         N_FFT, HOP_LENGTH, N_BANDS = 2048, 512, 32
         MIN_DB, MAX_DB = -80.0, 0.0
-        S_mel = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH, n_mels=N_BANDS, fmax=sr/2)
+
+        # Spectrogram calculation on combined audio
+        # --- Create a mono version of audio specifically for the spectrogram ---
+        # This resolves the TypeError while keeping the final audio in stereo.
+        y_mono_for_spec = librosa.to_mono(y_combined)
+        S_mel = librosa.feature.melspectrogram(y=y_mono_for_spec, sr=current_sr, n_fft=N_FFT, hop_length=HOP_LENGTH, n_mels=N_BANDS, fmax=current_sr/2)
         S_mel_db = librosa.power_to_db(S_mel, ref=np.max)
         
         # Frame generation logic for the spectrogram
@@ -351,13 +484,18 @@ def process_audio_to_video(
                 for i in range(1, 9):
                     y_pos = int(i * (HEIGHT / 9)); frame[y_pos-1:y_pos, :] = grid_rgb
 
-            time_idx = int((t / duration) * (S_mel_db.shape[1] - 1))
+            time_idx = min(int((t / duration) * S_mel_db.shape[1]), S_mel_db.shape[1] - 1)
             bar_width = WIDTH / N_BANDS
             for i in range(N_BANDS):
                 energy_db = S_mel_db[i, time_idx]
+                
+                # The denominator should be the range of DB values (MAX_DB - MIN_DB).
+                # Since MAX_DB is 0, this simplifies to -MIN_DB, which is a positive 80.0.
+                # This prevents the division by zero warning.
                 norm_height = np.clip((energy_db - MIN_DB) / (MAX_DB - MIN_DB), 0, 1)
-                bar_height = int(norm_height * HEIGHT)
-                if bar_height < 1: continue
+                bar_height = int(np.nan_to_num(norm_height) * HEIGHT)
+                if bar_height < 1:
+                    continue
                 x_start, x_end = int(i * bar_width), int((i + 1) * bar_width - 2)
                 y_start = HEIGHT - bar_height
                 for k in range(bar_height):
@@ -367,62 +505,19 @@ def process_audio_to_video(
             return frame
             
         video_clip = VideoClip(frame_function=frame_generator, duration=duration)
-
+        
         # --- NEW: Set Spectrogram Opacity ---
         # If image clips were created, make the spectrogram layer 50% transparent.
         if image_clips:
             print("Applying 50% opacity to spectrogram layer.")
             video_clip = video_clip.with_opacity(0.5)
 
-        audio_clip = AudioFileClip(audio_path)
+        # --- Use fractional progress (current/total) ---
+        progress(3 / TOTAL_STEPS, desc=f"Stage 4/{TOTAL_STEPS}: Rendering Base Video (this may take time)")
         
-        # CUE Sheet title overlay logic
-        text_clips = []
-        tracks = []
-        if audio_path.lower().endswith('.flac'):
-            try:
-                audio_meta = FLAC(audio_path)
-                if 'cuesheet' in audio_meta.tags:
-                    tracks = parse_cue_sheet_manually(audio_meta.tags['cuesheet'][0])
-            except Exception:
-                pass # Already handled above
+        # --- 4. Composition and Rendering ---
+        audio_clip = AudioFileClip(temp_audio_path)
         
-        if tracks:
-            font_path = SYSTEM_FONTS_MAP.get(font_name)
-            if not font_path: raise gr.Error(f"Font path for '{font_name}' not found!")
-            
-            # Use the robust parser for text colors as well
-            font_bg_rgb = parse_color_to_rgb(font_bg_color)
-
-            position = (pos_h.lower(), pos_v.lower())
-
-            print(f"Using font: {font_name}, Size: {font_size}, Position: {position}")
-            
-            # Create the RGBA tuple for the background color.
-            # The alpha value is converted from a 0.0-1.0 float to a 0-255 integer.
-            bg_color_tuple = (font_bg_rgb[0], font_bg_rgb[1], font_bg_rgb[2], int(font_bg_alpha * 255))
-            
-            # 1. Define a maximum width for the caption. 90% of the video width is a good choice.
-            caption_width = int(WIDTH * 0.9)
-
-            for i, track in enumerate(tracks):
-                start_time, title = track.get('start_time', 0), track.get('title', 'Unknown Track')
-                end_time = tracks[i+1].get('start_time', duration) if i + 1 < len(tracks) else duration
-                text_duration = end_time - start_time
-                if text_duration <= 0: continue
-                
-                txt_clip = (TextClip(text=f"{i+1}. {title}",
-                                     font_size=font_size,
-                                     color=font_color,
-                                     font=font_path, 
-                                     bg_color=bg_color_tuple,
-                                     method='caption', # <-- Set method to caption
-                                     size=(caption_width, None)) # <-- Provide size for wrapping
-                            .with_position(position)
-                            .with_duration(text_duration)
-                            .with_start(start_time))
-                text_clips.append(txt_clip)
-
         # --- Clip Composition ---
         # The final composition order is important: images at the bottom, then spectrogram, then text.
         # The base layer is now the list of image clips.
@@ -449,9 +544,14 @@ def process_audio_to_video(
             print("High-quality AAC audio encoding complete.")
         
         final_clip.close()
-
+        
         # Step 2: Use FFmpeg to quickly increase the framerate to 24 FPS
         print(f"\nStep 2/2: Remuxing video to {PLAYBACK_FPS} FPS...")
+
+        # --- Use fractional progress (current/total) ---
+        progress(4 / TOTAL_STEPS, desc=f"Stage 5/{TOTAL_STEPS}: Finalizing Video")
+
+        # --- 5. Finalizing ---
         increase_video_framerate(temp_fps1_path, final_output_path, target_fps=PLAYBACK_FPS)
         
         return final_output_path
@@ -461,37 +561,39 @@ def process_audio_to_video(
         raise e
     finally:
         # Step 3: Clean up the temporary file regardless of success or failure
-        if os.path.exists(temp_fps1_path):
-            print(f"Cleaning up temporary file: {temp_fps1_path}")
-            os.remove(temp_fps1_path)
+        for f in [temp_fps1_path, temp_audio_path]:
+            if os.path.exists(f):
+                print(f"Cleaning up temporary file: {f}")
+                os.remove(f)
 
 # --- Gradio UI ---
 with gr.Blocks(title="Spectrogram Video Generator") as iface:
     gr.Markdown("# Spectrogram Video Generator")
     with gr.Row():
         with gr.Column(scale=1):
-            audio_input = gr.Audio(type="filepath", label="Upload Audio File")
+            # --- Changed to gr.Files for multi-upload ---
+            audio_inputs = gr.Files(
+                label="Upload Audio File(s)", 
+                file_count="multiple",
+                file_types=["audio"]
+            )
             
             # --- Image Upload Component ---
+            gr.Markdown("### Background Image Options (Optional)")
             gr.Markdown(
                 """
-                ### Background Image Options (Optional)
-
-                Upload one or more images to create a dynamic background for the video. The display behavior changes based on your audio file and the number of images provided.
-
-                *   **Mode 1: CUE Sheet Synchronization**
-                    If your audio file contains an embedded CUE sheet AND the number of images you upload **exactly matches** the number of tracks, the images will be synchronized with the tracks. The first image will appear during the first track, the second during the second, and so on.
-
-                *   **Mode 2: Even Time Distribution**
-                    In all other cases (e.g., the audio has no CUE sheet, or the number of images and tracks do not match), the images will be displayed sequentially. The total duration of the video will be divided equally among all uploaded images.
-
-                **Note:** When any image is used as a background, the spectrogram visualizer will automatically become **semi-transparent** to ensure the background is clearly visible.
+                When background images are uploaded, they will be displayed in a looping sequence.
+                - The display duration for each image is calculated by dividing the total video length by the number of images, with a maximum duration of **3 minutes** per image.
+                - The sequence loops until the video ends.
                 """
             )
             image_uploads = gr.File(
                 label="Upload Background Images", 
                 file_count="multiple", # Allow multiple files
-                file_types=["image"]   # Accept only image formats
+                # Replace the generic "image" category with a specific list of extensions.
+                # Note that the dot (.) before each extension is required.
+                file_types=[".png", ".jpg", ".jpeg", ".bmp", ".gif", ".webp", ".avif"]
+
             )
             
             with gr.Accordion("Visualizer Options", open=True):
@@ -503,11 +605,34 @@ with gr.Blocks(title="Spectrogram Video Generator") as iface:
             
             with gr.Accordion("Text Overlay Options", open=True):
                 gr.Markdown(
-                    "**Note:** These options only take effect if the input audio file has an embedded CUE sheet."
+                    "**Note:** The title overlay feature automatically detects if a file has an embedded CUE sheet. If not, the filename will be used as the title."
                 )
                 gr.Markdown("---")
-                gr.Markdown("If your CUE sheet contains non-English characters, please select a compatible font.")
-                default_font = "Microsoft JhengHei" if "Microsoft JhengHei" in FONT_DISPLAY_NAMES else ("Arial" if "Arial" in FONT_DISPLAY_NAMES else (FONT_DISPLAY_NAMES[0] if FONT_DISPLAY_NAMES else None))
+                # --- Checkbox for number formatting ---
+                format_double_digits_checkbox = gr.Checkbox(label="Format track numbers as double digits (e.g., 01, 05-09)", value=True)
+                gr.Markdown("If the CUE sheet or filenames contain non-English characters, please select a compatible font.")
+                
+                # Define a priority list for default fonts, starting with common Japanese ones.
+                # This list can include multiple names for the same font to improve matching.
+                preferred_fonts = [
+                    "Meiryo", "メイリオ",
+                    "Yu Gothic", "游ゴシック",
+                    "MS Gothic", "ＭＳ ゴシック",
+                    "Hiragino Kaku Gothic ProN", # Common on macOS
+                    "Microsoft JhengHei", # Fallback to Traditional Chinese
+                    "Arial" # Generic fallback
+                ]
+                default_font = None
+                # Find the first available font from the preferred list
+                for font in preferred_fonts:
+                    if font in FONT_DISPLAY_NAMES:
+                        default_font = font
+                        break
+                    
+                # If none of the preferred fonts are found, use the first available font as a last resort
+                if not default_font and FONT_DISPLAY_NAMES:
+                    default_font = FONT_DISPLAY_NAMES[0]
+
                 font_name_dd = gr.Dropdown(choices=FONT_DISPLAY_NAMES, value=default_font, label="Font Family")
                 
                 with gr.Row():
@@ -528,11 +653,12 @@ with gr.Blocks(title="Spectrogram Video Generator") as iface:
         with gr.Column(scale=2):
             video_output = gr.Video(label="Generated Video")
     
-    # --- Add image_uploads to the inputs list ---
+    # --- Update inputs for the click event ---
     submit_btn.click(
         fn=process_audio_to_video,
         inputs=[
-            audio_input, image_uploads,
+            audio_inputs, image_uploads,
+            format_double_digits_checkbox,
             width_input, height_input,
             fg_color, bg_color, 
             font_name_dd, font_size_slider, font_color_picker,

requirements.txt

@@ -3,3 +3,4 @@ moviepy
 mutagen
 librosa
 matplotlib
+pillow-avif-plugin