fix(nodes): pass display resolution to VA-API encoders (fixes #292)

The AV1 encoder was passing only the superblock-aligned coded resolution
to cros-codecs, which set render_width/render_height in the AV1 frame
header to the coded dimensions.  For non-aligned inputs (e.g. 1280×720
→ coded 1280×768), decoders would show 48 pixels of black padding at
the bottom.

Add a display_resolution field to the vendored cros-codecs AV1
EncoderConfig and use it for render_width/render_height in the frame
header predictor.  When display differs from coded dimensions, the AV1
bitstream now signals render_and_frame_size_different=1 so decoders
crop the superblock padding.

For H.264, the SpsBuilder::resolution() method already handles
macroblock alignment and frame_crop offsets automatically, but we were
passing the pre-aligned coded resolution, bypassing the cropping logic.
Now we pass the original display resolution and let SpsBuilder compute
the correct frame_crop offsets.

Closes #292

Signed-off-by: StreamKit Devin <devin@streamkit.dev>
Co-Authored-By: Claudio Costa <cstcld91@gmail.com>

Author: streamkit-devin

crates/nodes/src/video/vaapi_av1.rs

@@ -973,10 +973,20 @@ impl StandardVideoEncoder for VaapiAv1Encoder {
             }
         };
 
+        // Pass display_resolution so the AV1 frame header sets
+        // render_width/render_height to the visible area, not the
+        // superblock-aligned coded dimensions (fixes #292).
+        let display_res = if width != coded_width || height != coded_height {
+            Some(CrosResolution { width, height })
+        } else {
+            None
+        };
+
         let cros_config = CrosEncoderConfig {
             profile: Av1Profile::Profile0,
             bit_depth: cros_codecs::codec::av1::parser::BitDepth::Depth8,
             resolution: CrosResolution { width: coded_width, height: coded_height },
+            display_resolution: display_res,
             pred_structure: PredictionStructure::LowDelay { limit: 1024 },
             initial_tunings: Tunings {
                 rate_control: RateControl::ConstantQuality(config.quality),

crates/nodes/src/video/vaapi_h264.rs

@@ -737,8 +737,11 @@ impl StandardVideoEncoder for VaapiH264Encoder {
             }
         };
 
+        // Pass the display resolution (not the macroblock-aligned coded
+        // resolution) so SpsBuilder::resolution() computes frame_crop offsets
+        // automatically, preventing visible padding bars (fixes #292).
         let cros_config = CrosH264EncoderConfig {
-            resolution: CrosResolution { width: coded_width, height: coded_height },
+            resolution: CrosResolution { width, height },
             profile: H264Profile::Main,
             level: H264Level::L4,
             pred_structure: PredictionStructure::LowDelay { limit: 1024 },

vendor/cros-codecs/src/encoder/av1.rs

@@ -15,6 +15,10 @@ pub struct EncoderConfig {
     pub profile: Profile,
     pub bit_depth: BitDepth,
     pub resolution: Resolution,
+    /// Display resolution (visible area) when it differs from coded resolution.
+    /// Used to set `render_width`/`render_height` in the AV1 frame header so
+    /// decoders crop superblock-alignment padding instead of showing black bars.
+    pub display_resolution: Option<Resolution>,
     pub pred_structure: PredictionStructure,
     /// Initial tunings values
     pub initial_tunings: Tunings,
@@ -27,6 +31,7 @@ impl Default for EncoderConfig {
             profile: Profile::Profile0,
             bit_depth: BitDepth::Depth8,
             resolution: Resolution { width: 320, height: 240 },
+            display_resolution: None,
             pred_structure: PredictionStructure::LowDelay { limit: 1024 },
             initial_tunings: Default::default(),
         }

vendor/cros-codecs/src/encoder/stateless/av1/predictor.rs

@@ -136,6 +136,14 @@ impl<Picture, Reference> LowDelayAV1<Picture, Reference> {
         let width = self.delegate.config.resolution.width;
         let height = self.delegate.config.resolution.height;
 
+        // Use display resolution for render_width/render_height when the
+        // visible area is smaller than the coded frame (superblock alignment
+        // padding).  This sets render_and_frame_size_different=1 in the frame
+        // header so decoders crop the padding instead of showing black bars.
+        let display = self.delegate.config.display_resolution.as_ref();
+        let render_width = display.map_or(width, |r| r.width);
+        let render_height = display.map_or(height, |r| r.height);
+
         // Superblock size
         let sb_size = if self.delegate.sequence.use_128x128_superblock { 128 } else { 64 };
 
@@ -213,8 +221,8 @@ impl<Picture, Reference> LowDelayAV1<Picture, Reference> {
             upscaled_width: width,
             frame_width: width,
             frame_height: height,
-            render_width: width,
-            render_height: height,
+            render_width,
+            render_height,
 
             ..Default::default()
         })