02f4a19 Merge branch 'feat/cef-linux-audio-output' into feat/cef-engine-adapter · dumber

M go.mod +3 -0


@@ -5,6 +5,7 @@ go 1.26.1
5	require (	5		require (
6	github.com/bnema/purego-cef v0.8.0	6		github.com/bnema/purego-cef v0.8.0
7	github.com/bnema/purego-ffmpeg v0.3.0	7		github.com/bnema/purego-ffmpeg v0.3.0
		8	+	github.com/bnema/purego-pipewire v0.0.0-00010101000000-000000000000
8	github.com/bnema/purego-sqlite v0.1.1	9		github.com/bnema/purego-sqlite v0.1.1
9	github.com/bnema/puregotk v0.3.0	10		github.com/bnema/puregotk v0.3.0
10	github.com/bnema/puregotk-webkit v0.0.16	11		github.com/bnema/puregotk-webkit v0.0.16

@@ -30,6 +31,8 @@ replace github.com/bnema/purego-cef => ../purego-cef
30		31
31	replace github.com/bnema/purego-ffmpeg => ../purego-ffmpeg	32		replace github.com/bnema/purego-ffmpeg => ../purego-ffmpeg
32		33
		34	+	replace github.com/bnema/purego-pipewire => ../../../purego-pipewire/.worktrees/dumber-cef-audio
		35	+
33	require (	36		require (
34	github.com/atotto/clipboard v0.1.4 // indirect	37		github.com/atotto/clipboard v0.1.4 // indirect
35	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect	38		github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect

A internal/application/port/audio_output.go +34 -0

@@ -0,0 +1,34 @@
	1	+	// Package port defines application-layer interfaces for external capabilities.
	2	+	// This file defines the Audio Output port for CEF audio streaming on Linux.
	3	+	package port
	4	+
	5	+	import "context"
	6	+
	7	+	// AudioStreamFormat represents the audio stream format configuration.
	8	+	// This is a value object that describes how audio data should be streamed.
	9	+	type AudioStreamFormat struct {
	10	+	// SampleRate is the audio sample rate in Hz (e.g., 48000, 44100).
	11	+	SampleRate int
	12	+	// ChannelCount is the number of audio channels (e.g., 1 for mono, 2 for stereo).
	13	+	ChannelCount int
	14	+	// FramesPerBuffer is the number of frames per buffer (e.g., 512, 1024).
	15	+	FramesPerBuffer int
	16	+	}
	17	+
	18	+	// AudioOutputStream represents an active audio output stream.
	19	+	// Implementations handle the low-level audio playback.
	20	+	type AudioOutputStream interface {
	21	+	// Write sends audio samples to the output device.
	22	+	// Samples are provided as a 2D slice: [channel][frame]float32.
	23	+	// This matches CEF's planar float32 audio format.
	24	+	Write(samples [][]float32) error
	25	+	// Close releases the audio stream and associated resources.
	26	+	Close() error
	27	+	}
	28	+
	29	+	// AudioOutputFactory creates audio output streams.
	30	+	// This is the primary interface for the audio output port.
	31	+	type AudioOutputFactory interface {
	32	+	// NewStream creates a new audio output stream with the given format.
	33	+	NewStream(ctx context.Context, format AudioStreamFormat) (AudioOutputStream, error)
	34	+	}

A internal/application/port/audio_output_test.go +51 -0

@@ -0,0 +1,51 @@
	1	+	package port_test
	2	+
	3	+	import (
	4	+	"context"
	5	+	"testing"
	6	+
	7	+	"github.com/bnema/dumber/internal/application/port"
	8	+	"github.com/stretchr/testify/assert"
	9	+	)
	10	+
	11	+	// TestAudioOutputPortContract verifies that the Audio Output port contract
	12	+	// matches the approved design exactly.
	13	+	func TestAudioOutputPortContract(t *testing.T) {
	14	+	t.Run("AudioStreamFormat is a struct with correct fields", func(t *testing.T) {
	15	+	format := port.AudioStreamFormat{
	16	+	SampleRate: 48000,
	17	+	ChannelCount: 2,
	18	+	FramesPerBuffer: 512,
	19	+	}
	20	+
	21	+	assert.Equal(t, 48000, format.SampleRate)
	22	+	assert.Equal(t, 2, format.ChannelCount)
	23	+	assert.Equal(t, 512, format.FramesPerBuffer)
	24	+	})
	25	+
	26	+	t.Run("AudioOutputStream interface has Write with [][]float32", func(_ *testing.T) {
	27	+	var _ port.AudioOutputStream = (*mockAudioOutputStream)(nil)
	28	+	})
	29	+
	30	+	t.Run("AudioOutputFactory has NewStream with context and format", func(_ *testing.T) {
	31	+	var _ port.AudioOutputFactory = (*mockAudioOutputFactory)(nil)
	32	+	})
	33	+	}
	34	+
	35	+	// mockAudioOutputStream is a test mock for the AudioOutputStream interface
	36	+	type mockAudioOutputStream struct{}
	37	+
	38	+	func (*mockAudioOutputStream) Write(_ [][]float32) error {
	39	+	return nil
	40	+	}
	41	+
	42	+	func (*mockAudioOutputStream) Close() error {
	43	+	return nil
	44	+	}
	45	+
	46	+	// mockAudioOutputFactory is a test mock for the AudioOutputFactory interface
	47	+	type mockAudioOutputFactory struct{}
	48	+
	49	+	func (*mockAudioOutputFactory) NewStream(_ context.Context, _ port.AudioStreamFormat) (port.AudioOutputStream, error) {
	50	+	return &mockAudioOutputStream{}, nil
	51	+	}

M internal/bootstrap/engine.go +3 -1

 	"fmt"
 	"github.com/bnema/dumber/internal/application/port"
+	audiofactory "github.com/bnema/dumber/internal/infrastructure/audio/factory"
 	"github.com/bnema/dumber/internal/infrastructure/cef"
 	"github.com/bnema/dumber/internal/infrastructure/config"
 	"github.com/bnema/dumber/internal/infrastructure/webkit"
 		)
 	case config.EngineTypeCEF:
 		cefCfg := cfg.Engine.CEF
-		return cef.NewEngine(input.Ctx, cefCfg, cfg.Transcoding)
+		audioFactory := audiofactory.NewAudioOutputFactory()
+		return cef.NewEngine(input.Ctx, cefCfg, cfg.Transcoding, audioFactory)
 	default:
 		return nil, fmt.Errorf("unknown engine type: %q", engineType)
 	}

M internal/bootstrap/handler_deps.go +1 -1


@@ -12,7 +12,7 @@ import (
12		// BuildHandlerDeps constructs handler dependencies from the config manager.	12		// BuildHandlerDeps constructs handler dependencies from the config manager.
13		// It combines keybinding use cases and config save into a single struct.	13		// It combines keybinding use cases and config save into a single struct.
14		// The context is accepted for future use (e.g., passing to constructors that may need cancellation).	14		// The context is accepted for future use (e.g., passing to constructors that may need cancellation).
15	-	func BuildHandlerDeps(ctx context.Context) (*port.HandlerDeps, error) {	15	+	func BuildHandlerDeps(_ context.Context) (*port.HandlerDeps, error) {
16		mgr := config.GetManager()	16		mgr := config.GetManager()
17		if mgr == nil {	17		if mgr == nil {
18		return nil, fmt.Errorf("config manager not initialized")	18		return nil, fmt.Errorf("config manager not initialized")

A internal/infrastructure/audio/factory/output.go +65 -0

@@ -0,0 +1,65 @@
	1	+	// Package factory provides audio backend selection with fallback support.
	2	+	package factory
	3	+
	4	+	import (
	5	+	"context"
	6	+	"errors"
	7	+	"fmt"
	8	+
	9	+	"github.com/bnema/dumber/internal/application/port"
	10	+	"github.com/bnema/dumber/internal/infrastructure/audio/null"
	11	+	"github.com/bnema/dumber/internal/infrastructure/audio/pipewire"
	12	+	)
	13	+
	14	+	// Selector chooses between a primary and fallback audio backend.
	15	+	// If the primary backend fails to create a stream, it falls back to the fallback.
	16	+	type Selector struct {
	17	+	Primary port.AudioOutputFactory
	18	+	Fallback port.AudioOutputFactory
	19	+	}
	20	+
	21	+	// NewStream attempts to create a stream from the primary backend.
	22	+	// If that fails, it falls back to the fallback backend.
	23	+	// Returns an error only if both backends fail.
	24	+	func (s *Selector) NewStream(ctx context.Context, format port.AudioStreamFormat) (port.AudioOutputStream, error) {
	25	+	if s.Primary != nil {
	26	+	stream, err := s.Primary.NewStream(ctx, format)
	27	+	if err == nil {
	28	+	return stream, nil
	29	+	}
	30	+
	31	+	// Primary failed, try fallback
	32	+	if s.Fallback != nil {
	33	+	fallbackStream, fallbackErr := s.Fallback.NewStream(ctx, format)
	34	+	if fallbackErr == nil {
	35	+	return fallbackStream, nil
	36	+	}
	37	+	return nil, fmt.Errorf("audio backends failed: %w", errors.Join(err, fallbackErr))
	38	+	}
	39	+	return nil, fmt.Errorf("primary failed: %w; no fallback configured", err)
	40	+	}
	41	+
	42	+	// No primary, try fallback only
	43	+	if s.Fallback != nil {
	44	+	return s.Fallback.NewStream(ctx, format)
	45	+	}
	46	+
	47	+	return nil, errors.New("no audio backend configured")
	48	+	}
	49	+
	50	+	// NewAudioOutputFactory creates the primary audio output factory with PipeWire
	51	+	// as the primary backend and null as the fallback.
	52	+	// If PipeWire stream creation fails at runtime, the Selector falls back to the
	53	+	// null backend automatically.
	54	+	func NewAudioOutputFactory() port.AudioOutputFactory {
	55	+	pwFactory, err := pipewire.NewFactory()
	56	+	if err != nil {
	57	+	// Unexpected failure; use null fallback only
	58	+	return &null.Factory{}
	59	+	}
	60	+
	61	+	return &Selector{
	62	+	Primary: pwFactory,
	63	+	Fallback: &null.Factory{},
	64	+	}
	65	+	}

A internal/infrastructure/audio/factory/output_test.go +172 -0

@@ -0,0 +1,172 @@
	1	+	package factory
	2	+
	3	+	import (
	4	+	"context"
	5	+	"errors"
	6	+	"testing"
	7	+
	8	+	"github.com/bnema/dumber/internal/application/port"
	9	+	"github.com/bnema/dumber/internal/infrastructure/audio/null"
	10	+	)
	11	+
	12	+	// failingFactory is a factory that always returns an error
	13	+	type failingFactory struct {
	14	+	err error
	15	+	}
	16	+
	17	+	func (f *failingFactory) NewStream(_ context.Context, _ port.AudioStreamFormat) (port.AudioOutputStream, error) {
	18	+	return nil, f.err
	19	+	}
	20	+
	21	+	func TestSelector_PrimaryFails_FallsBackToFallback(t *testing.T) {
	22	+	// Arrange
	23	+	primaryErr := errors.New("primary backend unavailable")
	24	+	primary := &failingFactory{err: primaryErr}
	25	+	fallback := &null.Factory{}
	26	+
	27	+	selector := &Selector{
	28	+	Primary: primary,
	29	+	Fallback: fallback,
	30	+	}
	31	+
	32	+	format := port.AudioStreamFormat{
	33	+	SampleRate: 48000,
	34	+	ChannelCount: 2,
	35	+	FramesPerBuffer: 512,
	36	+	}
	37	+	ctx := context.Background()
	38	+
	39	+	// Act
	40	+	stream, err := selector.NewStream(ctx, format)
	41	+
	42	+	// Assert
	43	+	if err != nil {
	44	+	t.Fatalf("Expected no error when fallback succeeds, got: %v", err)
	45	+	}
	46	+	if stream == nil {
	47	+	t.Fatal("Expected non-nil stream from fallback")
	48	+	}
	49	+
	50	+	// Verify the stream works (it's the null stream)
	51	+	samples := make([][]float32, format.ChannelCount)
	52	+	for i := range samples {
	53	+	samples[i] = make([]float32, format.FramesPerBuffer)
	54	+	}
	55	+
	56	+	if err := stream.Write(samples); err != nil {
	57	+	t.Errorf("Write failed: %v", err)
	58	+	}
	59	+	if err := stream.Close(); err != nil {
	60	+	t.Errorf("Close failed: %v", err)
	61	+	}
	62	+	}
	63	+
	64	+	func TestSelector_PrimarySucceeds_UsesPrimary(t *testing.T) {
	65	+	// Arrange
	66	+	primary := &null.Factory{} // Using null as primary for simplicity
	67	+	fallback := &failingFactory{err: errors.New("fallback should not be called")}
	68	+
	69	+	selector := &Selector{
	70	+	Primary: primary,
	71	+	Fallback: fallback,
	72	+	}
	73	+
	74	+	format := port.AudioStreamFormat{
	75	+	SampleRate: 48000,
	76	+	ChannelCount: 2,
	77	+	FramesPerBuffer: 512,
	78	+	}
	79	+	ctx := context.Background()
	80	+
	81	+	// Act
	82	+	stream, err := selector.NewStream(ctx, format)
	83	+
	84	+	// Assert
	85	+	if err != nil {
	86	+	t.Fatalf("Expected no error, got: %v", err)
	87	+	}
	88	+	if stream == nil {
	89	+	t.Fatal("Expected non-nil stream from primary")
	90	+	}
	91	+
	92	+	// Verify the stream works
	93	+	samples := make([][]float32, format.ChannelCount)
	94	+	for i := range samples {
	95	+	samples[i] = make([]float32, format.FramesPerBuffer)
	96	+	}
	97	+
	98	+	if err := stream.Write(samples); err != nil {
	99	+	t.Errorf("Write failed: %v", err)
	100	+	}
	101	+	if err := stream.Close(); err != nil {
	102	+	t.Errorf("Close failed: %v", err)
	103	+	}
	104	+	}
	105	+
	106	+	func TestSelector_BothFail_ReturnsError(t *testing.T) {
	107	+	// Arrange
	108	+	primaryErr := errors.New("primary backend unavailable")
	109	+	fallbackErr := errors.New("fallback backend unavailable")
	110	+
	111	+	selector := &Selector{
	112	+	Primary: &failingFactory{err: primaryErr},
	113	+	Fallback: &failingFactory{err: fallbackErr},
	114	+	}
	115	+
	116	+	format := port.AudioStreamFormat{
	117	+	SampleRate: 48000,
	118	+	ChannelCount: 2,
	119	+	FramesPerBuffer: 512,
	120	+	}
	121	+	ctx := context.Background()
	122	+
	123	+	// Act
	124	+	stream, err := selector.NewStream(ctx, format)
	125	+
	126	+	// Assert
	127	+	if err == nil {
	128	+	t.Fatal("Expected error when both backends fail")
	129	+	}
	130	+	if stream != nil {
	131	+	t.Error("Expected nil stream when both backends fail")
	132	+	}
	133	+	}
	134	+
	135	+	// TestNewAudioOutputFactory_ReturnsWorkingFactory verifies that
	136	+	// NewAudioOutputFactory returns a working Selector with PipeWire primary
	137	+	// and null fallback.
	138	+	func TestNewAudioOutputFactory_ReturnsWorkingFactory(t *testing.T) {
	139	+	factory := NewAudioOutputFactory()
	140	+	if factory == nil {
	141	+	t.Fatal("Expected non-nil factory")
	142	+	}
	143	+
	144	+	// Verify the factory produces a working stream
	145	+	format := port.AudioStreamFormat{
	146	+	SampleRate: 48000,
	147	+	ChannelCount: 2,
	148	+	FramesPerBuffer: 512,
	149	+	}
	150	+	ctx := context.Background()
	151	+
	152	+	stream, err := factory.NewStream(ctx, format)
	153	+	if err != nil {
	154	+	t.Fatalf("Expected no error creating stream, got: %v", err)
	155	+	}
	156	+	if stream == nil {
	157	+	t.Fatal("Expected non-nil stream")
	158	+	}
	159	+
	160	+	// Verify the stream works
	161	+	samples := make([][]float32, format.ChannelCount)
	162	+	for i := range samples {
	163	+	samples[i] = make([]float32, format.FramesPerBuffer)
	164	+	}
	165	+
	166	+	if err := stream.Write(samples); err != nil {
	167	+	t.Errorf("Write failed: %v", err)
	168	+	}
	169	+	if err := stream.Close(); err != nil {
	170	+	t.Errorf("Close failed: %v", err)
	171	+	}
	172	+	}

A internal/infrastructure/audio/null/output.go +33 -0

@@ -0,0 +1,33 @@
	1	+	// Package null provides a null audio backend that discards all audio data.
	2	+	// This is useful as a fallback when no real audio backend is available.
	3	+	package null
	4	+
	5	+	import (
	6	+	"context"
	7	+
	8	+	"github.com/bnema/dumber/internal/application/port"
	9	+	)
	10	+
	11	+	// Factory creates null audio output streams that discard all audio data.
	12	+	type Factory struct{}
	13	+
	14	+	// NewStream creates a new null audio output stream.
	15	+	// The stream accepts writes but discards all data silently.
	16	+	func (*Factory) NewStream(_ context.Context, _ port.AudioStreamFormat) (port.AudioOutputStream, error) {
	17	+	return &Stream{}, nil
	18	+	}
	19	+
	20	+	// Stream is a null audio output stream that discards all audio data.
	21	+	type Stream struct{}
	22	+
	23	+	// Write accepts audio samples but discards them silently.
	24	+	// This method never returns an error.
	25	+	func (*Stream) Write(_ [][]float32) error {
	26	+	return nil
	27	+	}
	28	+
	29	+	// Close releases the audio stream.
	30	+	// This method is idempotent and never returns an error.
	31	+	func (*Stream) Close() error {
	32	+	return nil
	33	+	}

A internal/infrastructure/audio/null/output_test.go +96 -0

@@ -0,0 +1,96 @@
	1	+	package null
	2	+
	3	+	import (
	4	+	"context"
	5	+	"testing"
	6	+
	7	+	"github.com/bnema/dumber/internal/application/port"
	8	+	)
	9	+
	10	+	func TestFactory_NewStream_ReturnsWritableClosableStream(t *testing.T) {
	11	+	// Arrange
	12	+	factory := &Factory{}
	13	+	format := port.AudioStreamFormat{
	14	+	SampleRate: 48000,
	15	+	ChannelCount: 2,
	16	+	FramesPerBuffer: 512,
	17	+	}
	18	+	ctx := context.Background()
	19	+
	20	+	// Act
	21	+	stream, err := factory.NewStream(ctx, format)
	22	+	if err != nil {
	23	+	t.Fatalf("NewStream failed: %v", err)
	24	+	}
	25	+	if stream == nil {
	26	+	t.Fatal("NewStream returned nil stream")
	27	+	}
	28	+
	29	+	// Assert: stream should accept writes
	30	+	samples := make([][]float32, format.ChannelCount)
	31	+	for i := range samples {
	32	+	samples[i] = make([]float32, format.FramesPerBuffer)
	33	+	}
	34	+
	35	+	if err := stream.Write(samples); err != nil {
	36	+	t.Errorf("Write failed: %v", err)
	37	+	}
	38	+
	39	+	// Assert: stream should be closable
	40	+	if err := stream.Close(); err != nil {
	41	+	t.Errorf("Close failed: %v", err)
	42	+	}
	43	+	}
	44	+
	45	+	func TestStream_Write_AcceptsMultipleCalls(t *testing.T) {
	46	+	// Arrange
	47	+	factory := &Factory{}
	48	+	format := port.AudioStreamFormat{
	49	+	SampleRate: 44100,
	50	+	ChannelCount: 2,
	51	+	FramesPerBuffer: 1024,
	52	+	}
	53	+	ctx := context.Background()
	54	+
	55	+	stream, err := factory.NewStream(ctx, format)
	56	+	if err != nil {
	57	+	t.Fatalf("NewStream failed: %v", err)
	58	+	}
	59	+	defer stream.Close()
	60	+
	61	+	samples := make([][]float32, format.ChannelCount)
	62	+	for i := range samples {
	63	+	samples[i] = make([]float32, format.FramesPerBuffer)
	64	+	}
	65	+
	66	+	// Act & Assert: multiple writes should succeed
	67	+	for i := 0; i < 3; i++ {
	68	+	if err := stream.Write(samples); err != nil {
	69	+	t.Errorf("Write #%d failed: %v", i+1, err)
	70	+	}
	71	+	}
	72	+	}
	73	+
	74	+	func TestStream_Close_Idempotent(t *testing.T) {
	75	+	// Arrange
	76	+	factory := &Factory{}
	77	+	format := port.AudioStreamFormat{
	78	+	SampleRate: 48000,
	79	+	ChannelCount: 1,
	80	+	FramesPerBuffer: 256,
	81	+	}
	82	+	ctx := context.Background()
	83	+
	84	+	stream, err := factory.NewStream(ctx, format)
	85	+	if err != nil {
	86	+	t.Fatalf("NewStream failed: %v", err)
	87	+	}
	88	+
	89	+	// Act & Assert: multiple closes should succeed
	90	+	if err := stream.Close(); err != nil {
	91	+	t.Errorf("First Close failed: %v", err)
	92	+	}
	93	+	if err := stream.Close(); err != nil {
	94	+	t.Errorf("Second Close failed: %v", err)
	95	+	}
	96	+	}

A internal/infrastructure/audio/pipewire/output.go +280 -0

@@ -0,0 +1,280 @@
	1	+	// Package pipewire provides a PipeWire-based audio output implementation.
	2	+	// This wraps purego-pipewire's high-level Player API.
	3	+	package pipewire
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"fmt"
	9	+	"sync"
	10	+	"sync/atomic"
	11	+
	12	+	pwpipewire "github.com/bnema/purego-pipewire/pipewire"
	13	+
	14	+	"github.com/bnema/dumber/internal/application/port"
	15	+	"github.com/bnema/dumber/internal/logging"
	16	+	)
	17	+
	18	+	// Compile-time interface checks.
	19	+	var (
	20	+	_ port.AudioOutputFactory = (*Factory)(nil)
	21	+	_ port.AudioOutputStream = (*playerStreamAdapter)(nil)
	22	+	)
	23	+
	24	+	// ErrInvalidFormat is returned when the audio stream format is invalid.
	25	+	var ErrInvalidFormat = errors.New("invalid audio stream format")
	26	+
	27	+	// ErrStreamClosed is returned when writing to a closed stream.
	28	+	var ErrStreamClosed = errors.New("audio stream closed")
	29	+
	30	+	// playerCreator is a function type that creates a Player from config and callbacks.
	31	+	// This exists to allow dependency injection in tests.
	32	+	type playerCreator func(config pwpipewire.PlayerConfig, callbacks pwpipewire.PlayerCallbacks) (pwpipewire.Player, error)
	33	+
	34	+	// Factory creates PipeWire audio output streams.
	35	+	// Each call to NewStream creates an independent purego-pipewire Player.
	36	+	type Factory struct {
	37	+	createPlayer playerCreator
	38	+	}
	39	+
	40	+	// NewFactory creates a new PipeWire audio factory.
	41	+	// The factory is stateless; players are created per-stream.
	42	+	func NewFactory() (*Factory, error) {
	43	+	return &Factory{
	44	+	createPlayer: pwpipewire.NewPlayer,
	45	+	}, nil
	46	+	}
	47	+
	48	+	// NewStream creates a new audio output stream with the given format.
	49	+	// It validates the Dumber format, creates a purego-pipewire Player configured
	50	+	// from the format, and returns a push-to-pull adapter that bridges Write()
	51	+	// calls into the Player's Fill callback.
	52	+	func (f *Factory) NewStream(ctx context.Context, format port.AudioStreamFormat) (port.AudioOutputStream, error) {
	53	+	// Check context cancellation
	54	+	if ctx.Err() != nil {
	55	+	return nil, ctx.Err()
	56	+	}
	57	+
	58	+	// Validate format
	59	+	if err := validateFormat(format); err != nil {
	60	+	return nil, err
	61	+	}
	62	+
	63	+	log := logging.FromContext(ctx)
	64	+	log.Info().
	65	+	Int("sample_rate", format.SampleRate).
	66	+	Int("channels", format.ChannelCount).
	67	+	Int("frames_per_buffer", format.FramesPerBuffer).
	68	+	Msg("pipewire: creating player")
	69	+
	70	+	// Create the adapter with its ring buffer before creating the player,
	71	+	// because the Fill callback captures the adapter.
	72	+	adapter := &playerStreamAdapter{
	73	+	ctx: ctx,
	74	+	buf: make(chan [][]float32, 4), // small buffer for push→pull bridging
	75	+	closed: make(chan struct{}),
	76	+	}
	77	+
	78	+	config := pwpipewire.PlayerConfig{
	79	+	SampleRate: format.SampleRate,
	80	+	Channels: format.ChannelCount,
	81	+	FramesPerBuffer: format.FramesPerBuffer,
	82	+	SampleFormat: pwpipewire.SampleFormatF32,
	83	+	UnderrunPolicy: pwpipewire.UnderrunFillSilence,
	84	+	}
	85	+
	86	+	callbacks := pwpipewire.PlayerCallbacks{
	87	+	Fill: adapter.fill,
	88	+	}
	89	+
	90	+	player, err := f.createPlayer(config, callbacks)
	91	+	if err != nil {
	92	+	log.Warn().Err(err).Msg("pipewire: failed to create player")
	93	+	return nil, fmt.Errorf("failed to create pipewire player: %w", err)
	94	+	}
	95	+	adapter.player = player
	96	+
	97	+	// Start the player so the Fill callback begins being called.
	98	+	if err := player.Start(); err != nil {
	99	+	_ = player.Close()
	100	+	log.Warn().Err(err).Msg("pipewire: failed to start player")
	101	+	return nil, fmt.Errorf("failed to start pipewire player: %w", err)
	102	+	}
	103	+
	104	+	log.Info().Msg("pipewire: player started successfully")
	105	+
	106	+	return adapter, nil
	107	+	}
	108	+
	109	+	// validateFormat checks if the audio format parameters are valid.
	110	+	func validateFormat(format port.AudioStreamFormat) error {
	111	+	// Sample rate must be reasonable (8kHz to 384kHz)
	112	+	if format.SampleRate < 8000 \|\| format.SampleRate > 384000 {
	113	+	return fmt.Errorf("%w: sample rate %d Hz out of range [8000, 384000]",
	114	+	ErrInvalidFormat, format.SampleRate)
	115	+	}
	116	+
	117	+	// Channel count must be 1 to 1024 (reasonable upper limit)
	118	+	if format.ChannelCount < 1 \|\| format.ChannelCount > 1024 {
	119	+	return fmt.Errorf("%w: channel count %d out of range [1, 1024]",
	120	+	ErrInvalidFormat, format.ChannelCount)
	121	+	}
	122	+
	123	+	// Frames per buffer must be positive and reasonable
	124	+	if format.FramesPerBuffer < 1 \|\| format.FramesPerBuffer > 8192 {
	125	+	return fmt.Errorf("%w: frames per buffer %d out of range [1, 8192]",
	126	+	ErrInvalidFormat, format.FramesPerBuffer)
	127	+	}
	128	+
	129	+	return nil
	130	+	}
	131	+
	132	+	// playerStreamAdapter bridges Dumber's push-style Write(samples) interface
	133	+	// to purego-pipewire's pull-style Fill callback.
	134	+	//
	135	+	// Write() sends sample buffers into a channel. The Fill callback drains them
	136	+	// into the PCMBuffer that purego-pipewire passes in. If no data is available,
	137	+	// the player's UnderrunFillSilence policy handles it.
	138	+	type playerStreamAdapter struct {
	139	+	player pwpipewire.Player
	140	+	ctx context.Context
	141	+	buf chan [][]float32 // push→pull handoff channel
	142	+
	143	+	closeOnce sync.Once
	144	+	closed chan struct{} // closed when Close is called
	145	+
	146	+	// Diagnostic counters (atomic, no mutex needed).
	147	+	fillCount atomic.Uint64 // total Fill callbacks
	148	+	underrunCount atomic.Uint64 // Fill callbacks with no data available
	149	+	dropCount atomic.Uint64 // Write calls that dropped data (buffer full)
	150	+	}
	151	+
	152	+	// Write sends audio samples to the PipeWire output.
	153	+	// Samples are provided as [channel][frame]float32 matching CEF's planar format.
	154	+	// If the internal buffer is full the packet is dropped silently so the caller
	155	+	// (CEF audio callback thread) is never blocked.
	156	+	// Safe for concurrent use with Close.
	157	+	func (a *playerStreamAdapter) Write(samples [][]float32) error {
	158	+	// Fast path: already closed.
	159	+	select {
	160	+	case <-a.closed:
	161	+	return ErrStreamClosed
	162	+	default:
	163	+	}
	164	+	// Non-blocking send: drop packet when buffer is full.
	165	+	select {
	166	+	case a.buf <- samples:
	167	+	return nil
	168	+	case <-a.closed:
	169	+	return ErrStreamClosed
	170	+	default:
	171	+	// Buffer full — drop to avoid blocking the CEF audio thread.
	172	+	n := a.dropCount.Add(1)
	173	+	if n == 1 \|\| n&(n-1) == 0 { // first drop, then powers of two
	174	+	if a.ctx != nil {
	175	+	logging.FromContext(a.ctx).Warn().
	176	+	Uint64("total_drops", n).
	177	+	Msg("pipewire: dropped audio packet (buffer full)")
	178	+	}
	179	+	}
	180	+	return nil
	181	+	}
	182	+	}
	183	+
	184	+	// fill is the PlayerCallbacks.Fill function called by purego-pipewire
	185	+	// when it needs audio data. It pulls from the internal buffer channel.
	186	+	func (a playerStreamAdapter) fill(pcm pwpipewire.PCMBuffer) (int, error) {
	187	+	select {
	188	+	case samples := <-a.buf:
	189	+	fillNum := a.fillCount.Add(1)
	190	+	if fillNum == 1 && a.ctx != nil {
	191	+	logging.FromContext(a.ctx).Info().
	192	+	Msg("pipewire: first Fill callback with data")
	193	+	}
	194	+	// Copy available samples into the PCM buffer
	195	+	copied := copyToPCM(pcm, samples)
	196	+	return copied, nil
	197	+	default:
	198	+	// No data available — return 0 frames, let underrun policy handle it
	199	+	underruns := a.underrunCount.Add(1)
	200	+	if underruns == 1 && a.ctx != nil {
	201	+	logging.FromContext(a.ctx).Debug().
	202	+	Msg("pipewire: first Fill underrun (no data available)")
	203	+	}
	204	+	return 0, nil
	205	+	}
	206	+	}
	207	+
	208	+	// copyToPCM copies planar samples into the PCMBuffer.
	209	+	// Returns the number of frames actually copied.
	210	+	func copyToPCM(pcm *pwpipewire.PCMBuffer, samples [][]float32) int {
	211	+	if pcm == nil \|\| len(samples) == 0 {
	212	+	return 0
	213	+	}
	214	+
	215	+	frames := pcm.Frames
	216	+	channels := len(samples)
	217	+	if channels > pcm.Channels {
	218	+	channels = pcm.Channels
	219	+	}
	220	+	if channels > len(pcm.Samples) {
	221	+	channels = len(pcm.Samples)
	222	+	}
	223	+	if channels == 0 {
	224	+	return 0
	225	+	}
	226	+
	227	+	minFrames := frames
	228	+
	229	+	for ch := 0; ch < channels && ch < len(samples); ch++ {
	230	+	dst := pcm.Samples[ch]
	231	+	src := samples[ch]
	232	+	if len(dst) == 0 \|\| len(src) == 0 {
	233	+	minFrames = 0
	234	+	continue
	235	+	}
	236	+	srcFrames := len(src)
	237	+	n := frames
	238	+	if srcFrames < n {
	239	+	n = srcFrames
	240	+	}
	241	+	if len(dst) < n {
	242	+	n = len(dst)
	243	+	}
	244	+	if n < minFrames {
	245	+	minFrames = n
	246	+	}
	247	+	copy(dst[:n], src[:n])
	248	+	}
	249	+
	250	+	return minFrames
	251	+	}
	252	+
	253	+	// Close stops the player and releases resources.
	254	+	// Safe to call multiple times.
	255	+	func (a *playerStreamAdapter) Close() error {
	256	+	var err error
	257	+	a.closeOnce.Do(func() {
	258	+	if a.ctx != nil {
	259	+	logging.FromContext(a.ctx).Info().
	260	+	Uint64("fills", a.fillCount.Load()).
	261	+	Uint64("underruns", a.underrunCount.Load()).
	262	+	Uint64("drops", a.dropCount.Load()).
	263	+	Msg("pipewire: closing player")
	264	+	}
	265	+
	266	+	// Signal writers to stop
	267	+	close(a.closed)
	268	+
	269	+	if a.player != nil {
	270	+	// Stop playback then close the player
	271	+	if stopErr := a.player.Stop(); stopErr != nil {
	272	+	err = stopErr
	273	+	}
	274	+	if closeErr := a.player.Close(); closeErr != nil && err == nil {
	275	+	err = closeErr
	276	+	}
	277	+	}
	278	+	})
	279	+	return err
	280	+	}

A internal/infrastructure/audio/pipewire/output_test.go +548 -0

@@ -0,0 +1,548 @@
	1	+	// Package pipewire provides a PipeWire-based audio output implementation.
	2	+	// This wraps purego-pipewire's high-level Player API.
	3	+	package pipewire
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"testing"
	9	+
	10	+	"github.com/bnema/dumber/internal/application/port"
	11	+	pwpipewire "github.com/bnema/purego-pipewire/pipewire"
	12	+	"github.com/stretchr/testify/assert"
	13	+	"github.com/stretchr/testify/require"
	14	+	)
	15	+
	16	+	// --- Test doubles ---
	17	+
	18	+	// fakePlayer is a test double for purego-pipewire Player.
	19	+	type fakePlayer struct {
	20	+	started bool
	21	+	paused bool
	22	+	stopped bool
	23	+	closedFlag bool
	24	+	state pwpipewire.PlayerState
	25	+
	26	+	startErr error
	27	+	stopErr error
	28	+	closeErr error
	29	+	}
	30	+
	31	+	func (p *fakePlayer) Start() error {
	32	+	if p.startErr != nil {
	33	+	return p.startErr
	34	+	}
	35	+	p.started = true
	36	+	p.state = pwpipewire.PlayerStatePlaying
	37	+	return nil
	38	+	}
	39	+
	40	+	func (p *fakePlayer) Pause() error {
	41	+	p.paused = true
	42	+	p.state = pwpipewire.PlayerStatePaused
	43	+	return nil
	44	+	}
	45	+
	46	+	func (p *fakePlayer) Stop() error {
	47	+	if p.stopErr != nil {
	48	+	return p.stopErr
	49	+	}
	50	+	p.stopped = true
	51	+	p.state = pwpipewire.PlayerStateStopped
	52	+	return nil
	53	+	}
	54	+
	55	+	func (p *fakePlayer) Close() error {
	56	+	if p.closeErr != nil {
	57	+	return p.closeErr
	58	+	}
	59	+	p.closedFlag = true
	60	+	p.state = pwpipewire.PlayerStateClosed
	61	+	return nil
	62	+	}
	63	+
	64	+	func (p *fakePlayer) State() pwpipewire.PlayerState {
	65	+	return p.state
	66	+	}
	67	+
	68	+	// --- Factory tests ---
	69	+
	70	+	func TestFactory_NewStream_ValidFormat_CreatesStream(t *testing.T) {
	71	+	var capturedConfig pwpipewire.PlayerConfig
	72	+	player := &fakePlayer{}
	73	+
	74	+	factory := &Factory{
	75	+	createPlayer: func(config pwpipewire.PlayerConfig, _ pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	76	+	capturedConfig = config
	77	+	return player, nil
	78	+	},
	79	+	}
	80	+
	81	+	format := port.AudioStreamFormat{
	82	+	SampleRate: 48000,
	83	+	ChannelCount: 2,
	84	+	FramesPerBuffer: 512,
	85	+	}
	86	+
	87	+	stream, err := factory.NewStream(context.Background(), format)
	88	+	require.NoError(t, err)
	89	+	require.NotNil(t, stream)
	90	+
	91	+	// Verify config mapping
	92	+	assert.Equal(t, 48000, capturedConfig.SampleRate)
	93	+	assert.Equal(t, 2, capturedConfig.Channels)
	94	+	assert.Equal(t, 512, capturedConfig.FramesPerBuffer)
	95	+	assert.Equal(t, pwpipewire.SampleFormatF32, capturedConfig.SampleFormat)
	96	+	assert.Equal(t, pwpipewire.UnderrunFillSilence, capturedConfig.UnderrunPolicy)
	97	+
	98	+	// Verify player was started
	99	+	assert.True(t, player.started)
	100	+
	101	+	// Clean up
	102	+	require.NoError(t, stream.Close())
	103	+	}
	104	+
	105	+	func TestFactory_NewStream_InvalidFormat_ReturnsError(t *testing.T) {
	106	+	factory := &Factory{
	107	+	createPlayer: func(_ pwpipewire.PlayerConfig, _ pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	108	+	t.Fatal("createPlayer should not be called for invalid format")
	109	+	return nil, nil
	110	+	},
	111	+	}
	112	+
	113	+	tests := []struct {
	114	+	name string
	115	+	format port.AudioStreamFormat
	116	+	}{
	117	+	{
	118	+	name: "zero sample rate",
	119	+	format: port.AudioStreamFormat{SampleRate: 0, ChannelCount: 2, FramesPerBuffer: 512},
	120	+	},
	121	+	{
	122	+	name: "zero channels",
	123	+	format: port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 0, FramesPerBuffer: 512},
	124	+	},
	125	+	{
	126	+	name: "negative sample rate",
	127	+	format: port.AudioStreamFormat{SampleRate: -48000, ChannelCount: 2, FramesPerBuffer: 512},
	128	+	},
	129	+	{
	130	+	name: "negative channels",
	131	+	format: port.AudioStreamFormat{SampleRate: 48000, ChannelCount: -2, FramesPerBuffer: 512},
	132	+	},
	133	+	{
	134	+	name: "excessive sample rate",
	135	+	format: port.AudioStreamFormat{SampleRate: 1000000, ChannelCount: 2, FramesPerBuffer: 512},
	136	+	},
	137	+	{
	138	+	name: "excessive channels",
	139	+	format: port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 1025, FramesPerBuffer: 512},
	140	+	},
	141	+	{
	142	+	name: "zero frames per buffer",
	143	+	format: port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 0},
	144	+	},
	145	+	{
	146	+	name: "excessive frames per buffer",
	147	+	format: port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 10000},
	148	+	},
	149	+	}
	150	+
	151	+	for _, tt := range tests {
	152	+	t.Run(tt.name, func(t *testing.T) {
	153	+	stream, err := factory.NewStream(context.Background(), tt.format)
	154	+	require.Error(t, err)
	155	+	assert.Nil(t, stream)
	156	+	assert.ErrorIs(t, err, ErrInvalidFormat)
	157	+	})
	158	+	}
	159	+	}
	160	+
	161	+	func TestFactory_NewStream_PlayerCreationFails_ReturnsError(t *testing.T) {
	162	+	expectedErr := errors.New("pipewire not available")
	163	+	factory := &Factory{
	164	+	createPlayer: func(_ pwpipewire.PlayerConfig, _ pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	165	+	return nil, expectedErr
	166	+	},
	167	+	}
	168	+
	169	+	format := port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 512}
	170	+	stream, err := factory.NewStream(context.Background(), format)
	171	+
	172	+	require.Error(t, err)
	173	+	assert.Nil(t, stream)
	174	+	assert.ErrorIs(t, err, expectedErr)
	175	+	}
	176	+
	177	+	func TestFactory_NewStream_PlayerStartFails_ClosesAndReturnsError(t *testing.T) {
	178	+	player := &fakePlayer{startErr: errors.New("start failed")}
	179	+	factory := &Factory{
	180	+	createPlayer: func(_ pwpipewire.PlayerConfig, _ pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	181	+	return player, nil
	182	+	},
	183	+	}
	184	+
	185	+	format := port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 512}
	186	+	stream, err := factory.NewStream(context.Background(), format)
	187	+
	188	+	require.Error(t, err)
	189	+	assert.Nil(t, stream)
	190	+	assert.True(t, player.closedFlag, "player should be closed after start failure")
	191	+	}
	192	+
	193	+	func TestFactory_NewStream_ContextCancelled_ReturnsError(t *testing.T) {
	194	+	factory := &Factory{
	195	+	createPlayer: func(_ pwpipewire.PlayerConfig, _ pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	196	+	t.Fatal("createPlayer should not be called when context is canceled")
	197	+	return nil, nil
	198	+	},
	199	+	}
	200	+
	201	+	ctx, cancel := context.WithCancel(context.Background())
	202	+	cancel()
	203	+
	204	+	format := port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 512}
	205	+	stream, err := factory.NewStream(ctx, format)
	206	+
	207	+	require.Error(t, err)
	208	+	assert.Nil(t, stream)
	209	+	}
	210	+
	211	+	func TestFactory_NewStream_MultipleFormats_Accepted(t *testing.T) {
	212	+	formats := []port.AudioStreamFormat{
	213	+	{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 512},
	214	+	{SampleRate: 44100, ChannelCount: 2, FramesPerBuffer: 512},
	215	+	{SampleRate: 48000, ChannelCount: 1, FramesPerBuffer: 256},
	216	+	{SampleRate: 96000, ChannelCount: 2, FramesPerBuffer: 1024},
	217	+	{SampleRate: 48000, ChannelCount: 6, FramesPerBuffer: 512},
	218	+	}
	219	+
	220	+	for _, fmt := range formats {
	221	+	t.Run("", func(t *testing.T) {
	222	+	factory := &Factory{
	223	+	createPlayer: func(config pwpipewire.PlayerConfig, _ pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	224	+	assert.Equal(t, fmt.SampleRate, config.SampleRate)
	225	+	assert.Equal(t, fmt.ChannelCount, config.Channels)
	226	+	assert.Equal(t, fmt.FramesPerBuffer, config.FramesPerBuffer)
	227	+	return &fakePlayer{}, nil
	228	+	},
	229	+	}
	230	+
	231	+	stream, err := factory.NewStream(context.Background(), fmt)
	232	+	require.NoError(t, err)
	233	+	assert.NotNil(t, stream)
	234	+
	235	+	_ = stream.Close()
	236	+	})
	237	+	}
	238	+	}
	239	+
	240	+	func TestFactory_ImplementsPortInterface(_ *testing.T) {
	241	+	var _ port.AudioOutputFactory = (*Factory)(nil)
	242	+	}
	243	+
	244	+	// --- Stream adapter tests ---
	245	+
	246	+	func TestPlayerStreamAdapter_Write_SendsToBuffer(t *testing.T) {
	247	+	player := &fakePlayer{}
	248	+	adapter := &playerStreamAdapter{
	249	+	player: player,
	250	+	buf: make(chan [][]float32, 4),
	251	+	closed: make(chan struct{}),
	252	+	}
	253	+
	254	+	samples := [][]float32{
	255	+	{0.1, 0.2},
	256	+	{0.3, 0.4},
	257	+	}
	258	+
	259	+	err := adapter.Write(samples)
	260	+	require.NoError(t, err)
	261	+
	262	+	// Verify data is in the channel
	263	+	received := <-adapter.buf
	264	+	assert.Equal(t, samples, received)
	265	+	}
	266	+
	267	+	func TestPlayerStreamAdapter_Write_AfterClose_ReturnsError(t *testing.T) {
	268	+	player := &fakePlayer{}
	269	+	adapter := &playerStreamAdapter{
	270	+	player: player,
	271	+	buf: make(chan [][]float32, 4),
	272	+	closed: make(chan struct{}),
	273	+	}
	274	+
	275	+	require.NoError(t, adapter.Close())
	276	+
	277	+	err := adapter.Write([][]float32{{0.1}})
	278	+	assert.ErrorIs(t, err, ErrStreamClosed)
	279	+	}
	280	+
	281	+	func TestPlayerStreamAdapter_Close_StopsAndClosesPlayer(t *testing.T) {
	282	+	player := &fakePlayer{}
	283	+	adapter := &playerStreamAdapter{
	284	+	player: player,
	285	+	buf: make(chan [][]float32, 4),
	286	+	closed: make(chan struct{}),
	287	+	}
	288	+
	289	+	err := adapter.Close()
	290	+	require.NoError(t, err)
	291	+
	292	+	assert.True(t, player.stopped)
	293	+	assert.True(t, player.closedFlag)
	294	+	}
	295	+
	296	+	func TestPlayerStreamAdapter_Close_IsIdempotent(t *testing.T) {
	297	+	player := &fakePlayer{}
	298	+	adapter := &playerStreamAdapter{
	299	+	player: player,
	300	+	buf: make(chan [][]float32, 4),
	301	+	closed: make(chan struct{}),
	302	+	}
	303	+
	304	+	require.NoError(t, adapter.Close())
	305	+	require.NoError(t, adapter.Close())
	306	+	}
	307	+
	308	+	func TestPlayerStreamAdapter_Close_PropagatesStopError(t *testing.T) {
	309	+	player := &fakePlayer{stopErr: errors.New("stop error")}
	310	+	adapter := &playerStreamAdapter{
	311	+	player: player,
	312	+	buf: make(chan [][]float32, 4),
	313	+	closed: make(chan struct{}),
	314	+	}
	315	+
	316	+	err := adapter.Close()
	317	+	require.Error(t, err)
	318	+	assert.Contains(t, err.Error(), "stop error")
	319	+	}
	320	+
	321	+	func TestPlayerStreamAdapter_Close_PropagatesCloseError(t *testing.T) {
	322	+	player := &fakePlayer{closeErr: errors.New("close error")}
	323	+	adapter := &playerStreamAdapter{
	324	+	player: player,
	325	+	buf: make(chan [][]float32, 4),
	326	+	closed: make(chan struct{}),
	327	+	}
	328	+
	329	+	err := adapter.Close()
	330	+	require.Error(t, err)
	331	+	assert.Contains(t, err.Error(), "close error")
	332	+	}
	333	+
	334	+	// --- Fill callback tests ---
	335	+
	336	+	func TestFill_PullsFromBuffer(t *testing.T) {
	337	+	adapter := &playerStreamAdapter{
	338	+	buf: make(chan [][]float32, 4),
	339	+	}
	340	+
	341	+	// Push samples
	342	+	samples := [][]float32{
	343	+	{0.1, 0.2, 0.3},
	344	+	{0.4, 0.5, 0.6},
	345	+	}
	346	+	adapter.buf <- samples
	347	+
	348	+	// Simulate Fill call
	349	+	pcm := &pwpipewire.PCMBuffer{
	350	+	Frames: 3,
	351	+	Channels: 2,
	352	+	Stride: 1,
	353	+	Samples: [][]float32{
	354	+	make([]float32, 3),
	355	+	make([]float32, 3),
	356	+	},
	357	+	}
	358	+
	359	+	frames, err := adapter.fill(pcm)
	360	+	require.NoError(t, err)
	361	+	assert.Equal(t, 3, frames)
	362	+	assert.InEpsilon(t, 0.1, pcm.Samples[0][0], 0.0001)
	363	+	assert.InEpsilon(t, 0.4, pcm.Samples[1][0], 0.0001)
	364	+	}
	365	+
	366	+	func TestFill_ReturnsZeroWhenEmpty(t *testing.T) {
	367	+	adapter := &playerStreamAdapter{
	368	+	buf: make(chan [][]float32, 4),
	369	+	}
	370	+
	371	+	pcm := &pwpipewire.PCMBuffer{
	372	+	Frames: 256,
	373	+	Channels: 2,
	374	+	Stride: 1,
	375	+	Samples: [][]float32{
	376	+	make([]float32, 256),
	377	+	make([]float32, 256),
	378	+	},
	379	+	}
	380	+
	381	+	frames, err := adapter.fill(pcm)
	382	+	require.NoError(t, err)
	383	+	assert.Equal(t, 0, frames)
	384	+	}
	385	+
	386	+	func TestCopyToPCM_HandlesChannelMismatch(t *testing.T) {
	387	+	// More source channels than PCM channels — truncates
	388	+	pcm := &pwpipewire.PCMBuffer{
	389	+	Frames: 2,
	390	+	Channels: 1,
	391	+	Samples: [][]float32{make([]float32, 2)},
	392	+	}
	393	+	samples := [][]float32{
	394	+	{1.0, 2.0},
	395	+	{3.0, 4.0}, // should be ignored
	396	+	}
	397	+	frames := copyToPCM(pcm, samples)
	398	+	assert.Equal(t, 2, frames)
	399	+	assert.InEpsilon(t, 1.0, pcm.Samples[0][0], 0.0001)
	400	+	}
	401	+
	402	+	func TestCopyToPCM_HandlesFrameMismatch(t *testing.T) {
	403	+	// Fewer source frames than PCM expects
	404	+	pcm := &pwpipewire.PCMBuffer{
	405	+	Frames: 4,
	406	+	Channels: 1,
	407	+	Samples: [][]float32{make([]float32, 4)},
	408	+	}
	409	+	samples := [][]float32{
	410	+	{1.0, 2.0}, // only 2 frames
	411	+	}
	412	+	frames := copyToPCM(pcm, samples)
	413	+	assert.Equal(t, 2, frames) // reports partial fill
	414	+	}
	415	+
	416	+	func TestCopyToPCM_NilPCM_ReturnsZero(t *testing.T) {
	417	+	assert.Equal(t, 0, copyToPCM(nil, [][]float32{{1.0}}))
	418	+	}
	419	+
	420	+	func TestCopyToPCM_EmptySamples_ReturnsZero(t *testing.T) {
	421	+	pcm := &pwpipewire.PCMBuffer{Frames: 1, Channels: 1, Samples: [][]float32{make([]float32, 1)}}
	422	+	assert.Equal(t, 0, copyToPCM(pcm, nil))
	423	+	assert.Equal(t, 0, copyToPCM(pcm, [][]float32{}))
	424	+	}
	425	+
	426	+	// --- Non-blocking Write tests ---
	427	+
	428	+	func TestPlayerStreamAdapter_Write_DropsWhenBufferFull(t *testing.T) {
	429	+	adapter := &playerStreamAdapter{
	430	+	player: &fakePlayer{},
	431	+	buf: make(chan [][]float32, 4),
	432	+	closed: make(chan struct{}),
	433	+	}
	434	+
	435	+	// Fill the buffer to capacity
	436	+	for i := 0; i < 4; i++ {
	437	+	require.NoError(t, adapter.Write([][]float32{{float32(i)}}))
	438	+	}
	439	+
	440	+	// The 5th write must NOT block — it should drop the packet and return nil.
	441	+	err := adapter.Write([][]float32{{99.0}})
	442	+	require.NoError(t, err, "Write must not return an error when dropping due to full buffer")
	443	+
	444	+	// Verify the drop was counted
	445	+	assert.Equal(t, uint64(1), adapter.dropCount.Load(), "one packet should have been dropped")
	446	+
	447	+	// Verify buffer still contains the original 4 packets (not the dropped one)
	448	+	assert.Len(t, adapter.buf, 4)
	449	+	}
	450	+
	451	+	func TestPlayerStreamAdapter_Write_DropsLogOnlyOnFirstAndPowerOfTwo(t *testing.T) {
	452	+	adapter := &playerStreamAdapter{
	453	+	player: &fakePlayer{},
	454	+	buf: make(chan [][]float32, 1), // tiny buffer to force drops
	455	+	closed: make(chan struct{}),
	456	+	}
	457	+
	458	+	// Fill buffer
	459	+	require.NoError(t, adapter.Write([][]float32{{0.0}}))
	460	+
	461	+	// Drop 10 packets
	462	+	for i := 0; i < 10; i++ {
	463	+	_ = adapter.Write([][]float32{{float32(i)}})
	464	+	}
	465	+
	466	+	// Verify all drops were counted
	467	+	assert.Equal(t, uint64(10), adapter.dropCount.Load())
	468	+	}
	469	+
	470	+	// --- Concurrent Write / Close tests ---
	471	+
	472	+	func TestPlayerStreamAdapter_ConcurrentWriteClose_NoRace(t *testing.T) {
	473	+	player := &fakePlayer{}
	474	+	adapter := &playerStreamAdapter{
	475	+	player: player,
	476	+	buf: make(chan [][]float32, 4),
	477	+	closed: make(chan struct{}),
	478	+	}
	479	+
	480	+	done := make(chan struct{})
	481	+	go func() {
	482	+	defer close(done)
	483	+	for i := 0; i < 100; i++ {
	484	+	err := adapter.Write([][]float32{{float32(i)}})
	485	+	if err != nil {
	486	+	assert.ErrorIs(t, err, ErrStreamClosed)
	487	+	return
	488	+	}
	489	+	}
	490	+	}()
	491	+
	492	+	// Let a few writes land, then close.
	493	+	adapter.Close()
	494	+	<-done
	495	+	}
	496	+
	497	+	// --- NewFactory tests ---
	498	+
	499	+	func TestNewFactory_Succeeds(t *testing.T) {
	500	+	factory, err := NewFactory()
	501	+	require.NoError(t, err)
	502	+	require.NotNil(t, factory)
	503	+	assert.NotNil(t, factory.createPlayer)
	504	+	}
	505	+
	506	+	// --- Integration-style test: full write-through ---
	507	+
	508	+	func TestStream_WriteFlowsThroughToFill(t *testing.T) {
	509	+	var capturedCallbacks pwpipewire.PlayerCallbacks
	510	+	player := &fakePlayer{}
	511	+
	512	+	factory := &Factory{
	513	+	createPlayer: func(_ pwpipewire.PlayerConfig, callbacks pwpipewire.PlayerCallbacks) (pwpipewire.Player, error) {
	514	+	capturedCallbacks = callbacks
	515	+	return player, nil
	516	+	},
	517	+	}
	518	+
	519	+	format := port.AudioStreamFormat{SampleRate: 48000, ChannelCount: 2, FramesPerBuffer: 4}
	520	+	stream, err := factory.NewStream(context.Background(), format)
	521	+	require.NoError(t, err)
	522	+
	523	+	// Write samples through the stream
	524	+	samples := [][]float32{
	525	+	{0.1, 0.2, 0.3, 0.4},
	526	+	{0.5, 0.6, 0.7, 0.8},
	527	+	}
	528	+	require.NoError(t, stream.Write(samples))
	529	+
	530	+	// Simulate the Fill callback being called by the player
	531	+	pcm := &pwpipewire.PCMBuffer{
	532	+	Frames: 4,
	533	+	Channels: 2,
	534	+	Stride: 1,
	535	+	Samples: [][]float32{
	536	+	make([]float32, 4),
	537	+	make([]float32, 4),
	538	+	},
	539	+	}
	540	+
	541	+	frames, err := capturedCallbacks.Fill(pcm)
	542	+	require.NoError(t, err)
	543	+	assert.Equal(t, 4, frames)
	544	+	assert.InEpsilon(t, 0.1, pcm.Samples[0][0], 0.0001)
	545	+	assert.InEpsilon(t, 0.5, pcm.Samples[1][0], 0.0001)
	546	+
	547	+	require.NoError(t, stream.Close())
	548	+	}

