Support the fractional scaling wayland protocol.

https://wayland.app/protocols/fractional-scale-v1

Reel sound rather generic to me, and currently is only a placeholder name. This issue is to decide on a final name for the product and update all references to "Reel" in this repo.

Implement the audio input interface for all Audio backends on Linux

• Pulse
• Pipewire
• Jack
• Alsa

Implement a widget that visualises the volume of the microphone in real time.

Currently the Simple API is used for audio capture for the pulse audio backend, this is a synchronous API that blocks in the main app loop. It's fine for now, but will need to be upgrade later on.

Compile and statically link both libraries if possible to reduce runtime deps

On Fedora / Gnome, resizing the application is very laggy. This issue isn't present with Sway

Add a build test to the CI that installs all the required dependencies and builds an executable

Currently text and icon are treated as if full images that are supposed to be mapped exactly as-is. The renderer should be updated so that these textures are uploaded as a 1-channel image and color is set on a per-vertex basis

Steps to reproduce:

Using sway, open the application and press the full-screen shortcut (Mod+f).

Expected:

Application runs as normal and remains responsive. Will resize framebuffer when application window is resized

Actual:

Application stops being responsive and updating UI in any way

To reproduce:

1. Add a screencast source
2. Add a webcam source
3. Click record

Expected:

The webcam source is always visible above the screencast source as it was added after it

Actual:

There is some flickering where the screencast source is visible over the webcam source.

NOTE: This behavior isn't present in the preview image, only in the recording.

When recording laptop screen, the webcam has a very low FPS. This issue isn't present using the wlroots backend so perhaps is something that could be fixed.

Currently output filename for each recording is hard-coded and non-changing

When application is hidden (E.g minimized, otherwise not shown on final composited image), CPU usage spikes quite a bit.

When converting from RGBA to NV12 (Y420), the UV values are downscaled by 2 horizontally and vertically. The current implementation just averages the values of each 2x2 pixel block.

As a result, pixel blocks that contain very distinct colors end up getting interpolated into colors that don't exist in the block at all. The simple linear interpolation should be replaced with something more sophisticated to improve this.

Currently if there isn't support for VAAPI the application isn't able to record. Support for non-hardware accelerated video encoding should be brought back

Pipewire backend is only returning frames in BGRx format, even though I'm able to get RGBA with wlroots backend. Reel should be able to support a list of reasonable pixel formats and use vulkan for most of the required conversions.

Implement reading from webcam and displaying on screen

I've noted that certain vertical placements cause the texture mapping of text to be distorted. This might also be an issue horizontally.

ffmpeg / libav provides options for what the quality / compression of the video should be. This should be exposed to the UI so that at the very least the user can select a quality of high, medium and low.

Allow for specifying what interface to use at runtime. Examples would be headless, cli and wayland_vulkan

Headless would basically be no UI, and you can only interact with the core via IPC.

Displayed text sometimes has incorrect horizontal spacing. This fix needs to happen in fontana

The current renderer uses the painters algorithm to place objects in front of others. This method doesn't scale well however and should be replaced with proper depth culling

This is most likely due to getting unexpected messages from pipewires Dbus api.

Implement & test screen capture on KDE based desktop environments.

As part of wayland core, the compositor can request that the application apply scaling.

https://wayland.app/protocols/wayland#wl_surface:request:set_buffer_scale

User should be able to select from some common format types such as MP4, AVI, etc before starting a recording

GenericVertex type stores both UV and Color values using f32. I think it would be more efficient to store these values as ints and do the conversion in the shader. Issue is to investigate this claim and refactor if there are no found performance detriments.

For color: Store as u8 and in shader divide by 255
For UV: Store as u16 and divide by texture dimensions (Can be hardcoded into shader or passed as push constants)

Current GenericVertex definition:

pub const GenericVertex = extern struct {
    x: f32 = 1.0,
    y: f32 = 1.0,
    tx: f32 = 1.0,
    ty: f32 = 1.0,
    color: RGBA(f32) = .{
        .r = 1.0,
        .g = 1.0,
        .b = 1.0,
        .a = 1.0,
    },
};

You should be able to initiate a Wayland move when you click and drag the windows decoration bar.

Implement & test screen capture on mutter based desktop environments (E.g Gnome)

Using the wayland frame callback to set the PTS isn't very reliable because we aren't given assurances about how often it will be called. Better to switch to calculating pts manually from timestamps