phonto 0.2.0

GPU-accelerated video wallpaper program for wayland compositors & MacOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

mod loop_observer;
mod screen_observer;

use std::path::Path;

use anyhow::Context;
use objc2::sel;
use objc2_app_kit::{
    NSApplication, NSApplicationActivationPolicy,
    NSApplicationDidChangeScreenParametersNotification, NSBackingStoreType, NSColor, NSScreen,
    NSView, NSWindow, NSWindowCollectionBehavior, NSWindowSharingType, NSWindowStyleMask,
};
use objc2_av_foundation::{
    AVPlayer, AVPlayerItem, AVPlayerItemDidPlayToEndTimeNotification, AVPlayerLayer,
};
use objc2_foundation::{MainThreadMarker, NSNotificationCenter, NSString, NSURL};
use objc2_quartz_core::CAAutoresizingMask;

use self::loop_observer::LoopObserver;
use self::screen_observer::ScreenObserver;
use super::Backend;

// One below kCGDesktopWindowLevel so a static system wallpaper sits on top of us.
const WALLPAPER_LEVEL: isize = -2_147_483_624;

pub struct MacosBackend {
    mtm: MainThreadMarker,
}

impl MacosBackend {
    pub fn new() -> anyhow::Result<Self> {
        let mtm = MainThreadMarker::new()
            .context("macOS backend must be constructed on the main thread")?;
        Ok(Self { mtm })
    }
}

impl Backend for MacosBackend {
    fn run(self, video_path: String) -> anyhow::Result<()> {
        let mtm = self.mtm;

        let app = NSApplication::sharedApplication(mtm);
        app.setActivationPolicy(NSApplicationActivationPolicy::Accessory);
        app.finishLaunching();

        let screen = NSScreen::mainScreen(mtm).context("no main screen")?;
        let frame = screen.frame();
        let backing_scale = screen.backingScaleFactor();

        let window = unsafe {
            NSWindow::initWithContentRect_styleMask_backing_defer(
                mtm.alloc::<NSWindow>(),
                frame,
                NSWindowStyleMask::Borderless,
                NSBackingStoreType::Buffered,
                false,
            )
        };
        window.setLevel(WALLPAPER_LEVEL);
        window.setCollectionBehavior(
            NSWindowCollectionBehavior::CanJoinAllSpaces
                | NSWindowCollectionBehavior::FullScreenAuxiliary
                | NSWindowCollectionBehavior::Stationary
                | NSWindowCollectionBehavior::IgnoresCycle,
        );
        window.setOpaque(false);
        window.setBackgroundColor(Some(&NSColor::clearColor()));
        window.setHasShadow(false);
        // `ReadOnly` so screen-capture / screen-sharing can read us. `None` blocks them.
        window.setSharingType(NSWindowSharingType::ReadOnly);
        window.setIgnoresMouseEvents(true);

        let content_view = NSView::initWithFrame(mtm.alloc::<NSView>(), frame);
        content_view.setWantsLayer(true);
        window.setContentView(Some(&content_view));

        // AVAsset resolves relative paths against the process cwd, which isn't
        // what users expect from `phonto ./video.mp4`.
        let abs = Path::new(&video_path)
            .canonicalize()
            .unwrap_or_else(|_| Path::new(&video_path).to_path_buf());
        let path_ns = NSString::from_str(&abs.to_string_lossy());
        let url = NSURL::fileURLWithPath(&path_ns);

        let item = unsafe { AVPlayerItem::playerItemWithURL(&url, mtm) };
        let player = unsafe { AVPlayer::playerWithPlayerItem(Some(&item), mtm) };
        unsafe {
            player.setMuted(true);
        }

        let player_layer = unsafe { AVPlayerLayer::playerLayerWithPlayer(Some(&player)) };
        player_layer.setFrame(content_view.bounds());
        player_layer.setAutoresizingMask(
            CAAutoresizingMask::LayerWidthSizable | CAAutoresizingMask::LayerHeightSizable,
        );
        player_layer.setContentsScale(backing_scale);

        let root_layer = content_view
            .layer()
            .context("content view has no root layer")?;
        root_layer.addSublayer(&player_layer);

        // Loop: AVPlayer posts AVPlayerItemDidPlayToEndTimeNotification when the
        // item reaches its end. The observer seeks back to zero and resumes.
        let loop_observer = LoopObserver::new(player.clone());
        unsafe {
            NSNotificationCenter::defaultCenter().addObserver_selector_name_object(
                &loop_observer,
                sel!(itemEnded:),
                Some(AVPlayerItemDidPlayToEndTimeNotification),
                None,
            );
        }

        // Re-apply geometry on display reconfiguration.
        let screen_observer = ScreenObserver::new(window.clone(), player_layer.clone());
        unsafe {
            NSNotificationCenter::defaultCenter().addObserver_selector_name_object(
                &screen_observer,
                sel!(screensChanged:),
                Some(NSApplicationDidChangeScreenParametersNotification),
                None,
            );
        }

        window.makeKeyAndOrderFront(None);
        unsafe { player.play() };

        log::info!(
            "macOS backend ready: {}x{} window at level {}",
            frame.size.width as u32,
            frame.size.height as u32,
            WALLPAPER_LEVEL,
        );

        app.run();
        drop(loop_observer);
        drop(screen_observer);

        Ok(())
    }
}