M internal/infrastructure/cef/app.go +2 -2


@@ -9,11 +9,11 @@ import (
9		const dumbSchemeName = "dumb"	9		const dumbSchemeName = "dumb"
10			10
11		func dumbSchemeOptions() int32 {	11		func dumbSchemeOptions() int32 {
12	-	return int32(purecef.SchemeOptionsSchemeOptionStandard \|	12	+	return purecef.SchemeOptionsSchemeOptionStandard \|
13		purecef.SchemeOptionsSchemeOptionSecure \|	13		purecef.SchemeOptionsSchemeOptionSecure \|
14		purecef.SchemeOptionsSchemeOptionCorsEnabled \|	14		purecef.SchemeOptionsSchemeOptionCorsEnabled \|
15		purecef.SchemeOptionsSchemeOptionCspBypassing \|	15		purecef.SchemeOptionsSchemeOptionCspBypassing \|
16	-	purecef.SchemeOptionsSchemeOptionFetchEnabled)	16	+	purecef.SchemeOptionsSchemeOptionFetchEnabled
17		}	17		}
18			18
19		func registerDumbScheme(registrar purecef.SchemeRegistrar) {	19		func registerDumbScheme(registrar purecef.SchemeRegistrar) {

M internal/infrastructure/cef/app_test.go +2 -2


@@ -25,11 +25,11 @@ func TestRegisterDumbScheme(t *testing.T) {
25		stub := &schemeRegistrarStub{}	25		stub := &schemeRegistrarStub{}
26		registerDumbScheme(stub)	26		registerDumbScheme(stub)
27			27
28	-	wantOptions := int32(purecef.SchemeOptionsSchemeOptionStandard \|	28	+	wantOptions := purecef.SchemeOptionsSchemeOptionStandard \|
29		purecef.SchemeOptionsSchemeOptionSecure \|	29		purecef.SchemeOptionsSchemeOptionSecure \|
30		purecef.SchemeOptionsSchemeOptionCorsEnabled \|	30		purecef.SchemeOptionsSchemeOptionCorsEnabled \|
31		purecef.SchemeOptionsSchemeOptionCspBypassing \|	31		purecef.SchemeOptionsSchemeOptionCspBypassing \|
32	-	purecef.SchemeOptionsSchemeOptionFetchEnabled)	32	+	purecef.SchemeOptionsSchemeOptionFetchEnabled
33			33
34		if stub.calls != 1 {	34		if stub.calls != 1 {
35		t.Fatalf("AddCustomScheme call count = %d, want 1", stub.calls)	35		t.Fatalf("AddCustomScheme call count = %d, want 1", stub.calls)

M internal/infrastructure/cef/content_injector.go +6 -2

   function monitorReplacement(video) {
     if (!video || video._dumberReplacementDiag) return;
     video._dumberReplacementDiag = true;
-    ['loadstart','loadedmetadata','loadeddata','canplay','playing','waiting','stalled','suspend','abort','emptied','error'].forEach(function(evt) {
+    [
+      'loadstart', 'loadedmetadata', 'loadeddata', 'canplay', 'playing',
+      'waiting', 'stalled', 'suspend', 'abort', 'emptied', 'error',
+    ].forEach(function(evt) {
       video.addEventListener(evt, function() {
         var err = video.error ? ('code=' + video.error.code + ' msg=' + video.error.message) : 'none';
         console.warn(tag, 'replacement', evt, 'ready:', video.readyState, 'net:', video.networkState,
-          'paused:', video.paused, 'error:', err, 'src:', (video.currentSrc || video.src || '').substring(0, 120));
+          'paused:', video.paused, 'error:', err, 'src:',
+          (video.currentSrc || video.src || '').substring(0, 120));
       });
     });
   }

M internal/infrastructure/cef/engine.go +9 -48

 	activeWebViews sync.Map // map[port.WebViewID]*WebView
 	activeCount    atomic.Int32
-	// shutdownNotify is signalled when the active webview count reaches 0
+	// shutdownNotify is signaled when the active webview count reaches 0
 	// during shutdown, replacing the busy-wait poll in closeActiveWebViews.
 	shutdownNotify chan struct{}
 	childLaunchGPU          atomic.Uint64
 	childLaunchOther        atomic.Uint64
-	browserCreateRequests    atomic.Uint64
+	browserCreateRequests   atomic.Uint64
-	browserAfterCreated      atomic.Uint64
+	browserAfterCreated     atomic.Uint64
-	browserCreateLastAtMs    atomic.Int64
+	browserCreateLastAtMs   atomic.Int64
-	browserCreateLastResult  atomic.Int32
+	browserCreateLastResult atomic.Int32
-	browserCreateLastWidth   atomic.Int32
+	browserCreateLastWidth  atomic.Int32
-	browserCreateLastHeight  atomic.Int32
+	browserCreateLastHeight atomic.Int32
-	lastStallLoggedCreateSeq atomic.Uint64
+	browserCreateComplete   atomic.Bool
-	browserCreateComplete    atomic.Bool
 	transcoderState       transcoderStartupState
 	transcoderStateLogged atomic.Bool
 	}
 	log := logging.FromContext(e.ctx)
+	e.shutdownNotify = make(chan struct{}, 1)
 	webViews := make([]*WebView, 0, e.activeWebViewCount())
 	e.activeWebViews.Range(func(_, value any) bool {
 		wv, ok := value.(*WebView)
 		Int("count", len(webViews)).
 		Msg("cef: closing active webviews before shutdown")
-	// Set up the shutdown notification channel before destroying webviews.
-	e.shutdownNotify = make(chan struct{}, 1)
 	for _, wv := range webViews {
 		wv.Destroy()
 	}
 	e.logTranscoderStartupState()
 }
-const browserCreateStallWarnMS int64 = 1500
 func (e *Engine) recordContextInitialized() {
 	count := e.contextInitializedCount.Add(1)
 	logging.FromContext(e.ctx).Debug().
 		Msg("cef: browser created")
 }
-func (e *Engine) maybeLogBrowserCreateStall() {
-	if e.browserCreateComplete.Load() {
-		return
-	}
-	createCount := e.browserCreateRequests.Load()
-	if createCount == 0 || createCount == e.browserAfterCreated.Load() || createCount == e.lastStallLoggedCreateSeq.Load() {
-		return
-	}
-	createdAt := e.browserCreateLastAtMs.Load()
-	if createdAt == 0 {
-		return
-	}
-	ageMs := time.Now().UnixMilli() - createdAt
-	if ageMs < browserCreateStallWarnMS {
-		return
-	}
-	e.lastStallLoggedCreateSeq.Store(createCount)
-	logging.FromContext(e.ctx).Warn().
-		Uint64("create_requests", createCount).
-		Uint64("after_created", e.browserAfterCreated.Load()).
-		Int64("create_age_ms", ageMs).
-		Int32("last_create_result", e.browserCreateLastResult.Load()).
-		Int32("last_create_width", e.browserCreateLastWidth.Load()).
-		Int32("last_create_height", e.browserCreateLastHeight.Load()).
-		Uint64("context_initialized", e.contextInitializedCount.Load()).
-		Uint64("renderer_launches", e.childLaunchRenderer.Load()).
-		Uint64("gpu_launches", e.childLaunchGPU.Load()).
-		Uint64("other_launches", e.childLaunchOther.Load()).
-		Msg("cef: browser creation appears stalled")
-}
 func (e *Engine) currentContext() context.Context {
 	if e == nil || e.ctx == nil {
 		return context.Background()

M internal/infrastructure/cef/engine_init.go +9 -19

 const puregoCEFInitTraceEnvVar = "PUREGO_CEF_INIT_TRACE"
 // NewEngine initializes the CEF runtime and returns a ready-to-use Engine.
-func NewEngine(ctx context.Context, cfg config.CEFEngineConfig, transcodingCfg config.TranscodingConfig) (*Engine, error) {
+func NewEngine(
+	ctx context.Context,
+	cfg config.CEFEngineConfig,
+	transcodingCfg config.TranscodingConfig,
+	audioFactory port.AudioOutputFactory,
+) (*Engine, error) {
 	logger := logging.FromContext(ctx)
 	cleanStaleSingletonLocks(logger)
 	}
 	os.Args = savedArgs
-	return wireEngine(ctx, eng, cfg, transcodingCfg, windowlessFrameRate, logger)
+	return wireEngine(ctx, eng, cfg, transcodingCfg, windowlessFrameRate, audioFactory, logger)
 }
 // prepareCEFSettings builds purecef.Settings from the engine config.
 // wireEngine creates GL loader, factory, pool, and scheme handler after CEF init.
 func wireEngine(
 	ctx context.Context, eng *Engine, cfg config.CEFEngineConfig, transcodingCfg config.TranscodingConfig,
-	windowlessFrameRate int32, logger *zerolog.Logger,
+	windowlessFrameRate int32, audioFactory port.AudioOutputFactory, logger *zerolog.Logger,
 ) (*Engine, error) {
 	gl, err := newGLLoader()
 	if err != nil {
 		windowlessFrameRate:      windowlessFrameRate,
 		enableContextMenuHandler: cfg.EnableContextMenuHandler,
 		transcoder:               mediaTranscoder,
+		audioOutputFactory:       audioFactory,
 	})
 	pool := newWebViewPool(factory)
 	return 1
 }
-// detectMonitorRefreshRate queries the primary GDK monitor for its refresh rate.
-// Returns the rate in Hz (e.g., 120 for a 120Hz display), or 0 if detection fails.
-func detectMonitorRefreshRate(logger *zerolog.Logger) int32 {
-	mon := getPrimaryMonitor()
-	if mon == nil {
-		return 0
-	}
-	milliHz := mon.GetRefreshRate()
-	if milliHz <= 0 {
-		return 0
-	}
-	hz := int32((milliHz + 500) / 1000) // round to nearest Hz
-	logger.Info().Int32("refresh_rate_hz", hz).Msg("cef: detected monitor refresh rate")
-	return hz
-}
 // appendIfMissing appends flag to args if it's not already present.
 func appendIfMissing(args []string, flag string) []string {
 	for _, a := range args {

M internal/infrastructure/cef/engine_init_test.go +10 -0


@@ -5,6 +5,7 @@ import (
5	"path/filepath"	5		"path/filepath"
6	"testing"	6		"testing"
7		7
		8	+	"github.com/bnema/dumber/internal/infrastructure/audio/factory"
8	"github.com/bnema/dumber/internal/infrastructure/config"	9		"github.com/bnema/dumber/internal/infrastructure/config"
9	"github.com/rs/zerolog"	10		"github.com/rs/zerolog"
10	"github.com/stretchr/testify/require"	11		"github.com/stretchr/testify/require"

@@ -64,3 +65,12 @@ func TestPrepareCEFSettings_RootCachePath_DevMode(t *testing.T) {
64	// In dev mode, should resolve under .dev/dumber/cef_user_data	65		// In dev mode, should resolve under .dev/dumber/cef_user_data
65	require.Equal(t, filepath.Join(tempDir, ".dev", "dumber", "cef_user_data"), settings.RootCachePath)	66		require.Equal(t, filepath.Join(tempDir, ".dev", "dumber", "cef_user_data"), settings.RootCachePath)
66	}	67		}
		68	+
		69	+	// TestCreateAudioOutputFactory_CreatesUsableFactory verifies that the audio
		70	+	// factory can be created and produces working streams. This tests the runtime
		71	+	// wiring decision to create the factory during CEF engine setup.
		72	+	func TestCreateAudioOutputFactory_ReturnsFactory(t *testing.T) {
		73	+	audioFactory := factory.NewAudioOutputFactory()
		74	+
		75	+	require.NotNil(t, audioFactory, "Audio factory should not be nil")
		76	+	}

M internal/infrastructure/cef/factory.go +19 -9

 	enableContextMenuHandler bool
 	bgColor                  atomic.Uint32 // packed ARGB for BrowserSettings.BackgroundColor
 	transcoder               port.MediaTranscoder
+	audioOutputFactory       port.AudioOutputFactory
 }
 type webViewFactoryOptions struct {
 	windowlessFrameRate      int32
 	enableContextMenuHandler bool
 	transcoder               port.MediaTranscoder
+	audioOutputFactory       port.AudioOutputFactory
 }
 // newWebViewFactory returns a factory that will create WebViews using the
 		windowlessFrameRate:      opts.windowlessFrameRate,
 		enableContextMenuHandler: opts.enableContextMenuHandler,
 		transcoder:               opts.transcoder,
+		audioOutputFactory:       opts.audioOutputFactory,
 	}
 }
 	pipeline := newRenderPipeline(ctx, f.gl, f.scale)
 	wv := &WebView{
-		id:       id,
+		id:                 id,
-		ctx:      ctx,
+		ctx:                ctx,
-		engine:   f.engine,
+		engine:             f.engine,
-		pipeline: pipeline,
+		pipeline:           pipeline,
+		audioOutputFactory: f.audioOutputFactory,
 	}
 	var transcodingHandler purecef.ResourceRequestHandler
 	// Defer browser creation until the GL area has a non-zero size.
 	// CEF requires GetViewRect to return a non-empty rect, but the GL area
 	// is not yet realized at this point.
+	f.configureInitialBrowserCreation(ctx, wv, pipeline, client, &windowInfo, &settings)
+	return wv, nil
+}
+func (f *WebViewFactory) configureInitialBrowserCreation(
+	ctx context.Context, wv *WebView, pipeline *renderPipeline, client purecef.Client,
+	windowInfo *purecef.WindowInfo, settings *purecef.BrowserSettings,
+) {
 	wv.pendingCreate = &pendingBrowserCreate{
-		windowInfo: &windowInfo,
+		windowInfo: windowInfo,
 		client:     client,
-		settings:   &settings,
+		settings:   settings,
 	}
-	// When the GL area gets its first non-zero size, create the browser.
 	pipeline.onFirstResize = func(w, h int32) {
 		log := logging.FromContext(ctx)
 		log.Debug().Int32("w", w).Int32("h", h).Msg("cef: onFirstResize fired, scheduling browser creation")
 			host.WasResized()
 		}
 	}
-	return wv, nil
 }
 // createRelatedWarned ensures the session sharing warning is logged only once.

M internal/infrastructure/cef/render_pipeline.go +89 -91

 	rp.mu.Unlock()
-	gl := rp.gl
 	if !rp.glReady || sizeChanged {
 		rp.initGL(uploadWidth, uploadHeight)
 	}
 	if !rp.glReady {
-		renderDuration := time.Since(renderStartedAt)
+		rp.recordGLRenderDuration(renderStartedAt)
-		rp.diagMu.Lock()
-		rp.glRenderCount++
-		rp.renderTotalNs += uint64(renderDuration)
-		if renderDuration.Nanoseconds() > rp.maxRenderNs {
-			rp.maxRenderNs = renderDuration.Nanoseconds()
-		}
-		rp.diagMu.Unlock()
-		rp.maybeLogDiagnostics()
 		return true
 	}
 		uploadStartedAt := time.Now()
 		uploadedBytes, fullUpload, didUpload := rp.uploadToPBO(renderSeq, paintSeq)
 		if didUpload {
-			uploadDuration := time.Since(uploadStartedAt)
+			rp.recordGLUploadDuration(uploadStartedAt, uploadedBytes, fullUpload)
-			rp.diagMu.Lock()
-			rp.uploadCount++
-			if fullUpload {
-				rp.fullUploadCount++
-			}
-			rp.uploadBytes += uploadedBytes
-			rp.uploadTotalNs += uint64(uploadDuration)
-			if uploadDuration.Nanoseconds() > rp.maxUploadNs {
-				rp.maxUploadNs = uploadDuration.Nanoseconds()
-			}
-			rp.diagMu.Unlock()
 		}
 	}
 	// Draw the main view texture.
+	gl := rp.gl
 	w, h, _ := rp.viewRectSize()
 	gl.viewport(0, 0, w, h)
 	gl.clearColor(0, 0, 0, 1)
 	}
 	renderDuration := time.Since(renderStartedAt)
-	rp.diagMu.Lock()
+	rp.recordGLRenderDuration(renderStartedAt)
-	rp.glRenderCount++
-	rp.renderTotalNs += uint64(renderDuration)
-	if renderDuration.Nanoseconds() > rp.maxRenderNs {
-		rp.maxRenderNs = renderDuration.Nanoseconds()
-	}
-	rp.diagMu.Unlock()
 	rp.maybeLogDiagnostics()
 	if rp.ctx != nil {
 		logging.FromContext(rp.ctx).Trace().
 	return true
 }
+func (rp *renderPipeline) recordGLRenderDuration(startedAt time.Time) {
+	renderDuration := time.Since(startedAt)
+	rp.diagMu.Lock()
+	rp.glRenderCount++
+	rp.renderTotalNs += uint64(renderDuration)
+	if renderDuration.Nanoseconds() > rp.maxRenderNs {
+		rp.maxRenderNs = renderDuration.Nanoseconds()
+	}
+	rp.diagMu.Unlock()
+	rp.maybeLogDiagnostics()
+}
+func (rp *renderPipeline) recordGLUploadDuration(startedAt time.Time, uploadedBytes uint64, fullUpload bool) {
+	uploadDuration := time.Since(startedAt)
+	rp.diagMu.Lock()
+	rp.uploadCount++
+	if fullUpload {
+		rp.fullUploadCount++
+	}
+	rp.uploadBytes += uploadedBytes
+	rp.uploadTotalNs += uint64(uploadDuration)
+	if uploadDuration.Nanoseconds() > rp.maxUploadNs {
+		rp.maxUploadNs = uploadDuration.Nanoseconds()
+	}
+	rp.diagMu.Unlock()
+}
 func (rp *renderPipeline) drawTexture(texture uint32) {
 	if texture == 0 {
 		return
 	bufSize := int64(w) * int64(h) * 4
 	stride := int(w) * 4
+	uploadedBytes, fullUpload, dirtyRectCount, ok := rp.uploadMappedPBO(gl, bufSize, stride, w, h, renderSeq, paintSeq)
+	if !ok {
+		return 0, fullUpload, false
+	}
-	// Bind the write PBO.
+	// Swap PBO index for next frame.
-	gl.bindBuffer(glPixelUnpackBuffer, rp.pbo[rp.pboIndex])
+	rp.pboIndex = 1 - rp.pboIndex
-	// Orphan the buffer to avoid GPU stall, then map.
+	gl.bindBuffer(glPixelUnpackBuffer, 0)
+	if rp.ctx != nil {
+		logging.FromContext(rp.ctx).Trace().
+			Uint64("render_seq", renderSeq).
+			Uint64("paint_seq", paintSeq).
+			Uint64("uploaded_bytes", uploadedBytes).
+			Int("dirty_rect_count", dirtyRectCount).
+			Bool("full_upload", fullUpload).
+			Int("next_pbo_index", rp.pboIndex).
+			Msg("cef: uploadToPBO end")
+	}
+	return uploadedBytes, fullUpload, true
+}
+func (rp *renderPipeline) uploadMappedPBO(
+	gl *glLoader, bufSize int64, stride int, w, h int32, renderSeq, paintSeq uint64,
+) (uint64, bool, int, bool) {
+	gl.bindBuffer(glPixelUnpackBuffer, rp.pbo[rp.pboIndex])
 	gl.bufferData(glPixelUnpackBuffer, bufSize, nil, glStreamDraw)
 	mapped := gl.mapBuffer(glPixelUnpackBuffer, glWriteOnly)
 	if mapped == nil {
 		gl.bindBuffer(glPixelUnpackBuffer, 0)
-		return 0, false, false
+		return 0, false, 0, false
 	}
 	mappedSlice := unsafe.Slice((*byte)(mapped), int(bufSize))
-	uploadedBytes := uint64(0)
+	defer gl.bindBuffer(glPixelUnpackBuffer, 0)
-	fullUpload := false
-	dirtyRects := make([]rect, 0)
 	rp.mu.Lock()
 	if !rp.needsUpload {
 		rp.mu.Unlock()
 		if !gl.unmapBuffer(glPixelUnpackBuffer) {
-			gl.bindBuffer(glPixelUnpackBuffer, 0)
+			return 0, false, 0, false
-			return 0, false, false
 		}
-		gl.bindBuffer(glPixelUnpackBuffer, 0)
+		return 0, false, 0, false
-		return 0, false, false
 	}
 	if rp.widthAtomic.Load() != rp.glWidth || rp.heightAtomic.Load() != rp.glHeight {
 		rp.mu.Unlock()
 		if !gl.unmapBuffer(glPixelUnpackBuffer) {
-			gl.bindBuffer(glPixelUnpackBuffer, 0)
+			return 0, false, 0, false
-			return 0, false, false
 		}
-		gl.bindBuffer(glPixelUnpackBuffer, 0)
 		if rp.ctx != nil {
 			logging.FromContext(rp.ctx).Trace().
 				Uint64("render_seq", renderSeq).
 				Uint64("paint_seq", paintSeq).
 				Msg("cef: skipping upload while newer surface resize is pending")
 		}
-		return 0, false, false
+		return 0, false, 0, false
 	}
-	fullUpload = rp.forceFullUpload
+	fullUpload := rp.forceFullUpload
+	dirtyRectCount, dirtyRects := len(rp.dirtyRects), make([]rect, 0, len(rp.dirtyRects))
 	if fullUpload {
 		copied := copy(mappedSlice, rp.staging)
 		if copied < len(mappedSlice) {
 			clear(mappedSlice[copied:])
 		}
-		uploadedBytes = uint64(copied)
 	} else {
 		dirtyRects = append(dirtyRects, rp.dirtyRects...)
-		uploadedBytes = copyDirtyRectsRaw(mappedSlice, rp.staging, w, h, dirtyRects)
 	}
-	rp.needsUpload = false
+	rp.needsUpload, rp.forceFullUpload = false, false
-	rp.forceFullUpload = false
 	rp.dirtyRects = rp.dirtyRects[:0]
 	rp.mu.Unlock()
 				Bool("full_upload", fullUpload).
 				Msg("cef: glUnmapBuffer reported corrupted PBO contents; dropping frame")
 		}
-		gl.bindBuffer(glPixelUnpackBuffer, 0)
+		return 0, fullUpload, dirtyRectCount, false
-		return 0, fullUpload, false
 	}
-	// Transfer PBO → texture. With PBO bound, the last arg is a byte offset.
 	gl.bindTexture(glTexture2D, rp.texture)
 	if fullUpload {
 		gl.texSubImage2D(glTexture2D, 0, 0, 0, w, h, glBGRA, glUnsignedByte, nil)
-	} else {
+		gl.bindTexture(glTexture2D, 0)
-		// Use GL_UNPACK_ROW_LENGTH so GL understands the PBO's full-width
+		return uint64(len(mappedSlice)), true, dirtyRectCount, true
-		// stride, allowing one glTexSubImage2D per dirty rect instead of
-		// one per row.
-		gl.pixelStorei(glUnpackRowLength, w)
-		for _, rawRect := range dirtyRects {
-			r, ok := clampDirtyRect(rawRect, w, h)
-			if !ok {
-				continue
-			}
-			offset := uintptr(int(r.Y)*stride + int(r.X)*4)
-			gl.texSubImage2D(glTexture2D, 0, r.X, r.Y, r.Width, r.Height,
-				glBGRA, glUnsignedByte, pboOffset(offset))
-		}
-		gl.pixelStorei(glUnpackRowLength, 0)
 	}
-	gl.bindTexture(glTexture2D, 0)
-	// Swap PBO index for next frame.
-	rp.pboIndex = 1 - rp.pboIndex
-	gl.bindBuffer(glPixelUnpackBuffer, 0)
+	gl.pixelStorei(glUnpackRowLength, w)
-	if rp.ctx != nil {
+	uploadedBytes := copyDirtyRectsRaw(mappedSlice, rp.staging, w, h, dirtyRects)
-		logging.FromContext(rp.ctx).Trace().
+	for _, rawRect := range dirtyRects {
-			Uint64("render_seq", renderSeq).
+		r, ok := clampDirtyRect(rawRect, w, h)
-			Uint64("paint_seq", paintSeq).
+		if !ok {
-			Uint64("uploaded_bytes", uploadedBytes).
+			continue
-			Int("dirty_rect_count", len(dirtyRects)).
+		}
-			Bool("full_upload", fullUpload).
+		offset := uintptr(int(r.Y)*stride + int(r.X)*4)
-			Int("next_pbo_index", rp.pboIndex).
+		gl.texSubImage2D(glTexture2D, 0, r.X, r.Y, r.Width, r.Height,
-			Msg("cef: uploadToPBO end")
+			glBGRA, glUnsignedByte, pboOffset(offset))
 	}
-	return uploadedBytes, fullUpload, true
+	gl.pixelStorei(glUnpackRowLength, 0)
+	gl.bindTexture(glTexture2D, 0)
+	return uploadedBytes, false, dirtyRectCount, true
 }
 func (rp *renderPipeline) uploadPopupTexture(renderSeq, paintSeq uint64) bool {
 	for changed {
 		changed = false
 		for i := 0; i < len(merged); i++ {
-			for j := i + 1; j < len(merged); j++ {
+			for j := i + 1; j < len(merged); {
-				if rectsTouch(merged[i], merged[j]) {
+				if !rectsTouch(merged[i], merged[j]) {
-					merged[i] = boundingBox(merged[i], merged[j])
+					j++
-					// Remove j by swapping with last element.
+					continue
-					merged[j] = merged[len(merged)-1]
-					merged = merged[:len(merged)-1]
-					changed = true
-					j-- // re-check the element now at index j
 				}
+				merged[i] = boundingBox(merged[i], merged[j])
+				// Remove j by swapping with last element.
+				merged[j] = merged[len(merged)-1]
+				merged = merged[:len(merged)-1]
+				changed = true
 			}
 		}
 	}

M internal/infrastructure/cef/scheme_handler.go +7 -6

 // Scheme path constants matching WebKit's naming.
 const (
-	homePath   = "home"
+	homePath                    = "home"
-	configPath = "config"
+	configPath                  = "config"
-	webrtcPath = "webrtc"
+	webrtcPath                  = "webrtc"
-	errorPath  = "error"
+	errorPath                   = "error"
-	indexHTML  = "index.html"
+	indexHTML                   = "index.html"
+	maxSchemeTruncatedURLLength = 240
 )
 // pageRootFiles maps internal page hosts/paths to their HTML entry points.
 	ctx, cancel := context.WithTimeout(h.ctx, 5*time.Minute)
 	h.logger.Info().
-		Str("source_url", logging.TruncateURL(sourceURL, 240)).
+		Str("source_url", logging.TruncateURL(sourceURL, maxSchemeTruncatedURLLength)).
 		Int("forwarded_header_count", len(headers)).
 		Msg("scheme handler returning transcoding stream")

M internal/infrastructure/cef/transcoding_handler.go +64 -26

 import (
 	"context"
+	"errors"
 	"io"
 	"strings"
 	"sync"
 var _ purecef.ResourceRequestHandler = (*transcodingRequestHandler)(nil)
+const (
+	maxTranscodingURLLength = 240
+	httpStatusOK            = 200
+)
 // transcodingResourceHandler is checked indirectly: purecef.NewResourceHandler
 // accepts a purecef.ResourceHandler, and the struct implements all methods.
 // Open starts the transcode session asynchronously. CEF will call
 // GetResponseHeaders and Read once the callback fires.
-func (rh *transcodingResourceHandler) Open(_ purecef.Request, handleRequest unsafe.Pointer, callback purecef.Callback) int32 {
+func (rh *transcodingResourceHandler) Open(
+	_ purecef.Request, handleRequest unsafe.Pointer, callback purecef.Callback,
+) int32 {
 	// Signal async handling: set handleRequest = 0.
 	*(*int32)(handleRequest) = 0
 	log := rh.logger()
+	sourceURL := logging.TruncateURL(rh.sourceURL, maxTranscodingURLLength)
 	log.Info().
-		Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).
+		Str("source_url", sourceURL).
 		Int("forwarded_header_count", len(rh.headers)).
 		Msg("cef: starting transcoding resource stream")
 		if err != nil {
 			log.Error().
 				Err(err).
-				Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).
+				Str("source_url", sourceURL).
 				Msg("cef: failed to start transcoding resource stream")
 			// Let CEF know we failed — Cancel will be called.
 			rh.cancel()
 		}
 		rh.session = session
 		log.Info().
-			Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).
+			Str("source_url", sourceURL).
 			Str("content_type", session.ContentType()).
 			Msg("cef: transcoding resource stream ready")
 		callback.Cont()
 }
 // GetResponseHeaders sets the streaming response metadata.
-func (rh *transcodingResourceHandler) GetResponseHeaders(response purecef.Response, responseLength unsafe.Pointer, _ uintptr) {
+func (rh *transcodingResourceHandler) GetResponseHeaders(
-	response.SetStatus(200)
+	response purecef.Response, responseLength unsafe.Pointer, _ uintptr,
+) {
+	response.SetStatus(httpStatusOK)
 	response.SetStatusText("OK")
 	response.SetMimeType("video/webm")
 	response.SetHeaderByName("Accept-Ranges", "none", 1)
 		rh.totalBytes += int64(n)
 		if rh.totalBytes == int64(n) {
 			rh.logger().Info().
-				Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).
+				Str("source_url", logging.TruncateURL(rh.sourceURL, maxTranscodingURLLength)).
 				Int("first_chunk_bytes", n).
 				Msg("cef: transcoding resource stream produced first bytes")
 		}
 		return 1
 	}
 	if err != nil {
+		sourceURL := logging.TruncateURL(rh.sourceURL, maxTranscodingURLLength)
 		log := rh.logger().With().
-			Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).
+			Str("source_url", sourceURL).
 			Int64("total_bytes", rh.totalBytes).
 			Logger()
 		switch {
-		case err == io.EOF && rh.totalBytes == 0:
+		case errors.Is(err, io.EOF) && rh.totalBytes == 0:
 			log.Warn().Msg("cef: transcoding resource stream ended before producing data")
-		case err == io.EOF:
+		case errors.Is(err, io.EOF):
 			log.Debug().Msg("cef: transcoding resource stream reached EOF")
 		default:
 			log.Error().Err(err).Msg("cef: transcoding resource stream read failed")
 // Cancel aborts the transcode session and releases resources.
 func (rh *transcodingResourceHandler) Cancel() {
+	sourceURL := logging.TruncateURL(rh.sourceURL, maxTranscodingURLLength)
 	rh.logger().Debug().
-		Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).
+		Str("source_url", sourceURL).
 		Int64("total_bytes", rh.totalBytes).
-		Msg("cef: transcoding resource stream cancelled")
+		Msg("cef: transcoding resource stream canceled")
 	if rh.session != nil {
-		rh.session.Close()
+		if err := rh.session.Close(); err != nil {
+			rh.logger().Warn().
+				Str("source_url", sourceURL).
+				Err(err).
+				Msg("cef: transcoding resource stream close failed")
+		}
 	}
 	if rh.cancel != nil {
 		rh.cancel()
 // newTranscodingRequestHandler creates a ResourceRequestHandler that detects
 // proprietary video containers and HLS/DASH manifest entrypoints, then
 // restarts those requests through a GPU transcoding ResourceHandler.
-func newTranscodingRequestHandler(tc port.MediaTranscoder, ctxf func() context.Context) purecef.ResourceRequestHandler {
+func newTranscodingRequestHandler(
+	tc port.MediaTranscoder, ctxf func() context.Context,
+) purecef.ResourceRequestHandler {
 	return purecef.NewResourceRequestHandler(&transcodingRequestHandler{
 		transcoder: tc,
 		ctxf:       ctxf,
 // matches a proprietary video format or a streaming manifest entrypoint, it
 // stores the request info and returns 1 to restart the request — at which
 // point GetResourceHandler will provide the transcoding handler.
-func (h *transcodingRequestHandler) OnResourceResponse(_ purecef.Browser, _ purecef.Frame, request purecef.Request, response purecef.Response) int32 {
+func (h *transcodingRequestHandler) OnResourceResponse(
+	_ purecef.Browser, _ purecef.Frame, request purecef.Request, response purecef.Response,
+) int32 {
 	if response == nil || request == nil {
 		return 0
 	}
 	isManifest := !isAlreadyOpen && (transcoder.IsStreamingManifestMIME(mimeType) || transcoder.IsStreamingManifestURL(url))
 	if isLikelyMediaResponse(url, mimeType) {
 		log.Debug().
-			Str("url", logging.TruncateURL(url, 240)).
+			Str("url", logging.TruncateURL(url, maxTranscodingURLLength)).
 			Str("mime_type", mimeType).
 			Bool("proprietary_match", isProprietary).
 			Bool("already_open", isAlreadyOpen).
 		reason = "streaming-manifest"
 	}
 	log.Info().
-		Str("url", logging.TruncateURL(url, 240)).
+		Str("url", logging.TruncateURL(url, maxTranscodingURLLength)).
 		Str("mime_type", mimeType).
 		Str("transcode_reason", reason).
 		Int("forwarded_header_count", len(info.headers)).
 // GetResourceHandler returns a transcoding ResourceHandler for URLs that were
 // either identified eagerly by URL heuristics or marked by OnResourceResponse.
-func (h *transcodingRequestHandler) GetResourceHandler(_ purecef.Browser, _ purecef.Frame, request purecef.Request) purecef.ResourceHandler {
+func (h *transcodingRequestHandler) GetResourceHandler(
+	_ purecef.Browser, _ purecef.Frame, request purecef.Request,
+) purecef.ResourceHandler {
 	if request == nil {
 		return nil
 	}
 		}
 	}
 	ctx, cancel := context.WithTimeout(parentCtx, 5*time.Minute)
+	shortURL := logging.TruncateURL(url, maxTranscodingURLLength)
+	shortSourceURL := logging.TruncateURL(sourceURL, maxTranscodingURLLength)
 	h.logger().Info().
-		Str("url", logging.TruncateURL(url, 240)).
+		Str("url", shortURL).
-		Str("source_url", logging.TruncateURL(sourceURL, 240)).
+		Str("source_url", shortSourceURL).
 		Bool("eager_match", eager).
 		Int("forwarded_header_count", len(info.headers)).
 		Msg("cef: GetResourceHandler returning transcoding resource handler")
 // --- No-op methods required by purecef.ResourceRequestHandler ---
-func (h *transcodingRequestHandler) GetCookieAccessFilter(_ purecef.Browser, _ purecef.Frame, _ purecef.Request) purecef.CookieAccessFilter {
+func (h *transcodingRequestHandler) GetCookieAccessFilter(
+	_ purecef.Browser, _ purecef.Frame, _ purecef.Request,
+) purecef.CookieAccessFilter {
 	return nil
 }
-func (h *transcodingRequestHandler) OnBeforeResourceLoad(_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Callback) purecef.ReturnValue {
+func (h *transcodingRequestHandler) OnBeforeResourceLoad(
+	_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Callback,
+) purecef.ReturnValue {
 	return purecef.ReturnValueRvContinue
 }
-func (h *transcodingRequestHandler) OnResourceRedirect(_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Response, _ uintptr) {
+func (h *transcodingRequestHandler) OnResourceRedirect(
+	_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Response, _ uintptr,
+) {
 }
-func (h *transcodingRequestHandler) GetResourceResponseFilter(_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Response) purecef.ResponseFilter {
+func (h *transcodingRequestHandler) GetResourceResponseFilter(
+	_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Response,
+) purecef.ResponseFilter {
 	return nil
 }
-func (h *transcodingRequestHandler) OnResourceLoadComplete(_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Response, _ purecef.UrlrequestStatus, _ int64) {
+func (h *transcodingRequestHandler) OnResourceLoadComplete(
+	_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ purecef.Response,
+	_ purecef.UrlrequestStatus, _ int64,
+) {
 }
 func (h *transcodingRequestHandler) OnProtocolExecution(_ purecef.Browser, _ purecef.Frame, _ purecef.Request, _ unsafe.Pointer) {
 func (rh *transcodingResourceHandler) logger() *zerolog.Logger {
 	if rh != nil && rh.logf != nil {
-		logger := rh.logf().With().Str("source_url", logging.TruncateURL(rh.sourceURL, 240)).Logger()
+		sourceURL := logging.TruncateURL(rh.sourceURL, maxTranscodingURLLength)
+		logger := rh.logf().With().Str("source_url", sourceURL).Logger()
 		return &logger
 	}
 	logger := logging.FromContext(context.Background()).With().Str("component", "cef-transcoding").Logger()

M internal/infrastructure/cef/webview.go +28 -0


@@ -80,6 +80,15 @@ type WebView struct {
80	generation atomic.Uint64	80		generation atomic.Uint64
81	audioPlaying atomic.Bool	81		audioPlaying atomic.Bool
82	zoomFactor atomic.Value // float64, initialized to 1.0	82		zoomFactor atomic.Value // float64, initialized to 1.0
		83	+
		84	+	// Audio output factory and active stream.
		85	+	audioOutputFactory port.AudioOutputFactory
		86	+	audioStreamMu sync.Mutex
		87	+	activeAudioStream port.AudioOutputStream
		88	+
		89	+	// Audio instrumentation counters (diagnostic only).
		90	+	audioPacketCount atomic.Uint64 // total OnAudioStreamPacket calls
		91	+	audioWriteCount atomic.Uint64 // successful Write calls to stream
83	}	92		}
84		93
85	// pendingBrowserCreate holds the parameters needed to create a CEF browser,	94		// pendingBrowserCreate holds the parameters needed to create a CEF browser,

@@ -463,6 +472,7 @@ func (wv *WebView) Destroy() {
463	if !wv.destroyed.CompareAndSwap(false, true) {	472		if !wv.destroyed.CompareAndSwap(false, true) {
464	return	473		return
465	}	474		}
		475	+	wv.closeAudioStream()
466	wv.scheduleStopBeginFrameLoop()	476		wv.scheduleStopBeginFrameLoop()
467	wv.mu.RLock()	477		wv.mu.RLock()
468	host := wv.host	478		host := wv.host

@@ -705,3 +715,21 @@ func (wv WebView) takePendingCreate() pendingBrowserCreate {
705	wv.pendingCreate = nil	715		wv.pendingCreate = nil
706	return pc	716		return pc
707	}	717		}
		718	+
		719	+	// closeAudioStream closes and clears the active audio output stream.
		720	+	// This is safe to call even if no stream is active.
		721	+	func (wv *WebView) closeAudioStream() {
		722	+	wv.audioStreamMu.Lock()
		723	+	defer wv.audioStreamMu.Unlock()
		724	+
		725	+	if wv.activeAudioStream != nil {
		726	+	if err := wv.activeAudioStream.Close(); err != nil {
		727	+	if wv.ctx != nil {
		728	+	logging.FromContext(wv.ctx).Debug().
		729	+	Err(err).
		730	+	Msg("cef: error closing audio stream")
		731	+	}
		732	+	}
		733	+	wv.activeAudioStream = nil
		734	+	}
		735	+	}

A internal/infrastructure/cef/webview_audio_test.go +634 -0

@@ -0,0 +1,634 @@
	1	+	package cef
	2	+
	3	+	import (
	4	+	"context"
	5	+	"errors"
	6	+	"testing"
	7	+	"time"
	8	+
	9	+	"github.com/bnema/dumber/internal/application/port"
	10	+	"github.com/bnema/dumber/internal/infrastructure/audio/null"
	11	+	purecef "github.com/bnema/purego-cef/cef"
	12	+	"github.com/stretchr/testify/assert"
	13	+	"github.com/stretchr/testify/require"
	14	+	)
	15	+
	16	+	// TestEngine_WiresAudioOutputFactory verifies that the audio output factory
	17	+	// is properly injected through engine initialization.
	18	+	func TestEngine_WiresAudioOutputFactory(t *testing.T) {
	19	+	// This test verifies the wiring pattern. Since we can't easily
	20	+	// initialize a full CEF engine in unit tests, we verify the
	21	+	// webViewFactoryOptions struct accepts the audio factory.
	22	+	audioFactory := &null.Factory{}
	23	+
	24	+	// Verify webViewFactoryOptions can hold the audio factory
	25	+	opts := webViewFactoryOptions{
	26	+	scale: 1,
	27	+	windowlessFrameRate: 60,
	28	+	audioOutputFactory: audioFactory,
	29	+	}
	30	+
	31	+	require.NotNil(t, opts.audioOutputFactory)
	32	+	assert.Equal(t, audioFactory, opts.audioOutputFactory)
	33	+
	34	+	// Verify the factory is passed through
	35	+	factory := newWebViewFactory(&Engine{}, &glLoader{}, opts)
	36	+	require.NotNil(t, factory.audioOutputFactory)
	37	+	}
	38	+
	39	+	// TestWebViewFactory_AudioFactoryIsOptional verifies that nil audio factory
	40	+	// is handled gracefully (no panic, no audio output).
	41	+	func TestWebViewFactory_AudioFactoryIsOptional(t *testing.T) {
	42	+	// Arrange
	43	+	opts := webViewFactoryOptions{
	44	+	scale: 1,
	45	+	windowlessFrameRate: 60,
	46	+	audioOutputFactory: nil,
	47	+	}
	48	+
	49	+	// Act
	50	+	factory := newWebViewFactory(&Engine{}, &glLoader{}, opts)
	51	+
	52	+	// Assert
	53	+	require.NotNil(t, factory)
	54	+	assert.Nil(t, factory.audioOutputFactory)
	55	+	}
	56	+
	57	+	// TestHandlerSet_ReceivesAudioFactory verifies the handler set receives
	58	+	// the audio factory from the WebView.
	59	+	func TestHandlerSet_ReceivesAudioFactory(t *testing.T) {
	60	+	// This test verifies that handlerSet can access the audio factory
	61	+	// through its associated WebView.
	62	+	audioFactory := &null.Factory{}
	63	+
	64	+	wv := &WebView{
	65	+	ctx: context.Background(),
	66	+	audioOutputFactory: audioFactory,
	67	+	}
	68	+
	69	+	handlers := &handlerSet{wv: wv}
	70	+
	71	+	// Verify the handler can access the audio factory through the WebView
	72	+	require.NotNil(t, handlers.wv)
	73	+	assert.Equal(t, audioFactory, handlers.wv.audioOutputFactory)
	74	+	}
	75	+
	76	+	// TestWebView_AudioStreamLifecycleFieldsExist verifies the WebView has
	77	+	// the necessary fields for audio stream lifecycle management.
	78	+	func TestWebView_AudioStreamLifecycleFieldsExist(t *testing.T) {
	79	+	wv := &WebView{
	80	+	ctx: context.Background(),
	81	+	audioOutputFactory: &null.Factory{},
	82	+	}
	83	+
	84	+	// Verify the fields exist and can be set
	85	+	wv.activeAudioStream = &mockAudioStream{}
	86	+
	87	+	assert.NotNil(t, wv.audioOutputFactory)
	88	+	assert.NotNil(t, wv.activeAudioStream)
	89	+	}
	90	+
	91	+	// mockAudioStream is a test double for port.AudioOutputStream
	92	+	type mockAudioStream struct {
	93	+	writeCalled bool
	94	+	closeCalled bool
	95	+	writeSamples [][]float32
	96	+	}
	97	+
	98	+	func (m *mockAudioStream) Write(samples [][]float32) error {
	99	+	m.writeCalled = true
	100	+	m.writeSamples = samples
	101	+	return nil
	102	+	}
	103	+
	104	+	func (m *mockAudioStream) Close() error {
	105	+	m.closeCalled = true
	106	+	return nil
	107	+	}
	108	+
	109	+	// Verify mock implements the interface
	110	+	var _ port.AudioOutputStream = (*mockAudioStream)(nil)
	111	+
	112	+	// racyMockAudioStream blocks inside Write until doneCh is closed, allowing
	113	+	// tests to verify that the caller holds a lock across the Write call.
	114	+	type racyMockAudioStream struct {
	115	+	writeCh chan struct{} // closed when Write is entered
	116	+	doneCh chan struct{} // Write blocks until this is closed
	117	+	closeCalled bool
	118	+	}
	119	+
	120	+	func (m *racyMockAudioStream) Write(_ [][]float32) error {
	121	+	close(m.writeCh) // signal that Write has been entered
	122	+	<-m.doneCh // block until test unblocks us
	123	+	return nil
	124	+	}
	125	+
	126	+	func (m *racyMockAudioStream) Close() error {
	127	+	m.closeCalled = true
	128	+	return nil
	129	+	}
	130	+
	131	+	var _ port.AudioOutputStream = (*racyMockAudioStream)(nil)
	132	+
	133	+	// ============================================================================
	134	+	// Task 6: Audio Stream Lifecycle Handling Tests
	135	+	// ============================================================================
	136	+
	137	+	// TestHandlerSet_OnAudioStreamStarted_CreatesStream verifies that
	138	+	// OnAudioStreamStarted creates a new audio stream from the factory.
	139	+	func TestHandlerSet_OnAudioStreamStarted_CreatesStream(t *testing.T) {
	140	+	ctx := context.Background()
	141	+	mockStream := &mockAudioStream{}
	142	+	mockFactory := &mockAudioFactory{stream: mockStream}
	143	+
	144	+	wv := &WebView{
	145	+	ctx: ctx,
	146	+	audioOutputFactory: mockFactory,
	147	+	}
	148	+
	149	+	handlers := &handlerSet{wv: wv}
	150	+
	151	+	params := &purecef.AudioParameters{
	152	+	SampleRate: 48000,
	153	+	ChannelLayout: purecef.ChannelLayoutStereo,
	154	+	FramesPerBuffer: 512,
	155	+	}
	156	+
	157	+	// Act — third arg is channels, not framesPerBuffer
	158	+	handlers.OnAudioStreamStarted(nil, params, 2)
	159	+
	160	+	// Assert
	161	+	require.NotNil(t, wv.activeAudioStream)
	162	+	assert.Equal(t, mockStream, wv.activeAudioStream)
	163	+	assert.True(t, wv.audioPlaying.Load())
	164	+
	165	+	// Verify factory was called with correct format
	166	+	require.NotNil(t, mockFactory.lastFormat)
	167	+	assert.Equal(t, 48000, mockFactory.lastFormat.SampleRate)
	168	+	assert.Equal(t, 2, mockFactory.lastFormat.ChannelCount)
	169	+	assert.Equal(t, 512, mockFactory.lastFormat.FramesPerBuffer)
	170	+	}
	171	+
	172	+	// TestHandlerSet_OnAudioStreamStarted_NoFactory_DoesNotPanic verifies
	173	+	// that OnAudioStreamStarted handles nil factory gracefully.
	174	+	func TestHandlerSet_OnAudioStreamStarted_NoFactory_DoesNotPanic(t *testing.T) {
	175	+	wv := &WebView{
	176	+	ctx: context.Background(),
	177	+	audioOutputFactory: nil,
	178	+	}
	179	+
	180	+	handlers := &handlerSet{wv: wv}
	181	+
	182	+	params := &purecef.AudioParameters{
	183	+	SampleRate: 48000,
	184	+	ChannelLayout: purecef.ChannelLayoutStereo,
	185	+	FramesPerBuffer: 512,
	186	+	}
	187	+
	188	+	// Should not panic
	189	+	assert.NotPanics(t, func() {
	190	+	handlers.OnAudioStreamStarted(nil, params, 512)
	191	+	})
	192	+
	193	+	assert.False(t, wv.audioPlaying.Load())
	194	+	}
	195	+
	196	+	// TestHandlerSet_OnAudioStreamStarted_ClosesExistingStream verifies
	197	+	// that starting a new stream closes any existing one.
	198	+	func TestHandlerSet_OnAudioStreamStarted_ClosesExistingStream(t *testing.T) {
	199	+	ctx := context.Background()
	200	+	oldStream := &mockAudioStream{}
	201	+	newStream := &mockAudioStream{}
	202	+	mockFactory := &mockAudioFactory{stream: newStream}
	203	+
	204	+	wv := &WebView{
	205	+	ctx: ctx,
	206	+	audioOutputFactory: mockFactory,
	207	+	activeAudioStream: oldStream,
	208	+	}
	209	+
	210	+	handlers := &handlerSet{wv: wv}
	211	+
	212	+	params := &purecef.AudioParameters{
	213	+	SampleRate: 44100,
	214	+	ChannelLayout: purecef.ChannelLayoutMono,
	215	+	FramesPerBuffer: 256,
	216	+	}
	217	+
	218	+	// Act — third arg is channels (1 for mono)
	219	+	handlers.OnAudioStreamStarted(nil, params, 1)
	220	+
	221	+	// Assert
	222	+	assert.True(t, oldStream.closeCalled)
	223	+	assert.Equal(t, newStream, wv.activeAudioStream)
	224	+	}
	225	+
	226	+	// TestHandlerSet_OnAudioStreamStarted_FactoryError_HandlesGracefully verifies
	227	+	// that factory errors are handled without panic and audioPlaying is reset to false.
	228	+	func TestHandlerSet_OnAudioStreamStarted_FactoryError_HandlesGracefully(t *testing.T) {
	229	+	ctx := context.Background()
	230	+	mockFactory := &mockAudioFactory{err: errors.New("factory error")}
	231	+
	232	+	wv := &WebView{
	233	+	ctx: ctx,
	234	+	audioOutputFactory: mockFactory,
	235	+	}
	236	+
	237	+	handlers := &handlerSet{wv: wv}
	238	+
	239	+	params := &purecef.AudioParameters{
	240	+	SampleRate: 48000,
	241	+	ChannelLayout: purecef.ChannelLayoutStereo,
	242	+	FramesPerBuffer: 512,
	243	+	}
	244	+
	245	+	// Should not panic
	246	+	assert.NotPanics(t, func() {
	247	+	handlers.OnAudioStreamStarted(nil, params, 512)
	248	+	})
	249	+
	250	+	// audioPlaying must be false when NewStream fails — if it stays true,
	251	+	// the UI/state layer incorrectly believes audio is active.
	252	+	assert.False(t, wv.audioPlaying.Load(), "audioPlaying must be false after NewStream failure")
	253	+	assert.Nil(t, wv.activeAudioStream, "activeAudioStream must be nil after NewStream failure")
	254	+	}
	255	+
	256	+	// ============================================================================
	257	+	// Task 7: PCM Packet Forwarding Tests
	258	+	// ============================================================================
	259	+
	260	+	// TestHandlerSet_OnAudioStreamPacket_CopiesAndWrites verifies that
	261	+	// OnAudioStreamPacket copies samples before writing to avoid data races.
	262	+	func TestHandlerSet_OnAudioStreamPacket_CopiesAndWrites(t *testing.T) {
	263	+	ctx := context.Background()
	264	+	mockStream := &mockAudioStream{}
	265	+
	266	+	wv := &WebView{
	267	+	ctx: ctx,
	268	+	activeAudioStream: mockStream,
	269	+	}
	270	+
	271	+	handlers := &handlerSet{wv: wv}
	272	+
	273	+	// Create sample data: 2 channels, 512 frames each
	274	+	originalData := [][]float32{
	275	+	make([]float32, 512), // Channel 0
	276	+	make([]float32, 512), // Channel 1
	277	+	}
	278	+	originalData[0][0] = 0.5
	279	+	originalData[1][0] = -0.5
	280	+
	281	+	// Act
	282	+	handlers.OnAudioStreamPacket(nil, originalData, 512, 0)
	283	+
	284	+	// Assert
	285	+	require.True(t, mockStream.writeCalled)
	286	+	require.Len(t, mockStream.writeSamples, 2)
	287	+	require.Len(t, mockStream.writeSamples[0], 512)
	288	+
	289	+	// Verify data was copied (values match)
	290	+	assert.InDelta(t, 0.5, mockStream.writeSamples[0][0], 0.000001)
	291	+	assert.InDelta(t, -0.5, mockStream.writeSamples[1][0], 0.000001)
	292	+
	293	+	// Verify it's a copy (different underlying array)
	294	+	assert.NotSame(t, &originalData[0][0], &mockStream.writeSamples[0][0])
	295	+	}
	296	+
	297	+	// TestHandlerSet_OnAudioStreamPacket_NoActiveStream_DoesNothing verifies
	298	+	// that packets are silently discarded when no stream is active.
	299	+	func TestHandlerSet_OnAudioStreamPacket_NoActiveStream_DoesNothing(t *testing.T) {
	300	+	wv := &WebView{
	301	+	ctx: context.Background(),
	302	+	activeAudioStream: nil,
	303	+	}
	304	+
	305	+	handlers := &handlerSet{wv: wv}
	306	+
	307	+	data := [][]float32{
	308	+	{0.1, 0.2, 0.3},
	309	+	{0.4, 0.5, 0.6},
	310	+	}
	311	+
	312	+	// Should not panic
	313	+	assert.NotPanics(t, func() {
	314	+	handlers.OnAudioStreamPacket(nil, data, 3, 0)
	315	+	})
	316	+	}
	317	+
	318	+	// TestHandlerSet_OnAudioStreamPacket_NilData_DoesNotPanic verifies
	319	+	// that nil data is handled gracefully.
	320	+	func TestHandlerSet_OnAudioStreamPacket_NilData_DoesNotPanic(t *testing.T) {
	321	+	mockStream := &mockAudioStream{}
	322	+	wv := &WebView{
	323	+	ctx: context.Background(),
	324	+	activeAudioStream: mockStream,
	325	+	}
	326	+
	327	+	handlers := &handlerSet{wv: wv}
	328	+
	329	+	// Should not panic with nil data
	330	+	assert.NotPanics(t, func() {
	331	+	handlers.OnAudioStreamPacket(nil, nil, 0, 0)
	332	+	})
	333	+	}
	334	+
	335	+	// ============================================================================
	336	+	// Task 8: Stream Cleanup Tests
	337	+	// ============================================================================
	338	+
	339	+	// TestHandlerSet_OnAudioStreamStopped_ClosesStream verifies that
	340	+	// OnAudioStreamStopped closes the active stream.
	341	+	func TestHandlerSet_OnAudioStreamStopped_ClosesStream(t *testing.T) {
	342	+	mockStream := &mockAudioStream{}
	343	+	wv := &WebView{
	344	+	ctx: context.Background(),
	345	+	activeAudioStream: mockStream,
	346	+	}
	347	+	wv.audioPlaying.Store(true)
	348	+
	349	+	handlers := &handlerSet{wv: wv}
	350	+
	351	+	// Act
	352	+	handlers.OnAudioStreamStopped(nil)
	353	+
	354	+	// Assert
	355	+	assert.True(t, mockStream.closeCalled)
	356	+	assert.Nil(t, wv.activeAudioStream)
	357	+	assert.False(t, wv.audioPlaying.Load())
	358	+	}
	359	+
	360	+	// TestHandlerSet_OnAudioStreamStopped_NoActiveStream_DoesNotPanic verifies
	361	+	// that stopping when no stream exists doesn't panic.
	362	+	func TestHandlerSet_OnAudioStreamStopped_NoActiveStream_DoesNotPanic(t *testing.T) {
	363	+	wv := &WebView{
	364	+	ctx: context.Background(),
	365	+	activeAudioStream: nil,
	366	+	}
	367	+	wv.audioPlaying.Store(true)
	368	+
	369	+	handlers := &handlerSet{wv: wv}
	370	+
	371	+	// Should not panic
	372	+	assert.NotPanics(t, func() {
	373	+	handlers.OnAudioStreamStopped(nil)
	374	+	})
	375	+
	376	+	assert.False(t, wv.audioPlaying.Load())
	377	+	}
	378	+
	379	+	// TestHandlerSet_OnAudioStreamError_ClosesStream verifies that
	380	+	// OnAudioStreamError closes the active stream.
	381	+	func TestHandlerSet_OnAudioStreamError_ClosesStream(t *testing.T) {
	382	+	mockStream := &mockAudioStream{}
	383	+	wv := &WebView{
	384	+	ctx: context.Background(),
	385	+	activeAudioStream: mockStream,
	386	+	}
	387	+	wv.audioPlaying.Store(true)
	388	+
	389	+	handlers := &handlerSet{wv: wv}
	390	+
	391	+	// Act
	392	+	handlers.OnAudioStreamError(nil, "test error")
	393	+
	394	+	// Assert
	395	+	assert.True(t, mockStream.closeCalled)
	396	+	assert.Nil(t, wv.activeAudioStream)
	397	+	assert.False(t, wv.audioPlaying.Load())
	398	+	}
	399	+
	400	+	// TestHandlerSet_OnAudioStreamError_NoActiveStream_DoesNotPanic verifies
	401	+	// that error handling when no stream exists doesn't panic.
	402	+	func TestHandlerSet_OnAudioStreamError_NoActiveStream_DoesNotPanic(t *testing.T) {
	403	+	wv := &WebView{
	404	+	ctx: context.Background(),
	405	+	activeAudioStream: nil,
	406	+	}
	407	+	wv.audioPlaying.Store(true)
	408	+
	409	+	handlers := &handlerSet{wv: wv}
	410	+
	411	+	// Should not panic
	412	+	assert.NotPanics(t, func() {
	413	+	handlers.OnAudioStreamError(nil, "test error")
	414	+	})
	415	+
	416	+	assert.False(t, wv.audioPlaying.Load())
	417	+	}
	418	+
	419	+	// TestWebView_Destroy_ClosesAudioStream verifies that destroying
	420	+	// the WebView closes any active audio stream.
	421	+	func TestWebView_Destroy_ClosesAudioStream(t *testing.T) {
	422	+	mockStream := &mockAudioStream{}
	423	+	wv := &WebView{
	424	+	ctx: context.Background(),
	425	+	activeAudioStream: mockStream,
	426	+	pipeline: &renderPipeline{},
	427	+	}
	428	+	wv.audioPlaying.Store(true)
	429	+
	430	+	// Act — Destroy must close the audio stream as part of teardown.
	431	+	wv.Destroy()
	432	+
	433	+	// Assert
	434	+	assert.True(t, mockStream.closeCalled, "Destroy must close the active audio stream")
	435	+	assert.Nil(t, wv.activeAudioStream)
	436	+	}
	437	+
	438	+	// TestWebView_Destroy_NoAudioStream_DoesNotPanic verifies that Destroy
	439	+	// handles the case where no audio stream is active.
	440	+	func TestWebView_Destroy_NoAudioStream_DoesNotPanic(t *testing.T) {
	441	+	wv := &WebView{
	442	+	ctx: context.Background(),
	443	+	pipeline: &renderPipeline{},
	444	+	}
	445	+
	446	+	assert.NotPanics(t, func() {
	447	+	wv.Destroy()
	448	+	})
	449	+	}
	450	+
	451	+	// ============================================================================
	452	+	// Callback parameter mapping tests
	453	+	// ============================================================================
	454	+
	455	+	// TestBuildAudioStreamFormat_UsesParamsFramesPerBuffer verifies that
	456	+	// buildAudioStreamFormat reads FramesPerBuffer from the AudioParameters struct,
	457	+	// NOT from the callback's third argument (which is channels).
	458	+	func TestBuildAudioStreamFormat_UsesParamsFramesPerBuffer(t *testing.T) {
	459	+	wv := &WebView{ctx: context.Background()}
	460	+	handlers := &handlerSet{wv: wv}
	461	+
	462	+	params := &purecef.AudioParameters{
	463	+	SampleRate: 48000,
	464	+	ChannelLayout: purecef.ChannelLayoutStereo,
	465	+	FramesPerBuffer: 1024,
	466	+	}
	467	+	channels := int32(2) // third callback arg is channels, not framesPerBuffer
	468	+
	469	+	format := handlers.buildAudioStreamFormat(params, channels)
	470	+
	471	+	assert.Equal(t, 48000, format.SampleRate, "sample rate should come from params")
	472	+	assert.Equal(t, 2, format.ChannelCount, "channel count should match callback channels arg")
	473	+	assert.Equal(t, 1024, format.FramesPerBuffer, "frames_per_buffer should come from params.FramesPerBuffer, not the channels arg")
	474	+	}
	475	+
	476	+	// TestBuildAudioStreamFormat_ChannelsArgDiffersFromLayout verifies correct
	477	+	// behavior when the callback's channels arg and the layout-derived count differ.
	478	+	// The channels callback arg is the authoritative channel count.
	479	+	func TestBuildAudioStreamFormat_ChannelsArgDiffersFromLayout(t *testing.T) {
	480	+	wv := &WebView{ctx: context.Background()}
	481	+	handlers := &handlerSet{wv: wv}
	482	+
	483	+	params := &purecef.AudioParameters{
	484	+	SampleRate: 44100,
	485	+	ChannelLayout: purecef.ChannelLayoutStereo, // layout says 2
	486	+	FramesPerBuffer: 512,
	487	+	}
	488	+	channels := int32(1) // but CEF says 1 channel
	489	+
	490	+	format := handlers.buildAudioStreamFormat(params, channels)
	491	+
	492	+	assert.Equal(t, 44100, format.SampleRate)
	493	+	assert.Equal(t, 1, format.ChannelCount, "should use callback channels arg, not layout-derived count")
	494	+	assert.Equal(t, 512, format.FramesPerBuffer, "should use params.FramesPerBuffer")
	495	+	}
	496	+
	497	+	// TestOnAudioStreamStarted_CorrectParameterMapping verifies end-to-end that
	498	+	// OnAudioStreamStarted passes the correct values to the factory:
	499	+	// - channels from the callback arg (not from params.FramesPerBuffer)
	500	+	// - framesPerBuffer from params.FramesPerBuffer
	501	+	func TestOnAudioStreamStarted_CorrectParameterMapping(t *testing.T) {
	502	+	ctx := context.Background()
	503	+	mockStream := &mockAudioStream{}
	504	+	mockFactory := &mockAudioFactory{stream: mockStream}
	505	+
	506	+	wv := &WebView{
	507	+	ctx: ctx,
	508	+	audioOutputFactory: mockFactory,
	509	+	}
	510	+
	511	+	handlers := &handlerSet{wv: wv}
	512	+
	513	+	params := &purecef.AudioParameters{
	514	+	SampleRate: 48000,
	515	+	ChannelLayout: purecef.ChannelLayoutStereo,
	516	+	FramesPerBuffer: 1024,
	517	+	}
	518	+
	519	+	// Third arg is channels=2, NOT framesPerBuffer.
	520	+	handlers.OnAudioStreamStarted(nil, params, 2)
	521	+
	522	+	require.NotNil(t, mockFactory.lastFormat)
	523	+	assert.Equal(t, 48000, mockFactory.lastFormat.SampleRate)
	524	+	assert.Equal(t, 2, mockFactory.lastFormat.ChannelCount, "channel count should be 2 (from callback arg)")
	525	+	assert.Equal(t, 1024, mockFactory.lastFormat.FramesPerBuffer, "frames_per_buffer should be 1024 (from params.FramesPerBuffer)")
	526	+	}
	527	+
	528	+	// ============================================================================
	529	+	// Race-window tests (write/close interleave)
	530	+	// ============================================================================
	531	+
	532	+	// TestOnAudioStreamPacket_WriteHoldsLock verifies that closeAudioStream cannot
	533	+	// interleave between the stream snapshot and Write. If the lock is NOT held
	534	+	// across Write, the goroutine calling closeAudioStream will Close the stream
	535	+	// while Write is in-flight, producing a write-after-close.
	536	+	func TestOnAudioStreamPacket_WriteHoldsLock(t *testing.T) {
	537	+	ctx := context.Background()
	538	+
	539	+	// racyStream blocks inside Write until we signal, giving closeAudioStream
	540	+	// a window to race if the mutex isn't held.
	541	+	stream := &racyMockAudioStream{
	542	+	writeCh: make(chan struct{}),
	543	+	doneCh: make(chan struct{}),
	544	+	}
	545	+
	546	+	wv := &WebView{
	547	+	ctx: ctx,
	548	+	activeAudioStream: stream,
	549	+	}
	550	+	handlers := &handlerSet{wv: wv}
	551	+
	552	+	data := [][]float32{{0.1, 0.2}, {0.3, 0.4}}
	553	+
	554	+	// Start a packet write — it will block inside Write.
	555	+	go handlers.OnAudioStreamPacket(nil, data, 2, 0)
	556	+
	557	+	// Wait for Write to be entered.
	558	+	<-stream.writeCh
	559	+
	560	+	// Now try to close. If the implementation holds the lock across Write,
	561	+	// this will block until Write returns. If not, Close races with Write.
	562	+	closeDone := make(chan struct{})
	563	+	go func() {
	564	+	wv.closeAudioStream()
	565	+	close(closeDone)
	566	+	}()
	567	+
	568	+	// Close should NOT have completed yet because Write holds the lock.
	569	+	// Give the goroutine time to acquire the lock if it can.
	570	+	time.Sleep(50 * time.Millisecond)
	571	+	select {
	572	+	case <-closeDone:
	573	+	t.Fatal("closeAudioStream completed while Write was in-flight — lock not held across Write")
	574	+	default:
	575	+	// expected: closeAudioStream is blocked
	576	+	}
	577	+
	578	+	// Unblock Write.
	579	+	close(stream.doneCh)
	580	+
	581	+	// Now closeAudioStream should complete.
	582	+	<-closeDone
	583	+
	584	+	assert.True(t, stream.closeCalled)
	585	+	assert.Nil(t, wv.activeAudioStream)
	586	+	}
	587	+
	588	+	// TestOnAudioStreamPacket_StreamClosedBetweenPackets verifies that when a
	589	+	// stream is closed between two OnAudioStreamPacket calls, the second call
	590	+	// sees nil and silently drops the packet.
	591	+	func TestOnAudioStreamPacket_StreamClosedBetweenPackets(t *testing.T) {
	592	+	ctx := context.Background()
	593	+	stream := &mockAudioStream{}
	594	+
	595	+	wv := &WebView{
	596	+	ctx: ctx,
	597	+	activeAudioStream: stream,
	598	+	}
	599	+	handlers := &handlerSet{wv: wv}
	600	+	data := [][]float32{{0.1, 0.2}, {0.3, 0.4}}
	601	+
	602	+	// First packet succeeds.
	603	+	handlers.OnAudioStreamPacket(nil, data, 2, 0)
	604	+	assert.True(t, stream.writeCalled)
	605	+
	606	+	// Close the stream.
	607	+	wv.closeAudioStream()
	608	+
	609	+	// Second packet should be silently dropped.
	610	+	assert.NotPanics(t, func() {
	611	+	handlers.OnAudioStreamPacket(nil, data, 2, 1)
	612	+	})
	613	+	}
	614	+
	615	+	// ============================================================================
	616	+	// Mock Factories
	617	+	// ============================================================================
	618	+
	619	+	// mockAudioFactory is a test double for port.AudioOutputFactory
	620	+	type mockAudioFactory struct {
	621	+	stream port.AudioOutputStream
	622	+	err error
	623	+	lastFormat *port.AudioStreamFormat
	624	+	lastCtx context.Context
	625	+	}
	626	+
	627	+	func (m *mockAudioFactory) NewStream(ctx context.Context, format port.AudioStreamFormat) (port.AudioOutputStream, error) {
	628	+	m.lastCtx = ctx
	629	+	m.lastFormat = &format
	630	+	return m.stream, m.err
	631	+	}
	632	+
	633	+	// Verify mock implements the interface
	634	+	var _ port.AudioOutputFactory = (*mockAudioFactory)(nil)

M internal/infrastructure/cef/webview_handlers.go +146 -8

@@ -1,6 +1,7 @@
1		package cef	1		package cef
2			2
3		import (	3		import (
			4	+	"context"
4		"strings"	5		"strings"
5			6
6		purecef "github.com/bnema/purego-cef/cef"	7		purecef "github.com/bnema/purego-cef/cef"

@@ -327,7 +328,8 @@ func (h *handlerSet) OnStatusMessage(_ purecef.Browser, value string) {
327		}	328		}
328			329
329		func (h *handlerSet) OnConsoleMessage(_ purecef.Browser, level purecef.LogSeverity, message, source string, line int32) int32 {	330		func (h *handlerSet) OnConsoleMessage(_ purecef.Browser, level purecef.LogSeverity, message, source string, line int32) int32 {
330	-	if h.wv != nil && h.wv.ctx != nil && (strings.Contains(message, consoleMarkerVideoDiag) \|\| strings.Contains(message, consoleMarkerRedditVideoPatch)) {	331	+	if h.wv != nil && h.wv.ctx != nil &&
			332	+	(strings.Contains(message, consoleMarkerVideoDiag) \|\| strings.Contains(message, consoleMarkerRedditVideoPatch)) {
331		log := logging.FromContext(h.wv.ctx).With().	333		log := logging.FromContext(h.wv.ctx).With().
332		Str("component", "cef-console").	334		Str("component", "cef-console").
333		Str("source", source).	335		Str("source", source).

@@ -460,8 +462,6 @@ func (h *handlerSet) OnLoadError(_ purecef.Browser, _ purecef.Frame, _ purecef.E
460		// OnBeforePopup intercepts popup requests (target="_blank", window.open).	462		// OnBeforePopup intercepts popup requests (target="_blank", window.open).
461		// CEF OSR cannot create popup windows, so we fire the OnCreate callback	463		// CEF OSR cannot create popup windows, so we fire the OnCreate callback
462		// to let the coordinator open the link in a new stacked pane.	464		// to let the coordinator open the link in a new stacked pane.
463	-	//
464	-	//nolint:gocritic // signature imposed by purecef.LifeSpanHandler interface
465		func (h *handlerSet) OnBeforePopup(	465		func (h *handlerSet) OnBeforePopup(
466		_ purecef.Browser, _ purecef.Frame, _ int32, targetURL, targetFrameName string,	466		_ purecef.Browser, _ purecef.Frame, _ int32, targetURL, targetFrameName string,
467		_ purecef.WindowOpenDisposition, userGesture int32, _ *purecef.PopupFeatures,	467		_ purecef.WindowOpenDisposition, userGesture int32, _ *purecef.PopupFeatures,

@@ -493,7 +493,6 @@ func (h *handlerSet) OnBeforePopup(
493			493
494		func (h *handlerSet) OnBeforePopupAborted(_ purecef.Browser, _ int32) {}	494		func (h *handlerSet) OnBeforePopupAborted(_ purecef.Browser, _ int32) {}
495			495
496	-	//nolint:gocritic // signature imposed by purecef.LifeSpanHandler interface
497		func (h *handlerSet) OnBeforeDevToolsPopup(	496		func (h *handlerSet) OnBeforeDevToolsPopup(
498		_ purecef.Browser, _ purecef.WindowInfo, _ purecef.Client,	497		_ purecef.Browser, _ purecef.WindowInfo, _ purecef.Client,
499		_ purecef.BrowserSettings, _ purecef.DictionaryValue, _ *bool,	498		_ purecef.BrowserSettings, _ purecef.DictionaryValue, _ *bool,

@@ -600,7 +599,7 @@ func (h *handlerSet) GetResourceRequestHandler(
600		*disableDefaultHandling = 1	599		*disableDefaultHandling = 1
601		if h.wv != nil && h.wv.ctx != nil {	600		if h.wv != nil && h.wv.ctx != nil {
602		logging.FromContext(h.wv.ctx).Info().	601		logging.FromContext(h.wv.ctx).Info().
603	-	Str("url", logging.TruncateURL(request.GetURL(), 240)).	602	+	Str("url", logging.TruncateURL(request.GetURL(), maxTranscodingURLLength)).
604		Msg("cef: disabled default handling for eager transcode candidate")	603		Msg("cef: disabled default handling for eager transcode candidate")
605		}	604		}
606		}	605		}

@@ -688,18 +687,157 @@ func (h handlerSet) GetAudioParameters(_ purecef.Browser, _ purecef.AudioParam
688		return 1 // proceed with defaults	687		return 1 // proceed with defaults
689		}	688		}
690			689
691	-	func (h handlerSet) OnAudioStreamStarted(_ purecef.Browser, _ purecef.AudioParameters, _ int32) {	690	+	// OnAudioStreamStarted handles the start of an audio stream.
			691	+	// The third callback argument is the channel count (not frames-per-buffer);
			692	+	// frames-per-buffer comes from params.FramesPerBuffer.
			693	+	func (h handlerSet) OnAudioStreamStarted(_ purecef.Browser, params purecef.AudioParameters, channels int32) {
			694	+	// Validate params and factory first
			695	+	if params == nil \|\| h.wv.audioOutputFactory == nil {
			696	+	return
			697	+	}
			698	+
			699	+	// Build format from CEF parameters
			700	+	format := h.buildAudioStreamFormat(params, channels)
			701	+
			702	+	if h.wv.ctx != nil {
			703	+	logging.FromContext(h.wv.ctx).Info().
			704	+	Int("sample_rate", format.SampleRate).
			705	+	Int("channels", format.ChannelCount).
			706	+	Int("frames_per_buffer", format.FramesPerBuffer).
			707	+	Int32("channel_layout", params.ChannelLayout).
			708	+	Msg("cef: OnAudioStreamStarted")
			709	+	}
			710	+
			711	+	// Reset packet counters for the new stream
			712	+	h.wv.audioPacketCount.Store(0)
			713	+	h.wv.audioWriteCount.Store(0)
			714	+
			715	+	// Close any existing stream first
			716	+	h.wv.closeAudioStream()
			717	+
			718	+	// Create new stream
			719	+	ctx := h.wv.ctx
			720	+	if ctx == nil {
			721	+	ctx = context.Background()
			722	+	}
			723	+
			724	+	stream, err := h.wv.audioOutputFactory.NewStream(ctx, format)
			725	+	if err != nil {
			726	+	// Log error but don't panic - audio is non-critical.
			727	+	// Do NOT set audioPlaying — the stream was never created.
			728	+	if h.wv.ctx != nil {
			729	+	logging.FromContext(h.wv.ctx).Warn().
			730	+	Err(err).
			731	+	Int("sample_rate", format.SampleRate).
			732	+	Int("channels", format.ChannelCount).
			733	+	Msg("cef: failed to create audio output stream")
			734	+	}
			735	+	return
			736	+	}
			737	+
			738	+	// Set playing state only after stream creation succeeds
692		h.wv.setAudioPlaying(true)	739		h.wv.setAudioPlaying(true)
			740	+
			741	+	if h.wv.ctx != nil {
			742	+	logging.FromContext(h.wv.ctx).Info().
			743	+	Int("sample_rate", format.SampleRate).
			744	+	Int("channels", format.ChannelCount).
			745	+	Int("frames_per_buffer", format.FramesPerBuffer).
			746	+	Msg("cef: audio output stream created successfully")
			747	+	}
			748	+
			749	+	// Store the new stream
			750	+	h.wv.audioStreamMu.Lock()
			751	+	h.wv.activeAudioStream = stream
			752	+	h.wv.audioStreamMu.Unlock()
693		}	753		}
694			754
695	-	func (h *handlerSet) OnAudioStreamPacket(_ purecef.Browser, _ [][]float32, _ int32, _ int64) {}	755	+	// buildAudioStreamFormat converts CEF AudioParameters to port.AudioStreamFormat.
			756	+	// channels is the authoritative channel count from the callback; params.FramesPerBuffer
			757	+	// supplies the buffer size.
			758	+	func (h handlerSet) buildAudioStreamFormat(params purecef.AudioParameters, channels int32) port.AudioStreamFormat {
			759	+	return port.AudioStreamFormat{
			760	+	SampleRate: int(params.SampleRate),
			761	+	ChannelCount: int(channels),
			762	+	FramesPerBuffer: int(params.FramesPerBuffer),
			763	+	}
			764	+	}
			765	+
			766	+	// OnAudioStreamPacket receives audio packets and forwards them to the output stream.
			767	+	// The mutex is held across both the stream snapshot and Write to prevent
			768	+	// closeAudioStream from closing the stream mid-write.
			769	+	func (h *handlerSet) OnAudioStreamPacket(_ purecef.Browser, data [][]float32, frames int32, pts int64) {
			770	+	if len(data) == 0 \|\| frames <= 0 {
			771	+	return
			772	+	}
			773	+
			774	+	// Copy the data before acquiring the stream lock because CEF can reuse the
			775	+	// buffer as soon as this callback returns.
			776	+	copiedData := make([][]float32, len(data))
			777	+	for i, channel := range data {
			778	+	if len(channel) < int(frames) {
			779	+	continue
			780	+	}
			781	+	copiedData[i] = make([]float32, frames)
			782	+	copy(copiedData[i], channel[:frames])
			783	+	}
			784	+
			785	+	// Hold the lock across the stream read and Write so closeAudioStream
			786	+	// cannot close the stream between snapshot and write.
			787	+	h.wv.audioStreamMu.Lock()
			788	+	stream := h.wv.activeAudioStream
			789	+	if stream == nil {
			790	+	h.wv.audioStreamMu.Unlock()
			791	+	return
			792	+	}
			793	+
			794	+	pktNum := h.wv.audioPacketCount.Add(1)
			795	+	if pktNum == 1 && h.wv.ctx != nil {
			796	+	logging.FromContext(h.wv.ctx).Info().
			797	+	Int("channels", len(data)).
			798	+	Int32("frames", frames).
			799	+	Int64("pts", pts).
			800	+	Msg("cef: first audio packet received")
			801	+	}
			802	+
			803	+	err := stream.Write(copiedData)
			804	+	h.wv.audioStreamMu.Unlock()
696			805
			806	+	if err != nil {
			807	+	if h.wv.ctx != nil {
			808	+	logging.FromContext(h.wv.ctx).Debug().
			809	+	Err(err).
			810	+	Uint64("packets_received", pktNum).
			811	+	Msg("cef: audio stream write failed")
			812	+	}
			813	+	return
			814	+	}
			815	+	h.wv.audioWriteCount.Add(1)
			816	+	}
			817	+
			818	+	// OnAudioStreamStopped handles stream stop.
697		func (h *handlerSet) OnAudioStreamStopped(_ purecef.Browser) {	819		func (h *handlerSet) OnAudioStreamStopped(_ purecef.Browser) {
			820	+	if h.wv.ctx != nil {
			821	+	logging.FromContext(h.wv.ctx).Info().
			822	+	Uint64("packets_received", h.wv.audioPacketCount.Load()).
			823	+	Uint64("writes_succeeded", h.wv.audioWriteCount.Load()).
			824	+	Msg("cef: OnAudioStreamStopped")
			825	+	}
698		h.wv.setAudioPlaying(false)	826		h.wv.setAudioPlaying(false)
			827	+	h.wv.closeAudioStream()
699		}	828		}
700			829
701	-	func (h *handlerSet) OnAudioStreamError(_ purecef.Browser, _ string) {	830	+	// OnAudioStreamError handles stream errors.
			831	+	func (h *handlerSet) OnAudioStreamError(_ purecef.Browser, message string) {
			832	+	if h.wv.ctx != nil {
			833	+	logging.FromContext(h.wv.ctx).Warn().
			834	+	Str("error", message).
			835	+	Uint64("packets_received", h.wv.audioPacketCount.Load()).
			836	+	Uint64("writes_succeeded", h.wv.audioWriteCount.Load()).
			837	+	Msg("cef: audio stream error")
			838	+	}
702		h.wv.setAudioPlaying(false)	839		h.wv.setAudioPlaying(false)
			840	+	h.wv.closeAudioStream()
703		}	841		}
704			842
705		// ===========================================================================	843		// ===========================================================================

M internal/infrastructure/config/defaults.go +1 -0


@@ -161,6 +161,7 @@ func DefaultConfig() *Config {
161	CEF: CEFEngineConfig{	161		CEF: CEFEngineConfig{
162	WindowlessFrameRate: defaultCEFWindowlessFrameRate,	162		WindowlessFrameRate: defaultCEFWindowlessFrameRate,
163	LogFile: "",	163		LogFile: "",
		164	+	EnableAudioHandler: true,
164	},	165		},
165	WebKit: WebKitEngineConfig{	166		WebKit: WebKitEngineConfig{
166	ITPEnabled: true,	167		ITPEnabled: true,

M internal/infrastructure/config/defaults_test.go +1 -1


@@ -22,7 +22,7 @@ func TestDefaultConfig_CoreDefaults(t *testing.T) {
22		assert.Equal(t, CookiePolicyAlways, cfg.Engine.CookiePolicy)	22		assert.Equal(t, CookiePolicyAlways, cfg.Engine.CookiePolicy)
23		assert.Equal(t, int32(defaultCEFWindowlessFrameRate), cfg.Engine.CEF.CEFWindowlessFrameRate())	23		assert.Equal(t, int32(defaultCEFWindowlessFrameRate), cfg.Engine.CEF.CEFWindowlessFrameRate())
24		assert.Empty(t, cfg.Engine.CEF.LogFile)	24		assert.Empty(t, cfg.Engine.CEF.LogFile)
25	-	assert.False(t, cfg.Engine.CEF.EnableAudioHandler)	25	+	assert.True(t, cfg.Engine.CEF.EnableAudioHandler)
26		assert.False(t, cfg.Engine.CEF.EnableContextMenuHandler)	26		assert.False(t, cfg.Engine.CEF.EnableContextMenuHandler)
27		assert.False(t, cfg.Engine.CEF.TraceHandlers)	27		assert.False(t, cfg.Engine.CEF.TraceHandlers)
28		assert.True(t, cfg.Engine.WebKit.ITPEnabled)	28		assert.True(t, cfg.Engine.WebKit.ITPEnabled)

M internal/infrastructure/config/engine.go +12 -12

 	EngineTypeCEF    = "cef"
 )
+// EngineConfig holds engine selection and universal engine options.
+type EngineConfig struct {
+	Type             string             `mapstructure:"type" toml:"type" yaml:"type"`
+	PoolPrewarmCount int                `mapstructure:"pool_prewarm_count" toml:"pool_prewarm_count" yaml:"pool_prewarm_count"`
+	ZoomCacheSize    int                `mapstructure:"zoom_cache_size" toml:"zoom_cache_size" yaml:"zoom_cache_size"`
+	Profile          PerformanceProfile `mapstructure:"profile" toml:"profile" yaml:"profile"`
+	CookiePolicy     CookiePolicy       `mapstructure:"cookie_policy" toml:"cookie_policy" yaml:"cookie_policy"`
+	WebKit           WebKitEngineConfig `mapstructure:"webkit" toml:"webkit" yaml:"webkit"`
+	CEF              CEFEngineConfig    `mapstructure:"cef" toml:"cef" yaml:"cef"`
+}
 // ResolveEngineType returns the effective engine type from config + env override.
 // It defaults to "webkit" when no type is configured, and allows DUMBER_ENGINE
 // to override the configured value for smoke testing.
 	return engineType
 }
-// EngineConfig holds engine selection and universal engine options.
-type EngineConfig struct {
-	Type             string             `mapstructure:"type" toml:"type" yaml:"type"`
-	PoolPrewarmCount int                `mapstructure:"pool_prewarm_count" toml:"pool_prewarm_count" yaml:"pool_prewarm_count"`
-	ZoomCacheSize    int                `mapstructure:"zoom_cache_size" toml:"zoom_cache_size" yaml:"zoom_cache_size"`
-	Profile          PerformanceProfile `mapstructure:"profile" toml:"profile" yaml:"profile"`
-	CookiePolicy     CookiePolicy       `mapstructure:"cookie_policy" toml:"cookie_policy" yaml:"cookie_policy"`
-	WebKit           WebKitEngineConfig `mapstructure:"webkit" toml:"webkit" yaml:"webkit"`
-	CEF              CEFEngineConfig    `mapstructure:"cef" toml:"cef" yaml:"cef"`
-}
 // WebKitEngineConfig holds WebKit-specific engine options.
 type WebKitEngineConfig struct {
 	// Skia rendering threads
 	// EnableAudioHandler opts into the experimental CEF AudioHandler bridge.
 	EnableAudioHandler bool `mapstructure:"enable_audio_handler" toml:"enable_audio_handler" yaml:"enable_audio_handler"`
 	// EnableContextMenuHandler opts into the experimental CEF ContextMenuHandler bridge.
-	EnableContextMenuHandler bool `mapstructure:"enable_context_menu_handler" toml:"enable_context_menu_handler" yaml:"enable_context_menu_handler"` //nolint:lll
+	EnableContextMenuHandler bool `mapstructure:"enable_context_menu_handler" toml:"enable_context_menu_handler" yaml:"enable_context_menu_handler"` //nolint:lll // struct tags exceed lll limit
 	// TraceHandlers enables purego-cef handler/refcount tracing for diagnostics.
 	TraceHandlers bool `mapstructure:"trace_handlers" toml:"trace_handlers" yaml:"trace_handlers"`
 }

M internal/infrastructure/config/validation.go +5 -2

 	domainvalidation "github.com/bnema/dumber/internal/domain/validation"
 )
+const cefLogSeverityDisabled = 99
 // validateConfig performs comprehensive validation of configuration values
 func validateConfig(config *Config) error {
 	var validationErrors []string
 	var validationErrors []string
 	switch config.Engine.CEF.LogSeverity {
-	case 0, 1, 2, 3, 4, 99:
+	case 0, 1, 2, 3, 4, cefLogSeverityDisabled:
 	default:
 		validationErrors = append(validationErrors, fmt.Sprintf(
-			"engine.cef.log_severity must be one of: 0, 1, 2, 3, 4, 99 (got: %d)",
+			"engine.cef.log_severity must be one of: 0, 1, 2, 3, 4, %d (got: %d)",
+			cefLogSeverityDisabled,
 			config.Engine.CEF.LogSeverity,
 		))
 	}

M internal/infrastructure/config/writer_test.go +10 -6

 package config
 import (
+	"bytes"
 	"os"
 	"path/filepath"
 	"strings"
 	}
 	// Match "enabled = true" specifically within the [transcoding] section to
 	// avoid false positives from other sections that may also have an enabled key.
-	transcodingIdx := strings.Index(string(content), "[transcoding]")
+	transcodingIdx := bytes.Index(content, []byte("[transcoding]"))
-	afterTranscoding := string(content)[transcodingIdx:]
+	if transcodingIdx < 0 {
-	nextSection := strings.Index(afterTranscoding[1:], "\n[")
+		t.Fatalf("expected transcoding section in generated config, got:\n%s", string(content))
-	var transcodingBlock string
+	}
+	afterTranscoding := content[transcodingIdx:]
+	nextSection := bytes.Index(afterTranscoding[1:], []byte("\n["))
+	var transcodingBlock []byte
 	if nextSection >= 0 {
 		transcodingBlock = afterTranscoding[:nextSection+1]
 	} else {
 		transcodingBlock = afterTranscoding
 	}
-	if !strings.Contains(transcodingBlock, "enabled = true") {
+	if !bytes.Contains(transcodingBlock, []byte("enabled = true")) {
-		t.Fatalf("expected enabled = true in [transcoding] section, got:\n%s", transcodingBlock)
+		t.Fatalf("expected enabled = true in [transcoding] section, got:\n%s", string(transcodingBlock))
 	}
 	t.Logf("Found %d sections, all sorted", len(sections))

M internal/infrastructure/filtering/manager_test.go +14 -0


@@ -51,6 +51,10 @@ func TestManager_LoadAsync_ChecksCacheFirst(t *testing.T) {
51	Return(nil, nil) // nil filter triggers fallback to download	51		Return(nil, nil) // nil filter triggers fallback to download
52		52
53	// Fallback: download will be triggered since Load returned nil filter	53		// Fallback: download will be triggered since Load returned nil filter
		54	+	mockDownloader.EXPECT().
		55	+	GetCachedFilterPaths().
		56	+	Return(nil)
		57	+
54	mockDownloader.EXPECT().	58		mockDownloader.EXPECT().
55	DownloadFilters(mock.Anything, mock.Anything).	59		DownloadFilters(mock.Anything, mock.Anything).
56	Return([]string{jsonFile}, nil)	60		Return([]string{jsonFile}, nil)

@@ -140,6 +144,10 @@ func TestManager_LoadAsync_DownloadsWhenCacheMiss(t *testing.T) {
140	Return([]string{}, nil)	144		Return([]string{}, nil)
141		145
142	// Download should be triggered	146		// Download should be triggered
		147	+	mockDownloader.EXPECT().
		148	+	GetCachedFilterPaths().
		149	+	Return(nil)
		150	+
143	mockDownloader.EXPECT().	151		mockDownloader.EXPECT().
144	DownloadFilters(mock.Anything, mock.Anything).	152		DownloadFilters(mock.Anything, mock.Anything).
145	Return([]string{jsonFile}, nil)	153		Return([]string{jsonFile}, nil)

@@ -455,6 +463,9 @@ func TestManager_StatusCallback_CalledOnStateChange(t *testing.T) {
455	mockStore.EXPECT().	463		mockStore.EXPECT().
456	Load(mock.Anything, "ublock-combined-0").	464		Load(mock.Anything, "ublock-combined-0").
457	Return(nil, nil) // nil triggers download fallback	465		Return(nil, nil) // nil triggers download fallback
		466	+	mockDownloader.EXPECT().
		467	+	GetCachedFilterPaths().
		468	+	Return(nil)
458	mockDownloader.EXPECT().	469		mockDownloader.EXPECT().
459	DownloadFilters(mock.Anything, mock.Anything).	470		DownloadFilters(mock.Anything, mock.Anything).
460	Return([]string{jsonFile}, nil)	471		Return([]string{jsonFile}, nil)

@@ -519,6 +530,9 @@ func TestManager_LoadAsync_QuarantinesInvalidDownloadedPayload(t *testing.T) {
519	mockStore.EXPECT().	530		mockStore.EXPECT().
520	FetchIdentifiers(mock.Anything).	531		FetchIdentifiers(mock.Anything).
521	Return([]string{}, nil)	532		Return([]string{}, nil)
		533	+	mockDownloader.EXPECT().
		534	+	GetCachedFilterPaths().
		535	+	Return(nil)
522		536
523	mockDownloader.EXPECT().	537		mockDownloader.EXPECT().
524	DownloadFilters(mock.Anything, mock.Anything).	538		DownloadFilters(mock.Anything, mock.Anything).

M internal/infrastructure/transcoder/audio.go +88 -73

 // 960 samples = 20 ms at 48 kHz, which is the standard Opus frame duration.
 const opusFrameSize = 960
+func freeCodecContext(ctx *unsafe.Pointer) {
+	//nolint:gosec // FFmpeg expects AVCodecContext** for ownership release.
+	ffmpeg.CodecFreeContext(unsafe.Pointer(ctx))
+}
+func freeFrame(frame *unsafe.Pointer) {
+	//nolint:gosec // FFmpeg expects AVFrame** for ownership release.
+	ffmpeg.FrameFree(unsafe.Pointer(frame))
+}
+func freeSwrContext(swr *unsafe.Pointer) {
+	//nolint:gosec // FFmpeg expects SwrContext** for ownership release.
+	ffmpeg.SwrFree(unsafe.Pointer(swr))
+}
+func freePacket(pkt *unsafe.Pointer) {
+	//nolint:gosec // FFmpeg expects AVPacket** for ownership release.
+	ffmpeg.PacketFree(unsafe.Pointer(pkt))
+}
+func swrConvert(swr, outFrame, inFrame unsafe.Pointer, outSamples, inSamples int32) int32 {
+	//nolint:gosec // FFmpeg expects raw AVFrame data pointers here.
+	return ffmpeg.SwrConvert(
+		swr,
+		unsafe.Pointer((*unsafe.Pointer)(outFrame)), outSamples,
+		unsafe.Pointer((*unsafe.Pointer)(inFrame)), inSamples,
+	)
+}
 // audioTranscoder decodes an input audio stream (typically AAC) and
 // re-encodes it to Opus, performing sample rate conversion if needed.
 type audioTranscoder struct {
 // outFmtCtx is the AVFormatContext* for the output container (used to
 // add the output stream). inStreamIdx is the input stream index.
 func newAudioTranscoder(inCodecPar, outFmtCtx unsafe.Pointer, inStreamIdx int) (*audioTranscoder, error) {
+	return newAudioTranscoderImpl(inCodecPar, outFmtCtx, inStreamIdx)
+}
+//nolint:gocyclo,funlen // FFmpeg decoder/encoder/resampler setup needs the necessary branches.
+func newAudioTranscoderImpl(inCodecPar, outFmtCtx unsafe.Pointer, inStreamIdx int) (*audioTranscoder, error) {
 	// --- Decoder setup ---
 	codecID := ffmpeg.CodecParCodecID(inCodecPar)
 	dec := ffmpeg.CodecFindDecoder(codecID)
 	}
 	if ret := ffmpeg.CodecParametersToContext(decCtx, inCodecPar); ret < 0 {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, fmt.Errorf("failed to copy audio codec parameters to decoder: %d", ret)
 	}
 	if ret := ffmpeg.CodecOpen2(decCtx, dec, nil); ret < 0 {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, fmt.Errorf("failed to open audio decoder: %d", ret)
 	}
 	// --- Encoder setup (libopus) ---
 	enc := ffmpeg.CodecFindEncoderByName("libopus")
 	if enc == nil {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, errors.New("libopus encoder not found")
 	}
 	encCtx := ffmpeg.CodecAllocContext3(enc)
 	if encCtx == nil {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, errors.New("failed to allocate audio encoder context")
 	}
 	// Note: WebM container does not require AV_CODEC_FLAG_GLOBAL_HEADER for Opus.
 	if ret := ffmpeg.CodecOpen2(encCtx, enc, nil); ret < 0 {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+		freeCodecContext(&encCtx)
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, fmt.Errorf("failed to open audio encoder: %d", ret)
 	}
 	// --- Add output stream ---
 	outStreamPtr := ffmpeg.FormatNewStream(outFmtCtx, nil)
 	if outStreamPtr == nil {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+		freeCodecContext(&encCtx)
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, errors.New("failed to create output audio stream")
 	}
 	// Copy encoder parameters to the output stream's codecpar.
 	if ret := ffmpeg.CodecParametersFromContext(outStreamWrap.Codecpar(), encCtx); ret < 0 {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+		freeCodecContext(&encCtx)
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, fmt.Errorf("failed to copy audio encoder params to stream: %d", ret)
 	}
 	if needResample {
 		swr = ffmpeg.SwrAlloc()
 		if swr == nil {
-			ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+			freeCodecContext(&encCtx)
-			ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+			freeCodecContext(&decCtx)
 			return nil, errors.New("failed to allocate resampler")
 		}
 		swrSetChLayoutFromCodecCtx(swr, decCtx, offsetSwrOutChLayout)
 		if ret := ffmpeg.SwrInit(swr); ret < 0 {
-			ffmpeg.SwrFree(unsafe.Pointer(&swr))
+			freeSwrContext(&swr)
-			ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+			freeCodecContext(&encCtx)
-			ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+			freeCodecContext(&decCtx)
 			return nil, fmt.Errorf("failed to init resampler: %d", ret)
 		}
 		// Allocate a reusable output frame for resampled data.
 		resampledFrame = ffmpeg.FrameAlloc()
 		if resampledFrame == nil {
-			ffmpeg.SwrFree(unsafe.Pointer(&swr))
+			freeSwrContext(&swr)
-			ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+			freeCodecContext(&encCtx)
-			ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+			freeCodecContext(&decCtx)
 			return nil, errors.New("failed to allocate resampled frame")
 		}
 	decFrame := ffmpeg.FrameAlloc()
 	if decFrame == nil {
 		if resampledFrame != nil {
-			ffmpeg.FrameFree(unsafe.Pointer(&resampledFrame))
+			freeFrame(&resampledFrame)
 		}
 		if swr != nil {
-			ffmpeg.SwrFree(unsafe.Pointer(&swr))
+			freeSwrContext(&swr)
 		}
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+		freeCodecContext(&encCtx)
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, errors.New("failed to allocate audio decode frame")
 	}
 	encPkt := ffmpeg.PacketAlloc()
 	if encPkt == nil {
-		ffmpeg.FrameFree(unsafe.Pointer(&decFrame))
+		freeFrame(&decFrame)
 		if resampledFrame != nil {
-			ffmpeg.FrameFree(unsafe.Pointer(&resampledFrame))
+			freeFrame(&resampledFrame)
 		}
 		if swr != nil {
-			ffmpeg.SwrFree(unsafe.Pointer(&swr))
+			freeSwrContext(&swr)
 		}
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
+		freeCodecContext(&encCtx)
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&decCtx))
+		freeCodecContext(&decCtx)
 		return nil, errors.New("failed to allocate audio encode packet")
 	}
 // to Opus, and writes the resulting packets to outFmtCtx.
 func (a *audioTranscoder) processPacket(pkt, outFmtCtx unsafe.Pointer) error {
 	// Send packet to decoder.
-	ret := ffmpeg.CodecSendPacket(a.decoder, pkt)
+	sendRet := ffmpeg.CodecSendPacket(a.decoder, pkt)
-	if ret < 0 {
+	if sendRet < 0 {
-		return fmt.Errorf("audio decode send packet: %d", ret)
+		return fmt.Errorf("audio decode send packet: %d", sendRet)
 	}
 	frame := a.decFrame
 	encPkt := a.encPkt
 	for {
-		ret = ffmpeg.CodecReceiveFrame(a.decoder, frame)
+		recvRet := ffmpeg.CodecReceiveFrame(a.decoder, frame)
-		if ret < 0 {
+		if recvRet < 0 {
 			// EAGAIN or EOF — no more frames from this packet.
 			break
 		}
 		if a.resampler != nil {
 			encFrame = a.frame
-			// AVFrame.data[0] is the first field at offset 0, so casting the
-			// frame pointer to *unsafe.Pointer yields &data[0]. This is the
-			// standard FFmpeg pattern for passing data pointers to swr_convert.
-			// purego-ffmpeg does not expose typed accessors for the data array,
-			// so raw pointer arithmetic is the only option.
-			inData := (*unsafe.Pointer)(frame)
-			outData := (*unsafe.Pointer)(a.frame)
 			inSamples := frameNbSamples(frame)
 			// Allocate buffer for output frame if needed.
 			frameSetNbSamples(a.frame, opusFrameSize)
-			if ret := ffmpeg.FrameGetBuffer(a.frame, 0); ret < 0 {
+			if bufferRet := ffmpeg.FrameGetBuffer(a.frame, 0); bufferRet < 0 {
 				ffmpeg.FrameUnref(frame)
-				return fmt.Errorf("failed to allocate resampled frame buffer: %d", ret)
+				return fmt.Errorf("failed to allocate resampled frame buffer: %d", bufferRet)
 			}
-			converted := ffmpeg.SwrConvert(
+			converted := swrConvert(a.resampler, a.frame, frame, opusFrameSize, inSamples)
-				a.resampler,
-				unsafe.Pointer(outData), opusFrameSize,
-				unsafe.Pointer(inData), inSamples,
-			)
 			if converted < 0 {
 				ffmpeg.FrameUnref(frame)
 				return fmt.Errorf("audio resample failed: %d", converted)
 		}
 		// Send frame to encoder.
-		if ret := ffmpeg.CodecSendFrame(a.encoder, encFrame); ret < 0 {
+		if sendFrameRet := ffmpeg.CodecSendFrame(a.encoder, encFrame); sendFrameRet < 0 {
 			ffmpeg.FrameUnref(frame)
-			return fmt.Errorf("audio encode send frame: %d", ret)
+			return fmt.Errorf("audio encode send frame: %d", sendFrameRet)
 		}
 		// Receive encoded packets.
 		for {
-			ret = ffmpeg.CodecReceivePacket(a.encoder, encPkt)
+			recvPktRet := ffmpeg.CodecReceivePacket(a.encoder, encPkt)
-			if ret < 0 {
+			if recvPktRet < 0 {
 				break
 			}
 	// Drain decoded frames.
 	for {
-		ret := ffmpeg.CodecReceiveFrame(a.decoder, frame)
+		recvRet := ffmpeg.CodecReceiveFrame(a.decoder, frame)
-		if ret < 0 {
+		if recvRet < 0 {
 			break
 		}
 		encFrame := frame
 		if a.resampler != nil {
 			encFrame = a.frame
-			// See processPacket for why these casts are safe: AVFrame.data[0]
-			// is at offset 0, so the frame pointer itself is &data[0].
-			inData := (*unsafe.Pointer)(frame)
-			outData := (*unsafe.Pointer)(a.frame)
 			inSamples := frameNbSamples(frame)
 			frameSetNbSamples(a.frame, opusFrameSize)
-			if ret := ffmpeg.FrameGetBuffer(a.frame, 0); ret < 0 {
+			if bufferRet := ffmpeg.FrameGetBuffer(a.frame, 0); bufferRet < 0 {
-				logger.Warn().Int32("ret", ret).Msg("failed to allocate resampled frame buffer during flush")
+				logger.Warn().Int32("ret", bufferRet).Msg("failed to allocate resampled frame buffer during flush")
 				ffmpeg.FrameUnref(frame)
 				continue
 			}
-			converted := ffmpeg.SwrConvert(
+			converted := swrConvert(a.resampler, a.frame, frame, opusFrameSize, inSamples)
-				a.resampler,
-				unsafe.Pointer(outData), opusFrameSize,
-				unsafe.Pointer(inData), inSamples,
-			)
 			if converted < 0 {
 				logger.Warn().Int32("ret", converted).Msg("audio resample failed during flush")
 				ffmpeg.FrameUnref(frame)
 		ffmpeg.CodecSendFrame(a.encoder, encFrame)
 		for {
-			ret := ffmpeg.CodecReceivePacket(a.encoder, encPkt)
+			recvPktRet := ffmpeg.CodecReceivePacket(a.encoder, encPkt)
-			if ret < 0 {
+			if recvPktRet < 0 {
 				break
 			}
 			pktSetStreamIndex(encPkt, int32(a.outStream))
 	// Flush encoder by sending NULL frame.
 	ffmpeg.CodecSendFrame(a.encoder, nil)
 	for {
-		ret := ffmpeg.CodecReceivePacket(a.encoder, encPkt)
+		flushPktRet := ffmpeg.CodecReceivePacket(a.encoder, encPkt)
-		if ret < 0 {
+		if flushPktRet < 0 {
 			break
 		}
 		pktSetStreamIndex(encPkt, int32(a.outStream))
 // close frees all FFmpeg resources owned by the audio transcoder.
 func (a *audioTranscoder) close() {
 	if a.encPkt != nil {
-		ffmpeg.PacketFree(unsafe.Pointer(&a.encPkt))
+		freePacket(&a.encPkt)
 	}
 	if a.decFrame != nil {
-		ffmpeg.FrameFree(unsafe.Pointer(&a.decFrame))
+		freeFrame(&a.decFrame)
 	}
 	if a.frame != nil {
-		ffmpeg.FrameFree(unsafe.Pointer(&a.frame))
+		freeFrame(&a.frame)
 	}
 	if a.resampler != nil {
-		ffmpeg.SwrFree(unsafe.Pointer(&a.resampler))
+		freeSwrContext(&a.resampler)
 	}
 	if a.encoder != nil {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&a.encoder))
+		freeCodecContext(&a.encoder)
 	}
 	if a.decoder != nil {
-		ffmpeg.CodecFreeContext(unsafe.Pointer(&a.decoder))
+		freeCodecContext(&a.decoder)
 	}
 }

M internal/infrastructure/transcoder/detect.go +4 -1

 // IsSyntheticTranscodeURL returns true for same-origin synthetic media URLs
 // that should be intercepted and resolved to an underlying source URL.
 func IsSyntheticTranscodeURL(rawURL string) bool {
-	_, _, _, ok := ParseSyntheticTranscodeURL(rawURL)
+	sourceURL, referer, origin, ok := ParseSyntheticTranscodeURL(rawURL)
+	_ = sourceURL
+	_ = referer
+	_ = origin
 	return ok
 }

M internal/infrastructure/transcoder/ffmpeg_offsets.go +11 -48

 // ---------------------------------------------------------------------------
 const (
-	offsetPktPts         = 8
-	offsetPktDts         = 16
 	offsetPktStreamIndex = 36
 )
 	*(*int32)(unsafe.Add(f, offsetFrameFormat)) = v
 }
-func frameSetHWFramesCtx(f unsafe.Pointer, v unsafe.Pointer) {
+func frameSetHWFramesCtx(f, v unsafe.Pointer) {
 	*(*unsafe.Pointer)(unsafe.Add(f, offsetFrameHWFramesCtx)) = v
 }
 	*(*int64)(unsafe.Add(f, offsetFramePts)) = v
 }
-func frameSampleRate(f unsafe.Pointer) int32 {
-	return *(*int32)(unsafe.Add(f, offsetFrameSampleRate))
-}
 func frameSetSampleRate(f unsafe.Pointer, v int32) {
 	*(*int32)(unsafe.Add(f, offsetFrameSampleRate)) = v
 }
 // ---------------------------------------------------------------------------
 const (
-	offsetCodecCtxFlags    = 64
 	offsetCodecCtxGopSize  = 332
 	offsetCodecCtxBitRate  = 56
 	offsetCodecCtxChLayout = 352 // AVChannelLayout struct (24 bytes)
 )
-// AV_CODEC_FLAG_GLOBAL_HEADER indicates the codec uses global headers
-// that should be stored in extradata instead of every keyframe.
-const avCodecFlagGlobalHeader = 1 << 22
-func codecCtxFlags(ctx unsafe.Pointer) int32 {
-	return *(*int32)(unsafe.Add(ctx, offsetCodecCtxFlags))
-}
-func codecCtxSetFlags(ctx unsafe.Pointer, v int32) {
-	*(*int32)(unsafe.Add(ctx, offsetCodecCtxFlags)) = v
-}
 func codecCtxSetGopSize(ctx unsafe.Pointer, v int32) {
 	*(*int32)(unsafe.Add(ctx, offsetCodecCtxGopSize)) = v
 }
 // chLayoutCopy copies the 24-byte AVChannelLayout from src to dst.
 // Both must point to the ch_layout field within their respective AVCodecContext.
+//
+//nolint:gosec // These offsets target fixed-size FFmpeg structs validated against headers.
 func codecCtxCopyChLayout(dst, src unsafe.Pointer) {
 	dstLayout := unsafe.Add(dst, offsetCodecCtxChLayout)
 	srcLayout := unsafe.Add(src, offsetCodecCtxChLayout)
 	// AVChannelLayout is 24 bytes in FFmpeg 8.x.
 	copy(
-		unsafe.Slice((*byte)(dstLayout), 24),
+		unsafe.Slice((*byte)(dstLayout), channelLayoutSize),
-		unsafe.Slice((*byte)(srcLayout), 24),
+		unsafe.Slice((*byte)(srcLayout), channelLayoutSize),
 	)
 }
 // ---------------------------------------------------------------------------
 const (
+	channelLayoutSize = 24
 	offsetSwrInChLayout  = 192 // AVChannelLayout (24 bytes)
 	offsetSwrOutChLayout = 216 // AVChannelLayout (24 bytes)
 )
 // swrCopyChLayoutFromCodecCtx copies an AVChannelLayout (24 bytes) from
 // an AVCodecContext's ch_layout field into the SwrContext's in/out ch_layout.
+//
+//nolint:gosec // These offsets target fixed-size FFmpeg structs validated against headers.
 func swrSetChLayoutFromCodecCtx(swr, codecCtx unsafe.Pointer, swrOffset int) {
 	dst := unsafe.Add(swr, swrOffset)
 	src := unsafe.Add(codecCtx, offsetCodecCtxChLayout)
 	copy(
-		unsafe.Slice((*byte)(dst), 24),
+		unsafe.Slice((*byte)(dst), channelLayoutSize),
-		unsafe.Slice((*byte)(src), 24),
+		unsafe.Slice((*byte)(src), channelLayoutSize),
-	)
-}
-// ---------------------------------------------------------------------------
-// AVCodecParameters additional offsets (FFmpeg 8.x, libavcodec 62)
-// ---------------------------------------------------------------------------
-const (
-	offsetCodecParSampleRate = 152
-	offsetCodecParChLayout   = 128 // AVChannelLayout (24 bytes)
-)
-func codecParSampleRate(par unsafe.Pointer) int32 {
-	return *(*int32)(unsafe.Add(par, offsetCodecParSampleRate))
-}
-// codecParCopyChLayoutTo copies the ch_layout from AVCodecParameters to
-// an AVCodecContext.
-func codecParCopyChLayoutTo(codecCtx, par unsafe.Pointer) {
-	dstLayout := unsafe.Add(codecCtx, offsetCodecCtxChLayout)
-	srcLayout := unsafe.Add(par, offsetCodecParChLayout)
-	copy(
-		unsafe.Slice((*byte)(dstLayout), 24),
-		unsafe.Slice((*byte)(srcLayout), 24),
 	)
 }

M internal/infrastructure/transcoder/hwprobe.go +5 -3

 	"av1_nvenc": true,
 }
+const hwAPINameVAAPI = "vaapi"
 // isUsableEncoder returns true only for hardware encoders whose output
 // codec is open and decodable by CEF (AV1, VP9).
 func isUsableEncoder(name string) bool {
 }
 var vaAPIProfile = hwProfile{
-	api:        "vaapi",
+	api:        hwAPINameVAAPI,
 	deviceType: int32(ffmpeg.HwdeviceTypeVaapi),
 	encoders:   []string{"av1_vaapi", "vp9_vaapi", "h264_vaapi"},
 	decoders:   []string{"h264_vaapi", "hevc_vaapi"},
 	var profiles []hwProfile
 	switch hwaccelPref {
-	case "vaapi":
+	case hwAPINameVAAPI:
 		profiles = []hwProfile{vaAPIProfile}
 	case "nvenc":
 		profiles = []hwProfile{nvencProfile}
-	default: // "auto" or unrecognised
+	default: // "auto" or unrecognized
 		profiles = []hwProfile{vaAPIProfile, nvencProfile}
 	}

M internal/infrastructure/transcoder/pipeline.go +78 -32

 // avioBufSize is the buffer size for custom AVIO contexts (32 KiB).
 const avioBufSize = 32 * 1024
+const (
+	vaapiInitialPoolSize = 20
+	minVideoBitrate      = 500_000
+)
 // pipeline orchestrates a single GPU transcode session. It reads from
 // an HTTP source, decodes with a hardware decoder (or software fallback),
 // encodes video to an open codec (AV1/VP9) via GPU, encodes audio to
 	headers   map[string]string
 	quality   string
 	pw        *io.PipeWriter
-	cancel    context.CancelFunc
 	logger    zerolog.Logger
 	// Prevent GC of callback closures and uintptrs.
 	},
 }
-func newPipeline(sessionID string, hwCaps port.HWCapabilities, sourceURL string, headers map[string]string, quality string, pw *io.PipeWriter, logger zerolog.Logger) *pipeline {
+func newPipeline(
+	sessionID string,
+	hwCaps port.HWCapabilities,
+	sourceURL string,
+	headers map[string]string,
+	quality string,
+	pw *io.PipeWriter,
+	logger zerolog.Logger,
+) *pipeline {
 	return &pipeline{
 		sessionID: sessionID,
 		hwCaps:    hwCaps,
 			Str("source_url", p.sourceURL).
 			Logger()
 		if errors.Is(err, context.Canceled) {
-			log.Debug().Err(err).Msg("transcode pipeline cancelled")
+			log.Debug().Err(err).Msg("transcode pipeline canceled")
 		} else {
 			log.Error().Err(err).Msg("transcode pipeline failed")
 		}
-		p.pw.CloseWithError(err)
+		_ = p.pw.CloseWithError(err)
 	} else {
 		p.logger.Debug().
 			Str("session_id", p.sessionID).
 			Str("source_url", p.sourceURL).
 			Msg("transcode pipeline completed")
-		p.pw.Close()
+		_ = p.pw.Close()
 	}
 }
 // doRun contains the actual pipeline logic. Errors are returned, and
 // the caller (run) closes the pipe writer accordingly.
 func (p *pipeline) doRun(ctx context.Context) error {
+	return p.doRunImpl(ctx)
+}
+//nolint:gocyclo,funlen,gosec // FFmpeg pipeline setup/teardown uses necessary branching and unsafe C-API calls.
+func (p *pipeline) doRunImpl(ctx context.Context) error {
 	// --- Step 1-3: Open the input using the appropriate strategy ---
 	inFmtCtx, closeInput, err := p.openInputFormatContext(ctx)
 	if err != nil {
 	if err != nil {
 		return fmt.Errorf("open video decoder: %w", err)
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 	defer ffmpeg.CodecFreeContext(unsafe.Pointer(&vidDecCtx))
 	// --- Step 7-8: Open video encoder with HW accel ---
 	if hwDeviceCtx != nil {
 		defer ffmpeg.BufferUnref(&hwDeviceCtx)
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 	defer ffmpeg.CodecFreeContext(unsafe.Pointer(&vidEncCtx))
 	// --- Step 9: Create output format context for WebM ---
 	var outFmtCtx unsafe.Pointer
+	//nolint:gosec // FFmpeg requires pointer-to-pointer allocation for output contexts.
 	if ret := ffmpeg.FormatAllocOutputContext2(unsafe.Pointer(&outFmtCtx), nil, "webm", ""); ret < 0 {
 		return fmt.Errorf("alloc output context: %d", ret)
 	}
 		if bufSize <= 0 {
 			return 0
 		}
+		//nolint:gosec // FFmpeg supplies a valid callback buffer and explicit byte count here.
 		goBuf := unsafe.Slice((*byte)(buf), int(bufSize))
 		n, writeErr := pw.Write(goBuf)
 		if writeErr != nil {
 	if writeAVIO == nil {
 		return errors.New("failed to allocate write AVIO context")
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for AVIO contexts.
 	defer ffmpeg.AvioContextFree(unsafe.Pointer(&writeAVIO))
 	ffmpeg.FmtCtxSetPB(outFmtCtx, writeAVIO)
 		audioCodecPar := audioStreamWrap.Codecpar()
 		var txErr error
-		audioTx, txErr = newAudioTranscoder(audioCodecPar, outFmtCtx, int(audioIdx))
+		audioTx, txErr = newAudioTranscoder(audioCodecPar, outFmtCtx, audioIdx)
 		if txErr != nil {
 			// Audio transcoding failure is non-fatal; we proceed with video only.
 			audioTx = nil
 	if pkt == nil {
 		return errors.New("failed to allocate read packet")
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for packet allocations.
 	defer ffmpeg.PacketFree(unsafe.Pointer(&pkt))
 	frame := ffmpeg.FrameAlloc()
 	if frame == nil {
 		return errors.New("failed to allocate decode frame")
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for frame allocations.
 	defer ffmpeg.FrameFree(unsafe.Pointer(&frame))
 	encPkt := ffmpeg.PacketAlloc()
 	if encPkt == nil {
 		return errors.New("failed to allocate encode packet")
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for packet allocations.
 	defer ffmpeg.PacketFree(unsafe.Pointer(&encPkt))
 	for {
 		switch {
 		case streamIdx == videoIdx:
-			if err := p.transcodeVideoPacket(pkt, frame, encPkt, vidDecCtx, vidEncCtx, outFmtCtx, videoStreamWrap, outVideoIdx); err != nil {
+			if err := p.transcodeVideoPacket(pkt, frame, encPkt, vidDecCtx, vidEncCtx, outFmtCtx, outVideoIdx); err != nil {
 				ffmpeg.PacketUnref(pkt)
 				return fmt.Errorf("video transcode: %w", err)
 			}
 		if ret < 0 {
 			break
 		}
-		p.encodeAndWriteVideoFrame(frame, encPkt, vidEncCtx, outFmtCtx, videoStreamWrap, outVideoIdx)
+		if err := p.encodeAndWriteVideoFrame(frame, encPkt, vidEncCtx, outFmtCtx, outVideoIdx); err != nil {
+			ffmpeg.FrameUnref(frame)
+			return fmt.Errorf("video flush: %w", err)
+		}
 		ffmpeg.FrameUnref(frame)
 	}
 	return nil
 }
-func (p *pipeline) selectInputStreams(inFmtCtx unsafe.Pointer) (videoIdx int, audioIdx int, err error) {
+func (p *pipeline) selectInputStreams(inFmtCtx unsafe.Pointer) (videoIdx, audioIdx int, err error) {
 	videoIdx = -1
 	audioIdx = -1
 	bestVideoPixels := int64(-1)
 		}
 		switch ffmpeg.CodecParCodecType(codecPar) {
-		case int32(ffmpeg.AVMEDIA_TYPE_VIDEO):
+		case ffmpeg.AVMEDIA_TYPE_VIDEO:
 			width := int64(ffmpeg.CodecParWidth(codecPar))
 			height := int64(ffmpeg.CodecParHeight(codecPar))
 			pixels := width * height
 				videoIdx = i
 				bestVideoPixels = pixels
 			}
-		case int32(ffmpeg.AVMEDIA_TYPE_AUDIO):
+		case ffmpeg.AVMEDIA_TYPE_AUDIO:
 			if audioIdx == -1 {
 				audioIdx = i
 			}
 }
 func (p *pipeline) openCustomIOInputContext(ctx context.Context) (unsafe.Pointer, func(), error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, p.sourceURL, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, p.sourceURL, http.NoBody)
 	if err != nil {
 		return nil, nil, fmt.Errorf("create request: %w", err)
 	}
 		req.Header.Set(k, v)
 	}
-	resp, err := httpClient.Do(req)
+	resp, err := httpClient.Do(req) //nolint:bodyclose // closed by returned cleanup after FFmpeg finishes reading.
 	if err != nil {
 		return nil, nil, fmt.Errorf("fetch source: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
-		resp.Body.Close()
+		_ = resp.Body.Close()
 		return nil, nil, fmt.Errorf("source returned HTTP %d", resp.StatusCode)
 	}
 		if bufSize <= 0 {
 			return -1
 		}
+		//nolint:gosec // FFmpeg supplies a valid callback buffer and explicit byte count here.
 		goBuf := unsafe.Slice((*byte)(buf), int(bufSize))
 		// Retry up to 3 times for the edge case where body.Read returns
 		// n=0, err=nil (allowed by the io.Reader contract but unusual).
 	readAVIO := ffmpeg.AvioAllocContext(avioBufSize, false, nil, p.readCb, 0, 0)
 	if readAVIO == nil {
-		resp.Body.Close()
+		_ = resp.Body.Close()
 		return nil, nil, errors.New("failed to allocate read AVIO context")
 	}
 	inFmtCtx := ffmpeg.FormatAllocContext()
 	if inFmtCtx == nil {
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for AVIO contexts.
 		ffmpeg.AvioContextFree(unsafe.Pointer(&readAVIO))
-		resp.Body.Close()
+		_ = resp.Body.Close()
 		return nil, nil, errors.New("failed to allocate input format context")
 	}
 	ffmpeg.FmtCtxSetPB(inFmtCtx, readAVIO)
 	ffmpeg.FmtCtxSetFlags(inFmtCtx, ffmpeg.FmtCtxFlags(inFmtCtx)|ffmpeg.AVFMT_FLAG_CUSTOM_IO)
+	//nolint:gosec // FFmpeg requires pointer-to-pointer input opening for format contexts.
 	if ret := ffmpeg.FormatOpenInput(unsafe.Pointer(&inFmtCtx), p.sourceURL, nil, nil); ret < 0 {
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for AVIO contexts.
 		ffmpeg.AvioContextFree(unsafe.Pointer(&readAVIO))
-		resp.Body.Close()
+		_ = resp.Body.Close()
 		ffmpeg.FormatFreeContext(inFmtCtx)
 		return nil, nil, fmt.Errorf("open input: %d", ret)
 	}
 	cleanup := func() {
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for format contexts.
 		ffmpeg.FormatCloseInput(unsafe.Pointer(&inFmtCtx))
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for AVIO contexts.
 		ffmpeg.AvioContextFree(unsafe.Pointer(&readAVIO))
-		resp.Body.Close()
+		_ = resp.Body.Close()
 	}
 	return inFmtCtx, cleanup, nil
 }
 		}
 	}
+	//nolint:gosec // FFmpeg requires pointer-to-pointer input opening for format contexts and option dictionaries.
 	if ret := ffmpeg.FormatOpenInput(unsafe.Pointer(&inFmtCtx), p.sourceURL, nil, unsafe.Pointer(&opts)); ret < 0 {
 		ffmpeg.FormatFreeContext(inFmtCtx)
 		return nil, nil, fmt.Errorf("open manifest input: %d", ret)
 	}
 	return inFmtCtx, func() {
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for format contexts.
 		ffmpeg.FormatCloseInput(unsafe.Pointer(&inFmtCtx))
 	}, nil
 }
 	}
 	// av_dict_free expects an AVDictionary**. Passing the dictionary pointer
 	// itself corrupts memory and can crash inside libavutil during cleanup.
+	//nolint:gosec // FFmpeg requires passing the dictionary pointer by address for cleanup.
 	ffmpeg.DictFree(unsafe.Pointer(opts))
 	*opts = nil
 }
 	if value == "" {
 		return nil
 	}
+	//nolint:gosec // FFmpeg requires passing the dictionary pointer by address for option updates.
 	if ret := ffmpeg.DictSet(unsafe.Pointer(opts), key, value, 0); ret < 0 {
 		return fmt.Errorf("set input option %q: %d", key, ret)
 	}
 // openVideoDecoder creates and opens a decoder context for the video stream.
 // It prefers hardware decoders (h264_vaapi, h264_cuvid) based on hwCaps,
 // falling back to the generic software decoder.
+//
+//nolint:gosec // FFmpeg decoder setup requires unsafe pointer-based contexts and cleanup.
 func (p *pipeline) openVideoDecoder(codecPar unsafe.Pointer) (unsafe.Pointer, error) {
 	codecID := ffmpeg.CodecParCodecID(codecPar)
 // openVideoEncoder creates a hardware device context and encoder for
 // the video stream. It uses the first available encoder from hwCaps.Encoders.
-func (p *pipeline) openVideoEncoder(decCtx unsafe.Pointer) (hwDeviceCtx unsafe.Pointer, encCtx unsafe.Pointer, err error) {
+func (p *pipeline) openVideoEncoder(decCtx unsafe.Pointer) (hwDeviceCtx, encCtx unsafe.Pointer, err error) {
 	if len(p.hwCaps.Encoders) == 0 {
 		return nil, nil, errors.New("no GPU encoders available")
 	}
 	// Create the HW device context.
 	var deviceType int32
 	switch p.hwCaps.API {
-	case "vaapi":
+	case hwAPINameVAAPI:
 		deviceType = int32(ffmpeg.HwdeviceTypeVaapi)
 	case "nvenc":
 		deviceType = int32(ffmpeg.HwdeviceTypeCuda)
 	ffmpeg.CodecCtxSetFramerate(encCtx, framerate)
 	ffmpeg.CodecCtxSetTimeBase(encCtx, ffmpeg.AVRational{Num: framerate.Den, Den: framerate.Num})
-	if p.hwCaps.API == "vaapi" {
+	if p.hwCaps.API == hwAPINameVAAPI {
 		ffmpeg.CodecCtxSetPixFmt(encCtx, int32(ffmpeg.PixFmtVaapi))
 	} else {
 		ffmpeg.CodecCtxSetPixFmt(encCtx, int32(ffmpeg.PixFmtNv12))
 	}
-	gopSize := int32(framerate.Num / framerate.Den * 2)
+	gopSize := framerate.Num / framerate.Den * 2
 	if gopSize <= 0 {
 		gopSize = 60
 	}
 	hwDeviceRef := ffmpeg.BufferRef(hwDeviceCtx)
 	if hwDeviceRef == nil {
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
 		return nil, errors.New("failed to ref HW device context for encoder")
 	}
 	ffmpeg.CodecCtxSetHwDeviceCtx(encCtx, hwDeviceRef)
-	if p.hwCaps.API == "vaapi" {
+	if p.hwCaps.API == hwAPINameVAAPI {
 		framesRef := ffmpeg.HWFrameCtxAlloc(hwDeviceCtx)
 		if framesRef == nil {
+			//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 			ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
 			return nil, errors.New("failed to allocate HW frames context")
 		}
 		hwFramesData := ffmpeg.BufferRefData(framesRef)
 		if hwFramesData == nil {
 			ffmpeg.BufferUnref(&framesRef)
+			//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 			ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
 			return nil, errors.New("failed to access HW frames context payload")
 		}
-		ffmpeg.HWFramesCtxSetInitialPoolSize(hwFramesData, 20)
+		ffmpeg.HWFramesCtxSetInitialPoolSize(hwFramesData, vaapiInitialPoolSize)
 		ffmpeg.HWFramesCtxSetFormat(hwFramesData, int32(ffmpeg.PixFmtVaapi))
 		ffmpeg.HWFramesCtxSetSWFormat(hwFramesData, int32(ffmpeg.PixFmtNv12))
 		ffmpeg.HWFramesCtxSetWidth(hwFramesData, width)
 		if ret := ffmpeg.HWFrameCtxInit(framesRef); ret < 0 {
 			ffmpeg.BufferUnref(&framesRef)
+			//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 			ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
 			return nil, fmt.Errorf("init HW frames context: %d", ret)
 		}
 	}
 	if ret := ffmpeg.CodecOpen2(encCtx, enc, nil); ret < 0 {
+		//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for codec contexts.
 		ffmpeg.CodecFreeContext(unsafe.Pointer(&encCtx))
 		return nil, fmt.Errorf("open video encoder %s: %d", encoderName, ret)
 	}
 	}
 	bitrate := int64(float64(pixels) * bitsPerPixel)
-	if bitrate < 500_000 {
+	if bitrate < minVideoBitrate {
-		bitrate = 500_000 // floor at 500 kbps
+		bitrate = minVideoBitrate // floor at 500 kbps
 	}
 	codecCtxSetBitRate(encCtx, bitrate)
 // transcodeVideoPacket decodes a video packet, encodes the resulting
 // frames, and writes them to the output.
-func (p *pipeline) transcodeVideoPacket(pkt, frame, encPkt, decCtx, encCtx, outFmtCtx unsafe.Pointer, inStreamWrap ffmpeg.Stream, outVideoIdx int) error {
+func (p *pipeline) transcodeVideoPacket(pkt, frame, encPkt, decCtx, encCtx, outFmtCtx unsafe.Pointer, outVideoIdx int) error {
 	ret := ffmpeg.CodecSendPacket(decCtx, pkt)
 	if ret < 0 {
 		return fmt.Errorf("video decode send packet: %d", ret)
 			break
 		}
-		if err := p.encodeAndWriteVideoFrame(frame, encPkt, encCtx, outFmtCtx, inStreamWrap, outVideoIdx); err != nil {
+		if err := p.encodeAndWriteVideoFrame(frame, encPkt, encCtx, outFmtCtx, outVideoIdx); err != nil {
 			ffmpeg.FrameUnref(frame)
 			return err
 		}
 // encodeAndWriteVideoFrame sends a decoded frame to the encoder and
 // writes any resulting packets to the output.
-func (p *pipeline) encodeAndWriteVideoFrame(frame, encPkt, encCtx, outFmtCtx unsafe.Pointer, inStreamWrap ffmpeg.Stream, outVideoIdx int) error {
+func (p *pipeline) encodeAndWriteVideoFrame(frame, encPkt, encCtx, outFmtCtx unsafe.Pointer, outVideoIdx int) error {
 	encFrame := frame
 	var cleanup func()
-	if p.hwCaps.API == "vaapi" {
+	if p.hwCaps.API == hwAPINameVAAPI {
 		var err error
-		encFrame, cleanup, err = p.uploadVideoFrameToVAAPI(frame, encCtx)
+		encFrame, cleanup, err = uploadVideoFrameToVAAPI(frame, encCtx)
 		if err != nil {
 			return err
 		}
 	return nil
 }
-func (p *pipeline) uploadVideoFrameToVAAPI(frame, encCtx unsafe.Pointer) (unsafe.Pointer, func(), error) {
+func uploadVideoFrameToVAAPI(frame, encCtx unsafe.Pointer) (unsafe.Pointer, func(), error) {
 	if frameFormat(frame) == int32(ffmpeg.PixFmtVaapi) {
 		return frame, func() {}, nil
 	}
 	cleanup := func() {
 		if hwFrame != nil {
+			//nolint:gosec // FFmpeg requires pointer-to-pointer cleanup for frame allocations.
 			ffmpeg.FrameFree(unsafe.Pointer(&hwFrame))
 		}
 	}

M internal/infrastructure/transcoder/pool.go +2 -2


@@ -39,7 +39,7 @@ func (s *session) Close() error {
39		}	39		}
40			40
41		// ContentType returns the MIME type of the transcoded output.	41		// ContentType returns the MIME type of the transcoded output.
42	-	func (s *session) ContentType() string {	42	+	func (*session) ContentType() string {
43		return "video/webm"	43		return "video/webm"
44		}	44		}
45			45

@@ -106,6 +106,6 @@ func (p *sessionPool) closeAll() {
106			106
107		// Close sessions outside the lock.	107		// Close sessions outside the lock.
108		for _, s := range snapshot {	108		for _, s := range snapshot {
109	-	s.Close()	109	+	_ = s.Close()
110		}	110		}
111		}	111		}

M internal/infrastructure/transcoder/transcoder.go +4 -4


@@ -84,7 +84,7 @@ func (t *Transcoder) Capabilities() port.HWCapabilities {
84		// Start begins a transcode session. It spawns a goroutine running the	84		// Start begins a transcode session. It spawns a goroutine running the
85		// FFmpeg pipeline and returns a TranscodeSession whose Read() streams	85		// FFmpeg pipeline and returns a TranscodeSession whose Read() streams
86		// the transcoded WebM output. The session is automatically removed from	86		// the transcoded WebM output. The session is automatically removed from
87	-	// the pool when the pipeline completes or the context is cancelled.	87	+	// the pool when the pipeline completes or the context is canceled.
88		func (t *Transcoder) Start(ctx context.Context, sourceURL string, headers map[string]string) (port.TranscodeSession, error) {	88		func (t *Transcoder) Start(ctx context.Context, sourceURL string, headers map[string]string) (port.TranscodeSession, error) {
89		if !t.Available() {	89		if !t.Available() {
90		return nil, errors.New("transcoder: no GPU encoder available")	90		return nil, errors.New("transcoder: no GPU encoder available")

@@ -107,8 +107,8 @@ func (t *Transcoder) Start(ctx context.Context, sourceURL string, headers map[st
107		// Check capacity and register before spawning the goroutine.	107		// Check capacity and register before spawning the goroutine.
108		if err := t.pool.add(s); err != nil {	108		if err := t.pool.add(s); err != nil {
109		cancel()	109		cancel()
110	-	pr.Close()	110	+	_ = pr.Close()
111	-	pw.Close()	111	+	_ = pw.Close()
112		return nil, fmt.Errorf("transcoder: %w", err)	112		return nil, fmt.Errorf("transcoder: %w", err)
113		}	113		}
114			114

@@ -128,7 +128,7 @@ func (t *Transcoder) Start(ctx context.Context, sourceURL string, headers map[st
128		defer func() {	128		defer func() {
129		if r := recover(); r != nil {	129		if r := recover(); r != nil {
130		t.logger.Error().Str("session_id", id).Interface("panic", r).Msg("transcode session panicked")	130		t.logger.Error().Str("session_id", id).Interface("panic", r).Msg("transcode session panicked")
131	-	pw.CloseWithError(fmt.Errorf("transcode session panicked: %v", r))	131	+	_ = pw.CloseWithError(fmt.Errorf("transcode session panicked: %v", r))
132		}	132		}
133		}()	133		}()
134		p.run(sessionCtx)	134		p.run(sessionCtx)

M internal/logging/logger_test.go +4 -4


@@ -27,8 +27,8 @@ func TestSessionFileWriter_DropsWritesAfterClose(t *testing.T) {
27		t.Fatalf("write before close returned %d, want %d", n, len("first\n"))	27		t.Fatalf("write before close returned %d, want %d", n, len("first\n"))
28		}	28		}
29			29
30	-	if err := writer.Close(); err != nil {	30	+	if closeErr := writer.Close(); closeErr != nil {
31	-	t.Fatalf("close writer: %v", err)	31	+	t.Fatalf("close writer: %v", closeErr)
32		}	32		}
33			33
34		n, err = writer.Write([]byte("second\n"))	34		n, err = writer.Write([]byte("second\n"))

@@ -60,8 +60,8 @@ func TestSessionFileWriter_IgnoresExternallyClosedFile(t *testing.T) {
60		}	60		}
61			61
62		writer := newSessionFileWriter(file)	62		writer := newSessionFileWriter(file)
63	-	if err := file.Close(); err != nil {	63	+	if closeErr := file.Close(); closeErr != nil {
64	-	t.Fatalf("close underlying file: %v", err)	64	+	t.Fatalf("close underlying file: %v", closeErr)
65		}	65		}
66			66
67		n, err := writer.Write([]byte("late\n"))	67		n, err := writer.Write([]byte("late\n"))

M internal/ui/adapter/favicon.go +72 -71


@@ -113,11 +113,7 @@ func (a *FaviconAdapter) GetOrFetch(ctx context.Context, pageURL string, callbac
113			113
114		// Handle internal dumb:// scheme URLs - use app logo	114		// Handle internal dumb:// scheme URLs - use app logo
115		if a.isInternalURL != nil && a.isInternalURL(pageURL) {	115		if a.isInternalURL != nil && a.isInternalURL(pageURL) {
116	-	texture := a.textureFromBytesOnGTK(ctx, a.getLogoBytes())	116	+	callback(a.getOrCreateLogoTexture(ctx))
117	-	if texture != nil {
118	-	a.setTexture(a.internalDomain, texture)
119	-	}
120	-	callback(texture)
121		return	117		return
122		}	118		}
123			119

@@ -152,82 +148,87 @@ func (a *FaviconAdapter) GetOrFetch(ctx context.Context, pageURL string, callbac
152		}	148		}
153		}	149		}
154			150
155	-	// Helper to invoke callback on main thread	151	+	// Try engine FaviconDatabase if available
156	-	invokeCallback := func(texture *gdk.Texture) {	152	+	if a.faviconDB != nil {
157	-	log.Debug().	153	+	a.faviconDB.GetFaviconAsync(pageURL, func(tex port.Texture) {
158	-	Str("domain", domain).	154	+	a.handleEngineFaviconDBTexture(ctx, domain, callback, tex)
159	-	Bool("texture_nil", texture == nil).
160	-	Msg("favicon: scheduling callback on GTK")
161	-	cb := glib.SourceFunc(func(uintptr) bool {
162	-	log.Debug().
163	-	Str("domain", domain).
164	-	Bool("texture_nil", texture == nil).
165	-	Msg("favicon: callback executing on GTK")
166	-	callback(texture)
167	-	return false
168		})	155		})
169	-	glib.IdleAdd(&cb, 0)	156	+	return
170		}	157		}
171			158
172	-	// Helper to fetch via service and invoke callback	159	+	// No WebKit DB, fetch via service directly
173	-	fetchViaService := func() {	160	+	log.Debug().Str("domain", domain).Msg("favicon: no engine db, fetching via service")
174	-	go func() {	161	+	a.fetchViaService(ctx, domain, callback)
175	-	log.Debug().Str("domain", domain).Msg("favicon: fetchViaService begin")	162	+	}
176	-	data, err := a.service.Get(ctx, domain)
177	-	if err != nil \|\| len(data) == 0 {
178	-	log.Debug().
179	-	Err(err).
180	-	Str("domain", domain).
181	-	Int("bytes", len(data)).
182	-	Msg("favicon: fetchViaService empty/error result")
183	-	invokeCallback(nil)
184	-	return
185	-	}
186			163
			164	+	func (a FaviconAdapter) invokeCallbackOnGTK(ctx context.Context, domain string, callback func(gdk.Texture), texture *gdk.Texture) {
			165	+	log := logging.FromContext(ctx)
			166	+	log.Debug().
			167	+	Str("domain", domain).
			168	+	Bool("texture_nil", texture == nil).
			169	+	Msg("favicon: scheduling callback on GTK")
			170	+	cb := glib.SourceFunc(func(uintptr) bool {
			171	+	log.Debug().
			172	+	Str("domain", domain).
			173	+	Bool("texture_nil", texture == nil).
			174	+	Msg("favicon: callback executing on GTK")
			175	+	callback(texture)
			176	+	return false
			177	+	})
			178	+	glib.IdleAdd(&cb, 0)
			179	+	}
			180	+
			181	+	func (a FaviconAdapter) fetchViaService(ctx context.Context, domain string, callback func(gdk.Texture)) {
			182	+	go func() {
			183	+	log := logging.FromContext(ctx)
			184	+	log.Debug().Str("domain", domain).Msg("favicon: fetchViaService begin")
			185	+	data, err := a.service.Get(ctx, domain)
			186	+	if err != nil \|\| len(data) == 0 {
187		log.Debug().	187		log.Debug().
			188	+	Err(err).
188		Str("domain", domain).	189		Str("domain", domain).
189		Int("bytes", len(data)).	190		Int("bytes", len(data)).
190	-	Msg("favicon: fetchViaService fetched data")	191	+	Msg("favicon: fetchViaService empty/error result")
191	-	texture := a.textureFromBytesOnGTK(ctx, data)	192	+	a.invokeCallbackOnGTK(ctx, domain, callback, nil)
192	-	if texture != nil {	193	+	return
193	-	a.setTexture(domain, texture)	194	+	}
194	-	}
195	-	log.Debug().
196	-	Str("domain", domain).
197	-	Bool("texture_nil", texture == nil).
198	-	Msg("favicon: fetchViaService end")
199	-	invokeCallback(texture)
200	-	}()
201	-	}
202			195
203	-	// Try engine FaviconDatabase if available	196	+	log.Debug().
204	-	if a.faviconDB != nil {	197	+	Str("domain", domain).
205	-	a.faviconDB.GetFaviconAsync(pageURL, func(tex port.Texture) {	198	+	Int("bytes", len(data)).
206	-	log.Debug().	199	+	Msg("favicon: fetchViaService fetched data")
207	-	Str("domain", domain).	200	+	texture := a.textureFromBytesOnGTK(ctx, data)
208	-	Bool("texture_nil", tex == nil).	201	+	if texture != nil {
209	-	Msg("favicon: engine db callback")	202	+	a.setTexture(domain, texture)
210	-	if tex == nil {	203	+	}
211	-	log.Debug().Str("domain", domain).Msg("favicon not in engine db, fetching via service")	204	+	log.Debug().
212	-	fetchViaService()	205	+	Str("domain", domain).
213	-	return	206	+	Bool("texture_nil", texture == nil).
214	-	}	207	+	Msg("favicon: fetchViaService end")
215	-	// Convert port.Texture to *gdk.Texture	208	+	a.invokeCallbackOnGTK(ctx, domain, callback, texture)
216	-	gdkTex, ok := tex.(*gdk.Texture)	209	+	}()
217	-	if !ok {	210	+	}
218	-	fetchViaService()	211	+
219	-	return	212	+	func (a FaviconAdapter) handleEngineFaviconDBTexture(ctx context.Context, domain string, callback func(gdk.Texture), tex port.Texture) {
220	-	}	213	+	log := logging.FromContext(ctx)
221	-	a.setTexture(domain, gdkTex)	214	+	log.Debug().
222	-	invokeCallback(gdkTex)	215	+	Str("domain", domain).
223	-	a.saveFaviconToDisk(ctx, domain, gdkTex)	216	+	Bool("texture_nil", tex == nil).
224	-	})	217	+	Msg("favicon: engine db callback")
			218	+	if tex == nil {
			219	+	log.Debug().Str("domain", domain).Msg("favicon not in engine db, fetching via service")
			220	+	a.fetchViaService(ctx, domain, callback)
225		return	221		return
226		}	222		}
227	-		223	+	// Convert port.Texture to *gdk.Texture
228	-	// No WebKit DB, fetch via service directly	224	+	gdkTex, ok := tex.(*gdk.Texture)
229	-	log.Debug().Str("domain", domain).Msg("favicon: no engine db, fetching via service")	225	+	if !ok {
230	-	fetchViaService()	226	+	a.fetchViaService(ctx, domain, callback)
			227	+	return
			228	+	}
			229	+	a.setTexture(domain, gdkTex)
			230	+	a.invokeCallbackOnGTK(ctx, domain, callback, gdkTex)
			231	+	a.saveFaviconToDisk(ctx, domain, gdkTex)
231		}	232		}
232			233
233		// StoreFromWebKit stores a favicon texture received from WebKit signals.	234		// StoreFromWebKit stores a favicon texture received from WebKit signals.