# core/visual_engine.py from PIL import Image, ImageDraw, ImageFont, ImageOps import base64 import mimetypes import numpy as np import os import openai import requests import io import time import random import logging from moviepy.editor import (ImageClip, VideoFileClip, concatenate_videoclips, TextClip, CompositeVideoClip, AudioFileClip) import moviepy.video.fx.all as vfx try: if hasattr(Image, 'Resampling') and hasattr(Image.Resampling, 'LANCZOS'): if not hasattr(Image, 'ANTIALIAS'): Image.ANTIALIAS = Image.Resampling.LANCZOS elif hasattr(Image, 'LANCZOS'): if not hasattr(Image, 'ANTIALIAS'): Image.ANTIALIAS = Image.LANCZOS elif not hasattr(Image, 'ANTIALIAS'): print("WARNING: Pillow version lacks common Resampling or ANTIALIAS. MoviePy effects might fail.") except Exception as e_mp: print(f"WARNING: ANTIALIAS monkey-patch error: {e_mp}") logger = logging.getLogger(__name__) # logger.setLevel(logging.DEBUG) # Uncomment for very verbose debugging ELEVENLABS_CLIENT_IMPORTED = False; ElevenLabsAPIClient = None; Voice = None; VoiceSettings = None try: from elevenlabs.client import ElevenLabs as ImportedElevenLabsClient from elevenlabs import Voice as ImportedVoice, VoiceSettings as ImportedVoiceSettings ElevenLabsAPIClient = ImportedElevenLabsClient; Voice = ImportedVoice; VoiceSettings = ImportedVoiceSettings ELEVENLABS_CLIENT_IMPORTED = True; logger.info("ElevenLabs client components imported.") except Exception as e_11l_imp: logger.warning(f"ElevenLabs client import failed: {e_11l_imp}. Audio disabled.") RUNWAYML_SDK_IMPORTED = False; RunwayMLAPIClientClass = None try: from runwayml import RunwayML as ImportedRunwayMLAPIClientClass RunwayMLAPIClientClass = ImportedRunwayMLAPIClientClass; RUNWAYML_SDK_IMPORTED = True logger.info("RunwayML SDK imported.") except Exception as e_rwy_imp: logger.warning(f"RunwayML SDK import failed: {e_rwy_imp}. RunwayML disabled.") class VisualEngine: DEFAULT_FONT_SIZE_PIL = 10; PREFERRED_FONT_SIZE_PIL = 20 VIDEO_OVERLAY_FONT_SIZE = 30; VIDEO_OVERLAY_FONT_COLOR = 'white' DEFAULT_MOVIEPY_FONT = 'DejaVu-Sans-Bold'; PREFERRED_MOVIEPY_FONT = 'Liberation-Sans-Bold' def __init__(self, output_dir="temp_cinegen_media", default_elevenlabs_voice_id="Rachel"): self.output_dir = output_dir; os.makedirs(self.output_dir, exist_ok=True) self.font_filename_pil_preference = "DejaVuSans-Bold.ttf" font_paths = [ self.font_filename_pil_preference, f"/usr/share/fonts/truetype/dejavu/{self.font_filename_pil_preference}", f"/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf", f"/System/Library/Fonts/Supplemental/Arial.ttf", f"C:/Windows/Fonts/arial.ttf", f"/usr/local/share/fonts/truetype/mycustomfonts/arial.ttf"] self.resolved_font_path_pil = next((p for p in font_paths if os.path.exists(p)), None) self.active_font_pil = ImageFont.load_default(); self.active_font_size_pil = self.DEFAULT_FONT_SIZE_PIL; self.active_moviepy_font_name = self.DEFAULT_MOVIEPY_FONT if self.resolved_font_path_pil: try: self.active_font_pil = ImageFont.truetype(self.resolved_font_path_pil, self.PREFERRED_FONT_SIZE_PIL); self.active_font_size_pil = self.PREFERRED_FONT_SIZE_PIL; logger.info(f"Pillow font: {self.resolved_font_path_pil} sz {self.active_font_size_pil}."); self.active_moviepy_font_name = 'DejaVu-Sans-Bold' if "dejavu" in self.resolved_font_path_pil.lower() else ('Liberation-Sans-Bold' if "liberation" in self.resolved_font_path_pil.lower() else self.DEFAULT_MOVIEPY_FONT) except IOError as e_font: logger.error(f"Pillow font IOError '{self.resolved_font_path_pil}': {e_font}. Default.") else: logger.warning("Preferred Pillow font not found. Default.") self.openai_api_key = None; self.USE_AI_IMAGE_GENERATION = False; self.dalle_model = "dall-e-3"; self.image_size_dalle3 = "1792x1024" self.video_frame_size = (1280, 720) self.elevenlabs_api_key = None; self.USE_ELEVENLABS = False; self.elevenlabs_client_instance = None; self.elevenlabs_voice_id = default_elevenlabs_voice_id if VoiceSettings and ELEVENLABS_CLIENT_IMPORTED: self.elevenlabs_voice_settings_obj = VoiceSettings(stability=0.60, similarity_boost=0.80, style=0.15, use_speaker_boost=True) else: self.elevenlabs_voice_settings_obj = None self.pexels_api_key = None; self.USE_PEXELS = False self.runway_api_key = None; self.USE_RUNWAYML = False; self.runway_ml_sdk_client_instance = None if RUNWAYML_SDK_IMPORTED and RunwayMLAPIClientClass and os.getenv("RUNWAYML_API_SECRET"): try: self.runway_ml_sdk_client_instance = RunwayMLAPIClientClass(); self.USE_RUNWAYML = True; logger.info("RunwayML Client init from env var at startup.") except Exception as e_rwy_init: logger.error(f"Initial RunwayML client init failed: {e_rwy_init}"); self.USE_RUNWAYML = False logger.info("VisualEngine initialized.") def set_openai_api_key(self, api_key_value): self.openai_api_key = api_key_value; self.USE_AI_IMAGE_GENERATION = bool(api_key_value); logger.info(f"DALL-E status: {'Ready' if self.USE_AI_IMAGE_GENERATION else 'Disabled'}") def set_elevenlabs_api_key(self, api_key_value, voice_id_from_secret=None): self.elevenlabs_api_key = api_key_value if voice_id_from_secret: self.elevenlabs_voice_id = voice_id_from_secret; logger.info(f"11L Voice ID updated to: {self.elevenlabs_voice_id} via set_elevenlabs_api_key.") if api_key_value and ELEVENLABS_CLIENT_IMPORTED and ElevenLabsAPIClient: try: self.elevenlabs_client_instance = ElevenLabsAPIClient(api_key=api_key_value); self.USE_ELEVENLABS = bool(self.elevenlabs_client_instance); logger.info(f"11L Client: {'Ready' if self.USE_ELEVENLABS else 'Failed'} (Voice: {self.elevenlabs_voice_id})") except Exception as e_11l_setkey_init: logger.error(f"11L client init error: {e_11l_setkey_init}. Disabled.", exc_info=True); self.USE_ELEVENLABS=False; self.elevenlabs_client_instance=None else: self.USE_ELEVENLABS = False; logger.info(f"11L Disabled (key/SDK).") def set_pexels_api_key(self, api_key_value): self.pexels_api_key = api_key_value; self.USE_PEXELS = bool(api_key_value); logger.info(f"Pexels status: {'Ready' if self.USE_PEXELS else 'Disabled'}") def set_runway_api_key(self, api_key_value): self.runway_api_key = api_key_value if api_key_value: if RUNWAYML_SDK_IMPORTED and RunwayMLAPIClientClass: if not self.runway_ml_sdk_client_instance: try: original_env_secret = os.getenv("RUNWAYML_API_SECRET") if not original_env_secret: os.environ["RUNWAYML_API_SECRET"] = api_key_value; logger.info("Temp set RUNWAYML_API_SECRET for SDK.") self.runway_ml_sdk_client_instance = RunwayMLAPIClientClass(); self.USE_RUNWAYML = True; logger.info("RunwayML Client init via set_runway_api_key.") if not original_env_secret: del os.environ["RUNWAYML_API_SECRET"]; logger.info("Cleared temp RUNWAYML_API_SECRET.") except Exception as e_runway_setkey_init: logger.error(f"RunwayML Client init in set_runway_api_key fail: {e_runway_setkey_init}", exc_info=True); self.USE_RUNWAYML=False;self.runway_ml_sdk_client_instance=None else: self.USE_RUNWAYML = True; logger.info("RunwayML Client already init.") else: logger.warning("RunwayML SDK not imported. Service disabled."); self.USE_RUNWAYML = False else: self.USE_RUNWAYML = False; self.runway_ml_sdk_client_instance = None; logger.info("RunwayML Disabled (no API key).") def _image_to_data_uri(self, image_path): try: mime_type, _ = mimetypes.guess_type(image_path) if not mime_type: ext = os.path.splitext(image_path)[1].lower() mime_map = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp"} mime_type = mime_map.get(ext, "application/octet-stream") if mime_type == "application/octet-stream": logger.warning(f"Could not determine MIME type for {image_path} from extension '{ext}', using default {mime_type}.") with open(image_path, "rb") as image_file_handle: image_binary_data = image_file_handle.read() encoded_base64_string = base64.b64encode(image_binary_data).decode('utf-8') data_uri_string = f"data:{mime_type};base64,{encoded_base64_string}" logger.debug(f"Generated data URI for {os.path.basename(image_path)} (MIME: {mime_type}). Data URI starts with: {data_uri_string[:100]}...") return data_uri_string except FileNotFoundError: logger.error(f"Image file not found at path: '{image_path}' when trying to create data URI."); return None except Exception as e_data_uri_conversion: logger.error(f"Error converting image '{image_path}' to data URI: {e_data_uri_conversion}", exc_info=True); return None def _map_resolution_to_runway_ratio(self, width, height): ratio_str=f"{width}:{height}";supported_ratios_gen4=["1280:720","720:1280","1104:832","832:1104","960:960","1584:672"]; if ratio_str in supported_ratios_gen4:return ratio_str logger.warning(f"Res {ratio_str} not in Gen-4 list. Default 1280:720.");return "1280:720" def _get_text_dimensions(self, text_content, font_object_pil): default_h = getattr(font_object_pil, 'size', self.active_font_size_pil) if not text_content: return 0, default_h try: if hasattr(font_object_pil,'getbbox'):bbox=font_object_pil.getbbox(text_content);w=bbox[2]-bbox[0];h=bbox[3]-bbox[1]; return w, h if h > 0 else default_h elif hasattr(font_object_pil,'getsize'):w,h=font_object_pil.getsize(text_content); return w, h if h > 0 else default_h else: return int(len(text_content)*default_h*0.6),int(default_h*1.2) except Exception as e_getdim: logger.warning(f"Error in _get_text_dimensions: {e_getdim}"); return int(len(text_content)*self.active_font_size_pil*0.6),int(self.active_font_size_pil*1.2) def _create_placeholder_image_content(self,text_description,filename,size=None): if size is None: size = self.video_frame_size img = Image.new('RGB', size, color=(20, 20, 40)); d = ImageDraw.Draw(img); padding = 25 max_w = size[0] - (2 * padding); lines_for_placeholder = [] if not text_description: text_description = "(Placeholder Image)" words_list = text_description.split(); current_line_buffer = "" for word_idx, word_item in enumerate(words_list): prospective_addition = word_item + (" " if word_idx < len(words_list) - 1 else "") test_line_candidate = current_line_buffer + prospective_addition current_w_text, _ = self._get_text_dimensions(test_line_candidate, self.active_font_pil) if current_w_text == 0 and test_line_candidate.strip(): current_w_text = len(test_line_candidate) * (self.active_font_size_pil * 0.6) if current_w_text <= max_w: current_line_buffer = test_line_candidate else: if current_line_buffer.strip(): lines_for_placeholder.append(current_line_buffer.strip()) current_line_buffer = prospective_addition if current_line_buffer.strip(): lines_for_placeholder.append(current_line_buffer.strip()) if not lines_for_placeholder and text_description: avg_char_w_est, _ = self._get_text_dimensions("W", self.active_font_pil); avg_char_w_est = avg_char_w_est or (self.active_font_size_pil * 0.6) chars_per_line_est = int(max_w / avg_char_w_est) if avg_char_w_est > 0 else 20 lines_for_placeholder.append(text_description[:chars_per_line_est] + ("..." if len(text_description) > chars_per_line_est else "")) elif not lines_for_placeholder: lines_for_placeholder.append("(Placeholder Error)") _, single_h = self._get_text_dimensions("Ay", self.active_font_pil); single_h = single_h if single_h > 0 else self.active_font_size_pil + 2 max_l = min(len(lines_for_placeholder), (size[1] - (2 * padding)) // (single_h + 2)) if single_h > 0 else 1; max_l = max(1, max_l) y_p = padding + (size[1] - (2 * padding) - max_l * (single_h + 2)) / 2.0 for i_line in range(max_l): line_txt_content = lines_for_placeholder[i_line]; line_w_val, _ = self._get_text_dimensions(line_txt_content, self.active_font_pil) if line_w_val == 0 and line_txt_content.strip(): line_w_val = len(line_txt_content) * (self.active_font_size_pil * 0.6) x_p = (size[0] - line_w_val) / 2.0 try: d.text((x_p, y_p), line_txt_content, font=self.active_font_pil, fill=(200, 200, 180)) except Exception as e_draw: logger.error(f"Pillow d.text error: {e_draw} for '{line_txt_content}'") y_p += single_h + 2 if i_line == 6 and max_l > 7: try: d.text((x_p, y_p), "...", font=self.active_font_pil, fill=(200, 200, 180)) except Exception as e_elip: logger.error(f"Pillow d.text ellipsis error: {e_elip}"); break filepath_placeholder = os.path.join(self.output_dir, filename) try: img.save(filepath_placeholder); return filepath_placeholder except Exception as e_save: logger.error(f"Saving placeholder image '{filepath_placeholder}' error: {e_save}", exc_info=True); return None def _search_pexels_image(self, query_str, output_fn_base): if not self.USE_PEXELS or not self.pexels_api_key: return None http_headers = {"Authorization": self.pexels_api_key} http_params = {"query": query_str, "per_page": 1, "orientation": "landscape", "size": "large2x"} base_name_px, _ = os.path.splitext(output_fn_base) pexels_fn_str = base_name_px + f"_pexels_{random.randint(1000,9999)}.jpg" file_path_px = os.path.join(self.output_dir, pexels_fn_str) try: logger.info(f"Pexels: Searching for '{query_str}'") eff_query_px = " ".join(query_str.split()[:5]) http_params["query"] = eff_query_px response_px = requests.get("https://api.pexels.com/v1/search", headers=http_headers, params=http_params, timeout=20) response_px.raise_for_status() data_px = response_px.json() if data_px.get("photos") and len(data_px["photos"]) > 0: photo_details_px = data_px["photos"][0] photo_url_px = photo_details_px.get("src", {}).get("large2x") if not photo_url_px: logger.warning(f"Pexels: 'large2x' URL missing for '{eff_query_px}'. Details: {photo_details_px}"); return None image_response_px = requests.get(photo_url_px, timeout=60); image_response_px.raise_for_status() img_pil_data_px = Image.open(io.BytesIO(image_response_px.content)) if img_pil_data_px.mode != 'RGB': img_pil_data_px = img_pil_data_px.convert('RGB') img_pil_data_px.save(file_path_px); logger.info(f"Pexels: Image saved to {file_path_px}"); return file_path_px else: logger.info(f"Pexels: No photos for '{eff_query_px}'."); return None except requests.exceptions.RequestException as e_req_px: logger.error(f"Pexels: RequestException for '{query_str}': {e_req_px}", exc_info=False); return None except Exception as e_px_gen: logger.error(f"Pexels: General error for '{query_str}': {e_px_gen}", exc_info=True); return None def _generate_video_clip_with_runwayml(self, text_prompt_for_motion, input_image_path, scene_identifier_filename_base, target_duration_seconds=5): if not self.USE_RUNWAYML or not self.runway_ml_sdk_client_instance: logger.warning("RunwayML not enabled/client not init. Skip video."); return None if not input_image_path or not os.path.exists(input_image_path): logger.error(f"Runway Gen-4 needs input image. Path invalid: {input_image_path}"); return None image_data_uri_str = self._image_to_data_uri(input_image_path) if not image_data_uri_str: return None runway_dur = 10 if target_duration_seconds >= 8 else 5 runway_ratio = self._map_resolution_to_runway_ratio(self.video_frame_size[0], self.video_frame_size[1]) base_name_for_runway_vid, _ = os.path.splitext(scene_identifier_filename_base); output_vid_fn = base_name_for_runway_vid + f"_runway_gen4_d{runway_dur}s.mp4" output_vid_fp = os.path.join(self.output_dir, output_vid_fn) logger.info(f"Runway Gen-4 task: motion='{text_prompt_for_motion[:100]}...', img='{os.path.basename(input_image_path)}', dur={runway_dur}s, ratio='{runway_ratio}'") try: task_submitted_runway = self.runway_ml_sdk_client_instance.image_to_video.create(model='gen4_turbo', prompt_image=image_data_uri_str, prompt_text=text_prompt_for_motion, duration=runway_dur, ratio=runway_ratio) task_id_runway = task_submitted_runway.id; logger.info(f"Runway Gen-4 task ID: {task_id_runway}. Polling...") poll_sec=10; max_poll_count=36; poll_start_time = time.time() while time.time() - poll_start_time < max_poll_count * poll_sec: time.sleep(poll_sec); task_details_runway = self.runway_ml_sdk_client_instance.tasks.retrieve(id=task_id_runway) logger.info(f"Runway task {task_id_runway} status: {task_details_runway.status}") if task_details_runway.status == 'SUCCEEDED': output_url_runway = getattr(getattr(task_details_runway,'output',None),'url',None) or \ (getattr(task_details_runway,'artifacts',None) and task_details_runway.artifacts and hasattr(task_details_runway.artifacts[0],'url')and task_details_runway.artifacts[0].url) or \ (getattr(task_details_runway,'artifacts',None) and task_details_runway.artifacts and hasattr(task_details_runway.artifacts[0],'download_url')and task_details_runway.artifacts[0].download_url) if not output_url_runway: logger.error(f"Runway task {task_id_runway} SUCCEEDED, but no output URL. Details: {vars(task_details_runway) if hasattr(task_details_runway,'__dict__') else task_details_runway}"); return None logger.info(f"Runway task {task_id_runway} SUCCEEDED. Downloading: {output_url_runway}") video_resp_get = requests.get(output_url_runway, stream=True, timeout=300); video_resp_get.raise_for_status() with open(output_vid_fp,'wb') as f_vid: for chunk_data in video_resp_get.iter_content(chunk_size=8192): f_vid.write(chunk_data) logger.info(f"Runway Gen-4 video saved: {output_vid_fp}"); return output_vid_fp elif task_details_runway.status in ['FAILED','ABORTED','ERROR']: err_msg_runway = getattr(task_details_runway,'error_message',None) or getattr(getattr(task_details_runway,'output',None),'error',"Unknown Runway error.") logger.error(f"Runway task {task_id_runway} status: {task_details_runway.status}. Error: {err_msg_runway}"); return None logger.warning(f"Runway task {task_id_runway} timed out."); return None except AttributeError as ae_sdk: logger.error(f"RunwayML SDK AttrError: {ae_sdk}. SDK/methods changed?", exc_info=True); return None except Exception as e_runway_gen: logger.error(f"Runway Gen-4 API error: {e_runway_gen}", exc_info=True); return None def _create_placeholder_video_content(self, text_desc_ph, filename_ph, duration_ph=4, size_ph=None): if size_ph is None: size_ph = self.video_frame_size filepath_ph = os.path.join(self.output_dir, filename_ph) text_clip_ph = None try: text_clip_ph = TextClip(text_desc_ph, fontsize=50, color='white', font=self.video_overlay_font, bg_color='black', size=size_ph, method='caption').set_duration(duration_ph) text_clip_ph.write_videofile(filepath_ph, fps=24, codec='libx264', preset='ultrafast', logger=None, threads=2) logger.info(f"Generic placeholder video created: {filepath_ph}") return filepath_ph except Exception as e_ph_vid: logger.error(f"Failed to create generic placeholder video '{filepath_ph}': {e_ph_vid}", exc_info=True) return None finally: if text_clip_ph and hasattr(text_clip_ph, 'close'): try: text_clip_ph.close() except Exception as e_cl_phv: logger.warning(f"Ignoring error closing placeholder TextClip: {e_cl_phv}") def generate_scene_asset(self, image_generation_prompt_text, motion_prompt_text_for_video, scene_data_dict, scene_identifier_fn_base, generate_as_video_clip_flag=False, runway_target_dur_val=5): base_name_asset, _ = os.path.splitext(scene_identifier_fn_base) asset_info_result = {'path': None, 'type': 'none', 'error': True, 'prompt_used': image_generation_prompt_text, 'error_message': 'Asset generation init failed'} path_for_input_image_runway = None fn_for_base_image = base_name_asset + ("_base_for_video.png" if generate_as_video_clip_flag else ".png") fp_for_base_image = os.path.join(self.output_dir, fn_for_base_image) if self.USE_AI_IMAGE_GENERATION and self.openai_api_key: max_r_dalle, attempt_count_dalle = 2,0; for att_n_dalle in range(max_r_dalle): attempt_count_dalle = att_n_dalle + 1 try: logger.info(f"Att {attempt_count_dalle} DALL-E (base img): {image_generation_prompt_text[:70]}..."); oai_cl = openai.OpenAI(api_key=self.openai_api_key,timeout=90.0); oai_r = oai_cl.images.generate(model=self.dalle_model,prompt=image_generation_prompt_text,n=1,size=self.image_size_dalle3,quality="hd",response_format="url",style="vivid"); oai_iu = oai_r.data[0].url; oai_rp = getattr(oai_r.data[0],'revised_prompt',None); if oai_rp: logger.info(f"DALL-E revised: {oai_rp[:70]}...") oai_ir = requests.get(oai_iu,timeout=120); oai_ir.raise_for_status(); oai_id = Image.open(io.BytesIO(oai_ir.content)); if oai_id.mode!='RGB': oai_id=oai_id.convert('RGB') oai_id.save(fp_for_base_image); logger.info(f"DALL-E base img saved: {fp_for_base_image}"); path_for_input_image_runway=fp_for_base_image; asset_info_result={'path':fp_for_base_image,'type':'image','error':False,'prompt_used':image_generation_prompt_text,'revised_prompt':oai_rp}; break except openai.RateLimitError as e_oai_rl: logger.warning(f"OpenAI RateLimit Att {attempt_count_dalle}:{e_oai_rl}.Retry...");time.sleep(5*attempt_count_dalle);asset_info_result['error_message']=str(e_oai_rl) except openai.APIError as e_oai_api: logger.error(f"OpenAI APIError Att {attempt_count_dalle}:{e_oai_api}");asset_info_result['error_message']=str(e_oai_api);break except requests.exceptions.RequestException as e_oai_req: logger.error(f"Requests Err DALL-E Att {attempt_count_dalle}:{e_oai_req}");asset_info_result['error_message']=str(e_oai_req);break except Exception as e_oai_gen: logger.error(f"General DALL-E Err Att {attempt_count_dalle}:{e_oai_gen}",exc_info=True);asset_info_result['error_message']=str(e_oai_gen);break if asset_info_result['error']: logger.warning(f"DALL-E failed after {attempt_count_dalle} attempts for base img.") if asset_info_result['error'] and self.USE_PEXELS: logger.info("Trying Pexels for base img.");px_qt=scene_data_dict.get('pexels_search_query_감독',f"{scene_data_dict.get('emotional_beat','')} {scene_data_dict.get('setting_description','')}");px_pp=self._search_pexels_image(px_qt,fn_for_base_image); if px_pp:path_for_input_image_runway=px_pp;asset_info_result={'path':px_pp,'type':'image','error':False,'prompt_used':f"Pexels:{px_qt}"} else:current_em_px=asset_info_result.get('error_message',"");asset_info_result['error_message']=(current_em_px+" Pexels failed for base.").strip() if asset_info_result['error']: logger.warning("Base img (DALL-E/Pexels) failed. Using placeholder.");ph_ppt=asset_info_result.get('prompt_used',image_generation_prompt_text);php=self._create_placeholder_image_content(f"[Base Placeholder]{ph_ppt[:70]}...",fn_for_base_image); if php:path_for_input_image_runway=php;asset_info_result={'path':php,'type':'image','error':False,'prompt_used':ph_ppt} else:current_em_ph=asset_info_result.get('error_message',"");asset_info_result['error_message']=(current_em_ph+" Base placeholder failed.").strip() if generate_as_video_clip_flag: if not path_for_input_image_runway:logger.error("RunwayML video: base img failed.");asset_info_result['error']=True;asset_info_result['error_message']=(asset_info_result.get('error_message',"")+" Base img miss, Runway abort.").strip();asset_info_result['type']='none';return asset_info_result if self.USE_RUNWAYML: runway_video_p=self._generate_video_clip_with_runwayml(motion_prompt_text_for_video,path_for_input_image_runway,base_name_asset,runway_target_dur_val) if runway_video_p and os.path.exists(runway_video_p):asset_info_result={'path':runway_video_p,'type':'video','error':False,'prompt_used':motion_prompt_text_for_video,'base_image_path':path_for_input_image_runway} else:logger.warning(f"RunwayML video failed for {base_name_asset}. Fallback to base img.");asset_info_result['error']=True;asset_info_result['error_message']=(asset_info_result.get('error_message',"Base img ok.")+" RunwayML video fail; use base img.").strip();asset_info_result['path']=path_for_input_image_runway;asset_info_result['type']='image';asset_info_result['prompt_used']=image_generation_prompt_text else:logger.warning("RunwayML selected but disabled. Use base img.");asset_info_result['error']=True;asset_info_result['error_message']=(asset_info_result.get('error_message',"Base img ok.")+" RunwayML disabled; use base img.").strip();asset_info_result['path']=path_for_input_image_runway;asset_info_result['type']='image';asset_info_result['prompt_used']=image_generation_prompt_text return asset_info_result def generate_narration_audio(self, text_to_narrate, output_filename="narration_overall.mp3"): if not self.USE_ELEVENLABS or not self.elevenlabs_client_instance or not text_to_narrate: logger.info("11L conditions not met. Skip audio."); return None audio_filepath_narration = os.path.join(self.output_dir, output_filename) try: logger.info(f"Generating 11L audio (Voice ID: {self.elevenlabs_voice_id}) for text: \"{text_to_narrate[:70]}...\"") audio_stream_method_11l = None if hasattr(self.elevenlabs_client_instance, 'text_to_speech') and hasattr(self.elevenlabs_client_instance.text_to_speech, 'stream'): audio_stream_method_11l = self.elevenlabs_client_instance.text_to_speech.stream; logger.info("Using 11L SDK: client.text_to_speech.stream()") elif hasattr(self.elevenlabs_client_instance, 'generate_stream'): audio_stream_method_11l = self.elevenlabs_client_instance.generate_stream; logger.info("Using 11L SDK: client.generate_stream()") elif hasattr(self.elevenlabs_client_instance, 'generate'): logger.info("Using 11L SDK: client.generate() (non-streaming).") voice_param_11l = str(self.elevenlabs_voice_id); if Voice and self.elevenlabs_voice_settings_obj: voice_param_11l = Voice(voice_id=str(self.elevenlabs_voice_id), settings=self.elevenlabs_voice_settings_obj) audio_bytes_data = self.elevenlabs_client_instance.generate(text=text_to_narrate, voice=voice_param_11l, model="eleven_multilingual_v2") with open(audio_filepath_narration, "wb") as audio_file_out: audio_file_out.write(audio_bytes_data) logger.info(f"11L audio (non-streamed) saved to: {audio_filepath_narration}"); return audio_filepath_narration else: logger.error("No recognized audio generation method on 11L client."); return None if audio_stream_method_11l: params_for_voice_stream = {"voice_id": str(self.elevenlabs_voice_id)} if self.elevenlabs_voice_settings_obj: if hasattr(self.elevenlabs_voice_settings_obj, 'model_dump'): params_for_voice_stream["voice_settings"] = self.elevenlabs_voice_settings_obj.model_dump() elif hasattr(self.elevenlabs_voice_settings_obj, 'dict'): params_for_voice_stream["voice_settings"] = self.elevenlabs_voice_settings_obj.dict() else: params_for_voice_stream["voice_settings"] = self.elevenlabs_voice_settings_obj audio_data_iterator_11l = audio_stream_method_11l(text=text_to_narrate, model_id="eleven_multilingual_v2", **params_for_voice_stream) with open(audio_filepath_narration, "wb") as audio_file_out_stream: for audio_chunk_data in audio_data_iterator_11l: if audio_chunk_data: audio_file_out_stream.write(audio_chunk_data) logger.info(f"11L audio (streamed) saved to: {audio_filepath_narration}"); return audio_filepath_narration except AttributeError as ae_11l_sdk: logger.error(f"AttributeError with 11L SDK client: {ae_11l_sdk}. SDK version/methods might differ.", exc_info=True); return None except Exception as e_11l_general_audio: logger.error(f"General error during 11L audio generation: {e_11l_general_audio}", exc_info=True); return None def assemble_animatic_from_assets(self, asset_data_list, overall_narration_path=None, output_filename="final_video.mp4", fps=24): if not asset_data_list: logger.warning("No assets for animatic."); return None processed_moviepy_clips_list = []; narration_audio_clip_mvpy = None; final_video_output_clip = None logger.info(f"Assembling from {len(asset_data_list)} assets. Target Frame: {self.video_frame_size}.") for i_asset, asset_info_item_loop in enumerate(asset_data_list): path_of_asset, type_of_asset, duration_for_scene = asset_info_item_loop.get('path'), asset_info_item_loop.get('type'), asset_info_item_loop.get('duration', 4.5) num_of_scene, action_in_key = asset_info_item_loop.get('scene_num', i_asset + 1), asset_info_item_loop.get('key_action', '') logger.info(f"S{num_of_scene}: Path='{path_of_asset}', Type='{type_of_asset}', Dur='{duration_for_scene}'s") if not (path_of_asset and os.path.exists(path_of_asset)): logger.warning(f"S{num_of_scene}: Not found '{path_of_asset}'. Skip."); continue if duration_for_scene <= 0: logger.warning(f"S{num_of_scene}: Invalid duration ({duration_for_scene}s). Skip."); continue active_scene_clip = None try: if type_of_asset == 'image': pil_img_original = Image.open(path_of_asset) logger.debug(f"S{num_of_scene} (0-Load): Original loaded. Mode:{pil_img_original.mode}, Size:{pil_img_original.size}") pil_img_original.save(os.path.join(self.output_dir,f"debug_0_ORIGINAL_S{num_of_scene}.png")) img_rgba_intermediate = pil_img_original.convert('RGBA') if pil_img_original.mode != 'RGBA' else pil_img_original.copy().convert('RGBA') logger.debug(f"S{num_of_scene} (1-ToRGBA): Converted to RGBA. Mode:{img_rgba_intermediate.mode}, Size:{img_rgba_intermediate.size}") img_rgba_intermediate.save(os.path.join(self.output_dir,f"debug_1_AS_RGBA_S{num_of_scene}.png")) thumbnailed_img_rgba = img_rgba_intermediate.copy() resample_filter_pil = Image.Resampling.LANCZOS if hasattr(Image.Resampling,'LANCZOS') else Image.BILINEAR thumbnailed_img_rgba.thumbnail(self.video_frame_size, resample_filter_pil) logger.debug(f"S{num_of_scene} (2-Thumbnail): Thumbnailed RGBA. Mode:{thumbnailed_img_rgba.mode}, Size:{thumbnailed_img_rgba.size}") thumbnailed_img_rgba.save(os.path.join(self.output_dir,f"debug_2_THUMBNAIL_RGBA_S{num_of_scene}.png")) canvas_for_compositing_rgba = Image.new('RGBA', self.video_frame_size, (0,0,0,0)) pos_x_paste = (self.video_frame_size[0] - thumbnailed_img_rgba.width) // 2 pos_y_paste = (self.video_frame_size[1] - thumbnailed_img_rgba.height) // 2 canvas_for_compositing_rgba.paste(thumbnailed_img_rgba, (pos_x_paste, pos_y_paste), thumbnailed_img_rgba) logger.debug(f"S{num_of_scene} (3-PasteOnRGBA): Image pasted onto transparent RGBA canvas. Mode:{canvas_for_compositing_rgba.mode}, Size:{canvas_for_compositing_rgba.size}") canvas_for_compositing_rgba.save(os.path.join(self.output_dir,f"debug_3_COMPOSITED_RGBA_S{num_of_scene}.png")) final_rgb_image_for_pil = Image.new("RGB", self.video_frame_size, (0, 0, 0)) if canvas_for_compositing_rgba.mode == 'RGBA': final_rgb_image_for_pil.paste(canvas_for_compositing_rgba, mask=canvas_for_compositing_rgba.split()[3]) else: final_rgb_image_for_pil.paste(canvas_for_compositing_rgba) logger.debug(f"S{num_of_scene} (4-ToRGB): Final RGB image created. Mode:{final_rgb_image_for_pil.mode}, Size:{final_rgb_image_for_pil.size}") debug_path_img_pre_numpy = os.path.join(self.output_dir,f"debug_4_PRE_NUMPY_RGB_S{num_of_scene}.png"); final_rgb_image_for_pil.save(debug_path_img_pre_numpy); logger.info(f"CRITICAL DEBUG: Saved PRE_NUMPY_RGB_S{num_of_scene} to {debug_path_img_pre_numpy}") numpy_frame_arr = np.array(final_rgb_image_for_pil, dtype=np.uint8) if not numpy_frame_arr.flags['C_CONTIGUOUS']: numpy_frame_arr = np.ascontiguousarray(numpy_frame_arr, dtype=np.uint8) logger.debug(f"S{num_of_scene} (5-NumPy): Final NumPy. Shape:{numpy_frame_arr.shape}, DType:{numpy_frame_arr.dtype}, Flags:{numpy_frame_arr.flags}") if numpy_frame_arr.size == 0 or numpy_frame_arr.ndim != 3 or numpy_frame_arr.shape[2] != 3: logger.error(f"S{num_of_scene}: Invalid NumPy shape/size ({numpy_frame_arr.shape}). Skipping."); continue base_image_clip_mvpy = ImageClip(numpy_frame_arr, transparent=False, ismask=False).set_duration(duration_for_scene) logger.debug(f"S{num_of_scene} (6-ImageClip): Base ImageClip created. Duration: {base_image_clip_mvpy.duration}") debug_path_moviepy_frame = os.path.join(self.output_dir,f"debug_7_MOVIEPY_FRAME_S{num_of_scene}.png") # <<< CORRECTED TRY-EXCEPT BLOCK FOR save_frame >>> try: save_frame_time = min(0.1, base_image_clip_mvpy.duration / 2 if base_image_clip_mvpy.duration > 0 else 0.1) base_image_clip_mvpy.save_frame(debug_path_moviepy_frame, t=save_frame_time) logger.info(f"CRITICAL DEBUG: Saved frame FROM MOVIEPY ImageClip S{num_of_scene} to {debug_path_moviepy_frame}") except Exception as e_save_mvpy_frame: logger.error(f"DEBUG: Error saving frame FROM MOVIEPY ImageClip S{num_of_scene}: {e_save_mvpy_frame}", exc_info=True) # <<< END CORRECTION >>> fx_image_clip_mvpy = base_image_clip_mvpy try: scale_end_kb_val = random.uniform(1.03, 1.08) if duration_for_scene > 0: fx_image_clip_mvpy = base_image_clip_mvpy.fx(vfx.resize, lambda t_val: 1 + (scale_end_kb_val - 1) * (t_val / duration_for_scene)).set_position('center'); logger.debug(f"S{num_of_scene} (8-KenBurns): Ken Burns applied.") else: logger.warning(f"S{num_of_scene}: Duration zero, skipping Ken Burns.") except Exception as e_kb_fx_loop: logger.error(f"S{num_of_scene} Ken Burns error: {e_kb_fx_loop}", exc_info=False) active_scene_clip = fx_image_clip_mvpy elif type_of_asset == 'video': source_video_clip_obj=None try: logger.debug(f"S{num_of_scene}: Loading VIDEO asset: {path_of_asset}") source_video_clip_obj=VideoFileClip(path_of_asset,target_resolution=(self.video_frame_size[1],self.video_frame_size[0])if self.video_frame_size else None, audio=False) temp_video_clip_obj_loop=source_video_clip_obj if source_video_clip_obj.duration!=duration_for_scene: if source_video_clip_obj.duration>duration_for_scene:temp_video_clip_obj_loop=source_video_clip_obj.subclip(0,duration_for_scene) else: if duration_for_scene/source_video_clip_obj.duration > 1.5 and source_video_clip_obj.duration>0.1:temp_video_clip_obj_loop=source_video_clip_obj.loop(duration=duration_for_scene) else:temp_video_clip_obj_loop=source_video_clip_obj.set_duration(source_video_clip_obj.duration);logger.info(f"S{num_of_scene} Video clip ({source_video_clip_obj.duration:.2f}s) shorter than target ({duration_for_scene:.2f}s).") active_scene_clip=temp_video_clip_obj_loop.set_duration(duration_for_scene) if active_scene_clip.size!=list(self.video_frame_size):active_scene_clip=active_scene_clip.resize(self.video_frame_size) logger.debug(f"S{num_of_scene}: Video asset processed. Final duration for scene: {active_scene_clip.duration:.2f}s") except Exception as e_vid_load_loop:logger.error(f"S{num_of_scene} Video load error '{path_of_asset}':{e_vid_load_loop}",exc_info=True);continue finally: if source_video_clip_obj and source_video_clip_obj is not active_scene_clip and hasattr(source_video_clip_obj,'close'): try: source_video_clip_obj.close() except Exception as e_close_src_vid: logger.warning(f"S{num_of_scene}: Error closing source VideoFileClip: {e_close_src_vid}") else: logger.warning(f"S{num_of_scene} Unknown asset type '{type_of_asset}'. Skipping."); continue if active_scene_clip and action_in_key: try: dur_text_overlay_val=min(active_scene_clip.duration-0.5,active_scene_clip.duration*0.8)if active_scene_clip.duration>0.5 else active_scene_clip.duration; start_text_overlay_val=0.25 if dur_text_overlay_val > 0: text_clip_for_overlay_obj=TextClip(f"Scene {num_of_scene}\n{action_in_key}",fontsize=self.VIDEO_OVERLAY_FONT_SIZE,color=self.VIDEO_OVERLAY_FONT_COLOR,font=self.active_moviepy_font_name,bg_color='rgba(10,10,20,0.7)',method='caption',align='West',size=(self.video_frame_size[0]*0.9,None),kerning=-1,stroke_color='black',stroke_width=1.5).set_duration(dur_text_overlay_val).set_start(start_text_overlay_val).set_position(('center',0.92),relative=True) active_scene_clip=CompositeVideoClip([active_scene_clip,text_clip_for_overlay_obj],size=self.video_frame_size,use_bgclip=True) logger.debug(f"S{num_of_scene}: Text overlay composited.") else: logger.warning(f"S{num_of_scene}: Text overlay duration zero or negative ({dur_text_overlay_val}). Skipping text overlay.") except Exception as e_txt_comp_loop:logger.error(f"S{num_of_scene} TextClip compositing error:{e_txt_comp_loop}. Proceeding without text for this scene.",exc_info=True) if active_scene_clip: processed_moviepy_clips_list.append(active_scene_clip); logger.info(f"S{num_of_scene}: Asset successfully processed. Clip duration: {active_scene_clip.duration:.2f}s. Added to final list.") except Exception as e_asset_loop_main_exc: logger.error(f"MAJOR UNHANDLED ERROR processing asset for S{num_of_scene} (Path: {path_of_asset}): {e_asset_loop_main_exc}", exc_info=True) finally: if active_scene_clip and hasattr(active_scene_clip,'close'): try: active_scene_clip.close() except Exception as e_close_active_err: logger.warning(f"S{num_of_scene}: Error closing active_scene_clip in error handler: {e_close_active_err}") # Continue was removed to ensure loop proceeds, error is logged above. If continue is desired, it must be inside the try. if not processed_moviepy_clips_list: logger.warning("No MoviePy clips were successfully processed. Aborting animatic assembly before concatenation."); return None transition_duration_val=0.75 try: logger.info(f"Concatenating {len(processed_moviepy_clips_list)} processed clips for final animatic."); if len(processed_moviepy_clips_list)>1: final_video_output_clip=concatenate_videoclips(processed_moviepy_clips_list, padding=-transition_duration_val if transition_duration_val > 0 else 0, method="compose") elif processed_moviepy_clips_list: final_video_output_clip=processed_moviepy_clips_list[0] if not final_video_output_clip: logger.error("Concatenation resulted in a None clip. Aborting."); return None logger.info(f"Concatenated animatic base duration:{final_video_output_clip.duration:.2f}s") if transition_duration_val > 0 and final_video_output_clip.duration > 0: if final_video_output_clip.duration > transition_duration_val * 2: final_video_output_clip=final_video_output_clip.fx(vfx.fadein,transition_duration_val).fx(vfx.fadeout,transition_duration_val) else: final_video_output_clip=final_video_output_clip.fx(vfx.fadein,min(transition_duration_val,final_video_output_clip.duration/2.0)) logger.debug("Applied fade in/out effects to final composite clip.") if overall_narration_path and os.path.exists(overall_narration_path) and final_video_output_clip.duration > 0: try: narration_audio_clip_mvpy=AudioFileClip(overall_narration_path); logger.info(f"Adding overall narration. Video duration: {final_video_output_clip.duration:.2f}s, Narration duration: {narration_audio_clip_mvpy.duration:.2f}s"); final_video_output_clip=final_video_output_clip.set_audio(narration_audio_clip_mvpy); logger.info("Overall narration successfully added to animatic.") except Exception as e_narr_add_final:logger.error(f"Error adding overall narration to animatic:{e_narr_add_final}",exc_info=True) elif final_video_output_clip.duration <= 0: logger.warning("Animatic has zero or negative duration before adding audio. Audio will not be added.") if final_video_output_clip and final_video_output_clip.duration > 0: final_output_path_str=os.path.join(self.output_dir,output_filename); logger.info(f"Writing final animatic video to: {final_output_path_str} (Target Duration: {final_video_output_clip.duration:.2f}s)") num_threads = os.cpu_count(); num_threads = num_threads if isinstance(num_threads, int) and num_threads >= 1 else 2 final_video_output_clip.write_videofile(final_output_path_str, fps=fps, codec='libx264', preset='medium', audio_codec='aac', temp_audiofile=os.path.join(self.output_dir,f'temp-audio-{os.urandom(4).hex()}.m4a'), remove_temp=True, threads=num_threads, logger='bar', bitrate="5000k", ffmpeg_params=["-pix_fmt", "yuv420p"]) logger.info(f"Animatic video created successfully: {final_output_path_str}"); return final_output_path_str else: logger.error("Final animatic clip is invalid or has zero duration. Cannot write video file."); return None except Exception as e_vid_write_final_op: logger.error(f"Error during final animatic video file writing or composition stage: {e_vid_write_final_op}", exc_info=True); return None finally: logger.debug("Closing all MoviePy clips in `assemble_animatic_from_assets` main finally block.") all_clips_for_closure = processed_moviepy_clips_list[:] if narration_audio_clip_mvpy: all_clips_for_closure.append(narration_audio_clip_mvpy) if final_video_output_clip: all_clips_for_closure.append(final_video_output_clip) for clip_to_close_item_final in all_clips_for_closure: if clip_to_close_item_final and hasattr(clip_to_close_item_final, 'close'): try: clip_to_close_item_final.close() except Exception as e_final_clip_close_op: logger.warning(f"Ignoring error while closing a MoviePy clip ({type(clip_to_close_item_final).__name__}): {e_final_clip_close_op}")