Upload 38 files

renderer/audio/mixer.py

@@ -19,14 +19,48 @@ class AudioMixer:
             "[ducked][voice]amix=inputs=2:duration=first:dropout_transition=2[aout]"
         )
 
-    def mix(self, video: Path, music: str | None, voiceover: str | None, output: Path, normalize: bool = False) -> Path:
+    def mix(
+        self,
+        video: Path,
+        music: str | None,
+        voiceover: str | None,
+        output: Path,
+        normalize: bool = False,
+        *,
+        duration: float | None = None,
+        music_volume: float = 0.316,
+        music_fade_in: float = 0.0,
+        music_fade_out: float = 0.0,
+        music_loop: bool = True,
+        music_start: float = 0.0,
+        music_ducking: bool = True,
+        voice_volume: float = 1.0,
+    ) -> Path:
         audio_tail = ",loudnorm=I=-16:TP=-1.5:LRA=11" if normalize else ""
         if not music and not voiceover:
             command = FFmpegCommand().add("-hide_banner").input(video).add("-c", "copy").overwrite().add(output).build()
             self.runner.run(command)
             return output
         if voiceover and music:
-            ducking_filter = self.ducking_filter()
+            music_filter = _music_filter(
+                music_volume,
+                fade_in=music_fade_in,
+                fade_out=music_fade_out,
+                duration=duration,
+            )
+            if music_ducking:
+                ducking_filter = (
+                    f"[1:a]{music_filter}[music];"
+                    "[music][2:a]sidechaincompress=threshold=0.02:ratio=8:attack=30:release=600[ducked];"
+                    f"[2:a]volume={voice_volume}[voice];"
+                    "[ducked][voice]amix=inputs=2:duration=first:dropout_transition=2[aout]"
+                )
+            else:
+                ducking_filter = (
+                    f"[1:a]{music_filter}[music];"
+                    f"[2:a]volume={voice_volume}[voice];"
+                    "[music][voice]amix=inputs=2:duration=first:dropout_transition=2[aout]"
+                )
             if normalize:
                 ducking_filter += ";[aout]loudnorm=I=-16:TP=-1.5:LRA=11[anorm]"
                 audio_map = "[anorm]"
@@ -36,7 +70,7 @@ class AudioMixer:
                 FFmpegCommand()
                 .add("-hide_banner")
                 .input(video)
-                .input(music)
+                .input(music, **_music_input_options(music_loop, music_start))
                 .input(voiceover)
                 .add("-filter_complex", ducking_filter)
                 .add("-map", "0:v", "-map", audio_map, "-c:v", "copy", "-c:a", "aac", "-shortest")
@@ -46,13 +80,17 @@ class AudioMixer:
             )
         else:
             audio = voiceover or music
-            volume = "1.0" if voiceover else "0.316"
+            input_options = {} if voiceover else _music_input_options(music_loop, music_start)
+            volume = voice_volume if voiceover else music_volume
+            audio_filter = f"volume={volume}"
+            if music and not voiceover:
+                audio_filter = _music_filter(music_volume, fade_in=music_fade_in, fade_out=music_fade_out, duration=duration)
             command = (
                 FFmpegCommand()
                 .add("-hide_banner")
                 .input(video)
-                .input(audio)
-                .add("-filter_complex", f"[1:a]volume={volume}{audio_tail}[aout]")
+                .input(audio, **input_options)
+                .add("-filter_complex", f"[1:a]{audio_filter}{audio_tail}[aout]")
                 .add("-map", "0:v", "-map", "[aout]", "-c:v", "copy", "-c:a", "aac", "-shortest")
                 .overwrite()
                 .add(output)
@@ -60,3 +98,21 @@ class AudioMixer:
             )
         self.runner.run(command)
         return output
+
+
+def _music_input_options(loop: bool, start: float) -> dict[str, object]:
+    options: dict[str, object] = {}
+    if loop:
+        options["stream_loop"] = -1
+    if start > 0:
+        options["ss"] = start
+    return options
+
+
+def _music_filter(volume: float, *, fade_in: float, fade_out: float, duration: float | None) -> str:
+    filters = [f"volume={volume}"]
+    if fade_in > 0:
+        filters.append(f"afade=t=in:st=0:d={fade_in}")
+    if fade_out > 0 and duration and duration > fade_out:
+        filters.append(f"afade=t=out:st={max(0.0, duration - fade_out):.3f}:d={fade_out}")
+    return ",".join(filters)

renderer/core/models.py

