A Kontur.Talk call — a ready video for social media

Set up OBS Studio on this Mac so that I can record Kontur.Talk calls as ready-to-post social media videos. You have access to my computer: do the work yourself and only ask me where my decision or a system permission is needed.

## The result

Two frame layouts:
- Landscape 16:9 (1920×1080): the screen fills the frame, two 280 px circles bottom right — me and the guest from Kontur.Talk.
- Portrait 9:16 (1080×1920): the screen at the top (a 1080×675 area, 260 px from the top edge), two 440 px circles below it. The top ~250 px and bottom ~450 px are covered by captions and buttons in Reels and Shorts, so nothing goes there.

Each layout has one scene, "Talk recording", with these sources:
- "Full screen" — display capture (visible);
- "Claude window" — application capture of Claude (hidden);
- "Browser window" — capture of a single Chrome window, 230 px cropped off the top: tab strip, address bar, bookmarks (hidden);
- "Me — camera" — built-in camera, filters: light colour correction and a circle mask, with a white ring on top;
- "Guest — Talk window" — window capture of Kontur.Talk, filters: crop to the guest's tile, colour correction, circle mask, with a ring on top;
- "Talk audio (guest)" — audio of the Kontur.Talk app, plus "My microphone".
Audio on the screen, window and camera sources is muted so voices are not doubled.

## Order of work

1. Check this is macOS. On Windows, stop and tell me: the sources are named differently there and the plan needs adapting.
2. Install OBS Studio if it is missing: `brew install --cask obs`, or, without Homebrew, ask me to download the installer from obsproject.com. Launch OBS. If the auto-configuration wizard opens, close it.
3. I grant system permissions myself. Ask me to allow OBS access to the camera, the microphone and "Screen & System Audio Recording" (System Settings → Privacy & Security). OBS has to be restarted after screen recording is allowed.
4. Create the masks and scene files with the script below. It needs Python 3 with Pillow: if Pillow is missing, run `pip3 install --user pillow`. The script puts everything into "Movies/OBS for Talk".
5. In OBS: menu Scene Collection → Import, add both "Talk recording 16x9.json" and "Talk recording 9x16.json", click Import.
6. Profiles: Profile → Duplicate → "Landscape 16x9", then again → "Portrait 9x16". In each, Settings → Video: Base (Canvas) Resolution and Output (Scaled) Resolution — 1920x1080 or 1080x1920. Settings → Output → Recording: Recording Quality — "High Quality, Medium File Size", Recording Format — "Hybrid MP4", Video Encoder — "Hardware (Apple, H.264)". Recording path — Movies.
7. Pick the devices in each of the two collections (switch with Profile + Scene Collection). Double-clicking a source opens its properties:
   - "Full screen": Display — the built-in display;
   - "Claude window": Display — the built-in display, Application — Claude;
   - "Me — camera": Device — FaceTime HD Camera, Preset — High;
   - "Guest — Talk window": Method — Window Capture, Window — the Kontur.Talk window (app name "Толк"). Kontur.Talk must be open;
   - leave "Browser window" empty unless I ask otherwise.
8. Check visually: screenshot the preview of both layouts — circles are round, the screen is in place. Make a 10-second test recording and check the file: `ffprobe` should report H.264, AAC and the right resolution.
9. Tell me briefly what is done and what is left to me: pointing the guest's circle at their face during a real call (the "Crop guest tile" filter, fields X, Y, Width, Height; width = height).

OBS labels may differ slightly between versions and interface languages — go by meaning.

## Known pitfalls

- The camera circle is empty after switching collections: the 1920x1080 preset is sometimes unavailable. Use "High".
- "Paste (Duplicate)" is not available for screen capture sources in OBS: a new capture source has to be created from scratch with "+".
- OBS does not see hidden or minimised windows. For the browser window, turn on the option to show fullscreen and hidden windows, and un-minimise the window.
- What gets recorded is the Program view. If Studio Mode is on and Program is empty, click Transition.
- Kontur.Talk rearranges its window while sharing a screen, so the guest's crop is tuned during the call.
- Suggest recording in headphones, otherwise the guest's voice reaches the microphone twice.

