抽象pipeline逻辑

pixelle_video/pipelines/__init__.py

@@ -0,0 +1,17 @@
+"""
+Pixelle-Video Pipelines
+
+Video generation pipelines with different strategies and workflows.
+Each pipeline implements a specific video generation approach.
+"""
+
+from pixelle_video.pipelines.base import BasePipeline
+from pixelle_video.pipelines.standard import StandardPipeline
+from pixelle_video.pipelines.custom import CustomPipeline
+
+__all__ = [
+    "BasePipeline",
+    "StandardPipeline",
+    "CustomPipeline",
+]
+

pixelle_video/pipelines/base.py

@@ -0,0 +1,102 @@
+"""
+Base Pipeline for Video Generation
+
+All custom pipelines should inherit from BasePipeline.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Callable
+
+from loguru import logger
+
+from pixelle_video.models.progress import ProgressEvent
+from pixelle_video.models.storyboard import VideoGenerationResult
+
+
+class BasePipeline(ABC):
+    """
+    Base pipeline for video generation
+    
+    All custom pipelines should inherit from this class and implement __call__.
+    
+    Design principles:
+    - Each pipeline represents a complete video generation workflow
+    - Pipelines are independent and can have completely different logic
+    - Pipelines have access to all core services via self.core
+    - Pipelines should report progress via progress_callback
+    
+    Example:
+        >>> class MyPipeline(BasePipeline):
+        ...     async def __call__(self, text: str, **kwargs):
+        ...         # Step 1: Generate content
+        ...         narrations = await some_logic(text)
+        ...         
+        ...         # Step 2: Process frames
+        ...         for narration in narrations:
+        ...             audio = await self.core.tts(narration)
+        ...             # ...
+        ...         
+        ...         return VideoGenerationResult(...)
+    """
+    
+    def __init__(self, pixelle_video_core):
+        """
+        Initialize pipeline with core services
+        
+        Args:
+            pixelle_video_core: PixelleVideoCore instance (provides access to all services)
+        """
+        self.core = pixelle_video_core
+        
+        # Quick access to services (convenience)
+        self.llm = pixelle_video_core.llm
+        self.tts = pixelle_video_core.tts
+        self.image = pixelle_video_core.image
+        self.video = pixelle_video_core.video
+    
+    @abstractmethod
+    async def __call__(
+        self,
+        text: str,
+        progress_callback: Optional[Callable[[ProgressEvent], None]] = None,
+        **kwargs
+    ) -> VideoGenerationResult:
+        """
+        Execute the pipeline
+        
+        Args:
+            text: Input text (meaning varies by pipeline)
+            progress_callback: Optional callback for progress updates (receives ProgressEvent)
+            **kwargs: Pipeline-specific parameters
+            
+        Returns:
+            VideoGenerationResult with video path and metadata
+            
+        Raises:
+            Exception: Pipeline-specific exceptions
+        """
+        pass
+    
+    def _report_progress(
+        self,
+        callback: Optional[Callable[[ProgressEvent], None]],
+        event_type: str,
+        progress: float,
+        **kwargs
+    ):
+        """
+        Report progress via callback
+        
+        Args:
+            callback: Progress callback function
+            event_type: Type of progress event
+            progress: Progress value (0.0-1.0)
+            **kwargs: Additional event-specific parameters (frame_current, frame_total, etc.)
+        """
+        if callback:
+            event = ProgressEvent(event_type=event_type, progress=progress, **kwargs)
+            callback(event)
+            logger.debug(f"Progress: {progress*100:.0f}% - {event_type}")
+        else:
+            logger.debug(f"Progress: {progress*100:.0f}% - {event_type}")
+

pixelle_video/pipelines/custom.py

@@ -0,0 +1,375 @@
+"""
+Custom Video Generation Pipeline
+
+Template pipeline for creating your own custom video generation workflows.
+This serves as a reference implementation showing how to extend BasePipeline.
+
+For real projects, copy this file and modify it according to your needs.
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Callable
+
+from loguru import logger
+
+from pixelle_video.pipelines.base import BasePipeline
+from pixelle_video.models.progress import ProgressEvent
+from pixelle_video.models.storyboard import (
+    Storyboard,
+    StoryboardFrame,
+    StoryboardConfig,
+    ContentMetadata,
+    VideoGenerationResult
+)
+
+
+class CustomPipeline(BasePipeline):
+    """
+    Custom video generation pipeline template
+    
+    This is a template showing how to create your own pipeline with custom logic.
+    You can customize:
+    - Content processing logic
+    - Narration generation strategy
+    - Image prompt generation
+    - Frame composition
+    - Video assembly
+    
+    Example usage:
+        # 1. Create your own pipeline by copying this file
+        # 2. Modify the __call__ method with your custom logic
+        # 3. Register it in service.py or dynamically
+        
+        from pixelle_video.pipelines.custom import CustomPipeline
+        pixelle_video.pipelines["my_custom"] = CustomPipeline(pixelle_video)
+        
+        # 4. Use it
+        result = await pixelle_video.generate_video(
+            text=your_content,
+            pipeline="my_custom",
+            # Your custom parameters here
+        )
+    """
+    
+    async def __call__(
+        self,
+        text: str,
+        # === Custom Parameters ===
+        # Add your own parameters here
+        custom_param_example: str = "default_value",
+        
+        # === Standard Parameters (keep these for compatibility) ===
+        voice_id: str = "[Chinese] zh-CN Yunjian",
+        tts_workflow: Optional[str] = None,
+        tts_speed: float = 1.2,
+        ref_audio: Optional[str] = None,
+        
+        image_workflow: Optional[str] = None,
+        image_width: int = 1024,
+        image_height: int = 1024,
+        
+        frame_template: str = "1080x1920/default.html",
+        video_fps: int = 30,
+        output_path: Optional[str] = None,
+        
+        bgm_path: Optional[str] = None,
+        bgm_volume: float = 0.2,
+        
+        progress_callback: Optional[Callable[[ProgressEvent], None]] = None,
+    ) -> VideoGenerationResult:
+        """
+        Custom video generation workflow
+        
+        Customize this method to implement your own logic.
+        
+        Args:
+            text: Input text (customize meaning as needed)
+            custom_param_example: Your custom parameter
+            (other standard parameters...)
+        
+        Returns:
+            VideoGenerationResult
+        """
+        logger.info("Starting CustomPipeline")
+        logger.info(f"Input text length: {len(text)} chars")
+        logger.info(f"Custom parameter: {custom_param_example}")
+        
+        # ========== Step 0: Setup ==========
+        self._report_progress(progress_callback, "initializing", 0.05)
+        
+        # Create task directory
+        from pixelle_video.utils.os_util import (
+            create_task_output_dir,
+            get_task_final_video_path
+        )
+        
+        task_dir, task_id = create_task_output_dir()
+        logger.info(f"Task directory: {task_dir}")
+        
+        user_specified_output = None
+        if output_path is None:
+            output_path = get_task_final_video_path(task_id)
+        else:
+            user_specified_output = output_path
+            output_path = get_task_final_video_path(task_id)
+        
+        # ========== Step 1: Process content (CUSTOMIZE THIS) ==========
+        self._report_progress(progress_callback, "processing_content", 0.10)
+        
+        # Example: Generate title using LLM
+        from pixelle_video.utils.content_generators import generate_title
+        title = await generate_title(self.llm, text, strategy="llm")
+        logger.info(f"Generated title: '{title}'")
+        
+        # Example: Split or generate narrations
+        # Option A: Split by lines (for fixed script)
+        narrations = [line.strip() for line in text.split('\n') if line.strip()]
+        
+        # Option B: Use LLM to generate narrations (uncomment to use)
+        # from pixelle_video.utils.content_generators import generate_narrations_from_topic
+        # narrations = await generate_narrations_from_topic(
+        #     self.llm,
+        #     topic=text,
+        #     n_scenes=5,
+        #     min_words=20,
+        #     max_words=80
+        # )
+        
+        logger.info(f"Generated {len(narrations)} narrations")
+        
+        # ========== Step 2: Generate image prompts (CUSTOMIZE THIS) ==========
+        self._report_progress(progress_callback, "generating_image_prompts", 0.25)
+        
+        # Example: Generate image prompts using LLM
+        from pixelle_video.utils.content_generators import generate_image_prompts
+        
+        image_prompts = await generate_image_prompts(
+            self.llm,
+            narrations=narrations,
+            min_words=30,
+            max_words=60
+        )
+        
+        # Example: Apply custom prompt prefix
+        from pixelle_video.utils.prompt_helper import build_image_prompt
+        custom_prefix = "cinematic style, professional lighting"  # Customize this
+        
+        final_image_prompts = []
+        for base_prompt in image_prompts:
+            final_prompt = build_image_prompt(base_prompt, custom_prefix)
+            final_image_prompts.append(final_prompt)
+        
+        logger.info(f"Generated {len(final_image_prompts)} image prompts")
+        
+        # ========== Step 3: Create storyboard ==========
+        config = StoryboardConfig(
+            task_id=task_id,
+            n_storyboard=len(narrations),
+            min_narration_words=20,
+            max_narration_words=80,
+            min_image_prompt_words=30,
+            max_image_prompt_words=60,
+            video_fps=video_fps,
+            voice_id=voice_id,
+            tts_workflow=tts_workflow,
+            tts_speed=tts_speed,
+            ref_audio=ref_audio,
+            image_width=image_width,
+            image_height=image_height,
+            image_workflow=image_workflow,
+            frame_template=frame_template
+        )
+        
+        # Optional: Add custom metadata
+        content_metadata = ContentMetadata(
+            title=title,
+            subtitle="Custom Pipeline Output"
+        )
+        
+        storyboard = Storyboard(
+            title=title,
+            config=config,
+            content_metadata=content_metadata,
+            created_at=datetime.now()
+        )
+        
+        # Create frames
+        for i, (narration, image_prompt) in enumerate(zip(narrations, final_image_prompts)):
+            frame = StoryboardFrame(
+                index=i,
+                narration=narration,
+                image_prompt=image_prompt,
+                created_at=datetime.now()
+            )
+            storyboard.frames.append(frame)
+        
+        try:
+            # ========== Step 4: Process each frame ==========
+            # This is the standard frame processing logic
+            # You can customize frame processing if needed
+            
+            for i, frame in enumerate(storyboard.frames):
+                base_progress = 0.3
+                frame_range = 0.5
+                per_frame_progress = frame_range / len(storyboard.frames)
+                
+                self._report_progress(
+                    progress_callback,
+                    "processing_frame",
+                    base_progress + (per_frame_progress * i),
+                    frame_current=i+1,
+                    frame_total=len(storyboard.frames)
+                )
+                
+                # Use core frame processor (standard logic)
+                processed_frame = await self.core.frame_processor(
+                    frame=frame,
+                    storyboard=storyboard,
+                    config=config,
+                    total_frames=len(storyboard.frames),
+                    progress_callback=None
+                )
+                storyboard.total_duration += processed_frame.duration
+                logger.info(f"Frame {i+1} completed ({processed_frame.duration:.2f}s)")
+            
+            # ========== Step 5: Concatenate videos ==========
+            self._report_progress(progress_callback, "concatenating", 0.85)
+            segment_paths = [frame.video_segment_path for frame in storyboard.frames]
+            
+            from pixelle_video.services.video import VideoService
+            video_service = VideoService()
+            
+            final_video_path = video_service.concat_videos(
+                videos=segment_paths,
+                output=output_path,
+                bgm_path=bgm_path,
+                bgm_volume=bgm_volume,
+                bgm_mode="loop"
+            )
+            
+            storyboard.final_video_path = final_video_path
+            storyboard.completed_at = datetime.now()
+            
+            # Copy to user-specified path if provided
+            if user_specified_output:
+                import shutil
+                Path(user_specified_output).parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(final_video_path, user_specified_output)
+                logger.info(f"Final video copied to: {user_specified_output}")
+                final_video_path = user_specified_output
+                storyboard.final_video_path = user_specified_output
+            
+            logger.success(f"Custom pipeline video completed: {final_video_path}")
+            
+            # ========== Step 6: Create result ==========
+            self._report_progress(progress_callback, "completed", 1.0)
+            
+            video_path_obj = Path(final_video_path)
+            file_size = video_path_obj.stat().st_size
+            
+            result = VideoGenerationResult(
+                video_path=final_video_path,
+                storyboard=storyboard,
+                duration=storyboard.total_duration,
+                file_size=file_size
+            )
+            
+            logger.info(f"Custom pipeline completed")
+            logger.info(f"Title: {title}")
+            logger.info(f"Duration: {storyboard.total_duration:.2f}s")
+            logger.info(f"Size: {file_size / (1024*1024):.2f} MB")
+            logger.info(f"Frames: {len(storyboard.frames)}")
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Custom pipeline failed: {e}")
+            raise
+    
+    # ==================== Custom Helper Methods ====================
+    # Add your own helper methods here
+    
+    async def _custom_content_analysis(self, text: str) -> dict:
+        """
+        Example: Custom content analysis logic
+        
+        You can add your own helper methods to process content,
+        extract metadata, or perform custom transformations.
+        """
+        # Your custom logic here
+        return {
+            "processed": text,
+            "metadata": {}
+        }
+    
+    async def _custom_prompt_generation(self, context: str) -> str:
+        """
+        Example: Custom prompt generation logic
+        
+        Create specialized prompts based on your use case.
+        """
+        prompt = f"Generate content based on: {context}"
+        response = await self.llm(prompt, temperature=0.7, max_tokens=500)
+        return response.strip()
+
+
+# ==================== Usage Examples ====================
+
+"""
+Example 1: Register and use custom pipeline
+----------------------------------------
+from pixelle_video import pixelle_video
+from pixelle_video.pipelines.custom import CustomPipeline
+
+# Initialize
+await pixelle_video.initialize()
+
+# Register custom pipeline
+pixelle_video.pipelines["my_custom"] = CustomPipeline(pixelle_video)
+
+# Use it
+result = await pixelle_video.generate_video(
+    text="Your input content here",
+    pipeline="my_custom",
+    custom_param_example="custom_value"
+)
+
+
+Example 2: Create your own pipeline class
+----------------------------------------
+from pixelle_video.pipelines.custom import CustomPipeline
+
+class MySpecialPipeline(CustomPipeline):
+    async def __call__(self, text: str, **kwargs):
+        # Your completely custom logic
+        logger.info("Running my special pipeline")
+        
+        # You can reuse parts from CustomPipeline or start from scratch
+        # ...
+        
+        return result
+
+
+Example 3: Inline custom pipeline
+----------------------------------------
+from pixelle_video.pipelines.base import BasePipeline
+
+class QuickPipeline(BasePipeline):
+    async def __call__(self, text: str, **kwargs):
+        # Quick custom logic
+        narrations = text.split('\\n')
+        
+        for narration in narrations:
+            audio = await self.tts(narration)
+            image = await self.image(prompt=f"illustration of {narration}")
+            # ... process frame
+        
+        # ... concatenate and return
+        return result
+
+# Use immediately
+pixelle_video.pipelines["quick"] = QuickPipeline(pixelle_video)
+result = await pixelle_video.generate_video(text=content, pipeline="quick")
+"""
+