@@ -24,9 +24,17 @@ class RenderRequest:
     scenes: list[Scene]
     template: str = "tiktok_classic"
     preset: str | None = None
+    platform: str | None = None
     output_name: str = "render.mp4"
     voiceover: str | None = None
     background_music: str | None = None
+    music_volume: float = 0.316
+    music_fade_in: float = 0.0
+    music_fade_out: float = 0.0
+    music_loop: bool = True
+    music_start: float = 0.0
+    music_ducking: bool = True
+    voice_volume: float = 1.0
     subtitle_format: Literal["srt", "ass"] = "ass"
     auto_subtitles: bool = False
     subtitle_language: str | None = None
@@ -51,8 +59,16 @@ class AIReelsRequest:
     voiceover: str
     assets: list[str]
     template: str = "tiktok_classic"
+    platform: str | None = None
     output_name: str = "ai_reel.mp4"
     background_music: str | None = None
+    music_volume: float = 0.316
+    music_fade_in: float = 0.0
+    music_fade_out: float = 0.0
+    music_loop: bool = True
+    music_start: float = 0.0
+    music_ducking: bool = True
+    voice_volume: float = 1.0
 
 
 @dataclass

renderer/core/render_engine.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations
 
 import mimetypes
 import shutil
@@ -17,6 +17,7 @@ from renderer.ffmpeg.normalize import Normalizer
 from renderer.ffmpeg.runner import FFmpegRunner
 from renderer.scenes import Timeline
 from renderer.subtitles import SubtitleGenerator
+from renderer.templates import PlatformProfile, get_platform_profile
 from renderer.transcription import WhisperTranscriber
 from renderer.transitions import TransitionBuilder
 
@@ -49,14 +50,31 @@ class RenderEngine:
             prepared = self._prepare_scene_media(resolved, workdir)
             subtitles = self._write_subtitles(resolved, timeline, workdir)
             video = self._compose_video(prepared, resolved, subtitles, workdir)
-            mixed = self.audio.mix(video, resolved.background_music, resolved.voiceover, workdir / "mixed.mp4", normalize=resolved.audio_normalize)
+            mixed = self.audio.mix(
+                video,
+                resolved.background_music,
+                resolved.voiceover,
+                workdir / "mixed.mp4",
+                normalize=resolved.audio_normalize,
+                duration=timeline.total_duration,
+                music_volume=resolved.music_volume,
+                music_fade_in=resolved.music_fade_in,
+                music_fade_out=resolved.music_fade_out,
+                music_loop=resolved.music_loop,
+                music_start=resolved.music_start,
+                music_ducking=resolved.music_ducking,
+                voice_volume=resolved.voice_volume,
+            )
             mixed = self._apply_watermark(mixed, resolved, workdir)
-            output = self.exports.save(mixed, job_id, request.output_name)
+            optimized = self._optimize_for_platform(mixed, resolved, workdir)
+            output = self.exports.save(optimized, job_id, request.output_name)
             cleanup_directory(workdir, keep={mixed})
+        profile = self._profile(request)
         metrics = {
             "render_time_seconds": round(time.time() - started, 3),
             "output_size_bytes": output.stat().st_size,
             "scene_count": len(request.scenes),
+            "platform": profile.metadata(),
         }
         return RenderResult(output_path=output, commands=list(self._commands), metrics=metrics, logs=list(self._logs))
 
@@ -84,9 +102,17 @@ class RenderEngine:
             render_request = RenderRequest(
                 scenes=Timeline.request_from_payload({"scenes": scenes}).scenes,
                 template=resolved.template,
+                platform=resolved.platform,
                 output_name=resolved.output_name,
                 voiceover=resolved.voiceover,
                 background_music=resolved.background_music,
+                music_volume=resolved.music_volume,
+                music_fade_in=resolved.music_fade_in,
+                music_fade_out=resolved.music_fade_out,
+                music_loop=resolved.music_loop,
+                music_start=resolved.music_start,
+                music_ducking=resolved.music_ducking,
+                voice_volume=resolved.voice_volume,
             )
             return self._render_resolved(render_request, job_id, workdir)
 
@@ -122,27 +148,45 @@ class RenderEngine:
         prepared = self._prepare_scene_media(request, workdir)
         subtitles = self._write_subtitles(request, timeline, workdir)
         video = self._compose_video(prepared, request, subtitles, workdir)
