Upload 3 files

README.md

@@ -0,0 +1,42 @@
+---
+title: AI Upscaler
+emoji: 🎨
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# 🎨 AI 이미지/영상 업스케일러
+
+Real-ESRGAN을 사용한 고품질 이미지 및 영상 업스케일링 도구입니다.
+
+## 기능
+
+- 📷 **이미지 업스케일**: 2배/4배 확대
+- 🎬 **영상 업스케일**: 2배/4배 확대
+- 💾 **다양한 포맷 지원**: PNG, JPG, WebP
+
+## 사용 방법
+
+1. 탭에서 이미지 또는 영상 선택
+2. 파일 업로드
+3. 배율 선택
+4. 업스케일 시작 버튼 클릭
+5. 결과 다운로드
+
+## 주의사항
+
+⚠️ **영상 처리는 시간이 오래 걸립니다**
+- CPU 모드: 10초 영상 = 10-30분 소요
+- 짧은 영상(5-10초)으로 테스트 권장
+- GPU 활성화 시 처리 속도 향상
+
+## 기술 스택
+
+- [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN)
+- [Gradio](https://gradio.app/)
+- PyTorch

app.py

@@ -0,0 +1,349 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+import io
+import cv2
+import tempfile
+import os
+
+# 전역 변수
+image_upsampler = None
+video_upsampler = None
+
+def load_model(model_type="image"):
+    """모델 로드 (이미지/영상 공통)"""
+    global image_upsampler, video_upsampler
+    
+    try:
+        from basicsr.archs.rrdbnet_arch import RRDBNet
+        from realesrgan import RealESRGANer
+        
+        # 이미 로드된 경우
+        if model_type == "image" and image_upsampler is not None:
+            return image_upsampler
+        if model_type == "video" and video_upsampler is not None:
+            return video_upsampler
+        
+        # 모델 설정
+        model = RRDBNet(
+            num_in_ch=3, 
+            num_out_ch=3, 
+            num_feat=64, 
+            num_block=23, 
+            num_grow_ch=32, 
+            scale=4
+        )
+        
+        # Real-ESRGAN 업샘플러 생성
+        upsampler = RealESRGANer(
+            scale=4,
+            model_path='https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth',
+            model=model,
+            tile=400,  # 타일 크기 증가 (메모리 충분하면)
+            tile_pad=10,
+            pre_pad=0,
+            half=False  # CPU에서는 False, GPU에서는 True 가능
+        )
+        
+        # 전역 변수에 저장
+        if model_type == "image":
+            image_upsampler = upsampler
+            print("✅ 이미지 모델 로드 완료")
+        else:
+            video_upsampler = upsampler
+            print("✅ 영상 모델 로드 완료")
+        
+        return upsampler
+        
+    except Exception as e:
+        print(f"❌ 모델 로드 실패: {e}")
+        return None
+
+def upscale_image(image, scale_factor, output_format):
+    """이미지 업스케일링"""
+    if image is None:
+        return None, None, "⚠️ 이미지를 먼저 업로드해주세요"
+    
+    try:
+        # 상태 업데이트
+        status_loading = f"🔄 모델 로딩 중...\n(처음 실행 시 시간이 걸립니다)"
+        
+        # 모델 로드
+        upsampler = load_model("image")
+        if upsampler is None:
+            error_msg = """❌ 모델 로드 실패
+
+필요한 라이브러리가 설치되어 있는지 확인하세요:
+- realesrgan
+- basicsr
+- torch"""
+            return None, None, error_msg
+        
+        # 이미지 검증
+        img = np.array(image)
+        if img is None or img.size == 0:
+            return None, None, "❌ 유효하지 않은 이미지입니다"
+        
+        # 이미지 크기 제한 (너무 큰 이미지 방지)
+        max_size = 2000
+        h, w = img.shape[:2]
+        if max(h, w) > max_size:
+            scale = max_size / max(h, w)
+            new_w = int(w * scale)
+            new_h = int(h * scale)
+            img = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_AREA)
+            print(f"이미지 크기 조정: {w}x{h} -> {new_w}x{new_h}")
+        
+        # RGB to BGR
+        img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+        
+        # 업스케일 수행
+        print(f"업스케일 시작: {img.shape} -> {scale_factor}배")
+        output, _ = upsampler.enhance(img_bgr, outscale=scale_factor)
+        
+        # BGR to RGB
+        result = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
+        result_img = Image.fromarray(result)
+        
+        # 포맷에 맞게 저장
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=f'.{output_format.lower()}')
+        
+        if output_format == "PNG":
+            result_img.save(temp_file.name, format="PNG", optimize=True)
+        elif output_format == "JPG":
+            result_img = result_img.convert("RGB")
+            result_img.save(temp_file.name, format="JPEG", quality=95, optimize=True)
+        else:  # WebP
+            result_img.save(temp_file.name, format="WebP", quality=95)
+        
+        temp_file.close()
+        
+        # 상태 메시지
+        original_size = f"{image.size[0]} × {image.size[1]}"
+        new_size = f"{result_img.size[0]} × {result_img.size[1]}"
+        
+        status = f"""✅ 업스케일 완료!
+
+📏 원본: {original_size}px
+📏 결과: {new_size}px
+📏 배율: {scale_factor}배
+💾 포맷: {output_format}
+🎨 품질: 최고"""
+        
+        return result_img, temp_file.name, status
+        
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ 오류 발생:\n{str(e)}\n\n{traceback.format_exc()}"
+        print(error_msg)
+        return None, None, error_msg
+
+def upscale_video(video, scale_factor, progress=gr.Progress()):
+    """영상 업스케일링 (진행률 표시 개선)"""
+    if video is None:
+        return None, "⚠️ 영상을 먼저 업로드해주세요"
+    
+    try:
+        progress(0, desc="모델 로딩 중...")
+        
+        # 모델 로드
+        upsampler = load_model("video")
+        if upsampler is None:
+            return None, "❌ 모델 로드 실패"
+        
+        progress(0.1, desc="영상 정보 읽는 중...")
+        print(f"영상 처리 시작: {video}")
+        
+        # 영상 열기
+        cap = cv2.VideoCapture(video)
+        if not cap.isOpened():
+            return None, "❌ 영상 파일을 열 수 없습니다"
+        
+        # 영상 정보
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        print(f"영상 정보: {width}x{height}, {fps}fps, {total_frames}프레임")
+        
+        # 프레임 수 제한 (너무 긴 영상 방지)
+        max_frames = 300  # 약 10초 @ 30fps
+        if total_frames > max_frames:
+            return None, f"❌ 영상이 너무 깁니다. {max_frames}프레임 이하로 업로드해주세요."
+        
+        progress(0.2, desc="첫 프레임 처리 중...")
+        
+        # 첫 프레임으로 출력 크기 결정
+        ret, first_frame = cap.read()
+        if not ret:
+            cap.release()
+            return None, "❌ 첫 프레임을 읽을 수 없습니다"
+        
+        output_frame, _ = upsampler.enhance(first_frame, outscale=scale_factor)
+        out_height, out_width = output_frame.shape[:2]
+        
+        # 출력 파일 설정
+        temp_output = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(temp_output, fourcc, fps, (out_width, out_height))
+        
+        if not out.isOpened():
+            cap.release()
+            return None, "❌ 출력 영상을 생성할 수 없습니다"
+        
+        # 첫 프레임 쓰기
+        out.write(output_frame)
+        
+        # 나머지 프레임 처리
+        frame_count = 1
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # 업스케일
+            output_frame, _ = upsampler.enhance(frame, outscale=scale_factor)
+            out.write(output_frame)
+            
+            frame_count += 1
+            
+            # 진행률 업데이트
+            progress_value = 0.2 + (frame_count / total_frames) * 0.8
+            progress(progress_value, desc=f"처리 중: {frame_count}/{total_frames} 프레임")
+            
+            if frame_count % 5 == 0:
+                print(f"처리 중: {frame_count}/{total_frames}")
+        
+        # 리소스 해제
+        cap.release()
+        out.release()
+        
+        duration = total_frames / fps if fps > 0 else 0
+        
+        status = f"""✅ 영상 업스케일 완료!
+
+📏 원본: {width}×{height}px
+📏 결과: {out_width}×{out_height}px
+🎬 프레임: {total_frames}개
+🎬 FPS: {fps}
+⏱️ 길이: {duration:.1f}초
+📏 배율: {scale_factor}배
+
+⚠️ 처리 시간: 약 {frame_count}프레임 처리"""
+        
+        print(f"영상 처리 완료: {temp_output}")
+        return temp_output, status
+        
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ 오류 발생:\n{str(e)}\n\n{traceback.format_exc()}"
+        print(error_msg)
+        return None, error_msg
+
+# CSS
+custom_css = """
+.upload-box {
+    border: 2px dashed #4F46E5 !important;
+    border-radius: 16px !important;
+    background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%) !important;
+    min-height: 350px !important;
+}
+
+.result-box {
+    border: 2px solid #10B981 !important;
+    border-radius: 16px !important;
+    background: #000000 !important;
+    min-height: 350px !important;
+}
+
+.gradio-button {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    border: none !important;
+    border-radius: 12px !important;
+    font-weight: 600 !important;
+    font-size: 16px !important;
+    padding: 16px 32px !important;
+}
+
+.status-box {
+    background: white !important;
+    border-radius: 12px !important;
+    padding: 16px !important;
+    border-left: 4px solid #4F46E5 !important;
+    font-family: monospace !important;
+    white-space: pre-wrap !important;
+}
+"""
+
+# Gradio UI
+with gr.Blocks(
+    theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="purple"),
+    css=custom_css,
+    title="AI Upscaler"
+) as demo:
+    
+    gr.Markdown("# 🎨 AI 이미지/영상 업스케일러")
+    gr.Markdown("### Real-ESRGAN으로 저화질을 고화질로 변환")
+    
+    with gr.Tabs():
+        # 이미지 탭
+        with gr.Tab("📷 이미지"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 📤 원본 이미지")
+                    input_img = gr.Image(label="이미지 업로드", type="pil")
+                    img_scale = gr.Radio([("2배", 2), ("4배", 4)], value=4, label="배율")
+                    img_format = gr.Radio(["PNG", "JPG", "WebP"], value="PNG", label="포맷")
+                    img_btn = gr.Button("🚀 업스케일 시작", variant="primary", size="lg")
+                
+                with gr.Column():
+                    gr.Markdown("### ✨ 결과")
+                    output_img = gr.Image(label="업스케일 이미지")
+                    download_img = gr.File(label="💾 다운로드")
+                    img_status = gr.Textbox(label="상태", value="대기 중...", lines=8, interactive=False)
+        
+        # 영상 탭
+        with gr.Tab("🎬 영상"):
+            gr.Markdown("""
+            ### ⚠️ 중요 안내
+            - **프레임 제한**: 최대 300프레임 (약 10초)
+            - **처리 시간**: CPU 모드에서 매우 느림
+            - **권장**: 5초 이하의 짧은 클립으로 테스트
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 📤 원본 영상")
+                    input_video = gr.Video(label="영상 업로드")
+                    video_scale = gr.Radio([("2배", 2), ("4배", 4)], value=2, label="배율")
+                    video_btn = gr.Button("🚀 업스케일 시작", variant="primary", size="lg")
+                
+                with gr.Column():
+                    gr.Markdown("### ✨ 결과")
+                    output_video = gr.Video(label="업스케일 영상")
+                    video_status = gr.Textbox(label="상태", value="대기 중...", lines=10, interactive=False)
+    
+    # 이벤트 연결
+    img_btn.click(
+        fn=upscale_image,
+        inputs=[input_img, img_scale, img_format],
+        outputs=[output_img, download_img, img_status]
+    )
+    
+    video_btn.click(
+        fn=upscale_video,
+        inputs=[input_video, video_scale],
+        outputs=[output_video, video_status]
+    )
+    
+    gr.Markdown("""
+    ---
+    <div style='text-align: center; color: #999;'>
+    Powered by <strong>Real-ESRGAN</strong>
+    </div>
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,10 @@
+gradio
+opencv-python-headless==4.8.1.78
+numpy==1.24.3
+pillow==10.0.0
+torch==2.0.1
+torchvision==0.15.2
+basicsr==1.4.2
+realesrgan==0.3.0
+facexlib==0.3.0
+gfpgan==1.3.8