pixelle_video/pipelines/standard.py

@@ -0,0 +1,388 @@
+"""
+Standard Video Generation Pipeline
+
+Standard workflow for generating short videos from topic or fixed script.
+This is the default pipeline that replicates the original VideoGeneratorService logic.
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Callable, Literal
+
+from loguru import logger
+
+from pixelle_video.pipelines.base import BasePipeline
+from pixelle_video.models.progress import ProgressEvent
+from pixelle_video.models.storyboard import (
+    Storyboard,
+    StoryboardFrame,
+    StoryboardConfig,
+    ContentMetadata,
+    VideoGenerationResult
+)
+from pixelle_video.utils.content_generators import (
+    generate_title,
+    generate_narrations_from_topic,
+    split_narration_script,
+    generate_image_prompts,
+)
+
+
+class StandardPipeline(BasePipeline):
+    """
+    Standard video generation pipeline
+    
+    Workflow:
+    1. Generate/determine title
+    2. Generate narrations (from topic or split fixed script)
+    3. Generate image prompts for each narration
+    4. For each frame:
+       - Generate audio (TTS)
+       - Generate image
+       - Compose frame with template
+       - Create video segment
+    5. Concatenate all segments
+    6. Add BGM (optional)
+    
+    Supports two modes:
+    - "generate": LLM generates narrations from topic
+    - "fixed": Use provided script as-is (each line = one narration)
+    """
+    
+    async def __call__(
+        self,
+        # === Input ===
+        text: str,
+        
+        # === Processing Mode ===
+        mode: Literal["generate", "fixed"] = "generate",
+        
+        # === Optional Title ===
+        title: Optional[str] = None,
+        
+        # === Basic Config ===
+        n_scenes: int = 5,  # Only used in generate mode; ignored in fixed mode
+        voice_id: str = "[Chinese] zh-CN Yunjian",
+        tts_workflow: Optional[str] = None,
+        tts_speed: float = 1.2,
+        ref_audio: Optional[str] = None,  # Reference audio for voice cloning
+        output_path: Optional[str] = None,
+        
+        # === LLM Parameters ===
+        min_narration_words: int = 5,
+        max_narration_words: int = 20,
+        min_image_prompt_words: int = 30,
+        max_image_prompt_words: int = 60,
+        
+        # === Image Parameters ===
+        image_width: int = 1024,
+        image_height: int = 1024,
+        image_workflow: Optional[str] = None,
+        
+        # === Video Parameters ===
+        video_fps: int = 30,
+        
+        # === Frame Template (determines video size) ===
+        frame_template: Optional[str] = None,
+        
+        # === Image Style ===
+        prompt_prefix: Optional[str] = None,
+        
+        # === BGM Parameters ===
+        bgm_path: Optional[str] = None,
+        bgm_volume: float = 0.2,
+        bgm_mode: Literal["once", "loop"] = "loop",
+        
+        # === Advanced Options ===
+        content_metadata: Optional[ContentMetadata] = None,
+        progress_callback: Optional[Callable[[ProgressEvent], None]] = None,
+    ) -> VideoGenerationResult:
+        """
+        Generate short video from text input
+        
+        Args:
+            text: Text input (required)
+                  - For generate mode: topic/theme (e.g., "如何提高学习效率")
+                  - For fixed mode: complete narration script (each line is a narration)
+            
+            mode: Processing mode (default "generate")
+                  - "generate": LLM generates narrations from topic, creates n_scenes
+                  - "fixed": Use existing script as-is, each line becomes a narration
+                  
+                  Note: In fixed mode, n_scenes is ignored (uses actual line count)
+            
+            title: Video title (optional)
+                   - If provided, use it as the video title
+                   - If not provided:
+                     * generate mode → use text as title
+                     * fixed mode → LLM generates title from script
+            
+            n_scenes: Number of storyboard scenes (default 5)
+                      Only effective in generate mode; ignored in fixed mode
+            
+            voice_id: TTS voice ID (default "[Chinese] zh-CN Yunjian")
+            tts_workflow: TTS workflow filename (e.g., "tts_edge.json", None = use default)
+            tts_speed: TTS speed multiplier (1.0 = normal, 1.2 = 20% faster, default 1.2)
+            ref_audio: Reference audio path for voice cloning (optional)
+            output_path: Output video path (auto-generated if None)
+            
+            min_narration_words: Min narration length (generate mode only)
+            max_narration_words: Max narration length (generate mode only)
+            min_image_prompt_words: Min image prompt length
+            max_image_prompt_words: Max image prompt length
+            
+            image_width: Generated image width (default 1024)
+            image_height: Generated image height (default 1024)
+            image_workflow: Image workflow filename (e.g., "image_flux.json", None = use default)
+            
+            video_fps: Video frame rate (default 30)
+            
+            frame_template: HTML template path with size (None = use default "1080x1920/default.html")
+                           Format: "SIZExSIZE/template.html" (e.g., "1080x1920/default.html", "1920x1080/modern.html")
+                           Video size is automatically determined from template path
+            
+            prompt_prefix: Image prompt prefix (overrides config.yaml if provided)
+                          e.g., "anime style, vibrant colors" or "" for no prefix
+            
+            bgm_path: BGM path (filename like "default.mp3", custom path, or None)
+            bgm_volume: BGM volume 0.0-1.0 (default 0.2)
+            bgm_mode: BGM mode "once" or "loop" (default "loop")
+            
+            content_metadata: Content metadata (optional, for display)
+            progress_callback: Progress callback function(ProgressEvent)
+        
+        Returns:
+            VideoGenerationResult with video path and metadata
+        """
+        # ========== Step 0: Process text and determine title ==========
+        logger.info(f"🚀 Starting StandardPipeline in '{mode}' mode")
+        logger.info(f"   Text length: {len(text)} chars")
+        
+        # Determine final title
+        if title:
+            final_title = title
+            logger.info(f"   Title: '{title}' (user-specified)")
+        else:
+            self._report_progress(progress_callback, "generating_title", 0.01)
+            if mode == "generate":
+                final_title = await generate_title(self.llm, text, strategy="auto")
+                logger.info(f"   Title: '{final_title}' (auto-generated)")
+            else:  # fixed
+                final_title = await generate_title(self.llm, text, strategy="llm")
+                logger.info(f"   Title: '{final_title}' (LLM-generated)")
+        
+        # ========== Step 0.5: Create isolated task directory ==========
+        from pixelle_video.utils.os_util import (
+            create_task_output_dir,
+            get_task_final_video_path
+        )
+        
+        task_dir, task_id = create_task_output_dir()
+        logger.info(f"📁 Task directory created: {task_dir}")
+        logger.info(f"   Task ID: {task_id}")
+        
+        # Determine final video path
+        user_specified_output = None
+        if output_path is None:
+            output_path = get_task_final_video_path(task_id)
+        else:
+            user_specified_output = output_path
+            output_path = get_task_final_video_path(task_id)
+            logger.info(f"   Will copy final video to: {user_specified_output}")
+        
+        # Create storyboard config
+        config = StoryboardConfig(
+            task_id=task_id,
+            n_storyboard=n_scenes,
+            min_narration_words=min_narration_words,
+            max_narration_words=max_narration_words,
+            min_image_prompt_words=min_image_prompt_words,
+            max_image_prompt_words=max_image_prompt_words,
+            video_fps=video_fps,
+            voice_id=voice_id,
+            tts_workflow=tts_workflow,
+            tts_speed=tts_speed,
+            ref_audio=ref_audio,
+            image_width=image_width,
+            image_height=image_height,
+            image_workflow=image_workflow,
+            frame_template=frame_template or "1080x1920/default.html"
+        )
+        
+        # Create storyboard
+        storyboard = Storyboard(
+            title=final_title,
+            config=config,
+            content_metadata=content_metadata,
+            created_at=datetime.now()
+        )
+        
+        try:
+            # ========== Step 1: Generate/Split narrations ==========
+            if mode == "generate":
+                self._report_progress(progress_callback, "generating_narrations", 0.05)
+                narrations = await generate_narrations_from_topic(
+                    self.llm,
+                    topic=text,
+                    n_scenes=n_scenes,
+                    min_words=min_narration_words,
+                    max_words=max_narration_words
+                )
+                logger.info(f"✅ Generated {len(narrations)} narrations")
+            else:  # fixed
+                self._report_progress(progress_callback, "splitting_script", 0.05)
+                narrations = await split_narration_script(text)
+                logger.info(f"✅ Split script into {len(narrations)} segments (by lines)")
+                logger.info(f"   Note: n_scenes={n_scenes} is ignored in fixed mode")
+            
+            # ========== Step 2: Generate image prompts ==========
+            self._report_progress(progress_callback, "generating_image_prompts", 0.15)
+            
+            # Override prompt_prefix if provided
+            original_prefix = None
+            if prompt_prefix is not None:
+                image_config = self.core.config.get("comfyui", {}).get("image", {})
+                original_prefix = image_config.get("prompt_prefix")
+                image_config["prompt_prefix"] = prompt_prefix
+                logger.info(f"Using custom prompt_prefix: '{prompt_prefix}'")
+            
+            try:
+                # Create progress callback wrapper for image prompt generation
+                def image_prompt_progress(completed: int, total: int, message: str):
+                    batch_progress = completed / total if total > 0 else 0
+                    overall_progress = 0.15 + (batch_progress * 0.15)
+                    self._report_progress(
+                        progress_callback,
+                        "generating_image_prompts",
+                        overall_progress,
+                        extra_info=message
+                    )
+                
+                # Generate base image prompts
+                base_image_prompts = await generate_image_prompts(
+                    self.llm,
+                    narrations=narrations,
+                    min_words=min_image_prompt_words,
+                    max_words=max_image_prompt_words,
+                    progress_callback=image_prompt_progress
+                )
+                
+                # Apply prompt prefix
+                from pixelle_video.utils.prompt_helper import build_image_prompt
+                image_config = self.core.config.get("comfyui", {}).get("image", {})
+                prompt_prefix_to_use = prompt_prefix if prompt_prefix is not None else image_config.get("prompt_prefix", "")
+                
+                image_prompts = []
+                for base_prompt in base_image_prompts:
+                    final_prompt = build_image_prompt(base_prompt, prompt_prefix_to_use)
+                    image_prompts.append(final_prompt)
+                
+            finally:
+                # Restore original prompt_prefix
+                if original_prefix is not None:
+                    image_config["prompt_prefix"] = original_prefix
+            
+            logger.info(f"✅ Generated {len(image_prompts)} image prompts")
+            
+            # ========== Step 3: Create frames ==========
+            for i, (narration, image_prompt) in enumerate(zip(narrations, image_prompts)):
+                frame = StoryboardFrame(
+                    index=i,
+                    narration=narration,
+                    image_prompt=image_prompt,
+                    created_at=datetime.now()
+                )
+                storyboard.frames.append(frame)
+            
+            # ========== Step 4: Process each frame ==========
+            for i, frame in enumerate(storyboard.frames):
+                base_progress = 0.2
+                frame_range = 0.6
+                per_frame_progress = frame_range / len(storyboard.frames)
+                
+                # Create frame-specific progress callback
+                def frame_progress_callback(event: ProgressEvent):
+                    overall_progress = base_progress + (per_frame_progress * i) + (per_frame_progress * event.progress)
+                    if progress_callback:
+                        adjusted_event = ProgressEvent(
+                            event_type=event.event_type,
+                            progress=overall_progress,
+                            frame_current=event.frame_current,
+                            frame_total=event.frame_total,
+                            step=event.step,
+                            action=event.action
+                        )
+                        progress_callback(adjusted_event)
+                
+                # Report frame start
+                self._report_progress(
+                    progress_callback,
+                    "processing_frame",
+                    base_progress + (per_frame_progress * i),
+                    frame_current=i+1,
+                    frame_total=len(storyboard.frames)
+                )
+                
+                processed_frame = await self.core.frame_processor(
+                    frame=frame,
+                    storyboard=storyboard,
+                    config=config,
+                    total_frames=len(storyboard.frames),
+                    progress_callback=frame_progress_callback
+                )
+                storyboard.total_duration += processed_frame.duration
+                logger.info(f"✅ Frame {i+1} completed ({processed_frame.duration:.2f}s)")
+            
+            # ========== Step 5: Concatenate videos ==========
+            self._report_progress(progress_callback, "concatenating", 0.85)
+            segment_paths = [frame.video_segment_path for frame in storyboard.frames]
+            
+            from pixelle_video.services.video import VideoService
+            video_service = VideoService()
+            
+            final_video_path = video_service.concat_videos(
+                videos=segment_paths,
+                output=output_path,
+                bgm_path=bgm_path,
+                bgm_volume=bgm_volume,
+                bgm_mode=bgm_mode
+            )
+            
+            storyboard.final_video_path = final_video_path
+            storyboard.completed_at = datetime.now()
+            
+            # Copy to user-specified path if provided
+            if user_specified_output:
+                import shutil
+                Path(user_specified_output).parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(final_video_path, user_specified_output)
+                logger.info(f"📹 Final video copied to: {user_specified_output}")
+                final_video_path = user_specified_output
+                storyboard.final_video_path = user_specified_output
+            
+            logger.success(f"🎬 Video generation completed: {final_video_path}")
+            
+            # ========== Step 6: Create result ==========
+            self._report_progress(progress_callback, "completed", 1.0)
+            
+            video_path_obj = Path(final_video_path)
+            file_size = video_path_obj.stat().st_size
+            
+            result = VideoGenerationResult(
+                video_path=final_video_path,
+                storyboard=storyboard,
+                duration=storyboard.total_duration,
+                file_size=file_size
+            )
+            
+            logger.info(f"✅ Generated video: {final_video_path}")
+            logger.info(f"   Duration: {storyboard.total_duration:.2f}s")
+            logger.info(f"   Size: {file_size / (1024*1024):.2f} MB")
+            logger.info(f"   Frames: {len(storyboard.frames)}")
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"❌ Video generation failed: {e}")
+            raise
+