-        mixed = self.audio.mix(video, request.background_music, request.voiceover, workdir / "mixed.mp4", normalize=request.audio_normalize)
+        mixed = self.audio.mix(
+            video,
+            request.background_music,
+            request.voiceover,
+            workdir / "mixed.mp4",
+            normalize=request.audio_normalize,
+            duration=timeline.total_duration,
+            music_volume=request.music_volume,
+            music_fade_in=request.music_fade_in,
+            music_fade_out=request.music_fade_out,
+            music_loop=request.music_loop,
+            music_start=request.music_start,
+            music_ducking=request.music_ducking,
+            voice_volume=request.voice_volume,
+        )
         mixed = self._apply_watermark(mixed, request, workdir)
-        output = self.exports.save(mixed, job_id, request.output_name)
+        optimized = self._optimize_for_platform(mixed, request, workdir)
+        output = self.exports.save(optimized, job_id, request.output_name)
+        profile = self._profile(request)
         metrics = {
             "render_time_seconds": round(time.time() - started, 3),
             "output_size_bytes": output.stat().st_size,
             "scene_count": len(request.scenes),
+            "platform": profile.metadata(),
         }
         return RenderResult(output_path=output, commands=list(self._commands), metrics=metrics, logs=list(self._logs))
 
     def _prepare_scene_media(self, request: RenderRequest, workdir: Path) -> list[Path]:
         prepared: list[Path] = []
+        profile = self._profile(request)
         for idx, scene in enumerate(request.scenes):
             source = Path(scene.media)
             metadata = self.assets.probe(source)
             target = workdir / f"scene_{idx:03d}.mp4"
             mime_type = metadata.mime_type or mimetypes.guess_type(str(source))[0] or ""
             if mime_type.startswith("image/") or source.suffix.lower() in {".jpg", ".jpeg", ".png", ".webp", ".gif"}:
-                self.normalizer.image_to_video(source, target, scene.duration)
-            elif request.normalize and self.normalizer.needs_normalization(metadata):
-                self.normalizer.normalize(source, target, scene.duration)
+                self.normalizer.image_to_video(source, target, scene.duration, profile=profile)
+            elif request.normalize and self.normalizer.needs_normalization(metadata, profile=profile):
+                self.normalizer.normalize(source, target, scene.duration, profile=profile)
             else:
                 shutil.copy2(source, target)
             if request.preview:
@@ -230,6 +274,66 @@ class RenderEngine:
         self._run(command)
         return output
 