## Script

```python
import json, uuid
from pathlib import Path
from PIL import Image, ImageDraw

D = Path.home() / "Movies" / "OBS for Talk"
D.mkdir(parents=True, exist_ok=True)

# --- masks and ring ---
def draw(w, h, box, ring=0):
    s = 4
    im = Image.new("RGBA", (w * s, h * s), (0, 0, 0, 0))
    d = ImageDraw.Draw(im)
    b = [v * s for v in box]
    b[2] -= 1; b[3] -= 1
    if ring:
        d.ellipse(b, outline=(255, 255, 255, 255), width=ring * s)
    else:
        d.ellipse(b, fill=(255, 255, 255, 255))
    return im.resize((w, h), Image.LANCZOS)

draw(1000, 1000, (0, 0, 1000, 1000)).save(D / "circle-mask.png")
draw(1920, 1080, (420, 0, 1500, 1080)).save(D / "circle-mask-16x9.png")
draw(1000, 1000, (0, 0, 1000, 1000), ring=14).save(D / "circle-ring.png")

# --- scene collections ---
P = str(D) + "/"
HK = {"libobs.mute": [], "libobs.unmute": [], "libobs.push-to-mute": [], "libobs.push-to-talk": []}

def src(name, id_, settings, vid=None, filters=None, mixers=255, mute=False):
    s = {"prev_ver": 537001986, "name": name, "uuid": str(uuid.uuid4()), "id": id_,
         "versioned_id": vid or id_, "settings": settings, "mixers": mixers, "sync": 0,
         "flags": 0, "volume": 1.0, "balance": 0.5, "enabled": True, "muted": mute,
         "push-to-mute": False, "push-to-mute-delay": 0, "push-to-talk": False,
         "push-to-talk-delay": 0, "hotkeys": dict(HK), "deinterlace_mode": 0,
         "deinterlace_field_order": 0, "monitoring_type": 0, "private_settings": {}}
    if filters:
        s["filters"] = filters
    return s

def flt(name, id_, settings, vid=None):
    return {"prev_ver": 537001986, "name": name, "uuid": str(uuid.uuid4()), "id": id_,
            "versioned_id": vid or id_, "settings": settings, "enabled": True,
            "mixers": 0, "sync": 0, "flags": 0, "volume": 1.0, "balance": 0.5, "muted": False,
            "hotkeys": {}, "deinterlace_mode": 0, "deinterlace_field_order": 0,
            "monitoring_type": 0, "private_settings": {}}

def look():
    return flt("Light colour correction", "color_filter",
               {"gamma": -0.08, "brightness": 0.02, "contrast": 0.06, "saturation": 0.10,
                "hue_shift": 0.0, "opacity": 1.0, "color_multiply": 4293850879,
                "color_add": 4278190080}, "color_filter_v2")

def mask(path):
    return flt("Circle", "mask_filter",
               {"type": "mask_alpha_filter.effect", "image_path": path}, "mask_filter_v2")

def collection(name, W, H, L):
    screen = src("Full screen", "screen_capture", {"type": 0, "show_cursor": True, "hide_obs": True}, mute=True)
    claude = src("Claude window", "screen_capture", {"type": 2, "application": "com.anthropic.claudefordesktop",
                 "show_cursor": True, "hide_obs": True}, mute=True)
    browser = src("Browser window", "screen_capture", {"type": 1, "show_cursor": True}, mute=True)
    cam = src("Me — camera", "macos-avcapture", {"use_preset": True, "preset": "AVCaptureSessionPresetHigh"},
              filters=[look(), mask(P + "circle-mask-16x9.png")], mute=True)
    talk = src("Guest — Talk window", "screen_capture", {"type": 1, "show_cursor": False},
               filters=[flt("Crop guest tile", "crop_filter",
                            {"relative": False, "left": 0, "top": 0, "cx": 600, "cy": 600}),
                        look(), mask(P + "circle-mask.png")], mute=True)
    talk_audio = src("Talk audio (guest)", "sck_audio_capture", {"type": 1, "application": "kontur.talk"})
    ring_me = src("Ring — me", "image_source", {"file": P + "circle-ring.png"})
    ring_talk = src("Ring — guest", "image_source", {"file": P + "circle-ring.png"})
    bg = src("Background", "color_source", {"color": 4280295456, "width": W, "height": H}, "color_source_v3")

    items, hot = [], {"OBSBasic.SelectScene": []}
    def item(s, x, y, bw, bh, btype=2, crop=False, visible=True, top=0):
        i = len(items) + 1
        hot[f"libobs.show_scene_item.{i}"] = []
        hot[f"libobs.hide_scene_item.{i}"] = []
        items.append({"name": s["name"], "source_uuid": s["uuid"], "visible": visible, "locked": False,
                      "rot": 0.0, "align": 5, "bounds_type": btype, "bounds_align": 0, "bounds_crop": crop,
                      "crop_left": 0, "crop_top": top, "crop_right": 0, "crop_bottom": 0, "id": i,
                      "group_item_backup": False, "pos": {"x": float(x), "y": float(y)},
                      "scale": {"x": 1.0, "y": 1.0}, "bounds": {"x": float(bw), "y": float(bh)},
                      "scale_filter": "disable", "blend_method": "default", "blend_type": "normal",
                      "show_transition": {"duration": 300}, "hide_transition": {"duration": 300},
                      "private_settings": {}})
    item(bg, 0, 0, W, H, btype=1)
    item(screen, *L["screen"])
    item(browser, *L["screen"], visible=False, top=230)  # 230 px off the top: tab strip, address bar, bookmarks
    item(claude, *L["screen"], visible=False)
    item(talk, *L["talk"])
    item(ring_talk, *L["talk"])
    item(cam, *L["me"], btype=3, crop=True)
    item(ring_me, *L["me"])
    item(talk_audio, 0, 0, 0, 0, btype=0)

    scene = src("Talk recording", "scene", {"id_counter": len(items), "custom_size": False, "items": items}, mixers=0)
    scene["hotkeys"] = hot
    scene["canvas_uuid"] = "6c69626f-6273-4c00-9d88-c5136d61696e"
    return {"name": name,
            "AuxAudioDevice1": src("My microphone", "coreaudio_input_capture", {"device_id": "default"}),
            "groups": [], "scene_order": [{"name": "Talk recording"}],
            "current_scene": "Talk recording", "current_program_scene": "Talk recording",
            "canvases": [], "current_transition": "Fade", "transition_duration": 300,
            "transitions": [], "quick_transitions": [], "saved_projectors": [], "preview_locked": False,
            "scaling_enabled": False, "scaling_level": 0, "scaling_off_x": 0.0, "scaling_off_y": 0.0,
            "modules": {}, "resolution": {"x": W, "y": H}, "version": 2,
            "sources": [screen, browser, claude, cam, talk, talk_audio, ring_me, ring_talk, bg, scene]}

d, m, g = 280, 40, 24
h = collection("Talk recording 16x9", 1920, 1080, {"screen": (0, 0, 1920, 1080),
               "me": (1920 - m - d, 1080 - m - d, d, d), "talk": (1920 - m - 2 * d - g, 1080 - m - d, d, d)})
d, g = 440, 60
x0 = (1080 - 2 * d - g) // 2
v = collection("Talk recording 9x16", 1080, 1920, {"screen": (0, 260, 1080, 675),
               "talk": (x0, 1010, d, d), "me": (x0 + d + g, 1010, d, d)})
for c in (h, v):
    (D / f"{c['name']}.json").write_text(json.dumps(c, ensure_ascii=False, indent=2), encoding="utf-8")
print("Done:", D)
```