| import gradio as gr |
| from faster_whisper import WhisperModel |
| import os |
| import subprocess |
| import cv2 |
| import asyncio |
| import edge_tts |
| import shutil |
| import time |
| import numpy as np |
| import re |
| import json |
| from google import genai |
| from datetime import datetime, date |
| from PIL import Image, ImageDraw, ImageFont |
|
|
| |
| |
| |
| MAX_SUBTITLE_DURATION_SECONDS = 7.0 |
|
|
| |
| ACCOUNTS = { |
| "abcd123": "abcd123" |
| } |
|
|
| EXPIRY_DATE_STR = "2026-8-31" |
|
|
| |
| IP_TRACKER = {} |
|
|
| SYSTEM_INSTRUCTION = "You are a professional movie recap writer. Translate English movie subtitle lines into natural, engaging, and thrilling Burmese movie recap style. Keep it concise." |
| MODEL_NAME = "gemini-2.5-flash" |
|
|
| def check_app_expiry(): |
| try: |
| expiry_date = datetime.strptime(EXPIRY_DATE_STR, "%Y-%m-%d").date() |
| current_date = datetime.now().date() |
| if current_date > expiry_date: |
| return False, f"❌ ဤ App သည် သက်တမ်းကုန်ဆုံးသွားပါပြီ ({EXPIRY_DATE_STR})။" |
| return True, "Active" |
| except Exception as e: |
| return False, f"လုံခြုံရေး စစ်ဆေးမှု မှားယွင်းနေပါသည်- {str(e)}" |
|
|
| print("Loading Lightweight Faster-Whisper Tiny Model...") |
| model = WhisperModel("tiny", device="cpu", compute_type="int8") |
|
|
| |
| |
| |
| def update_preview_image(video_path, blur_y_percent, blur_strength): |
| if not video_path: return None |
| try: |
| cap = cv2.VideoCapture(video_path) |
| ret, frame = cap.read() |
| cap.release() |
| if not ret: return None |
| |
| h_o, w_o, _ = frame.shape |
| b_h = int(h_o * 0.12) |
| b_y = max(0, min(int(h_o * (blur_y_percent / 100)) - (b_h // 2), h_o - b_h)) |
| |
| k_size = int(blur_strength) |
| if k_size % 2 == 0: k_size += 1 |
| |
| preview_frame = frame.copy() |
| |
| roi = preview_frame[b_y:b_y+b_h, 0:w_o] |
| if roi.shape[0] > 0 and roi.shape[1] > 0: |
| small_roi = cv2.resize(roi, (w_o // 4, b_h // 4), interpolation=cv2.INTER_LINEAR) |
| blurred_small = cv2.GaussianBlur(small_roi, (k_size // 4 | 1, k_size // 4 | 1), 0) |
| preview_frame[b_y:b_y+b_h, 0:w_o] = cv2.resize(blurred_small, (w_o, b_h), interpolation=cv2.INTER_LINEAR) |
| cv2.rectangle(preview_frame, (0, b_y), (w_o, b_y+b_h), (0, 0, 255), 3) |
| |
| preview_rgb = cv2.cvtColor(preview_frame, cv2.COLOR_BGR2RGB) |
| return Image.fromarray(preview_rgb) |
| except Exception as e: |
| print(f"Preview Error: {e}") |
| return None |
|
|
| |
| |
| |
| def google_backup_translate(text): |
| from urllib.parse import quote |
| import urllib.request |
| import json |
| try: |
| url = f"https://translate.googleapis.com/translate_a/single?client=gtx&sl=en&tl=my&dt=t&q={quote(text)}" |
| req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'}) |
| response = urllib.request.urlopen(req, timeout=5).read().decode('utf-8') |
| result = json.loads(response) |
| return result[0][0][0] or text |
| except: |
| return text |
|
|
| def translate_segments_batch(segments, user_api_key, source_lang="en"): |
| if not segments: return segments |
| |
| if not user_api_key or not user_api_key.strip(): |
| print("⚠️ User က Gemini API Key မထည့်ထားပါ။ Google Translate Backup စနစ်ဖြင့် ဘာသာပြန်နေပါသည်။") |
| for seg in segments: |
| seg['mm_text'] = google_backup_translate(seg['text']) |
| return segments |
|
|
| payload_dict = {str(idx): seg['text'] for idx, seg in enumerate(segments)} |
| large_prompt_text = json.dumps(payload_dict, ensure_ascii=False, indent=2) |
|
|
| prompt = f""" |
| You are an expert movie recap translator. Translate the following English movie subtitle lines into thrilling, natural, and engaging Burmese movie recap style. |
| |
| CRITICAL: You MUST respond in valid JSON format only, keeping the exact same keys (0, 1, 2, etc.) as the input. The values should be the translated Burmese text. |
| Do NOT include any markdown formatting like ```json or ``` in your response. Respond with pure JSON raw string only. |
| |
| Input Data: |
| {large_prompt_text} |
| """ |
| |
| translated_map = {} |
| try: |
| client = genai.Client(api_key=user_api_key.strip()) |
| response = client.models.generate_content( |
| model=MODEL_NAME, |
| contents=prompt, |
| config={ |
| "system_instruction": SYSTEM_INSTRUCTION, |
| "temperature": 0.3, |
| } |
| ) |
| response_text = response.text.strip() |
| |
| if response_text.startswith("```"): |
| response_text = response_text.split("\n", 1)[1].rsplit("\n", 1)[0].strip() |
| if response_text.startswith("json"): |
| response_text = response_text.split("\n", 1)[1].strip() |
| |
| translated_map = json.loads(response_text) |
| except Exception as e: |
| print(f"⚠️ User Gemini API Error သို့မဟုတ် Format Error: {e} -> Google Translate သို့ ပြောင်းလဲနေသည်။") |
|
|
| for idx, seg in enumerate(segments): |
| key_str = str(idx) |
| if key_str in translated_map and translated_map[key_str]: |
| seg['mm_text'] = translated_map[key_str] |
| else: |
| seg['mm_text'] = google_backup_translate(seg['text']) |
| |
| return segments |
|
|
| |
| |
| |
| def segment_myanmar_syllables(text): |
| return re.findall(r'[a-zA-Z0-9\s\-\.,!\?]+|[\u1000-\u102a\u103f\u1040-\u1049]+[\u102b-\u103e\u1060-\u109f]*|[^\s]', text) |
|
|
| def wrap_text_myanmar_smart(text, font, max_width, draw): |
| cleaned_text = text.replace(" ြ", "ြ").replace("ြ ", "ြ").strip() |
| tokens = segment_myanmar_syllables(cleaned_text) |
| lines, current_line = [], "" |
| for token in tokens: |
| test_line = current_line + token |
| bbox = draw.textbbox((0, 0), test_line, font=font) |
| if (bbox[2] - bbox[0]) <= max_width: |
| current_line = test_line |
| else: |
| if current_line: lines.append(current_line.strip()) |
| current_line = token |
| if current_line: lines.append(current_line.strip()) |
| return lines |
|
|
| def hex_to_rgb(hex_str): |
| if not hex_str: return (255, 255, 0) |
| hex_str = hex_str.lstrip('#') |
| return tuple(int(hex_str[i:i+2], 16) for i in (0, 2, 4)) |
|
|
| def draw_line_perfect_rendering(draw, position, text, font_primary, fill_color, stroke_w, stroke_c): |
| x, y = position |
| clean_text = text.replace(" ြ", "ြ").replace("ြ ", "ြ") |
| draw.text((x, y), clean_text, font=font_primary, fill=fill_color, stroke_width=stroke_w, stroke_fill=stroke_c) |
|
|
| def generate_voice_sync(text, voice_id, filename, desired_speed, target_duration_sec=None): |
| rate_percentage = int((desired_speed - 1.0) * 100) |
| rate_str = f"{'+' if rate_percentage >= 0 else ''}{rate_percentage}%" |
| |
| if target_duration_sec and target_duration_sec > 0: |
| char_count = len(text) |
| cps = char_count / target_duration_sec |
| if cps > 15: rate_str = f"+{rate_percentage + 30}%" |
| elif cps > 11: rate_str = f"+{rate_percentage + 15}%" |
| elif cps > 7: rate_str = f"+{rate_percentage + 5}%" |
| |
| async def _async_gen(): |
| communicate = edge_tts.Communicate(text, voice_id, rate=rate_str) |
| await communicate.save(filename) |
| |
| try: loop = asyncio.get_event_loop() |
| except RuntimeError: |
| loop = asyncio.new_event_loop() |
| asyncio.set_event_loop(loop) |
| |
| if loop.is_running(): |
| import threading |
| t = threading.Thread(target=lambda: asyncio.run(_async_gen())) |
| t.start() |
| t.join() |
| else: |
| loop.run_until_complete(_async_gen()) |
|
|
| |
| |
| |
| def process_magic_recap_video( |
| video_path, user_api_key, ratio_select, background_fill, enable_zoom, zoom_level, |
| logo_file, mirror_flip, filter_color, voice_gender, tone_style, |
| text_color, stroke_color, blur_y_percent, blur_strength, sub_pos_percent, desired_speed, |
| request: gr.Request, |
| progress=gr.Progress(track_tqdm=True) |
| ): |
| is_valid, msg = check_app_expiry() |
| if not is_valid: raise gr.Error(msg) |
| if not video_path: return None |
| |
| |
| login_username = request.username if request and request.username else "unknown" |
| user_ip = request.client.host if request and request.client else "unknown_ip" |
| current_timestamp = time.time() |
| |
| |
| if login_username != "abcd123" and user_ip != "unknown_ip": |
| if user_ip in IP_TRACKER: |
| last_generated_time = IP_TRACKER[user_ip] |
| elapsed_time = current_timestamp - last_generated_time |
| if elapsed_time < 86400: |
| remaining_seconds = 86400 - elapsed_time |
| rem_hours = int(remaining_seconds // 3600) |
| rem_mins = int((remaining_seconds % 3600) // 60) |
| raise gr.Error(f"❌ ခွင့်ပြုချက်ကျော်လွန်နေပါသည်။ Free အသုံးပြုသူများသည် တစ်ရက်လျှင် ဗီဒီယို (၁) ပုဒ်သာ ထုတ်ယူခွင့်ရှိသည်။ ပြန်လည်စမ်းသပ်ရန် {rem_hours} နာရီ {rem_mins} မိနစ် လိုအပ်ပါသေးသည်။") |
| |
| IP_TRACKER[user_ip] = current_timestamp |
| temp_dir = "temp_space_workspace" |
| if os.path.exists(temp_dir): shutil.rmtree(temp_dir) |
| os.makedirs(temp_dir, exist_ok=True) |
| |
| try: |
| progress(0.10, desc="🎙️ Faster-Whisper ဖြင့် စာသားဖတ်နေပါသည်...") |
| segments_raw, info = model.transcribe(video_path, beam_size=1) |
| raw_segments = [{"start": seg.start, "end": seg.end, "text": seg.text} for seg in segments_raw] |
| |
| cap = cv2.VideoCapture(video_path) |
| fps = cap.get(cv2.CAP_PROP_FPS) or 30.0 |
| orig_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) |
| orig_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) |
| video_duration = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) / fps |
| |
| if not raw_segments: |
| raw_segments = [{'start': 0.0, 'end': min(6.0, video_duration), 'text': "Welcome to this movie recap."}] |
|
|
| segments = [] |
| for seg in raw_segments: |
| s_start = seg['start'] |
| s_end = seg['end'] |
| s_text = seg['text'].strip() |
| if not s_text: continue |
| |
| dur = s_end - s_start |
| if dur > MAX_SUBTITLE_DURATION_SECONDS and MAX_SUBTITLE_DURATION_SECONDS > 0: |
| words = s_text.split() |
| chunks_count = int(np.ceil(dur / MAX_SUBTITLE_DURATION_SECONDS)) |
| words_per_chunk = int(np.ceil(len(words) / chunks_count)) |
| for i in range(chunks_count): |
| w_sub = words[i*words_per_chunk : (i+1)*words_per_chunk] |
| if not w_sub: continue |
| segments.append({'start': s_start + (i * (dur / chunks_count)), 'end': min(s_end, s_start + ((i+1) * (dur / chunks_count))), 'text': " ".join(w_sub)}) |
| else: |
| segments.append({'start': s_start, 'end': s_end, 'text': s_text}) |
|
|
| if user_api_key and user_api_key.strip(): |
| progress(0.30, desc="⚡ ထည့်သွင်းထားသော Gemini API စနစ်ဖြင့် ဘာသာပြန်နေပါသည်...") |
| else: |
| progress(0.30, desc="🌐 Google Translate Backup စနစ်ဖြင့် ဘာသာပြန်နေပါသည်...") |
| |
| segments = translate_segments_batch(segments, user_api_key, source_lang=info.language) |
|
|
| if ratio_select == "9:16 (Tiktok/Reels)": target_w, target_h = 720, 1280 |
| else: target_w, target_h = 1280, 720 |
|
|
| logo_img = None |
| if logo_file: |
| try: |
| logo_cv = cv2.imread(logo_file, cv2.IMREAD_UNCHANGED) |
| if logo_cv is not None: |
| l_w = int(target_w * 0.16) |
| logo_img = cv2.resize(logo_cv, (l_w, int(l_w * (logo_cv.shape[0] / logo_cv.shape[1])))) |
| except Exception as le: |
| print(f"Logo error: {le}") |
|
|
| progress(0.50, desc="🎙️ AI အသံများ စတင်ဖန်တီးနေပါသည်...") |
| audio_segments = [] |
| python_srt_segments = [] |
| voice_id = "my-MM-NilarNeural" if "မိန်းကလေး" in voice_gender else "my-MM-ThihaNeural" |
| v_segments_time_map = [] |
| total_adjusted_duration = 0.0 |
|
|
| for idx, seg in enumerate(segments): |
| mm_text = seg.get('mm_text', seg['text']) |
| mm_text = mm_text.replace(" ြ", "ြ").replace("ြ ", "ြ").strip() |
| |
| orig_start, orig_end = float(seg.get('start', 0.0)), float(seg.get('end', 0.0)) |
| orig_dur = orig_end - orig_start if (orig_end - orig_start) > 0 else 2.0 |
| |
| raw_seg_filename = os.path.join(temp_dir, f"raw_{idx}.mp3") |
| fixed_seg_filename = os.path.join(temp_dir, f"fixed_{idx}.mp3") |
| |
| generate_voice_sync(mm_text, voice_id, raw_seg_filename, 1.15, orig_dur) |
| |
| if os.path.exists(raw_seg_filename) and os.path.getsize(raw_seg_filename) > 0: |
| subprocess.run([ |
| 'ffmpeg', '-y', '-i', raw_seg_filename, |
| '-filter:a', f"atempo={desired_speed}", |
| fixed_seg_filename |
| ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) |
| |
| if os.path.exists(fixed_seg_filename) and os.path.getsize(fixed_seg_filename) > 0: |
| probe_res = subprocess.run(['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', fixed_seg_filename], stdout=subprocess.PIPE, text=True) |
| try: audio_dur = float(probe_res.stdout.strip()) |
| except: audio_dur = orig_dur / desired_speed |
|
|
| python_srt_segments.append({'start': total_adjusted_duration, 'end': total_adjusted_duration + audio_dur, 'text': mm_text}) |
| audio_segments.append(fixed_seg_filename) |
| v_segments_time_map.append({'orig_start': orig_start, 'orig_end': orig_end, 'new_start': total_adjusted_duration, 'new_end': total_adjusted_duration + audio_dur, 'pts_ratio': audio_dur / orig_dur}) |
| total_adjusted_duration += audio_dur |
|
|
| progress(0.70, desc="⚡ Render ဗီဒီယိုနှင့် စာတန်းထိုးများ ပေါင်းစပ်နေပါသည်...") |
| output_video_path = os.path.abspath("magic_recap_output.mp4") |
| if os.path.exists(output_video_path): os.remove(output_video_path) |
| |
| final_burn_temp = os.path.join(temp_dir, "final_burn_temp.mp4") |
| video_writer = cv2.VideoWriter(final_burn_temp, cv2.VideoWriter_fourcc(*'mp4v'), fps, (target_w, target_h)) |
| |
| font_size = int(target_h * 0.038) |
| font_path = "Myanmar font.ttf" |
| font_primary = ImageFont.truetype(font_path, font_size) if os.path.exists(font_path) else ImageFont.load_default() |
|
|
| t_color, s_color = hex_to_rgb(text_color), hex_to_rgb(stroke_color) |
| b_h = int(target_h * 0.12) |
| b_y = max(0, min(int(target_h * (blur_y_percent / 100)) - (b_h // 2), target_h - b_h)) |
| m_w, s_w = int(target_w * 0.90), max(2, int(font_size * 0.12)) |
| k_size = int(blur_strength) | 1 |
|
|
| frame_list = [] |
| while True: |
| ret, frame = cap.read() |
| if not ret or frame is None: break |
| frame_list.append(frame) |
| cap.release() |
| |
| total_input_frames = len(frame_list) |
| if total_input_frames == 0: |
| frame_list.append(np.zeros((orig_h, orig_w, 3), dtype=np.uint8)) |
| total_input_frames = 1 |
|
|
| total_output_frames = int(total_adjusted_duration * fps) |
|
|
| for f_out_idx in range(total_output_frames): |
| c_sec = f_out_idx / fps |
| target_orig_sec = 0.0 |
| for mapping in v_segments_time_map: |
| if mapping['new_start'] <= c_sec <= mapping['new_end']: |
| target_orig_sec = mapping['orig_start'] + ((c_sec - mapping['new_start']) / mapping['pts_ratio']) |
| break |
| else: |
| if v_segments_time_map: target_orig_sec = v_segments_time_map[-1]['orig_end'] |
| |
| target_frame_idx = int(target_orig_sec * fps) |
| target_frame_idx = max(0, min(target_frame_idx, total_input_frames - 1)) |
| orig_frame = frame_list[target_frame_idx] |
| |
| if background_fill == "Blur Background (အနောက်ခံ ဝါးမည်)": |
| small_bg = cv2.resize(orig_frame, (target_w // 4, target_h // 4), interpolation=cv2.INTER_LINEAR) |
| blurred_small_bg = cv2.blur(small_bg, (11, 11)) |
| bg_layer = cv2.resize(blurred_small_bg, (target_w, target_h), interpolation=cv2.INTER_LINEAR) |
| else: |
| bg_layer = np.zeros((target_h, target_w, 3), dtype=np.uint8) |
|
|
| if enable_zoom and zoom_level > 1.0: |
| fg_cropped = orig_frame[int((orig_h - orig_h/zoom_level)//2):int((orig_h + orig_h/zoom_level)//2), int((orig_w - orig_w/zoom_level)//2):int((orig_w + orig_w/zoom_level)//2)] |
| else: |
| fg_cropped = orig_frame |
|
|
| fg_w = target_w |
| fg_h = int(fg_w / (fg_cropped.shape[1] / fg_cropped.shape[0])) |
| if fg_h > target_h: |
| fg_h = target_h |
| fg_w = int(fg_h * (fg_cropped.shape[1] / fg_cropped.shape[0])) |
| |
| fg_resized = cv2.flip(cv2.resize(fg_cropped, (fg_w, fg_h)), 1) if mirror_flip else cv2.resize(fg_cropped, (fg_w, fg_h)) |
|
|
| if filter_color == "Chrome Cool": fg_resized = cv2.convertScaleAbs(fg_resized, alpha=1.0, beta=15) |
| elif filter_color == "Warm Cinema": fg_resized = cv2.convertScaleAbs(fg_resized, alpha=1.05, beta=5) |
| else: fg_resized = cv2.convertScaleAbs(fg_resized, alpha=0.99, beta=2) |
|
|
| bg_layer[(target_h - fg_h)//2:(target_h - fg_h)//2+fg_h, (target_w - fg_w)//2:(target_w - fg_w)//2+fg_w] = fg_resized |
| frame = bg_layer |
|
|
| if logo_img is not None: |
| ly, lx = 25, target_w - logo_img.shape[1] - 25 |
| if logo_img.shape[2] == 4: |
| alpha_l = logo_img[:, :, 3] / 255.0 |
| for c in range(3): frame[ly:ly+logo_img.shape[0], lx:lx+logo_img.shape[1], c] = alpha_l * logo_img[:, :, c] + (1.0 - alpha_l) * frame[ly:ly+logo_img.shape[0], lx:lx+logo_img.shape[1], c] |
| else: frame[ly:ly+logo_img.shape[0], lx:lx+logo_img.shape[1]] = logo_img[:, :, :3] |
|
|
| if b_h > 0 and (b_y + b_h) <= target_h: |
| roi = frame[b_y:b_y+b_h, 0:target_w] |
| if roi.shape[0] > 0 and roi.shape[1] > 0: |
| roi_small = cv2.resize(roi, (target_w // 4, b_h // 4), interpolation=cv2.INTER_LINEAR) |
| roi_blur = cv2.GaussianBlur(roi_small, (k_size // 4 | 1, k_size // 4 | 1), 0) |
| frame[b_y:b_y+b_h, 0:target_w] = cv2.resize(roi_blur, (target_w, b_h), interpolation=cv2.INTER_LINEAR) |
|
|
| text_str = "" |
| for s in python_srt_segments: |
| if s['start'] <= c_sec <= s['end']: |
| text_str = s['text'] |
| break |
|
|
| if text_str and isinstance(font_primary, ImageFont.FreeTypeFont): |
| pil_img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) |
| draw = ImageDraw.Draw(pil_img) |
| sub_lines = wrap_text_myanmar_smart(text_str, font_primary, m_w, draw) |
| |
| y_offset = int(target_h * (sub_pos_percent / 100)) |
| for line in sub_lines: |
| text_bbox = draw.textbbox((0, 0), line, font=font_primary) |
| text_w = text_bbox[2] - text_bbox[0] |
| text_x = (target_w - text_w) // 2 |
| draw_line_perfect_rendering(draw, (text_x, y_offset), line, font_primary, t_color, s_w, s_color) |
| y_offset += font_size + 5 |
| frame = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR) |
| |
| video_writer.write(frame) |
| |
| video_writer.release() |
| |
| |
| concat_list_file = os.path.join(temp_dir, "concat_list.txt") |
| with open(concat_list_file, 'w', encoding='utf-8') as f: |
| for aud in audio_segments: |
| f.write(f"file '{os.path.abspath(aud)}'\n") |
| |
| final_audio_path = os.path.join(temp_dir, "final_combined.mp3") |
| subprocess.run([ |
| 'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', concat_list_file, '-c', 'copy', final_audio_path |
| ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) |
| |
| |
| progress(0.95, desc="🎵 ဗီဒီယိုနှင့် AI အသံဖိုင်ကို ပေါင်းစပ်နေပါသည်...") |
| if os.path.exists(final_audio_path) and os.path.getsize(final_audio_path) > 0: |
| subprocess.run([ |
| 'ffmpeg', '-y', '-i', final_burn_temp, '-i', final_audio_path, '-c:v', 'copy', '-c:a', 'aac', '-map', '0:v:0', '-map', '1:a:0', output_video_path |
| ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) |
| else: |
| shutil.move(final_burn_temp, output_video_path) |
| |
| return output_video_path |
| |
| except Exception as e: |
| raise gr.Error(f"ဗီဒီယိုထုတ်ယူရာတွင် အမှားအယွင်းရှိနေပါသည်- {str(e)}") |
| finally: |
| if 'cap' in locals() and cap.isOpened(): cap.release() |
| if 'video_writer' in locals(): video_writer.release() |
|
|
| |
| |
| |
| with gr.Blocks(theme=gr.themes.Soft(), title="Auto Movie Recap Generator") as demo: |
| gr.Markdown("# 🎬 Auto Movie Recap & Dubbing Production Suite") |
| gr.Markdown("English ဗီဒီယိုများကို ဉာဏ်ရည်တုစနစ်ဖြင့် မြန်မာအသံသွင်း၊ မြန်မာစာတန်းထိုး အလိုအလျောက်ပြုလုပ်ပေးသော စနစ်။") |
| |
| with gr.Row(): |
| with gr.Column(scale=1): |
| video_input = gr.Video(label="📹 မူရင်းဗီဒီယိုတင်ရန် (Upload English Video)") |
| user_api_key = gr.Textbox(label="🔑 Gemini API Key (မထည့်ပါက Google Translate ကိုသုံးပါမည်)", placeholder="AIzaSy...", type="password") |
| |
| with gr.Tab("📐 ဗီဒီယို ပုံစံ ချိန်ညှိချက်"): |
| ratio_select = gr.Radio(["16:9 (Landscape)", "9:16 (Tiktok/Reels)"], label="ဗီဒီယိုအချိုး (Ratio)", value="16:9 (Landscape)") |
| background_fill = gr.Radio(["Black Background", "Blur Background (အနောက်ခံ ဝါးမည်)"], label="နောက်ခံစနစ် (Background)", value="Blur Background (အနောက်ခံ ဝါးမည်)") |
| enable_zoom = gr.Checkbox(label="ရုပ်ထွက် Zoom ဆွဲမည်", value=False) |
| zoom_level = gr.Slider(1.0, 3.0, value=1.0, step=0.1, label="Zoom Level") |
| mirror_flip = gr.Checkbox(label="ဘယ်ညာပြောင်းမည် (Mirror Flip)", value=False) |
| filter_color = gr.Dropdown(["Normal Cinema", "Chrome Cool", "Warm Cinema"], label="ရုပ်ထွက်ကာလာ (Filters)", value="Normal Cinema") |
| logo_file = gr.File(label="ตรา/Logo ထည့်ရန် (PNG format သာ)", file_types=[".png"]) |
|
|
| with gr.Tab("🎙️ အသံနှင့် စာတန်းထိုး ချိန်ညှိချက်"): |
| voice_gender = gr.Radio(["ယောကျ်ားလေး (Thiha)", "မိန်းကလေး (Nilar)"], label="AI အသံရွေးချယ်ရန်", value="ယောကျ်ားလေး (Thiha)") |
| tone_style = gr.Radio(["Normal Style", "Thrilling Style"], label="အပြောပုံစံ (Tone)", value="Thrilling Style") |
| desired_speed = gr.Slider(0.5, 2.0, value=1.15, step=0.05, label="အသံအမြန်နှုန်း (Audio Speed)") |
| text_color = gr.ColorPicker(label="စာတန်းအရောင် (Text Color)", value="#FFFFFF") |
| stroke_color = gr.ColorPicker(label="စာတန်းအနားသတ်အရောင် (Stroke Color)", value="#000000") |
| sub_pos_percent = gr.Slider(0, 100, value=80, step=1, label="စာတန်းထိုး တည်နေရာ % (Y Position)") |
| blur_y_percent = gr.Slider(0, 100, value=85, step=1, label="ဝါးမည့်နေရာ % (Blur Y Position)") |
| blur_strength = gr.Slider(1, 50, value=15, step=2, label="ဝါးမည့်ပမာဏ (Blur Strength)") |
|
|
| with gr.Column(scale=1): |
| gr.Markdown("### 🖼️ ရုပ်ထွက်ပုံရိပ် တိုက်ရိုက်ကြည့်ရှုရန် (Live Preview)") |
| preview_btn = gr.Button("👁️ Preview ပုံရိပ်ကြည့်မည်", variant="secondary") |
| preview_output = gr.Image(label="Preview Image Frame") |
| |
| gr.Markdown("---") |
| generate_btn = gr.Button("🚀 ဗီဒီယိုအလိုအလျောက် ထုတ်ယူမည်", variant="primary") |
| video_output = gr.Video(label="📥 ထွက်ပေါ်လာသော ဗီဒီယို (Output Result)") |
|
|
| |
| preview_btn.click( |
| fn=update_preview_image, |
| inputs=[video_input, blur_y_percent, blur_strength], |
| outputs=preview_output |
| ) |
|
|
| generate_btn.click( |
| fn=process_magic_recap_video, |
| inputs=[ |
| video_input, user_api_key, ratio_select, background_fill, enable_zoom, zoom_level, |
| logo_file, mirror_flip, filter_color, voice_gender, tone_style, |
| text_color, stroke_color, blur_y_percent, blur_strength, sub_pos_percent, desired_speed |
| ], |
| outputs=video_output |
| ) |
|
|
| |
| |
| |
| if __name__ == "__main__": |
| |
| demo.launch(auth=lambda u, p: ACCOUNTS.get(u) == p) |
|
|