+    def _optimize_for_platform(self, video: Path, request: RenderRequest, workdir: Path) -> Path:
+        profile = self._profile(request)
+        output = workdir / "platform_optimized.mp4"
+        vf = (
+            f"scale={profile.width}:{profile.height}:force_original_aspect_ratio=increase,"
+            f"crop={profile.width}:{profile.height},fps={profile.fps},format=yuv420p"
+        )
+        command_builder = (
+            FFmpegCommand()
+            .add("-hide_banner")
+            .input(video)
+            .add(
+                "-vf",
+                vf,
+                "-c:v",
+                profile.video_codec,
+                "-profile:v",
+                "high",
+                "-pix_fmt",
+                "yuv420p",
+                "-preset",
+                self.settings.preset,
+                "-crf",
+                profile.crf,
+                "-r",
+                profile.fps,
+                "-g",
+                max(1, profile.fps * 2),
+            )
+        )
+        if profile.maxrate:
+            command_builder.add("-maxrate", profile.maxrate)
+        if profile.bufsize:
+            command_builder.add("-bufsize", profile.bufsize)
+        command = (
+            command_builder.add(
+                "-c:a",
+                profile.audio_codec,
+                "-b:a",
+                profile.audio_bitrate,
+                "-ar",
+                profile.audio_sample_rate,
+                "-ac",
+                "2",
+                "-movflags",
+                "+faststart",
+                "-shortest",
+            )
+            .overwrite()
+            .add(output)
+            .build()
+        )
+        self._run(command)
+        return output
+
+    def _profile(self, request: RenderRequest) -> PlatformProfile:
+        profile_key = request.platform or request.metadata.get("platform") or request.metadata.get("target_platform")
+        return get_platform_profile(str(profile_key) if profile_key else None)
+
+
     def _scale_preview(self, source: Path, output: Path) -> None:
         command = (
             FFmpegCommand()
@@ -262,3 +366,4 @@ def _split_script(script: str, chunks: int) -> list[str]:
 
 def _ffmpeg_subtitle_path(path: Path) -> str:
     return str(path).replace("\\", "/").replace(":", r"\:")
+

renderer/ffmpeg/normalize.py

@@ -6,6 +6,7 @@ from renderer.core.config import Settings
 from renderer.core.models import AssetMetadata
 from renderer.ffmpeg.command import FFmpegCommand
 from renderer.ffmpeg.runner import FFmpegRunner
+from renderer.templates import PlatformProfile
 
 
 class Normalizer:
@@ -13,27 +14,34 @@ class Normalizer:
         self.settings = settings
         self.runner = runner
 
-    def needs_normalization(self, metadata: AssetMetadata) -> bool:
+    def needs_normalization(self, metadata: AssetMetadata, profile: PlatformProfile | None = None) -> bool:
+        width = profile.width if profile else self.settings.output_width
+        height = profile.height if profile else self.settings.output_height
+        fps = profile.fps if profile else self.settings.output_fps
         return not (
-            metadata.width == self.settings.output_width
-            and metadata.height == self.settings.output_height
-            and round(metadata.fps or 0) == self.settings.output_fps
+            metadata.width == width
+            and metadata.height == height
+            and round(metadata.fps or 0) == fps
             and metadata.video_codec == "h264"
             and (metadata.audio_codec in ("aac", None))
         )
 
-    def normalize(self, path: str | Path, output: Path, duration: float | None = None) -> Path:
+    def normalize(self, path: str | Path, output: Path, duration: float | None = None, profile: PlatformProfile | None = None) -> Path:
+        width = profile.width if profile else self.settings.output_width
+        height = profile.height if profile else self.settings.output_height
+        fps = profile.fps if profile else self.settings.output_fps
+        crf = profile.crf if profile else self.settings.crf
         vf = (
-            f"scale={self.settings.output_width}:{self.settings.output_height}:"
+            f"scale={width}:{height}:"
             "force_original_aspect_ratio=increase,"
-            f"crop={self.settings.output_width}:{self.settings.output_height},"
-            f"fps={self.settings.output_fps},format=yuv420p"
+            f"crop={width}:{height},"
+            f"fps={fps},format=yuv420p"
         )
         cmd = (
             FFmpegCommand()
             .add("-hide_banner")
             .input(path)
-            .add("-vf", vf, "-c:v", "libx264", "-preset", self.settings.preset, "-crf", self.settings.crf)
+            .add("-vf", vf, "-c:v", "libx264", "-preset", self.settings.preset, "-crf", crf)
             .add("-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart")
         )
         if duration:
@@ -42,18 +50,22 @@ class Normalizer:
         self.runner.run(command)
         return output
 
-    def image_to_video(self, path: str | Path, output: Path, duration: float) -> Path:
+    def image_to_video(self, path: str | Path, output: Path, duration: float, profile: PlatformProfile | None = None) -> Path:
+        width = profile.width if profile else self.settings.output_width
+        height = profile.height if profile else self.settings.output_height
+        fps = profile.fps if profile else self.settings.output_fps
+        crf = profile.crf if profile else self.settings.crf
         vf = (
-            f"scale={self.settings.output_width}:{self.settings.output_height}:"
+            f"scale={width}:{height}:"
             "force_original_aspect_ratio=increase,"
-            f"crop={self.settings.output_width}:{self.settings.output_height},"
-            f"fps={self.settings.output_fps},format=yuv420p"
+            f"crop={width}:{height},"
+            f"fps={fps},format=yuv420p"
         )
         command = (
             FFmpegCommand()
             .add("-hide_banner", "-loop", "1", "-t", duration)
             .input(path)
-            .add("-vf", vf, "-an", "-c:v", "libx264", "-preset", self.settings.preset, "-crf", self.settings.crf)
+            .add("-vf", vf, "-an", "-c:v", "libx264", "-preset", self.settings.preset, "-crf", crf)
             .overwrite()
             .add(output)
             .build()

renderer/scenes/timeline.py

@@ -18,9 +18,18 @@ class Timeline:
         return RenderRequest(
             scenes=scenes,
             template=payload.get("template", "tiktok_classic"),
+            preset=payload.get("preset"),
+            platform=payload.get("platform"),
             output_name=payload.get("output_name", "render.mp4"),
             voiceover=payload.get("voiceover"),
             background_music=payload.get("background_music"),
+            music_volume=payload.get("music_volume", 0.316),
+            music_fade_in=payload.get("music_fade_in", 0.0),
+            music_fade_out=payload.get("music_fade_out", 0.0),
+            music_loop=payload.get("music_loop", True),
+            music_start=payload.get("music_start", 0.0),
+            music_ducking=payload.get("music_ducking", True),
+            voice_volume=payload.get("voice_volume", 1.0),
             subtitle_format=payload.get("subtitle_format", "ass"),
             auto_subtitles=payload.get("auto_subtitles", False),
             subtitle_language=payload.get("subtitle_language"),

renderer/templates/__init__.py

@@ -1,4 +1,15 @@
 from renderer.templates.caption_templates import CaptionTemplate, get_template, list_templates
+from renderer.templates.platforms import PlatformProfile, get_platform_profile, list_platform_profiles, platform_profile_metadata
 from renderer.templates.presets import apply_preset, list_presets
 
-__all__ = ["CaptionTemplate", "apply_preset", "get_template", "list_presets", "list_templates"]
+__all__ = [
+    "CaptionTemplate",
+    "PlatformProfile",
+    "apply_preset",
+    "get_platform_profile",
+    "get_template",
+    "list_platform_profiles",
+    "list_presets",
+    "list_templates",
+    "platform_profile_metadata",
+]

renderer/templates/platforms.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PlatformProfile:
+    key: str
+    label: str
+    width: int
+    height: int
+    fps: int = 30
+    video_codec: str = "libx264"
+    audio_codec: str = "aac"
+    audio_bitrate: str = "128k"
+    audio_sample_rate: int = 48000
+    crf: int = 23
+    maxrate: str | None = None
+    bufsize: str | None = None
+    max_duration_seconds: int | None = None
+    recommended_duration_seconds: tuple[int, int] | None = None
+    safe_zones: dict[str, int] = field(default_factory=dict)
+    notes: tuple[str, ...] = ()
+
+    @property
+    def aspect_ratio(self) -> str:
+        return f"{self.width}:{self.height}"
+
+    def metadata(self) -> dict[str, Any]:
+        return {
+            "platform": self.key,
+            "label": self.label,
+            "width": self.width,
+            "height": self.height,
+            "fps": self.fps,
+            "aspect_ratio": self.aspect_ratio,
+            "video_codec": self.video_codec,
+            "audio_codec": self.audio_codec,
+            "audio_bitrate": self.audio_bitrate,
+            "max_duration_seconds": self.max_duration_seconds,
+            "recommended_duration_seconds": self.recommended_duration_seconds,
+            "safe_zones": self.safe_zones,
+            "notes": list(self.notes),
+        }
+
+
+COMMON_VERTICAL_SAFE_ZONES = {
+    "top_px": 220,
+    "bottom_px": 340,
+    "left_px": 80,
+    "right_px": 80,
+}
+
+
+PLATFORM_PROFILES: dict[str, PlatformProfile] = {
+    "tiktok": PlatformProfile(
+        key="tiktok",
+        label="TikTok vertical",
+        width=1080,
+        height=1920,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=600,
+        recommended_duration_seconds=(12, 60),
+        safe_zones=COMMON_VERTICAL_SAFE_ZONES,
+        notes=(
+            "9:16 vertical MP4 keeps the frame full-screen in the For You feed.",
+            "Use licensed or original music to avoid muted audio or takedowns.",
+        ),
+    ),
+    "instagram_reels": PlatformProfile(
+        key="instagram_reels",
+        label="Instagram Reels",
+        width=1080,
+        height=1920,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=180,
+        recommended_duration_seconds=(7, 90),
+        safe_zones=COMMON_VERTICAL_SAFE_ZONES,
+        notes=(
+            "9:16 is the safest Reels export to avoid cropping or blank space.",
+            "Keep captions and logos away from top and bottom app chrome.",
+        ),
+    ),
+    "facebook_reels": PlatformProfile(
+        key="facebook_reels",
+        label="Facebook Reels",
+        width=1080,
+        height=1920,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=180,
+        recommended_duration_seconds=(7, 90),
+        safe_zones=COMMON_VERTICAL_SAFE_ZONES,
+    ),
+    "youtube_shorts": PlatformProfile(
+        key="youtube_shorts",
+        label="YouTube Shorts",
+        width=1080,
+        height=1920,
+        fps=30,
+        audio_bitrate="192k",
+        maxrate="10M",
+        bufsize="20M",
+        max_duration_seconds=180,
+        recommended_duration_seconds=(15, 60),
+        safe_zones={"top_px": 180, "bottom_px": 300, "left_px": 80, "right_px": 80},
+        notes=(
+            "YouTube categorizes square or vertical videos up to 3 minutes as Shorts.",
+            "Avoid Content ID-claimed music in Shorts longer than 60 seconds.",
+        ),
+    ),
+    "youtube_1080p": PlatformProfile(
+        key="youtube_1080p",
+        label="YouTube 1080p landscape",
+        width=1920,
+        height=1080,
+        fps=30,
+        audio_bitrate="192k",
+        maxrate="12M",
+        bufsize="24M",
+        recommended_duration_seconds=(60, 600),
+        notes=("16:9 H.264/AAC output for standard YouTube uploads.",),
+    ),
+    "instagram_feed_square": PlatformProfile(
+        key="instagram_feed_square",
+        label="Instagram feed square",
+        width=1080,
+        height=1080,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=3600,
+        recommended_duration_seconds=(5, 60),
+        safe_zones={"top_px": 80, "bottom_px": 120, "left_px": 80, "right_px": 80},
+    ),
+    "instagram_feed_portrait": PlatformProfile(
+        key="instagram_feed_portrait",
+        label="Instagram feed portrait",
+        width=1080,
+        height=1350,
+        fps=30,
+        maxrate="8M",
+        bufsize="16M",
+        max_duration_seconds=3600,
+        recommended_duration_seconds=(5, 60),
+        safe_zones={"top_px": 80, "bottom_px": 140, "left_px": 80, "right_px": 80},
+    ),
+}
+
+
+def get_platform_profile(key: str | None) -> PlatformProfile:
+    if not key:
+        return PLATFORM_PROFILES["tiktok"]
+    return PLATFORM_PROFILES.get(key, PLATFORM_PROFILES["tiktok"])
+
+
+def list_platform_profiles() -> list[str]:
+    return sorted(PLATFORM_PROFILES)
+
+
+def platform_profile_metadata() -> dict[str, dict[str, Any]]:
+    return {key: profile.metadata() for key, profile in sorted(PLATFORM_PROFILES.items())}

renderer/templates/presets.py

@@ -6,6 +6,7 @@ from typing import Any
 
 PRESETS: dict[str, dict[str, Any]] = {
     "tiktok_9_16_fast": {
+        "platform": "tiktok",
         "template": "tiktok_classic",
         "subtitle_format": "ass",
         "auto_subtitles": True,
@@ -13,12 +14,14 @@ PRESETS: dict[str, dict[str, Any]] = {
         "normalize": True,
     },
     "youtube_shorts_hd": {
+        "platform": "youtube_shorts",
         "template": "youtube_shorts",
         "subtitle_format": "ass",
         "auto_subtitles": True,
         "normalize": True,
     },
     "podcast_square": {
+        "platform": "instagram_feed_square",
         "template": "podcast_style",
         "subtitle_format": "ass",
         "auto_subtitles": True,
@@ -26,17 +29,53 @@ PRESETS: dict[str, dict[str, Any]] = {
         "metadata": {"target_aspect": "1:1"},
     },
     "reels_with_subtitles": {
+        "platform": "instagram_reels",
         "template": "modern_minimal",
         "subtitle_format": "ass",
         "auto_subtitles": True,
         "normalize": True,
     },
     "draft_preview": {
+        "platform": "tiktok",
         "template": "modern_minimal",
         "subtitle_format": "ass",
         "preview": True,
         "normalize": True,
     },
+    "tiktok_music_ducked": {
+        "platform": "tiktok",
+        "template": "tiktok_classic",
+        "subtitle_format": "ass",
+        "auto_subtitles": True,
+        "audio_normalize": True,
+        "music_volume": 0.25,
+        "music_fade_in": 0.4,
+        "music_fade_out": 1.0,
+        "music_loop": True,
+        "music_ducking": True,
+        "normalize": True,
+    },
+    "instagram_reels_music": {
+        "platform": "instagram_reels",
+        "template": "modern_minimal",
+        "subtitle_format": "ass",
+        "auto_subtitles": True,
+        "audio_normalize": True,
+        "music_volume": 0.28,
+        "music_fade_in": 0.3,
+        "music_fade_out": 0.8,
+        "music_loop": True,
+        "music_ducking": True,
+        "normalize": True,
+    },
+    "youtube_landscape_1080p": {
+        "platform": "youtube_1080p",
+        "template": "news_style",
+        "subtitle_format": "ass",
+        "auto_subtitles": False,
+        "audio_normalize": True,
+        "normalize": True,
+    },
 }