{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "031b42e0", "metadata": {}, "outputs": [], "source": [ "import subprocess\n", "import tempfile\n", "import pathlib\n", "from yt_dlp import YoutubeDL\n", "import pathlib\n", "import os\n", "from pathlib import Path\n", "import requests\n", "import time\n", "import json\n", "from typing import Dict, Any" ] }, { "cell_type": "markdown", "id": "3b0c1b56", "metadata": {}, "source": [ "secrets" ] }, { "cell_type": "code", "execution_count": 2, "id": "113505ac", "metadata": {}, "outputs": [], "source": [ "API_BASE = \"https://studio-api.staging.suno.com\"\n", "def _headers():\n", " # token = os.getenv(\"SUNO_TOKEN\")\n", " token = \"ae6cb0480e2e493cbab61a7324030ec5\"\n", " if not token:\n", " raise RuntimeError(\"SUNO_TOKEN env var missing\")\n", " return {\"Authorization\": f\"Bearer {token}\", \"Content-Type\": \"application/json\"}" ] }, { "cell_type": "code", "execution_count": 3, "id": "3e66924c", "metadata": {}, "outputs": [], "source": [ "TICTAK = \"https://www.tiktok.com/@ethan.stee1e/video/7529957148734786838?kref=vGWRdzLJnjYf&kuid=31b6d78a-c086-437f-9ab0-df56eaf7fd8b\"" ] }, { "cell_type": "code", "execution_count": 4, "id": "39125da1", "metadata": {}, "outputs": [], "source": [ "def upload_audio(audio_path: Path) -> str:\n", " # Step 1: Reserve upload slot\n", " payload = {\n", " \"filename\": audio_path.name,\n", " \"content_type\": \"audio/wav\"\n", " }\n", " \n", " r = requests.post(f\"{API_BASE}/api/uploads/audio\", json=payload, headers=_headers())\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"Upload reservation failed: {r.text}\")\n", " \n", " upload_data = r.json()\n", " upload_id = upload_data.get(\"id\") or upload_data.get(\"upload_id\")\n", " \n", " # Step 2: Upload file\n", " if \"fields\" in upload_data:\n", " # Staging flow - multipart POST\n", " url = upload_data[\"url\"]\n", " fields = upload_data[\"fields\"]\n", " \n", " with open(audio_path, \"rb\") as f:\n", " files = {\"file\": (audio_path.name, f, fields.get(\"Content-Type\", \"audio/mpeg\"))}\n", " r = requests.post(url, data=fields, files=files)\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"File upload failed: {r.text}\")\n", " else:\n", " # Production flow - presigned PUT\n", " presigned_url = upload_data.get(\"upload_url\")\n", " \n", " with open(audio_path, \"rb\") as f:\n", " r = requests.put(presigned_url, data=f, headers={\"Content-Type\": \"audio/wav\"})\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"File upload failed: {r.text}\")\n", " \n", " # Step 3: Mark upload complete\n", " finish_payload = {\n", " \"upload_type\": \"audio\",\n", " \"upload_filename\": audio_path.name,\n", " \"upload_key\": upload_data.get(\"fields\", {}).get(\"key\", f\"raw_uploads/{upload_id}.mp3\")\n", " }\n", " \n", " r = requests.post(\n", " f\"{API_BASE}/api/uploads/audio/{upload_id}/upload-finish\",\n", " json=finish_payload,\n", " headers=_headers()\n", " )\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"Upload finish failed: {r.text}\")\n", " \n", " # Step 4: Poll for processing completion\n", " poll_start = time.time()\n", " \n", " while True:\n", " r = requests.get(f\"{API_BASE}/api/uploads/audio/{upload_id}\", headers=_headers())\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"Status poll failed: {r.text}\")\n", " \n", " status_data = r.json()\n", " status = status_data.get(\"status\", \"unknown\")\n", " \n", " if status == \"complete\" or status == \"error\":\n", " break\n", " \n", " if time.time() - poll_start > 180:\n", " raise TimeoutError(\"Upload processing timed out\")\n", " \n", " time.sleep(3)\n", " \n", " if status == \"error\":\n", " raise RuntimeError(f\"Upload processing failed: {status_data}\")\n", " \n", " # Step 5: Initialize clip\n", " r = requests.post(\n", " f\"{API_BASE}/api/uploads/audio/{upload_id}/initialize-clip\",\n", " json={},\n", " headers=_headers()\n", " )\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"Clip initialization failed: {r.text}\")\n", " \n", " clip_data = r.json()\n", " clip_id = clip_data.get(\"clip_id\") or clip_data.get(\"id\")\n", " \n", " if not clip_id:\n", " raise RuntimeError(\"No clip ID returned from initialization\")\n", " \n", " return clip_id" ] }, { "cell_type": "code", "execution_count": 5, "id": "a551f036", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Temporary directory created at: /var/folders/ly/kj0fsj152c5_wz64hcbvn2kc0000gn/T/tmpm7k0enzx\n", " \r" ] } ], "source": [ "# Create a temporary directory\n", "temp_dir = tempfile.TemporaryDirectory()\n", "print(f\"Temporary directory created at: {temp_dir.name}\")\n", "def download_tiktok(url: str, out_dir: str) -> str:\n", " out_dir = pathlib.Path(out_dir)\n", " out_dir.mkdir(parents=True, exist_ok=True)\n", " tmpl = str(out_dir / \"%(id)s.%(ext)s\")\n", " ydl_opts = {\"outtmpl\": tmpl, \"format\": \"mp4/best\", \"quiet\": True, \"no_warnings\": True}\n", " with YoutubeDL(ydl_opts) as ydl:\n", " info = ydl.extract_info(url, download=True)\n", " return str(pathlib.Path(ydl.prepare_filename(info)).with_suffix(\".mp4\"))\n", "mp4 = download_tiktok(TICTAK, temp_dir.name)\n", "cmd = [\n", " \"ffmpeg\", \"-y\",\n", " \"-i\", mp4,\n", " \"-ac\", \"1\", # mono\n", " \"-ar\", \"16000\", # 16 kHz sample‑rate\n", " \"-c:a\", \"pcm_s16le\", # 16‑bit little‑endian PCM (valid WAV)\n", " str(f\"{temp_dir.name}/audio.wav\"),\n", " ]\n", "subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n", "clip_id = upload_audio(Path(f\"{temp_dir.name}/audio.wav\"))" ] }, { "cell_type": "code", "execution_count": 6, "id": "d0258391", "metadata": {}, "outputs": [], "source": [ "def get_lyrics(clip_id:str):\n", " while True:\n", " lyrics = requests.get(f\"{API_BASE}/api/gen/{clip_id}/aligned_lyrics/v2/\", headers=_headers()).json()\n", " try:\n", " if lyrics['aligned_words']:\n", " return lyrics\n", " except(Exception) as e:\n", " print(e)\n", " time.sleep(1)" ] }, { "cell_type": "code", "execution_count": 7, "id": "90628fc7", "metadata": {}, "outputs": [], "source": [ "def create_remix(clip_id:str, audio_weight: float = 0.5):\n", " \"\"\"create remix/cover from clip_id\"\"\"\n", "\n", " lyrics = get_lyrics(clip_id)\n", " words = [item['word'] for item in lyrics['aligned_words']]\n", "\n", " joined_text = ''.join(words)\n", " \n", " # Enable remixes for the clip\n", " requests.post(\n", " f\"{API_BASE}/api/gen/{clip_id}/enable_remixes\",\n", " headers=_headers()\n", " )\n", " \n", " # Set remix type\n", " requests.post(\n", " f\"{API_BASE}/api/gen/{clip_id}/update_remix_type\",\n", " json={\"type\": \"REMIX\"},\n", " headers=_headers()\n", " )\n", " \n", " # Generate the remix/cover\n", " \n", " generation_payload = {\n", " \"prompt\": joined_text,\n", " \"generation_type\": \"TEXT\",\n", " \"tags\": \"pop\",\n", " \"mv\": \"chirp-bluejay-t2\",\n", " \"task\": \"cover\",\n", " \"cover_clip_id\": clip_id,\n", " \"metadata\": {\n", " \"control_sliders\": {\n", " \"audio_weight\": audio_weight,\n", " \"style_weight\": 0.5,\n", " \"weirdness_constraint\": 0.0\n", " },\n", " \"is_remix\": True\n", " }\n", " }\n", " \n", " r = requests.post(f\"{API_BASE}/api/generate/v2\", json=generation_payload, headers=_headers())\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"Generation failed: {r.text}\")\n", " \n", " gen_data = r.json()\n", " gen_id = gen_data.get(\"id\")\n", " \n", " # Poll for completion\n", " final_clips = []\n", " poll_start = time.time()\n", " \n", " while True:\n", " time.sleep(5)\n", " \n", " r = requests.get(f\"{API_BASE}/api/generate/requests?ids={gen_id}\", headers=_headers())\n", " \n", " if not r.ok:\n", " raise RuntimeError(f\"Status poll failed: {r.text}\")\n", " \n", " status_data = r.json()\n", " if status_data and len(status_data) > 0:\n", " gen_status = status_data[0]\n", " status = gen_status.get(\"status\", \"unknown\")\n", " \n", " if status in [\"complete\", \"streaming\", \"error\", \"failed\"]:\n", " final_clips = gen_status.get(\"clips\", [])\n", " break\n", " \n", " if time.time() - poll_start > 300:\n", " raise TimeoutError(\"Generation timed out\")\n", " \n", " if status in [\"error\", \"failed\"]:\n", " raise RuntimeError(f\"Generation failed: {gen_status}\")\n", " \n", " return final_clips[0]['id'], final_clips[1]['id']" ] }, { "cell_type": "code", "execution_count": 8, "id": "5984169c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "'aligned_words'\n", "'aligned_words'\n" ] } ], "source": [ "remix1, remix2 = create_remix(clip_id)" ] }, { "cell_type": "code", "execution_count": 9, "id": "f411a3f6", "metadata": {}, "outputs": [], "source": [ "original_lyrics = get_lyrics(clip_id)\n", "lyrics_remix1 = get_lyrics(remix1)\n", "lyrics_remix2 = get_lyrics(remix2)" ] }, { "cell_type": "code", "execution_count": 10, "id": "57dca940", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(249, 249)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def make_cleaned_lyrics(lyrics:dict):\n", " return [item for sublist in ([[i['start_s'], i['end_s']] for i in lyrics['aligned_words']]) for item in sublist]\n", "\n", "cleaned_lyrics1 = make_cleaned_lyrics(original_lyrics)\n", "cleaned_lyrics2 = make_cleaned_lyrics(lyrics_remix1)\n", "cleaned_lyrics3 = make_cleaned_lyrics(lyrics_remix2)\n", "\n", "original_remix = list(zip(cleaned_lyrics1, cleaned_lyrics2))\n", "deduped = sorted({item[0]: item for item in original_remix}.values(), key=lambda x: x[0])\n", "\n", "dd_original = [item[0] for item in deduped]\n", "dd_remix1 = [item[1] for item in deduped]\n", "len(dd_original), len(dd_remix1)" ] }, { "cell_type": "code", "execution_count": 11, "id": "98ac17db", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from scipy.interpolate import CubicSpline\n", "import cv2\n", "import matplotlib.pyplot as plt\n", "import os\n", "import subprocess\n", "import tempfile\n", "\n", "def create_smooth_time_warp(original_times, target_times, total_duration):\n", " \"\"\"\n", " Create a smooth time warping function using cubic spline interpolation.\n", " \"\"\"\n", " # Ensure endpoints are included\n", " if original_times[0] != 0:\n", " original_times = [0] + list(original_times)\n", " target_times = [0] + list(target_times)\n", " \n", " if original_times[-1] != total_duration:\n", " original_times = list(original_times) + [total_duration]\n", " target_times = list(target_times) + [total_duration]\n", " \n", " # Create cubic spline interpolation\n", " cs = CubicSpline(original_times, target_times, bc_type='natural')\n", " \n", " return cs\n", "\n", "def visualize_warp_function(warp_func, total_duration, original_times, target_times):\n", " \"\"\"Visualize the time warping function.\"\"\"\n", " t = np.linspace(0, total_duration, 1000)\n", " warped_t = warp_func(t)\n", " \n", " plt.figure(figsize=(10, 6))\n", " plt.plot(t, warped_t, 'b-', label='Smooth warp function')\n", " plt.plot(t, t, 'k--', alpha=0.5, label='Linear (no warp)')\n", " plt.scatter(original_times, target_times, color='red', s=50, zorder=5, label='Control points')\n", " \n", " plt.xlabel('Original Time (seconds)')\n", " plt.ylabel('Warped Time (seconds)')\n", " plt.title('Time Warping Function')\n", " plt.legend()\n", " plt.grid(True, alpha=0.3)\n", " plt.show()\n", "\n", "def warp_video_core(input_path, output_path, original_times, target_times, visualize=True):\n", " \"\"\"\n", " Core video warping function without audio.\n", " \"\"\"\n", " # Open video\n", " cap = cv2.VideoCapture(input_path)\n", " if not cap.isOpened():\n", " raise ValueError(f\"Cannot open video file: {input_path}\")\n", " \n", " fps = cap.get(cv2.CAP_PROP_FPS)\n", " total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n", " width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n", " height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n", " total_duration = total_frames / fps\n", " \n", " print(f\"Input video info:\")\n", " print(f\" Resolution: {width}x{height}\")\n", " print(f\" FPS: {fps}\")\n", " print(f\" Duration: {total_duration:.2f}s\")\n", " \n", " # Create warp function\n", " warp_func = create_smooth_time_warp(original_times, target_times, total_duration)\n", " \n", " if visualize:\n", " visualize_warp_function(warp_func, total_duration, original_times, target_times)\n", " \n", " # Setup output video\n", " fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n", " out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))\n", " \n", " if not out.isOpened():\n", " # Try alternative codec\n", " fourcc = cv2.VideoWriter_fourcc(*'XVID')\n", " output_path = output_path.replace('.mp4', '.avi')\n", " out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))\n", " \n", " if not out.isOpened():\n", " raise ValueError(\"Failed to open video writer\")\n", " \n", " # Calculate output duration\n", " output_duration = warp_func(total_duration)\n", " output_frames = int(output_duration * fps)\n", " \n", " print(f\"\\nProcessing video...\")\n", " print(f\"Output duration: {output_duration:.2f}s\")\n", " \n", " # Process video frames\n", " for out_frame_idx in range(output_frames):\n", " out_time = out_frame_idx / fps\n", " \n", " # Binary search for input time\n", " left, right = 0, total_duration\n", " while right - left > 1e-6:\n", " mid = (left + right) / 2\n", " if warp_func(mid) < out_time:\n", " left = mid\n", " else:\n", " right = mid\n", " \n", " input_time = (left + right) / 2\n", " input_frame_idx = int(input_time * fps)\n", " input_frame_idx = min(max(0, input_frame_idx), total_frames - 1)\n", " \n", " cap.set(cv2.CAP_PROP_POS_FRAMES, input_frame_idx)\n", " ret, frame = cap.read()\n", " \n", " if ret and frame is not None:\n", " out.write(frame)\n", " \n", " if out_frame_idx % 30 == 0:\n", " progress = ((out_frame_idx + 1) / output_frames) * 100\n", " print(f\"Progress: {progress:.1f}%\", end='\\r')\n", " \n", " print(\"\\n\\nVideo warping complete!\")\n", " \n", " # Release resources\n", " cap.release()\n", " out.release()\n", " cv2.destroyAllWindows()\n", " \n", " return output_path, output_duration\n", "\n", "def add_audio_ffmpeg(video_path, audio_path, output_path, audio_start_time=0, \n", " audio_volume=1.0, preserve_original_audio=False, video_duration=None):\n", " \"\"\"\n", " Add audio to video using ffmpeg directly.\n", " \"\"\"\n", " print(\"\\nAdding audio with ffmpeg...\")\n", " \n", " # Build ffmpeg command\n", " cmd = ['ffmpeg', '-i', video_path]\n", " \n", " if audio_path:\n", " cmd.extend(['-i', audio_path])\n", " \n", " # Video codec (copy without re-encoding)\n", " cmd.extend(['-c:v', 'copy'])\n", " \n", " # Audio processing\n", " if audio_path:\n", " filter_parts = []\n", " \n", " # Apply volume adjustment\n", " if audio_volume != 1.0:\n", " filter_parts.append(f\"[1:a]volume={audio_volume}[vol]\")\n", " audio_ref = \"[vol]\"\n", " else:\n", " audio_ref = \"[1:a]\"\n", " \n", " # Apply delay if needed\n", " if audio_start_time > 0:\n", " delay_ms = int(audio_start_time * 1000)\n", " filter_parts.append(f\"{audio_ref}adelay={delay_ms}|{delay_ms}[delayed]\")\n", " audio_ref = \"[delayed]\"\n", " \n", " # Trim audio if video is shorter\n", " if video_duration:\n", " filter_parts.append(f\"{audio_ref}atrim=0:{video_duration}[final]\")\n", " audio_ref = \"[final]\"\n", " \n", " if filter_parts:\n", " cmd.extend(['-filter_complex', ';'.join(filter_parts)])\n", " cmd.extend(['-map', '0:v', '-map', f'{audio_ref}'])\n", " else:\n", " cmd.extend(['-map', '0:v', '-map', '1:a'])\n", " \n", " # Audio codec\n", " cmd.extend(['-c:a', 'aac'])\n", " \n", " # Cut to video length\n", " cmd.extend(['-shortest'])\n", " \n", " # Output\n", " cmd.extend(['-y', output_path])\n", " \n", " try:\n", " # Run ffmpeg\n", " result = subprocess.run(cmd, capture_output=True, text=True)\n", " if result.returncode != 0:\n", " print(f\"ffmpeg stderr: {result.stderr}\")\n", " return False\n", " print(f\"Audio added successfully!\")\n", " return True\n", " except FileNotFoundError:\n", " print(\"ffmpeg not found. Please install ffmpeg:\")\n", " print(\" - Ubuntu/Debian: sudo apt-get install ffmpeg\")\n", " print(\" - macOS: brew install ffmpeg\")\n", " print(\" - Windows: Download from https://ffmpeg.org/download.html\")\n", " return False\n", "\n", "def warp_video_with_audio(input_path, output_path, original_times, target_times,\n", " audio_path=None, audio_start_time=0, audio_volume=1.0,\n", " preserve_original_audio=False, visualize=True):\n", " \"\"\"\n", " Complete function to warp video and add audio.\n", " \"\"\"\n", " # Create temporary file for warped video\n", " temp_video = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name\n", " \n", " try:\n", " # Step 1: Create warped video\n", " warped_path, video_duration = warp_video_core(\n", " input_path, temp_video, original_times, target_times, visualize\n", " )\n", " \n", " # Step 2: Add audio if provided\n", " if audio_path and os.path.exists(audio_path):\n", " success = add_audio_ffmpeg(\n", " warped_path, audio_path, output_path,\n", " audio_start_time, audio_volume, preserve_original_audio,\n", " video_duration\n", " )\n", " \n", " if success:\n", " os.unlink(temp_video)\n", " else:\n", " # If audio addition failed, just use the warped video\n", " print(\"Audio addition failed, keeping video without audio\")\n", " os.rename(temp_video, output_path)\n", " else:\n", " # No audio to add, just rename the warped video\n", " os.rename(temp_video, output_path)\n", " \n", " print(f\"\\nFinal output saved to: {output_path}\")\n", " \n", " except Exception as e:\n", " print(f\"Error: {e}\")\n", " if os.path.exists(temp_video):\n", " os.unlink(temp_video)\n", " raise" ] }, { "cell_type": "code", "execution_count": 14, "id": "6640fb4d", "metadata": {}, "outputs": [], "source": [ "url = f'https://cdn1.suno.ai/{remix1}.mp3'\n", "file_path = os.path.join(temp_dir.name, 'song_audio.mp3')\n", "response = requests.get(url)\n", "response.raise_for_status() # Raises an exception for bad status codes\n", "\n", "with open(file_path, 'wb') as f:\n", " f.write(response.content)" ] }, { "cell_type": "code", "execution_count": 15, "id": "70808d99", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Input video info:\n", " Resolution: 1080x1920\n", " FPS: 30.32763723150358\n", " Duration: 34.95s\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Processing video...\n", "Output duration: 34.95s\n", "Progress: 99.2%\n", "\n", "Video warping complete!\n", "\n", "Adding audio with ffmpeg...\n", "Audio added successfully!\n", "\n", "Final output saved to: /var/folders/ly/kj0fsj152c5_wz64hcbvn2kc0000gn/T/tmpm7k0enzx/warped_video.mp4\n" ] } ], "source": [ "# Basic warping\n", "warp_video_with_audio(\n", " input_path=mp4,\n", " output_path=f\"{temp_dir.name}/warped_video.mp4\",\n", " original_times=dd_original,\n", " target_times=dd_remix1,\n", " visualize=True,\n", " preserve_original_audio=False,\n", " audio_path=f'{temp_dir.name}/song_audio.mp3'\n", ")\n", "\n", "# Or use the version with frame interpolation for smoother results\n", "# warp_video_with_interpolation(\n", "# input_path=\"input_video.mp4\",\n", "# output_path=\"warped_smooth_video.mp4\",\n", "# original_times=original_times,\n", "# target_times=target_times,\n", "# visualize=True\n", "# )" ] }, { "cell_type": "code", "execution_count": 17, "id": "6b8d67c8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'/var/folders/ly/kj0fsj152c5_wz64hcbvn2kc0000gn/T/tmpm7k0enzx/warped_video.mp4'" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f\"{temp_dir.name}/warped_video.mp4\"" ] }, { "cell_type": "code", "execution_count": 18, "id": "e8adda89", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'https://cdn1.suno.ai/6b416d4c-661f-4305-bc6f-b7f6e87880bd.mp3'" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "url" ] }, { "cell_type": "code", "execution_count": null, "id": "932cec3b", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": ".venv", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 5 }