From 5f9771ddb61988064edb20f292f4301f08f2143d Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Mon, 31 Mar 2025 14:48:18 -0700
Subject: [PATCH 01/15] working with webcam

---
 .gitignore        |   2 +
 package.json      |  18 +++++
 scripts.bash      |   6 ++
 src/server.ts     | 172 ++++++++++++++++++++++++++++++++++++++++++++++
 static/index.html |  70 +++++++++++++++++++
 tsconfig.json     | 116 +++++++++++++++++++++++++++++++
 6 files changed, 384 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 package.json
 create mode 100644 scripts.bash
 create mode 100644 src/server.ts
 create mode 100644 static/index.html
 create mode 100644 tsconfig.json

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8f9d799
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+node_modules/*
+dist/*
\ No newline at end of file
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..a1d92f0
--- /dev/null
+++ b/package.json
@@ -0,0 +1,18 @@
+{
+  "dependencies": {
+    "@roamhq/wrtc": "^0.8.0",
+    "node-pre-gyp": "^0.17.0",
+    "ws": "^8.18.0"
+  },
+  "scripts": {
+    "build": "npx tsc --skipLibCheck --outDir dist src/server.ts",
+    "start": "npm run build && node dist/server.js",
+    "debug": "npx ts-node src/server.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2"
+  }
+}
diff --git a/scripts.bash b/scripts.bash
new file mode 100644
index 0000000..44c397c
--- /dev/null
+++ b/scripts.bash
@@ -0,0 +1,6 @@
+curl https://git.linuxtv.org/dtv-scan-tables.git/plain/atsc/us-ATSC-center-frequencies-8VSB
+
+
+dvbv5-zap -c dvb_channel.conf -CUS -IZAP "ION"
+
+dvbv5-scan -Cus -o dvb_channel.conf -O zap -v  us-ATSC-center-frequencies-8VSB
\ No newline at end of file
diff --git a/src/server.ts b/src/server.ts
new file mode 100644
index 0000000..dcff874
--- /dev/null
+++ b/src/server.ts
@@ -0,0 +1,172 @@
+// @ts-ignore
+import { nonstandard, RTCPeerConnection, MediaStreamTrack, MediaStream, RTCSessionDescription } from '@roamhq/wrtc';
+import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
+import { Readable } from 'stream';
+import * as ws from 'ws'
+import * as fs from 'fs';
+import { i420ToRgba, RTCVideoSource } from '@roamhq/wrtc/types/nonstandard';
+// import { RTCVideoSource } from '@roamhq/wrtc/types/nonstandard';
+
+
+
+// type RTCVideoSource = nonstandard.RTCVideoSource;
+// const RTCVideoSource = wrtc.nonstandard.RTCVideoSource;
+// const {mediaDevices} = wrtc
+
+// Constants
+const VIDEO_DEVICE = '/dev/video0'; // Video source device
+const WIDTH = 640; // Video width
+const HEIGHT = 480; // Video height
+const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
+
+class VideoStream extends Readable {
+    private device: fs.ReadStream;
+
+    constructor(devicePath: string) {
+        super();
+        this.device = fs.createReadStream(devicePath);
+    }
+
+    _read(size: number): void {
+        const chunk = this.device.read(size);
+        if (chunk === null) {
+            this.push(null); // Signal end of stream
+        } else {
+            this.push(chunk);
+        }
+    }
+}
+
+
+// Function to start FFmpeg and capture raw video
+function startFFmpeg(): ChildProcessWithoutNullStreams {
+    return spawn('ffmpeg', [
+        '-f', 'v4l2', // Use Video4Linux2 for video capture
+        '-i', VIDEO_DEVICE, // Input device
+        '-vf', `scale=${WIDTH}:${HEIGHT}`, // Scale video resolution
+        '-vcodec', 'rawvideo', // Output raw video codec
+        '-pix_fmt', 'yuv420p', // Pixel format for WebRTC
+        '-f', 'rawvideo', // Output format
+        'pipe:1' // Pipe to stdout
+    ]);
+}
+
+// const videoSource = 
+
+
+
+
+let frameBuffer = Buffer.alloc(0);
+const ffmpegProcess = startFFmpeg();
+const videoSource = new nonstandard.RTCVideoSource();
+// Function to create a WebRTC PeerConnection
+async function createPeerConnection(): Promise<RTCPeerConnection> {
+    
+    const peerConnection = new RTCPeerConnection({iceServers: []} );
+
+    // Create a video source
+
+    // const videoStream = new VideoStream('/dev/video0');
+
+    // track.addEventListener('')
+
+
+
+    // Start FFmpeg and pipe video frames to the source
+
+   
+    ffmpegProcess.stdout.on('data', (chunk: Buffer) => {
+        // Push video frames to the RTCVideoSource
+      
+        frameBuffer = Buffer.concat([frameBuffer, chunk]);
+        while (frameBuffer.length >= FRAME_SIZE) {
+
+            const frameData = frameBuffer.slice(0, FRAME_SIZE);
+            frameBuffer = frameBuffer.slice(FRAME_SIZE); // Keep remaining data
+
+         
+            const frame: nonstandard.RTCVideoFrame = {
+                width: WIDTH,
+                height: HEIGHT,
+                data: new Uint8Array(frameData),
+            }
+
+            videoSource.onFrame(frame);
+        } 
+    });
+
+    ffmpegProcess.stderr.on('data', (data: Buffer) => {
+        // console.error('FFmpeg Error:', data.toString());
+    });
+
+    ffmpegProcess.on('exit', (code) => {
+        console.log(`FFmpeg exited with code ${code}`);
+    });
+
+    // Add the track to the PeerConnection
+    const track: MediaStreamTrack = videoSource.createTrack();
+    console.log('vdei src ',videoSource.isScreencast)
+    const stream = new MediaStream()
+    stream.addTrack(track)
+    console.log('enabled ',track.enabled, track.id, track.kind, track.label, track.readyState);
+    // track.
+    console.log('get',stream.getVideoTracks()[0].id)
+    peerConnection.addTrack(track, stream)
+    // peerConnection.addTransceiver(track, { direction: 'sendonly' });    // peerConnection.add
+    // peerConnection.addIceCandidate();
+    // peerConnection
+    // console.log('Stream with track:', s.track.);
+    return peerConnection;
+}
+
+
+
+// WebSocket signaling server
+const wss = new ws.WebSocketServer({ port: 8080 });
+
+wss.on('connection', async (ws: ws.WebSocket) => {
+    const peerConnection: RTCPeerConnection = await createPeerConnection();
+    // const source = new RTCVideoSource();
+
+    console.log('Client connected');
+    ws.on('message', async (message: Buffer) => {
+        const { type, data} = JSON.parse(message.toString());
+        console.log("message type", type)
+
+        if(type == 'offer') {
+            await peerConnection.setRemoteDescription(data);
+            const answer = await peerConnection.createAnswer();
+            await peerConnection.setLocalDescription(answer);
+            ws.send(JSON.stringify({ type: 'answer', data: peerConnection.localDescription }));
+        }
+
+        if (type === 'ice-candidate') {
+            console.log('type ice')
+            await peerConnection.addIceCandidate(data);
+          }
+
+    });
+
+    peerConnection.oniceconnectionstatechange = () => {
+        console.log('ICE connection state:', peerConnection.iceConnectionState);
+        if (peerConnection.iceConnectionState === 'failed') {
+            console.error('ICE connection failed');
+        }
+    };
+    
+
+    // Send ICE candidates to the client
+    peerConnection.onicecandidate = ({ candidate }) => {
+        console.log("onicecandidate")
+        if (candidate) {
+            ws.send(JSON.stringify({  type: 'ice-candidate', data: candidate  }));
+        }
+    };
+
+    ws.on('close', () => {
+        console.log('Client disconnected');
+        peerConnection.close();
+    });
+});
+
+console.log('WebRTC signaling server running on ws://localhost:8080');
diff --git a/static/index.html b/static/index.html
new file mode 100644
index 0000000..ee479f8
--- /dev/null
+++ b/static/index.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>WebRTC Stream</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/dashjs/4.7.1/dash.all.min.js"></script>
+
+</head>
+
+<body>
+  <h1>Video streams</h1>
+  <h2>WebRTC</h2>
+  <video id="video" autoplay playsinline controls></video>
+
+  <script>
+    const ws = new WebSocket('ws://localhost:8080');
+    const pc = new RTCPeerConnection({ iceServers: [] });
+    const video = document.getElementById('video');
+
+    pc.onconnectionstatechange = (event) => {
+      console.log("onconnectionstatechange ", event)
+    }
+
+    pc.ondatachannel = (event) => {
+      console.log("ondatachannel ", event)
+    }
+
+    pc.ontrack = (event) => {
+      console.log("Received track event", event.streams);
+      video.srcObject = event.streams[0];
+    };
+
+    pc.onicecandidate = ({ candidate }) => {
+      console.log("pc.onicecandidate")
+      if (candidate) {
+        ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate })); // Use 'candidate' instead of 'ice-candidate'
+      }
+    };
+    pc.onicegatheringstatechange = () => {
+      console.log('ICE state:', pc.iceGatheringState);
+    };
+
+    ws.onopen = async () => {
+      pc.addTransceiver('video', { direction: 'recvonly' });
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      // ws.send(JSON.stringify(offer));
+      console.log("on open ")
+      // ws.send(JSON.stringify(offer));
+      ws.send(JSON.stringify({ type: 'offer', data: offer }));
+    }
+
+    ws.onmessage = async (message) => {
+      const msg = JSON.parse(message.data);
+      console.log("onmessage type:", msg.type, msg)
+
+      if (msg.type === 'answer') {
+        await pc.setRemoteDescription(msg.data);
+      }
+
+      else if (msg.type === 'ice-candidate') {
+        await pc.addIceCandidate(msg.data);
+      }
+    };
+
+    ;
+  </script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..633cb3e
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,116 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+    /* Language and Environment */
+    "target": "ES2020", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": [
+      "esnext",
+      "ES2020",
+      "DOM"
+    ], /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    "noLib": false, /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+    /* Modules */
+    "module": "commonjs", /* Specify what module code is generated. */
+    "rootDir": "src",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node10", /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "types": ["node", "webrtc"],
+    // "typeRoots": ["./node_modules/@types"],
+    // "typeRoots": ["./node_modules/@types/webrtc"],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    "noEmitOnError": false, /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
+    /* Type Checking */
+    "strict": false, /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+    /* Completeness */
+    "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"],
+  "exclude": [
+    "node_modules","./node_modules/@roamhq/wrtc"
+  ]
+  //   "include": [
+  //  "./src", "./types"
+  //   ]
+}
\ No newline at end of file

From 795fd0cd386affe836b609efed1c034926eec976 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Mon, 31 Mar 2025 15:59:40 -0700
Subject: [PATCH 02/15] working with tv

---
 scripts.bash      |  2 +-
 src/server.ts     | 37 +++++++++++++++++++++++++++++++++----
 static/index.html |  1 +
 3 files changed, 35 insertions(+), 5 deletions(-)

diff --git a/scripts.bash b/scripts.bash
index 44c397c..76319a8 100644
--- a/scripts.bash
+++ b/scripts.bash
@@ -1,6 +1,6 @@
 curl https://git.linuxtv.org/dtv-scan-tables.git/plain/atsc/us-ATSC-center-frequencies-8VSB
 
 
-dvbv5-zap -c dvb_channel.conf -CUS -IZAP "ION"
+dvbv5-zap -r -c dvb_channel.conf -CUS -IZAP "ION"
 
 dvbv5-scan -Cus -o dvb_channel.conf -O zap -v  us-ATSC-center-frequencies-8VSB
\ No newline at end of file
diff --git a/src/server.ts b/src/server.ts
index dcff874..f3adad9 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -14,7 +14,8 @@ import { i420ToRgba, RTCVideoSource } from '@roamhq/wrtc/types/nonstandard';
 // const {mediaDevices} = wrtc
 
 // Constants
-const VIDEO_DEVICE = '/dev/video0'; // Video source device
+// const VIDEO_DEVICE = '/dev/video0'; // Video source device
+const VIDEO_DEVICE = '/dev/dvb/adapter0/dvr0'; // Video source device
 const WIDTH = 640; // Video width
 const HEIGHT = 480; // Video height
 const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
@@ -40,15 +41,37 @@ class VideoStream extends Readable {
 
 // Function to start FFmpeg and capture raw video
 function startFFmpeg(): ChildProcessWithoutNullStreams {
-    return spawn('ffmpeg', [
-        '-f', 'v4l2', // Use Video4Linux2 for video capture
+    const p =  spawn('ffmpeg', [
+        '-loglevel', 'debug',
         '-i', VIDEO_DEVICE, // Input device
         '-vf', `scale=${WIDTH}:${HEIGHT}`, // Scale video resolution
         '-vcodec', 'rawvideo', // Output raw video codec
         '-pix_fmt', 'yuv420p', // Pixel format for WebRTC
         '-f', 'rawvideo', // Output format
         'pipe:1' // Pipe to stdout
-    ]);
+    ], {
+//         stdio: ['ignore', 'pipe', 'pipe'],
+//   detached: true
+    });
+    process.on('SIGINT', () => {
+        console.log('🔻 Server shutting down... KILLING');
+        let b = p.kill('SIGINT');
+        // let b = process.kill(p.pid)
+        process.exit(0);
+      });
+      
+      process.on('SIGTERM', () => {
+        console.log('🔻 SIGTERM received');
+        p.kill('SIGTERM');
+        process.exit(0);
+      });
+      process.on('exit', () => {
+        p.kill('SIGHUP'); //this one
+        let b = p.kill('SIGTERM');
+        console.log("b ",b)
+      });
+
+    return p;
 }
 
 // const videoSource = 
@@ -58,6 +81,8 @@ function startFFmpeg(): ChildProcessWithoutNullStreams {
 
 let frameBuffer = Buffer.alloc(0);
 const ffmpegProcess = startFFmpeg();
+
+
 const videoSource = new nonstandard.RTCVideoSource();
 // Function to create a WebRTC PeerConnection
 async function createPeerConnection(): Promise<RTCPeerConnection> {
@@ -99,10 +124,14 @@ async function createPeerConnection(): Promise<RTCPeerConnection> {
         // console.error('FFmpeg Error:', data.toString());
     });
 
+
+
     ffmpegProcess.on('exit', (code) => {
         console.log(`FFmpeg exited with code ${code}`);
     });
 
+
+
     // Add the track to the PeerConnection
     const track: MediaStreamTrack = videoSource.createTrack();
     console.log('vdei src ',videoSource.isScreencast)
diff --git a/static/index.html b/static/index.html
index ee479f8..e39ec6a 100644
--- a/static/index.html
+++ b/static/index.html
@@ -42,6 +42,7 @@
 
     ws.onopen = async () => {
       pc.addTransceiver('video', { direction: 'recvonly' });
+      pc.addTransceiver('audio', { direction: 'recvonly' })
       const offer = await pc.createOffer();
       await pc.setLocalDescription(offer);
       // ws.send(JSON.stringify(offer));

From b69b0dbcec642e13850253e8a1b29aa1951f44cd Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Mon, 31 Mar 2025 16:40:05 -0700
Subject: [PATCH 03/15] audio support

---
 src/server.ts     | 120 ++++++++++++++++++++++++++++++----------------
 static/index.html |   5 +-
 2 files changed, 83 insertions(+), 42 deletions(-)

diff --git a/src/server.ts b/src/server.ts
index f3adad9..d473c9c 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -41,35 +41,46 @@ class VideoStream extends Readable {
 
 // Function to start FFmpeg and capture raw video
 function startFFmpeg(): ChildProcessWithoutNullStreams {
-    const p =  spawn('ffmpeg', [
+    const p = spawn('ffmpeg', [
         '-loglevel', 'debug',
         '-i', VIDEO_DEVICE, // Input device
+
+        '-map', '0:v:0',
         '-vf', `scale=${WIDTH}:${HEIGHT}`, // Scale video resolution
         '-vcodec', 'rawvideo', // Output raw video codec
         '-pix_fmt', 'yuv420p', // Pixel format for WebRTC
         '-f', 'rawvideo', // Output format
-        'pipe:1' // Pipe to stdout
+        'pipe:3', // Pipe to stdout
+
+        // Audio
+        '-map', '0:a:0',
+        '-acodec', 'pcm_s16le',
+        '-ac', '1',
+        '-ar', '48000',
+        '-f', 's16le',
+        'pipe:4'
+
     ], {
-//         stdio: ['ignore', 'pipe', 'pipe'],
-//   detached: true
+        stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
+        //   detached: true
     });
     process.on('SIGINT', () => {
         console.log('🔻 Server shutting down... KILLING');
         let b = p.kill('SIGINT');
         // let b = process.kill(p.pid)
         process.exit(0);
-      });
-      
-      process.on('SIGTERM', () => {
+    });
+
+    process.on('SIGTERM', () => {
         console.log('🔻 SIGTERM received');
         p.kill('SIGTERM');
         process.exit(0);
-      });
-      process.on('exit', () => {
+    });
+    process.on('exit', () => {
         p.kill('SIGHUP'); //this one
         let b = p.kill('SIGTERM');
-        console.log("b ",b)
-      });
+        console.log("b ", b)
+    });
 
     return p;
 }
@@ -84,32 +95,26 @@ const ffmpegProcess = startFFmpeg();
 
 
 const videoSource = new nonstandard.RTCVideoSource();
+const audioSource = new nonstandard.RTCAudioSource();
 // Function to create a WebRTC PeerConnection
 async function createPeerConnection(): Promise<RTCPeerConnection> {
-    
-    const peerConnection = new RTCPeerConnection({iceServers: []} );
-
-    // Create a video source
-
-    // const videoStream = new VideoStream('/dev/video0');
-
-    // track.addEventListener('')
 
+    const peerConnection = new RTCPeerConnection({ iceServers: [] });
 
+    const videoStream = ffmpegProcess.stdio[3]; // pipe:3
+    const audioStream = ffmpegProcess.stdio[4]; // pipe:4
 
     // Start FFmpeg and pipe video frames to the source
-
-   
-    ffmpegProcess.stdout.on('data', (chunk: Buffer) => {
+    videoStream.on('data', (chunk: Buffer) => {
         // Push video frames to the RTCVideoSource
-      
+
         frameBuffer = Buffer.concat([frameBuffer, chunk]);
         while (frameBuffer.length >= FRAME_SIZE) {
 
             const frameData = frameBuffer.slice(0, FRAME_SIZE);
             frameBuffer = frameBuffer.slice(FRAME_SIZE); // Keep remaining data
 
-         
+
             const frame: nonstandard.RTCVideoFrame = {
                 width: WIDTH,
                 height: HEIGHT,
@@ -117,16 +122,52 @@ async function createPeerConnection(): Promise<RTCPeerConnection> {
             }
 
             videoSource.onFrame(frame);
-        } 
+        }
     });
 
-    ffmpegProcess.stderr.on('data', (data: Buffer) => {
+    videoStream.on('data', (data: Buffer) => {
         // console.error('FFmpeg Error:', data.toString());
     });
 
 
 
-    ffmpegProcess.on('exit', (code) => {
+    videoStream.on('exit', (code) => {
+        console.log(`FFmpeg exited with code ${code}`);
+    });
+
+    // --- AUDIO handling ---
+    const AUDIO_FRAME_SIZE = 480 * 2; // 480 samples * 2 bytes (s16le)
+    let audioBuffer = Buffer.alloc(0);
+
+    audioStream.on('data', (chunk: Buffer) => {
+        audioBuffer = Buffer.concat([audioBuffer, chunk]);
+        while (audioBuffer.length >= AUDIO_FRAME_SIZE) {
+            const frameData = audioBuffer.slice(0, AUDIO_FRAME_SIZE);
+            // const sampleBuffer = Buffer.from(frameData.buffer.; // makes an isolated buffer
+            audioBuffer = audioBuffer.slice(AUDIO_FRAME_SIZE);
+
+            const samples = new Int16Array(480);
+            for (let i = 0; i < 480; i++) {
+                samples[i] = frameData.readInt16LE(i * 2);
+            }
+
+            audioSource.onData({
+                samples: samples,
+                sampleRate: 48000,
+                bitsPerSample: 16,
+                channelCount: 1,
+                numberOfFrames: 480
+            });
+        }
+    });
+
+    audioStream.on('data', (data: Buffer) => {
+        // console.error('FFmpeg Error:', data.toString());
+    });
+
+
+
+    audioStream.on('exit', (code) => {
         console.log(`FFmpeg exited with code ${code}`);
     });
 
@@ -134,17 +175,16 @@ async function createPeerConnection(): Promise<RTCPeerConnection> {
 
     // Add the track to the PeerConnection
     const track: MediaStreamTrack = videoSource.createTrack();
-    console.log('vdei src ',videoSource.isScreencast)
+    const track1 = audioSource.createTrack();
+    console.log('vdei src ', videoSource.isScreencast)
     const stream = new MediaStream()
     stream.addTrack(track)
-    console.log('enabled ',track.enabled, track.id, track.kind, track.label, track.readyState);
+    stream.addTrack(track1);
+    console.log('enabled ', track.enabled, track.id, track.kind, track.label, track.readyState);
     // track.
-    console.log('get',stream.getVideoTracks()[0].id)
-    peerConnection.addTrack(track, stream)
-    // peerConnection.addTransceiver(track, { direction: 'sendonly' });    // peerConnection.add
-    // peerConnection.addIceCandidate();
-    // peerConnection
-    // console.log('Stream with track:', s.track.);
+    console.log('get', stream.getVideoTracks()[0].id)
+    peerConnection.addTrack(track, stream);
+    peerConnection.addTrack(track1, stream);
     return peerConnection;
 }
 
@@ -159,10 +199,10 @@ wss.on('connection', async (ws: ws.WebSocket) => {
 
     console.log('Client connected');
     ws.on('message', async (message: Buffer) => {
-        const { type, data} = JSON.parse(message.toString());
+        const { type, data } = JSON.parse(message.toString());
         console.log("message type", type)
 
-        if(type == 'offer') {
+        if (type == 'offer') {
             await peerConnection.setRemoteDescription(data);
             const answer = await peerConnection.createAnswer();
             await peerConnection.setLocalDescription(answer);
@@ -172,7 +212,7 @@ wss.on('connection', async (ws: ws.WebSocket) => {
         if (type === 'ice-candidate') {
             console.log('type ice')
             await peerConnection.addIceCandidate(data);
-          }
+        }
 
     });
 
@@ -182,13 +222,13 @@ wss.on('connection', async (ws: ws.WebSocket) => {
             console.error('ICE connection failed');
         }
     };
-    
+
 
     // Send ICE candidates to the client
     peerConnection.onicecandidate = ({ candidate }) => {
         console.log("onicecandidate")
         if (candidate) {
-            ws.send(JSON.stringify({  type: 'ice-candidate', data: candidate  }));
+            ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
         }
     };
 
diff --git a/static/index.html b/static/index.html
index e39ec6a..f06515b 100644
--- a/static/index.html
+++ b/static/index.html
@@ -28,16 +28,17 @@
     pc.ontrack = (event) => {
       console.log("Received track event", event.streams);
       video.srcObject = event.streams[0];
+      // video.muted = false;
     };
 
     pc.onicecandidate = ({ candidate }) => {
-      console.log("pc.onicecandidate")
+      // console.log("pc.onicecandidate")
       if (candidate) {
         ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate })); // Use 'candidate' instead of 'ice-candidate'
       }
     };
     pc.onicegatheringstatechange = () => {
-      console.log('ICE state:', pc.iceGatheringState);
+      // console.log('ICE state:', pc.iceGatheringState);
     };
 
     ws.onopen = async () => {

From 3610c37585d46f233523fc3af44cb642517d2bc6 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Mon, 31 Mar 2025 16:50:10 -0700
Subject: [PATCH 04/15] code tidy up

---
 src/server.ts     | 113 ++++++++++------------------------------------
 static/index.html |   6 ---
 2 files changed, 23 insertions(+), 96 deletions(-)

diff --git a/src/server.ts b/src/server.ts
index d473c9c..0cd7bd8 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,56 +1,26 @@
-// @ts-ignore
-import { nonstandard, RTCPeerConnection, MediaStreamTrack, MediaStream, RTCSessionDescription } from '@roamhq/wrtc';
-import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
-import { Readable } from 'stream';
-import * as ws from 'ws'
-import * as fs from 'fs';
-import { i420ToRgba, RTCVideoSource } from '@roamhq/wrtc/types/nonstandard';
-// import { RTCVideoSource } from '@roamhq/wrtc/types/nonstandard';
-
-
-
-// type RTCVideoSource = nonstandard.RTCVideoSource;
-// const RTCVideoSource = wrtc.nonstandard.RTCVideoSource;
-// const {mediaDevices} = wrtc
+import { MediaStream, MediaStreamTrack, nonstandard, RTCPeerConnection } from '@roamhq/wrtc';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import * as ws from 'ws';
 
 // Constants
-// const VIDEO_DEVICE = '/dev/video0'; // Video source device
 const VIDEO_DEVICE = '/dev/dvb/adapter0/dvr0'; // Video source device
 const WIDTH = 640; // Video width
 const HEIGHT = 480; // Video height
 const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
 
-class VideoStream extends Readable {
-    private device: fs.ReadStream;
-
-    constructor(devicePath: string) {
-        super();
-        this.device = fs.createReadStream(devicePath);
-    }
-
-    _read(size: number): void {
-        const chunk = this.device.read(size);
-        if (chunk === null) {
-            this.push(null); // Signal end of stream
-        } else {
-            this.push(chunk);
-        }
-    }
-}
-
-
 // Function to start FFmpeg and capture raw video
-function startFFmpeg(): ChildProcessWithoutNullStreams {
+const startFFmpeg = (): ChildProcessWithoutNullStreams => {
     const p = spawn('ffmpeg', [
         '-loglevel', 'debug',
-        '-i', VIDEO_DEVICE, // Input device
+        '-i', VIDEO_DEVICE,
 
+        // Video
         '-map', '0:v:0',
-        '-vf', `scale=${WIDTH}:${HEIGHT}`, // Scale video resolution
-        '-vcodec', 'rawvideo', // Output raw video codec
-        '-pix_fmt', 'yuv420p', // Pixel format for WebRTC
-        '-f', 'rawvideo', // Output format
-        'pipe:3', // Pipe to stdout
+        '-vf', `scale=${WIDTH}:${HEIGHT}`,
+        '-vcodec', 'rawvideo',
+        '-pix_fmt', 'yuv420p',
+        '-f', 'rawvideo',
+        'pipe:3',
 
         // Audio
         '-map', '0:a:0',
@@ -62,12 +32,10 @@ function startFFmpeg(): ChildProcessWithoutNullStreams {
 
     ], {
         stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
-        //   detached: true
     });
     process.on('SIGINT', () => {
-        console.log('🔻 Server shutting down... KILLING');
-        let b = p.kill('SIGINT');
-        // let b = process.kill(p.pid)
+        console.log('🔻 Server shutting down...');
+        p.kill('SIGINT');
         process.exit(0);
     });
 
@@ -78,49 +46,33 @@ function startFFmpeg(): ChildProcessWithoutNullStreams {
     });
     process.on('exit', () => {
         p.kill('SIGHUP'); //this one
-        let b = p.kill('SIGTERM');
-        console.log("b ", b)
+        p.kill('SIGTERM');
     });
-
     return p;
 }
 
-// const videoSource = 
-
-
-
 
 let frameBuffer = Buffer.alloc(0);
 const ffmpegProcess = startFFmpeg();
-
-
 const videoSource = new nonstandard.RTCVideoSource();
 const audioSource = new nonstandard.RTCAudioSource();
-// Function to create a WebRTC PeerConnection
-async function createPeerConnection(): Promise<RTCPeerConnection> {
+const createPeerConnection = async (): Promise<RTCPeerConnection> => {
 
     const peerConnection = new RTCPeerConnection({ iceServers: [] });
-
     const videoStream = ffmpegProcess.stdio[3]; // pipe:3
     const audioStream = ffmpegProcess.stdio[4]; // pipe:4
 
     // Start FFmpeg and pipe video frames to the source
     videoStream.on('data', (chunk: Buffer) => {
-        // Push video frames to the RTCVideoSource
-
         frameBuffer = Buffer.concat([frameBuffer, chunk]);
         while (frameBuffer.length >= FRAME_SIZE) {
-
             const frameData = frameBuffer.slice(0, FRAME_SIZE);
-            frameBuffer = frameBuffer.slice(FRAME_SIZE); // Keep remaining data
-
-
+            frameBuffer = frameBuffer.slice(FRAME_SIZE);
             const frame: nonstandard.RTCVideoFrame = {
                 width: WIDTH,
                 height: HEIGHT,
                 data: new Uint8Array(frameData),
             }
-
             videoSource.onFrame(frame);
         }
     });
@@ -129,8 +81,6 @@ async function createPeerConnection(): Promise<RTCPeerConnection> {
         // console.error('FFmpeg Error:', data.toString());
     });
 
-
-
     videoStream.on('exit', (code) => {
         console.log(`FFmpeg exited with code ${code}`);
     });
@@ -143,16 +93,13 @@ async function createPeerConnection(): Promise<RTCPeerConnection> {
         audioBuffer = Buffer.concat([audioBuffer, chunk]);
         while (audioBuffer.length >= AUDIO_FRAME_SIZE) {
             const frameData = audioBuffer.slice(0, AUDIO_FRAME_SIZE);
-            // const sampleBuffer = Buffer.from(frameData.buffer.; // makes an isolated buffer
             audioBuffer = audioBuffer.slice(AUDIO_FRAME_SIZE);
-
             const samples = new Int16Array(480);
             for (let i = 0; i < 480; i++) {
                 samples[i] = frameData.readInt16LE(i * 2);
             }
-
             audioSource.onData({
-                samples: samples,
+                samples,
                 sampleRate: 48000,
                 bitsPerSample: 16,
                 channelCount: 1,
@@ -165,26 +112,18 @@ async function createPeerConnection(): Promise<RTCPeerConnection> {
         // console.error('FFmpeg Error:', data.toString());
     });
 
-
-
     audioStream.on('exit', (code) => {
         console.log(`FFmpeg exited with code ${code}`);
     });
 
-
-
     // Add the track to the PeerConnection
-    const track: MediaStreamTrack = videoSource.createTrack();
-    const track1 = audioSource.createTrack();
-    console.log('vdei src ', videoSource.isScreencast)
+    const videoTrack: MediaStreamTrack = videoSource.createTrack();
+    const audioTrack: MediaStreamTrack = audioSource.createTrack();
     const stream = new MediaStream()
-    stream.addTrack(track)
-    stream.addTrack(track1);
-    console.log('enabled ', track.enabled, track.id, track.kind, track.label, track.readyState);
-    // track.
-    console.log('get', stream.getVideoTracks()[0].id)
-    peerConnection.addTrack(track, stream);
-    peerConnection.addTrack(track1, stream);
+    stream.addTrack(videoTrack)
+    stream.addTrack(audioTrack);
+    peerConnection.addTrack(videoTrack, stream);
+    peerConnection.addTrack(audioTrack, stream);
     return peerConnection;
 }
 
@@ -195,12 +134,9 @@ const wss = new ws.WebSocketServer({ port: 8080 });
 
 wss.on('connection', async (ws: ws.WebSocket) => {
     const peerConnection: RTCPeerConnection = await createPeerConnection();
-    // const source = new RTCVideoSource();
 
-    console.log('Client connected');
     ws.on('message', async (message: Buffer) => {
         const { type, data } = JSON.parse(message.toString());
-        console.log("message type", type)
 
         if (type == 'offer') {
             await peerConnection.setRemoteDescription(data);
@@ -210,14 +146,12 @@ wss.on('connection', async (ws: ws.WebSocket) => {
         }
 
         if (type === 'ice-candidate') {
-            console.log('type ice')
             await peerConnection.addIceCandidate(data);
         }
 
     });
 
     peerConnection.oniceconnectionstatechange = () => {
-        console.log('ICE connection state:', peerConnection.iceConnectionState);
         if (peerConnection.iceConnectionState === 'failed') {
             console.error('ICE connection failed');
         }
@@ -226,7 +160,6 @@ wss.on('connection', async (ws: ws.WebSocket) => {
 
     // Send ICE candidates to the client
     peerConnection.onicecandidate = ({ candidate }) => {
-        console.log("onicecandidate")
         if (candidate) {
             ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
         }
diff --git a/static/index.html b/static/index.html
index f06515b..01ce2a8 100644
--- a/static/index.html
+++ b/static/index.html
@@ -28,11 +28,9 @@
     pc.ontrack = (event) => {
       console.log("Received track event", event.streams);
       video.srcObject = event.streams[0];
-      // video.muted = false;
     };
 
     pc.onicecandidate = ({ candidate }) => {
-      // console.log("pc.onicecandidate")
       if (candidate) {
         ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate })); // Use 'candidate' instead of 'ice-candidate'
       }
@@ -46,15 +44,11 @@
       pc.addTransceiver('audio', { direction: 'recvonly' })
       const offer = await pc.createOffer();
       await pc.setLocalDescription(offer);
-      // ws.send(JSON.stringify(offer));
-      console.log("on open ")
-      // ws.send(JSON.stringify(offer));
       ws.send(JSON.stringify({ type: 'offer', data: offer }));
     }
 
     ws.onmessage = async (message) => {
       const msg = JSON.parse(message.data);
-      console.log("onmessage type:", msg.type, msg)
 
       if (msg.type === 'answer') {
         await pc.setRemoteDescription(msg.data);

From a83a5fa605a432a2d8f3c186db915006b3700531 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 12:54:04 -0700
Subject: [PATCH 05/15] restructure

---
 src/http.ts               |  38 ++++++++
 src/server.ts             | 175 ++----------------------------------
 src/static/css/index.scss |  44 +++++++++
 src/static/index.html     |  19 ++++
 src/static/js/index.ts    |  48 ++++++++++
 src/ws.ts                 | 185 ++++++++++++++++++++++++++++++++++++++
 static/index.html         |  66 --------------
 7 files changed, 342 insertions(+), 233 deletions(-)
 create mode 100644 src/http.ts
 create mode 100644 src/static/css/index.scss
 create mode 100644 src/static/index.html
 create mode 100644 src/static/js/index.ts
 create mode 100644 src/ws.ts
 delete mode 100644 static/index.html

diff --git a/src/http.ts b/src/http.ts
new file mode 100644
index 0000000..6fa3235
--- /dev/null
+++ b/src/http.ts
@@ -0,0 +1,38 @@
+import * as http from "http";
+import * as fs from "fs";
+import * as path from "path";
+
+
+export default class HttpServer {
+
+    private httpServer: http.Server;
+    private port: number;
+    private root: string;
+    public constructor(port: number, root : string) {
+        this.port = port;
+        this.root = root;
+        this.httpServer = http.createServer((req, res) => {
+            const filePath = path.join(root, req.url === "/" ? "index.html" : req.url || "");
+            fs.readFile(filePath, (err, data) => {
+                if (err) {
+                    res.writeHead(404);
+                    res.end("Not Found");
+                } else {
+                    res.writeHead(200);
+                    res.end(data);
+                }
+            });
+        });
+    }
+    public start() {
+        this.httpServer.listen(this.port, () => {
+            console.log(`Serving ${this.root} at http://localhost:${this.port}`);
+        });
+    }
+
+
+
+
+
+}
+
diff --git a/src/server.ts b/src/server.ts
index 0cd7bd8..72cad74 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,174 +1,15 @@
-import { MediaStream, MediaStreamTrack, nonstandard, RTCPeerConnection } from '@roamhq/wrtc';
-import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
-import * as ws from 'ws';
+import HttpServer from './http';
+import TVWebSocket from './ws';
 
-// Constants
-const VIDEO_DEVICE = '/dev/dvb/adapter0/dvr0'; // Video source device
-const WIDTH = 640; // Video width
-const HEIGHT = 480; // Video height
-const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
+const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT,10) : 8080;
+const WS_PORT = process.env.WS_PORT ? parseInt(process.env.WS_PORT, 10) : 3001;
+const STATIC_ROOT = process.cwd() + "/dist/static";;
 
-// Function to start FFmpeg and capture raw video
-const startFFmpeg = (): ChildProcessWithoutNullStreams => {
-    const p = spawn('ffmpeg', [
-        '-loglevel', 'debug',
-        '-i', VIDEO_DEVICE,
+const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT);
+const tvWebSocket = new TVWebSocket(WS_PORT);
 
-        // Video
-        '-map', '0:v:0',
-        '-vf', `scale=${WIDTH}:${HEIGHT}`,
-        '-vcodec', 'rawvideo',
-        '-pix_fmt', 'yuv420p',
-        '-f', 'rawvideo',
-        'pipe:3',
-
-        // Audio
-        '-map', '0:a:0',
-        '-acodec', 'pcm_s16le',
-        '-ac', '1',
-        '-ar', '48000',
-        '-f', 's16le',
-        'pipe:4'
-
-    ], {
-        stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
-    });
-    process.on('SIGINT', () => {
-        console.log('🔻 Server shutting down...');
-        p.kill('SIGINT');
-        process.exit(0);
-    });
-
-    process.on('SIGTERM', () => {
-        console.log('🔻 SIGTERM received');
-        p.kill('SIGTERM');
-        process.exit(0);
-    });
-    process.on('exit', () => {
-        p.kill('SIGHUP'); //this one
-        p.kill('SIGTERM');
-    });
-    return p;
-}
-
-
-let frameBuffer = Buffer.alloc(0);
-const ffmpegProcess = startFFmpeg();
-const videoSource = new nonstandard.RTCVideoSource();
-const audioSource = new nonstandard.RTCAudioSource();
-const createPeerConnection = async (): Promise<RTCPeerConnection> => {
-
-    const peerConnection = new RTCPeerConnection({ iceServers: [] });
-    const videoStream = ffmpegProcess.stdio[3]; // pipe:3
-    const audioStream = ffmpegProcess.stdio[4]; // pipe:4
-
-    // Start FFmpeg and pipe video frames to the source
-    videoStream.on('data', (chunk: Buffer) => {
-        frameBuffer = Buffer.concat([frameBuffer, chunk]);
-        while (frameBuffer.length >= FRAME_SIZE) {
-            const frameData = frameBuffer.slice(0, FRAME_SIZE);
-            frameBuffer = frameBuffer.slice(FRAME_SIZE);
-            const frame: nonstandard.RTCVideoFrame = {
-                width: WIDTH,
-                height: HEIGHT,
-                data: new Uint8Array(frameData),
-            }
-            videoSource.onFrame(frame);
-        }
-    });
-
-    videoStream.on('data', (data: Buffer) => {
-        // console.error('FFmpeg Error:', data.toString());
-    });
-
-    videoStream.on('exit', (code) => {
-        console.log(`FFmpeg exited with code ${code}`);
-    });
-
-    // --- AUDIO handling ---
-    const AUDIO_FRAME_SIZE = 480 * 2; // 480 samples * 2 bytes (s16le)
-    let audioBuffer = Buffer.alloc(0);
-
-    audioStream.on('data', (chunk: Buffer) => {
-        audioBuffer = Buffer.concat([audioBuffer, chunk]);
-        while (audioBuffer.length >= AUDIO_FRAME_SIZE) {
-            const frameData = audioBuffer.slice(0, AUDIO_FRAME_SIZE);
-            audioBuffer = audioBuffer.slice(AUDIO_FRAME_SIZE);
-            const samples = new Int16Array(480);
-            for (let i = 0; i < 480; i++) {
-                samples[i] = frameData.readInt16LE(i * 2);
-            }
-            audioSource.onData({
-                samples,
-                sampleRate: 48000,
-                bitsPerSample: 16,
-                channelCount: 1,
-                numberOfFrames: 480
-            });
-        }
-    });
-
-    audioStream.on('data', (data: Buffer) => {
-        // console.error('FFmpeg Error:', data.toString());
-    });
-
-    audioStream.on('exit', (code) => {
-        console.log(`FFmpeg exited with code ${code}`);
-    });
-
-    // Add the track to the PeerConnection
-    const videoTrack: MediaStreamTrack = videoSource.createTrack();
-    const audioTrack: MediaStreamTrack = audioSource.createTrack();
-    const stream = new MediaStream()
-    stream.addTrack(videoTrack)
-    stream.addTrack(audioTrack);
-    peerConnection.addTrack(videoTrack, stream);
-    peerConnection.addTrack(audioTrack, stream);
-    return peerConnection;
-}
+httpServer.start();
 
 
 
-// WebSocket signaling server
-const wss = new ws.WebSocketServer({ port: 8080 });
 
-wss.on('connection', async (ws: ws.WebSocket) => {
-    const peerConnection: RTCPeerConnection = await createPeerConnection();
-
-    ws.on('message', async (message: Buffer) => {
-        const { type, data } = JSON.parse(message.toString());
-
-        if (type == 'offer') {
-            await peerConnection.setRemoteDescription(data);
-            const answer = await peerConnection.createAnswer();
-            await peerConnection.setLocalDescription(answer);
-            ws.send(JSON.stringify({ type: 'answer', data: peerConnection.localDescription }));
-        }
-
-        if (type === 'ice-candidate') {
-            await peerConnection.addIceCandidate(data);
-        }
-
-    });
-
-    peerConnection.oniceconnectionstatechange = () => {
-        if (peerConnection.iceConnectionState === 'failed') {
-            console.error('ICE connection failed');
-        }
-    };
-
-
-    // Send ICE candidates to the client
-    peerConnection.onicecandidate = ({ candidate }) => {
-        if (candidate) {
-            ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
-        }
-    };
-
-    ws.on('close', () => {
-        console.log('Client disconnected');
-        peerConnection.close();
-    });
-});
-
-console.log('WebRTC signaling server running on ws://localhost:8080');
diff --git a/src/static/css/index.scss b/src/static/css/index.scss
new file mode 100644
index 0000000..55f9c80
--- /dev/null
+++ b/src/static/css/index.scss
@@ -0,0 +1,44 @@
+$background-color: #c7c7c7;
+$primary-color: #333;
+$secondary-color: #d11414;
+$text-color: #123455;
+
+body {
+    font-family: sans-serif;
+    background-color: $background-color;
+    header {
+        nav {
+            ul {
+                display: flex;
+                list-style: none;
+                gap: 1em;
+                li {
+
+                }
+            }
+            a {
+                &:hover {}
+            }
+        }
+    }
+
+    main {
+        display: flex;
+        flex-direction: column;
+        text-align: center;
+        h1 {}
+
+        p {}
+        img {
+            width: 20em;
+            border-radius: 50%;
+        }
+    }
+
+
+    footer {
+        text-align: center;
+        // background: #eee;
+        padding: 1em;
+    }
+}
\ No newline at end of file
diff --git a/src/static/index.html b/src/static/index.html
new file mode 100644
index 0000000..9bee2f7
--- /dev/null
+++ b/src/static/index.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>WebRTC Stream</title>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="stylesheet" href="css/index.css" />
+</head>
+
+<body>
+  <h1>Video streams</h1>
+  <h2>WebRTC</h2>
+  <video id="video" autoplay playsinline controls></video>
+
+  <script src="js/index.js"></script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/static/js/index.ts b/src/static/js/index.ts
new file mode 100644
index 0000000..276a004
--- /dev/null
+++ b/src/static/js/index.ts
@@ -0,0 +1,48 @@
+const host = window.location.hostname
+const ws = new WebSocket(`ws://${host}:3001`);
+const pc = new RTCPeerConnection({ iceServers: [] });
+const video = document.getElementById('video') as HTMLVideoElement;
+
+pc.onconnectionstatechange = (event) => {
+  console.log("onconnectionstatechange ", event)
+}
+
+pc.ondatachannel = (event) => {
+  console.log("ondatachannel ", event)
+}
+
+pc.ontrack = (event) => {
+  console.log("Received track event", event.streams);
+  video.srcObject = event.streams[0];
+};
+
+pc.onicecandidate = ({ candidate }) => {
+  if (candidate) {
+    ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate })); // Use 'candidate' instead of 'ice-candidate'
+  }
+};
+pc.onicegatheringstatechange = () => {
+  // console.log('ICE state:', pc.iceGatheringState);
+};
+
+ws.onopen = async () => {
+  pc.addTransceiver('video', { direction: 'recvonly' });
+  pc.addTransceiver('audio', { direction: 'recvonly' })
+  const offer = await pc.createOffer();
+  await pc.setLocalDescription(offer);
+  ws.send(JSON.stringify({ type: 'offer', data: offer }));
+}
+
+ws.onmessage = async (message) => {
+  const msg = JSON.parse(message.data);
+
+  if (msg.type === 'answer') {
+    await pc.setRemoteDescription(msg.data);
+  }
+
+  else if (msg.type === 'ice-candidate') {
+    await pc.addIceCandidate(msg.data);
+  }
+};
+
+;
\ No newline at end of file
diff --git a/src/ws.ts b/src/ws.ts
new file mode 100644
index 0000000..1cb1ce9
--- /dev/null
+++ b/src/ws.ts
@@ -0,0 +1,185 @@
+import { MediaStream, MediaStreamTrack, nonstandard, RTCPeerConnection } from '@roamhq/wrtc';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import * as ws from 'ws';
+
+// Constants
+const VIDEO_DEVICE = '/dev/dvb/adapter0/dvr0'; // Video source device
+const WIDTH = 640; // Video width
+const HEIGHT = 480; // Video height
+const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
+
+export default class TVWebSocket {
+
+    public constructor(port: number) {    
+        const ffmpegProcess = this.startFFmpeg();
+        const videoTrack = this.createVideoTrack(ffmpegProcess);
+        const audioTrack = this.createAudioTrack(ffmpegProcess);
+
+        // WebSocket signaling server
+        const wss = new ws.WebSocketServer({ port });
+
+        wss.on('connection', async (ws: ws.WebSocket) => {
+            const peerConnection: RTCPeerConnection =  this.createPeerConnection(videoTrack, audioTrack);
+
+            ws.on('message', async (message: Buffer) => {
+                const { type, data } = JSON.parse(message.toString());
+
+                if (type == 'offer') {
+                    await peerConnection.setRemoteDescription(data);
+                    const answer = await peerConnection.createAnswer();
+                    await peerConnection.setLocalDescription(answer);
+                    ws.send(JSON.stringify({ type: 'answer', data: peerConnection.localDescription }));
+                }
+
+                if (type === 'ice-candidate') {
+                    await peerConnection.addIceCandidate(data);
+                }
+
+            });
+
+            peerConnection.oniceconnectionstatechange = () => {
+                if (peerConnection.iceConnectionState === 'failed') {
+                    console.error('ICE connection failed');
+                }
+            };
+
+
+            // Send ICE candidates to the client
+            peerConnection.onicecandidate = ({ candidate }) => {
+                if (candidate) {
+                    ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+                }
+            };
+
+            ws.on('close', () => {
+                console.log('Client disconnected');
+                peerConnection.close();
+            });
+        });
+    }
+
+    // Function to start FFmpeg and capture raw video
+    startFFmpeg = (): ChildProcessWithoutNullStreams => {
+        const p = spawn('ffmpeg', [
+            '-loglevel', 'debug',
+            '-i', VIDEO_DEVICE,
+
+            // Video
+            '-map', '0:v:0',
+            '-vf', `scale=${WIDTH}:${HEIGHT}`,
+            '-vcodec', 'rawvideo',
+            '-pix_fmt', 'yuv420p',
+            '-f', 'rawvideo',
+            'pipe:3',
+
+            // Audio
+            '-map', '0:a:0',
+            '-acodec', 'pcm_s16le',
+            '-ac', '1',
+            '-ar', '48000',
+            '-f', 's16le',
+            'pipe:4'
+
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
+        });
+        process.on('SIGINT', () => {
+            console.log('🔻 Server shutting down...');
+            p.kill('SIGINT');
+            process.exit(0);
+        });
+
+        process.on('SIGTERM', () => {
+            console.log('🔻 SIGTERM received');
+            p.kill('SIGTERM');
+            process.exit(0);
+        });
+        process.on('exit', () => {
+            p.kill('SIGHUP'); //this one
+            p.kill('SIGTERM');
+        });
+        return p;
+    }
+
+    
+    createVideoTrack = (ffmpegProcess: ChildProcessWithoutNullStreams) => {
+        let videoBuffer = Buffer.alloc(0);
+        const videoSource = new nonstandard.RTCVideoSource();
+        const videoStream = ffmpegProcess.stdio[3]; // pipe:3
+        // Start FFmpeg and pipe video frames to the source
+        videoStream.on('data', (chunk: Buffer) => {
+            videoBuffer = Buffer.concat([videoBuffer, chunk]);
+            while (videoBuffer.length >= FRAME_SIZE) {
+                const frameData = videoBuffer.slice(0, FRAME_SIZE);
+                videoBuffer = videoBuffer.slice(FRAME_SIZE);
+                const frame: nonstandard.RTCVideoFrame = {
+                    width: WIDTH,
+                    height: HEIGHT,
+                    data: new Uint8Array(frameData),
+                }
+                videoSource.onFrame(frame);
+            }
+        });
+
+        videoStream.on('data', (data: Buffer) => {
+            // console.error('FFmpeg Error:', data.toString());
+        });
+
+        videoStream.on('exit', (code) => {
+            console.log(`FFmpeg exited with code ${code}`);
+        });
+        return videoSource.createTrack();
+
+    }
+
+    createAudioTrack = (ffmpegProcess: ChildProcessWithoutNullStreams) => {
+        let audioBuffer = Buffer.alloc(0);
+        const audioSource = new nonstandard.RTCAudioSource();
+        const audioStream = ffmpegProcess.stdio[4]; // pipe:4
+        // --- AUDIO handling ---
+        const AUDIO_FRAME_SIZE = 480 * 2; // 480 samples * 2 bytes (s16le)
+
+
+        audioStream.on('data', (chunk: Buffer) => {
+            audioBuffer = Buffer.concat([audioBuffer, chunk]);
+            while (audioBuffer.length >= AUDIO_FRAME_SIZE) {
+                const frameData = audioBuffer.slice(0, AUDIO_FRAME_SIZE);
+                audioBuffer = audioBuffer.slice(AUDIO_FRAME_SIZE);
+                const samples = new Int16Array(480);
+                for (let i = 0; i < 480; i++) {
+                    samples[i] = frameData.readInt16LE(i * 2);
+                }
+                audioSource.onData({
+                    samples,
+                    sampleRate: 48000,
+                    bitsPerSample: 16,
+                    channelCount: 1,
+                    numberOfFrames: 480
+                });
+            }
+        });
+
+        audioStream.on('data', (data: Buffer) => {
+            // console.error('FFmpeg Error:', data.toString());
+        });
+
+        audioStream.on('exit', (code) => {
+            console.log(`FFmpeg exited with code ${code}`);
+        });
+        return audioSource.createTrack();
+    }
+
+    createPeerConnection = (videoTrack: MediaStreamTrack, audioTrack: MediaStreamTrack): RTCPeerConnection => {
+        const peerConnection = new RTCPeerConnection({ iceServers: [] });
+        const stream = new MediaStream()
+        stream.addTrack(videoTrack)
+        stream.addTrack(audioTrack);
+        peerConnection.addTrack(videoTrack, stream);
+        peerConnection.addTrack(audioTrack, stream);
+        return peerConnection;
+    }
+
+}
+
+
+
diff --git a/static/index.html b/static/index.html
deleted file mode 100644
index 01ce2a8..0000000
--- a/static/index.html
+++ /dev/null
@@ -1,66 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-  <title>WebRTC Stream</title>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/dashjs/4.7.1/dash.all.min.js"></script>
-
-</head>
-
-<body>
-  <h1>Video streams</h1>
-  <h2>WebRTC</h2>
-  <video id="video" autoplay playsinline controls></video>
-
-  <script>
-    const ws = new WebSocket('ws://localhost:8080');
-    const pc = new RTCPeerConnection({ iceServers: [] });
-    const video = document.getElementById('video');
-
-    pc.onconnectionstatechange = (event) => {
-      console.log("onconnectionstatechange ", event)
-    }
-
-    pc.ondatachannel = (event) => {
-      console.log("ondatachannel ", event)
-    }
-
-    pc.ontrack = (event) => {
-      console.log("Received track event", event.streams);
-      video.srcObject = event.streams[0];
-    };
-
-    pc.onicecandidate = ({ candidate }) => {
-      if (candidate) {
-        ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate })); // Use 'candidate' instead of 'ice-candidate'
-      }
-    };
-    pc.onicegatheringstatechange = () => {
-      // console.log('ICE state:', pc.iceGatheringState);
-    };
-
-    ws.onopen = async () => {
-      pc.addTransceiver('video', { direction: 'recvonly' });
-      pc.addTransceiver('audio', { direction: 'recvonly' })
-      const offer = await pc.createOffer();
-      await pc.setLocalDescription(offer);
-      ws.send(JSON.stringify({ type: 'offer', data: offer }));
-    }
-
-    ws.onmessage = async (message) => {
-      const msg = JSON.parse(message.data);
-
-      if (msg.type === 'answer') {
-        await pc.setRemoteDescription(msg.data);
-      }
-
-      else if (msg.type === 'ice-candidate') {
-        await pc.addIceCandidate(msg.data);
-      }
-    };
-
-    ;
-  </script>
-</body>
-
-</html>
\ No newline at end of file

From 358f9c8784d0c4e729dec7d2c7af3dc0e18be472 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 16:29:56 -0700
Subject: [PATCH 06/15] API support for channel change

---
 dvb_channel.conf |   6 +++
 package.json     |  10 ++--
 src/http.ts      |  47 ++++++++++++++----
 src/server.ts    |  44 ++++++++++++++--
 src/zap.ts       | 127 +++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 217 insertions(+), 17 deletions(-)
 create mode 100644 dvb_channel.conf
 create mode 100644 src/zap.ts

diff --git a/dvb_channel.conf b/dvb_channel.conf
new file mode 100644
index 0000000..2617fe6
--- /dev/null
+++ b/dvb_channel.conf
@@ -0,0 +1,6 @@
+ION:521028615:8VSB:49:52:3
+KATU:533028615:8VSB:49:52:3
+KOIN-HD:539028615:8VSB:49:52:3
+KGW:545028615:8VSB:49:52:3
+KBLN-DT:575028615:8VSB:49:52:1
+TBN HD:581028615:8VSB:49:52:3
diff --git a/package.json b/package.json
index a1d92f0..fa1d49d 100644
--- a/package.json
+++ b/package.json
@@ -5,9 +5,13 @@
     "ws": "^8.18.0"
   },
   "scripts": {
-    "build": "npx tsc --skipLibCheck --outDir dist src/server.ts",
+    "build:scss": "npx sass src/static/css:dist/static/css",
+    "copy:html": "cp src/static/index.html dist/static",
+    "build:js:fe": "npx tsc src/static/js/*.ts --outDir dist/static/js",
+    "build:js:be": "npx tsc --skipLibCheck src/*.ts --outDir dist",
+    "build": "npm run build:js:fe && npm run build:js:be && npm run build:scss && npm run copy:html",
     "start": "npm run build && node dist/server.js",
-    "debug": "npx ts-node src/server.ts"
+    "dev": "npm run build && npx ts-node src/server.ts"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
@@ -15,4 +19,4 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2"
   }
-}
+}
\ No newline at end of file
diff --git a/src/http.ts b/src/http.ts
index 6fa3235..882ba0a 100644
--- a/src/http.ts
+++ b/src/http.ts
@@ -8,20 +8,45 @@ export default class HttpServer {
     private httpServer: http.Server;
     private port: number;
     private root: string;
-    public constructor(port: number, root : string) {
+    public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void) {
         this.port = port;
         this.root = root;
         this.httpServer = http.createServer((req, res) => {
-            const filePath = path.join(root, req.url === "/" ? "index.html" : req.url || "");
-            fs.readFile(filePath, (err, data) => {
-                if (err) {
-                    res.writeHead(404);
-                    res.end("Not Found");
-                } else {
-                    res.writeHead(200);
-                    res.end(data);
+            let status: number = 404;
+            let body: any;
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const pathname = path.normalize(url.pathname);
+            if (req.method === 'GET') {
+                const filePath = path.join(root, path.extname(pathname) === '' ? pathname + "/index.html" : pathname);
+                try {
+                    body = fs.readFileSync(filePath);
+                    status = 200;
                 }
-            });
+                catch (err) {
+                    body = "Invalid File"
+                }
+
+            }
+            else if (req.method === 'PUT' && pathname.startsWith('/api/')) {
+                const query = pathname.split('/');
+                const api = query[2];
+                switch (api) {
+                    case "channel":
+                        const channel = query[3];
+                        const adapter = parseInt(url.searchParams.get('adapter'));
+                        tune(channel, adapter);
+                        break;
+                    default:
+                        body = "Invalid API Endpoint"
+                        break;
+                }
+            }
+            else {
+                body = "Invalid Request"
+            }
+            res.writeHead(status);
+            res.end(body);
+
         });
     }
     public start() {
@@ -34,5 +59,7 @@ export default class HttpServer {
 
 
 
+
+
 }
 
diff --git a/src/server.ts b/src/server.ts
index 72cad74..0582ac4 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,15 +1,51 @@
 import HttpServer from './http';
 import TVWebSocket from './ws';
+import Zap, { IZap } from './zap';
 
-const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT,10) : 8080;
+import * as readline from 'readline';
+
+const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT, 10) : 8080;
 const WS_PORT = process.env.WS_PORT ? parseInt(process.env.WS_PORT, 10) : 3001;
-const STATIC_ROOT = process.cwd() + "/dist/static";;
+const STATIC_ROOT = process.cwd() + "/dist/static";
+const TV_DEV_0 = process.env.TV_DEV_0 ?? '/dev/dvb/adapter0/dvr0'
+const TV_DEV_1 = process.env.TV_DEV_1 ? '/dev/dvb/adapter0/dvr1' : null;
 
-const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT);
+const zap = new Zap();
+
+
+const tune = (reqChannel: string, reqAdapter?: number) => {
+    const adapter = reqAdapter === 0 || reqAdapter === 1 ? reqAdapter : 0;
+    zap.zapTo(reqChannel, adapter).then((zap: IZap) => {
+        console.log(`Tuned ${zap.adapter} to ${zap.channel}`)
+    }).catch((err: Error) => {
+        console.error(err.message);
+    });
+}
+
+const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune);
 const tvWebSocket = new TVWebSocket(WS_PORT);
-
 httpServer.start();
 
 
+process.stdin.setEncoding("utf8");
+process.stdin.resume();
+
+console.log("Enter Channel Name:");
+
+process.stdin.on("data", async (data: string) => {
+    const input = data.trim();
+    console.log(`Received: "${input}"`);
+    await zap.zapTo(input).then((zap: IZap) => {
+        console.log(`Tuned ${zap.adapter} to ${zap.channel}`)
+
+    }).catch((err: Error) => {
+        console.error(err.message);
+    });
+
+});
+
+
+
+
 
 
diff --git a/src/zap.ts b/src/zap.ts
new file mode 100644
index 0000000..d912b73
--- /dev/null
+++ b/src/zap.ts
@@ -0,0 +1,127 @@
+import { spawn, ChildProcessWithoutNullStreams } from "child_process";
+import * as fs from "fs";
+
+export interface IZap {
+    process: ChildProcessWithoutNullStreams | null,
+    channel: string,
+    adapter: 0 | 1
+}
+
+export default class Zap {
+    private zap0: IZap;
+    private zap1: IZap;
+    private channelNameList: string[];
+    private fileName: string;
+    public constructor(fileName = "dvb_channel.conf", channel = "ION") {
+        const zap0: IZap = {
+            process: null,
+            channel,
+            adapter: 0
+        }
+        const zap1: IZap = {
+            process: null,
+            channel,
+            adapter: 1
+        }
+        this.zap0 = zap0;
+        this.zap1 = zap1;
+
+        const file = fs.readFileSync('./' + fileName, "utf-8");
+        const lines = file.split("\n").map(line => line.trim()).filter(line => line && !line.startsWith("#")).map(line => line.split(":")[0]);
+        this.channelNameList = lines;
+        this.fileName = fileName;
+
+    }
+
+    private nextChannel(channel: string) {
+        const size = this.channelNameList.length;
+        const currentIndex = this.channelNameList.indexOf(channel);
+        if (currentIndex >= 0) {
+            return this.channelNameList[this.mod(currentIndex + 1, size)];
+        }
+        else {
+            return channel;
+        }
+    }
+
+    private mod(n: number, m: number) {
+        return ((n % m) + m) % m;
+    }
+
+    private previousChannel(channel: string) {
+        const size = this.channelNameList.length;
+        const currentIndex = this.channelNameList.indexOf(channel);
+        if (currentIndex >= 0) {
+            return this.channelNameList[this.mod(currentIndex - 1, size)];
+        }
+        else {
+            return channel;
+        }
+    }
+
+    private cleanup(proc: ChildProcessWithoutNullStreams): Promise<void> {
+        proc.kill('SIGHUP');
+        return new Promise((resolve, reject) => {
+            proc.once('exit', () =>
+                resolve()
+            )
+            proc.on("error", (err:Error) =>
+                reject(err)
+            );
+        })
+    }
+
+    public async zapTo(channel: string, adapter: 0 | 1 = 0): Promise<IZap> {
+        let zap = adapter == 0 ? this.zap0 : this.zap1;
+        let verifiedChannel: string;
+        if (channel == '+') {
+            verifiedChannel = this.nextChannel(zap.channel);
+        }
+        else if (channel == '-') {
+            verifiedChannel = this.previousChannel(zap.channel);
+        }
+        else {
+            if (!this.channelNameList.includes(channel)) {
+                return Promise.reject(new Error("Invalid Channel name"));
+            }
+            else {
+                verifiedChannel = channel;
+            }
+        }
+        const cmd = 'dvbv5-zap'
+        const args: string[] = ["-r", "-C", "US", "-I", "ZAP", "-c", this.fileName, "-a", adapter.toString(), verifiedChannel];
+        if (zap.process != null) {
+            await this.cleanup(zap.process).catch(err => Promise.reject(err));
+
+        }
+        zap.process = spawn(cmd, args);
+        return new Promise((resolve, reject) => {
+            let lockTimer: NodeJS.Timeout;
+
+
+            zap.process.stderr.on("data", (data) => {
+                const output = data.toString();
+
+                if (/Lock/.test(output)) {
+                    clearTimeout(lockTimer);
+                    zap.channel = verifiedChannel;
+                    resolve(zap);
+                }
+
+                if (/Not locked/.test(output)) {
+                    clearTimeout(lockTimer);
+                    zap.process.kill("SIGHUP");
+                }
+            });
+
+            zap.process.on("exit", (code) => {
+                reject(new Error("Unexpected exit of Zap"));
+            });
+
+            lockTimer = setTimeout(() => {
+                reject(new Error("Failed to Zap in time"));
+            }, 5000);
+        })
+
+    }
+} 
\ No newline at end of file

From a74b90c6bef6fafdbcb243ff1084cd12e4675fff Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 16:40:44 -0700
Subject: [PATCH 07/15] get channels api

---
 src/http.ts   | 48 ++++++++++++++++++++++++++++++------------------
 src/server.ts |  5 ++++-
 src/zap.ts    | 12 ++++++++----
 3 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/src/http.ts b/src/http.ts
index 882ba0a..d4f7710 100644
--- a/src/http.ts
+++ b/src/http.ts
@@ -8,15 +8,42 @@ export default class HttpServer {
     private httpServer: http.Server;
     private port: number;
     private root: string;
-    public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void) {
+    public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void, getChannels: ()=>string[]) {
         this.port = port;
         this.root = root;
         this.httpServer = http.createServer((req, res) => {
             let status: number = 404;
-            let body: any;
+            let body: any = "";
             const url = new URL(req.url, `http://${req.headers.host}`);
             const pathname = path.normalize(url.pathname);
-            if (req.method === 'GET') {
+
+            if (pathname.startsWith('/api/')) {
+                const query = pathname.split('/');
+                const api = query[2];
+                switch (req.method) {
+                    case "GET":
+                        switch (api) {
+                            case "list":
+                                body = JSON.stringify(getChannels());
+                                status = 200;
+                                break;
+
+                        }
+                        break;
+                    case "PUT":
+                        switch (api) {
+                            case "tune":
+                                const channel = query[3];
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                tune(channel, adapter);
+                                status = 202;
+                                break;
+     
+                        }
+
+                }
+            }
+            else if (req.method === 'GET') {
                 const filePath = path.join(root, path.extname(pathname) === '' ? pathname + "/index.html" : pathname);
                 try {
                     body = fs.readFileSync(filePath);
@@ -25,21 +52,6 @@ export default class HttpServer {
                 catch (err) {
                     body = "Invalid File"
                 }
-
-            }
-            else if (req.method === 'PUT' && pathname.startsWith('/api/')) {
-                const query = pathname.split('/');
-                const api = query[2];
-                switch (api) {
-                    case "channel":
-                        const channel = query[3];
-                        const adapter = parseInt(url.searchParams.get('adapter'));
-                        tune(channel, adapter);
-                        break;
-                    default:
-                        body = "Invalid API Endpoint"
-                        break;
-                }
             }
             else {
                 body = "Invalid Request"
diff --git a/src/server.ts b/src/server.ts
index 0582ac4..1bb12a8 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -22,7 +22,10 @@ const tune = (reqChannel: string, reqAdapter?: number) => {
     });
 }
 
-const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune);
+const getChannels = () =>
+    zap.getChannels();
+
+const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune, getChannels);
 const tvWebSocket = new TVWebSocket(WS_PORT);
 httpServer.start();
 
diff --git a/src/zap.ts b/src/zap.ts
index d912b73..686ebad 100644
--- a/src/zap.ts
+++ b/src/zap.ts
@@ -33,7 +33,11 @@ export default class Zap {
 
     }
 
-    private nextChannel(channel: string) {
+    public getChannels(): string[] {
+        return this.channelNameList;
+    }
+
+    private nextChannel(channel: string) :string {
         const size = this.channelNameList.length;
         const currentIndex = this.channelNameList.indexOf(channel);
         if (currentIndex >= 0) {
@@ -44,11 +48,11 @@ export default class Zap {
         }
     }
 
-    private mod(n: number, m: number) {
+    private mod(n: number, m: number) :number{
         return ((n % m) + m) % m;
     }
 
-    private previousChannel(channel: string) {
+    private previousChannel(channel: string):string {
         const size = this.channelNameList.length;
         const currentIndex = this.channelNameList.indexOf(channel);
         if (currentIndex >= 0) {
@@ -65,7 +69,7 @@ export default class Zap {
             proc.once('exit', () =>
                 resolve()
             )
-            proc.on("error", (err:Error) =>
+            proc.on("error", (err: Error) =>
                 reject(err)
             );
         })

From 3dbf27e1490fdcb990560ebfd64e0c909d08da04 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 16:54:50 -0700
Subject: [PATCH 08/15] rename file

---
 src/static/index.html                | 2 +-
 src/static/js/{index.ts => video.ts} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/static/js/{index.ts => video.ts} (100%)

diff --git a/src/static/index.html b/src/static/index.html
index 9bee2f7..1682648 100644
--- a/src/static/index.html
+++ b/src/static/index.html
@@ -13,7 +13,7 @@
   <h2>WebRTC</h2>
   <video id="video" autoplay playsinline controls></video>
 
-  <script src="js/index.js"></script>
+  <script src="js/video.js"></script>
 </body>
 
 </html>
\ No newline at end of file
diff --git a/src/static/js/index.ts b/src/static/js/video.ts
similarity index 100%
rename from src/static/js/index.ts
rename to src/static/js/video.ts

From 6f1faf275313c101da735fb813ae06a29adfe637 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 17:29:27 -0700
Subject: [PATCH 09/15] added frontend tuning ability

---
 src/static/index.html |  7 ++++++-
 src/static/js/doc.ts  | 46 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)
 create mode 100644 src/static/js/doc.ts

diff --git a/src/static/index.html b/src/static/index.html
index 1682648..0e833d2 100644
--- a/src/static/index.html
+++ b/src/static/index.html
@@ -11,9 +11,14 @@
 <body>
   <h1>Video streams</h1>
   <h2>WebRTC</h2>
-  <video id="video" autoplay playsinline controls></video>
+  <div class="player">
+    <video id="video" autoplay playsinline controls></video>
+    <div id="channel-group" class="channel-group" ></div>
+    <button onClick="tune()">Tune</button>
+  </div>
 
   <script src="js/video.js"></script>
+  <script src="js/doc.js"></script>
 </body>
 
 </html>
\ No newline at end of file
diff --git a/src/static/js/doc.ts b/src/static/js/doc.ts
new file mode 100644
index 0000000..fa52d58
--- /dev/null
+++ b/src/static/js/doc.ts
@@ -0,0 +1,46 @@
+const getChannels = () => {
+    fetch('/api/list').then(async (res) => {
+        const channelNames: string[] = await res.json()
+        const radioGroup = document.getElementById('channel-group');
+        if (!radioGroup) {
+            throw new Error("Radio group not found")
+        }
+        radioGroup.innerHTML = ''
+        channelNames.forEach((channelName,index) => {
+            const id = `radio-${index}`;
+
+            const input = document.createElement('input');
+            input.type = "radio"
+            input.name = 'grp';
+            input.value = channelName;
+            input.id = id
+
+
+            const lbl = document.createElement("label");
+            lbl.htmlFor = id;
+            lbl.textContent = channelName;
+      
+            // Wrap in a div or line
+            const wrapper = document.createElement("div");
+            wrapper.appendChild(input);
+            wrapper.appendChild(lbl);
+
+
+
+            radioGroup.appendChild(wrapper)
+        })
+    }).catch(err => {
+        console.log("nope ",err)
+    })
+}
+
+const tune = () =>{
+    const choice = document.querySelector<HTMLInputElement>('input[name="grp"]:checked')
+    const channel = choice?.value;
+    if(channel){
+        fetch(`/api/tune/${channel}`, {method:'PUT'})
+    }
+    
+}
+
+getChannels();
\ No newline at end of file

From b98717201e60a837570177d8fa636a909ddb6815 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 17:48:29 -0700
Subject: [PATCH 10/15] frontend add 2nd player, style touch ups

---
 src/static/css/index.scss | 14 ++++++++
 src/static/index.html     | 23 +++++++++----
 src/static/js/doc.ts      | 71 +++++++++++++++++++++------------------
 src/static/js/video.ts    |  6 ++--
 4 files changed, 74 insertions(+), 40 deletions(-)

diff --git a/src/static/css/index.scss b/src/static/css/index.scss
index 55f9c80..a2db5ac 100644
--- a/src/static/css/index.scss
+++ b/src/static/css/index.scss
@@ -33,6 +33,20 @@ body {
             width: 20em;
             border-radius: 50%;
         }
+        .content{
+            display: flex;
+            flex-direction: column;
+            gap: 1em;
+            .player{
+
+                .channel-group{
+                    display: flex;
+                    align-self: center;
+                    justify-self: center;
+                }
+            }
+        }
+        
     }
 
 
diff --git a/src/static/index.html b/src/static/index.html
index 0e833d2..516f991 100644
--- a/src/static/index.html
+++ b/src/static/index.html
@@ -9,12 +9,23 @@
 </head>
 
 <body>
-  <h1>Video streams</h1>
-  <h2>WebRTC</h2>
-  <div class="player">
-    <video id="video" autoplay playsinline controls></video>
-    <div id="channel-group" class="channel-group" ></div>
-    <button onClick="tune()">Tune</button>
+  <header></header>
+  <main>
+    <h1>Video streams</h1>
+    <h2>WebRTC</h2>
+    <div class="content">
+      <div class="player">
+        <video id="video0" autoplay playsinline controls></video>
+        <div id="channel-container-0" class="channel-group"></div>
+        <button onClick="tune(0)">Tune</button>
+      </div>
+
+      <div class="player">
+        <video id="video1" autoplay playsinline controls></video>
+        <div id="channel-container-1" class="channel-group"></div>
+        <button onClick="tune(1)">Tune</button>
+      </div>
+  </main>
   </div>
 
   <script src="js/video.js"></script>
diff --git a/src/static/js/doc.ts b/src/static/js/doc.ts
index fa52d58..4289e85 100644
--- a/src/static/js/doc.ts
+++ b/src/static/js/doc.ts
@@ -1,46 +1,53 @@
-const getChannels = () => {
+const PLAYERS = 2;
+
+const populateChannels = (players:number) => {
     fetch('/api/list').then(async (res) => {
         const channelNames: string[] = await res.json()
-        const radioGroup = document.getElementById('channel-group');
-        if (!radioGroup) {
-            throw new Error("Radio group not found")
+        
+ 
+        for(let i = 0; i < players; ++i){
+            const radioGroup = document.getElementById(`channel-container-${i}`);
+            if (!radioGroup) {
+                throw new Error("Radio group not found")
+            }
+            radioGroup.innerHTML = ''
+            channelNames.forEach((channelName,_) => {
+                const id = `radio-${channelName}`;
+    
+                const input = document.createElement('input');
+                input.type = "radio"
+                input.name = `channel-radio-${i}`;
+                input.value = channelName;
+                input.id = id
+    
+    
+                const lbl = document.createElement("label");
+                lbl.htmlFor = id;
+                lbl.textContent = channelName;
+          
+                // Wrap in a div or line
+                const wrapper = document.createElement("div");
+                wrapper.appendChild(input);
+                wrapper.appendChild(lbl);
+    
+    
+    
+                radioGroup.appendChild(wrapper)
+            })
         }
-        radioGroup.innerHTML = ''
-        channelNames.forEach((channelName,index) => {
-            const id = `radio-${index}`;
-
-            const input = document.createElement('input');
-            input.type = "radio"
-            input.name = 'grp';
-            input.value = channelName;
-            input.id = id
-
-
-            const lbl = document.createElement("label");
-            lbl.htmlFor = id;
-            lbl.textContent = channelName;
-      
-            // Wrap in a div or line
-            const wrapper = document.createElement("div");
-            wrapper.appendChild(input);
-            wrapper.appendChild(lbl);
-
-
-
-            radioGroup.appendChild(wrapper)
-        })
+       
     }).catch(err => {
         console.log("nope ",err)
     })
 }
 
-const tune = () =>{
-    const choice = document.querySelector<HTMLInputElement>('input[name="grp"]:checked')
+const tune = (adapter=0) =>{
+    const choice = document.querySelector<HTMLInputElement>(`input[name="channel-radio-${adapter}"]:checked`)
     const channel = choice?.value;
     if(channel){
-        fetch(`/api/tune/${channel}`, {method:'PUT'})
+        fetch(`/api/tune/${channel}?adapter=${adapter}`, {method:'PUT'})
     }
     
 }
 
-getChannels();
\ No newline at end of file
+populateChannels(PLAYERS);
\ No newline at end of file
diff --git a/src/static/js/video.ts b/src/static/js/video.ts
index 276a004..69312de 100644
--- a/src/static/js/video.ts
+++ b/src/static/js/video.ts
@@ -1,7 +1,8 @@
 const host = window.location.hostname
 const ws = new WebSocket(`ws://${host}:3001`);
 const pc = new RTCPeerConnection({ iceServers: [] });
-const video = document.getElementById('video') as HTMLVideoElement;
+const video0 = document.getElementById('video0') as HTMLVideoElement;
+const video1 = document.getElementById('video1') as HTMLVideoElement;
 
 pc.onconnectionstatechange = (event) => {
   console.log("onconnectionstatechange ", event)
@@ -13,7 +14,8 @@ pc.ondatachannel = (event) => {
 
 pc.ontrack = (event) => {
   console.log("Received track event", event.streams);
-  video.srcObject = event.streams[0];
+  video0.srcObject = event.streams[0];
+  video1.srcObject = event.streams[0];
 };
 
 pc.onicecandidate = ({ candidate }) => {

From d1ad73fbf06b43dce6446f0f819020a16fd9b391 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 18:07:45 -0700
Subject: [PATCH 11/15] more support for dual tuners

---
 src/server.ts          |  7 ++--
 src/static/js/video.ts | 75 ++++++++++++++++++++++++++----------------
 src/ws.ts              |  8 ++---
 3 files changed, 53 insertions(+), 37 deletions(-)

diff --git a/src/server.ts b/src/server.ts
index 1bb12a8..3c8c5be 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -2,13 +2,11 @@ import HttpServer from './http';
 import TVWebSocket from './ws';
 import Zap, { IZap } from './zap';
 
-import * as readline from 'readline';
-
 const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT, 10) : 8080;
 const WS_PORT = process.env.WS_PORT ? parseInt(process.env.WS_PORT, 10) : 3001;
 const STATIC_ROOT = process.cwd() + "/dist/static";
 const TV_DEV_0 = process.env.TV_DEV_0 ?? '/dev/dvb/adapter0/dvr0'
-const TV_DEV_1 = process.env.TV_DEV_1 ? '/dev/dvb/adapter0/dvr1' : null;
+const TV_DEV_1 = process.env.TV_DEV_1 ?? '/dev/dvb/adapter0/dvr1';
 
 const zap = new Zap();
 
@@ -26,7 +24,8 @@ const getChannels = () =>
     zap.getChannels();
 
 const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune, getChannels);
-const tvWebSocket = new TVWebSocket(WS_PORT);
+const tvWebSocket0 = new TVWebSocket(WS_PORT, TV_DEV_0);
+// const tvWebSocket1 = new TVWebSocket(WS_PORT + 1, TV_DEV_1);
 httpServer.start();
 
 
diff --git a/src/static/js/video.ts b/src/static/js/video.ts
index 69312de..1b6e5d3 100644
--- a/src/static/js/video.ts
+++ b/src/static/js/video.ts
@@ -1,50 +1,67 @@
 const host = window.location.hostname
-const ws = new WebSocket(`ws://${host}:3001`);
-const pc = new RTCPeerConnection({ iceServers: [] });
+const ws0 = new WebSocket(`ws://${host}:3001`);
+const ws1 = new WebSocket(`ws://${host}:3002`);
+const pc0 = new RTCPeerConnection({ iceServers: [] });
+const pc1 = new RTCPeerConnection({ iceServers: [] });
 const video0 = document.getElementById('video0') as HTMLVideoElement;
 const video1 = document.getElementById('video1') as HTMLVideoElement;
 
-pc.onconnectionstatechange = (event) => {
-  console.log("onconnectionstatechange ", event)
-}
-
-pc.ondatachannel = (event) => {
-  console.log("ondatachannel ", event)
-}
-
-pc.ontrack = (event) => {
+// 0
+pc0.ontrack = (event) => {
   console.log("Received track event", event.streams);
   video0.srcObject = event.streams[0];
+};
+
+pc0.onicecandidate = ({ candidate }) => {
+  if (candidate) {
+    ws0.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+  }
+};
+
+ws0.onopen = async () => {
+  pc0.addTransceiver('video', { direction: 'recvonly' });
+  pc0.addTransceiver('audio', { direction: 'recvonly' })
+  const offer = await pc0.createOffer();
+  await pc0.setLocalDescription(offer);
+  ws0.send(JSON.stringify({ type: 'offer', data: offer }));
+}
+
+ws0.onmessage = async (message) => {
+  const msg = JSON.parse(message.data);
+  if (msg.type === 'answer') {
+    await pc0.setRemoteDescription(msg.data);
+  }
+  else if (msg.type === 'ice-candidate') {
+    await pc0.addIceCandidate(msg.data);
+  }
+};
+
+// 1
+pc1.ontrack = (event) => {
+  console.log("Received track event", event.streams);
   video1.srcObject = event.streams[0];
 };
 
-pc.onicecandidate = ({ candidate }) => {
+pc1.onicecandidate = ({ candidate }) => {
   if (candidate) {
-    ws.send(JSON.stringify({ type: 'ice-candidate', data: candidate })); // Use 'candidate' instead of 'ice-candidate'
+    ws1.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
   }
 };
-pc.onicegatheringstatechange = () => {
-  // console.log('ICE state:', pc.iceGatheringState);
-};
 
-ws.onopen = async () => {
-  pc.addTransceiver('video', { direction: 'recvonly' });
-  pc.addTransceiver('audio', { direction: 'recvonly' })
-  const offer = await pc.createOffer();
-  await pc.setLocalDescription(offer);
-  ws.send(JSON.stringify({ type: 'offer', data: offer }));
+ws1.onopen = async () => {
+  pc1.addTransceiver('video', { direction: 'recvonly' });
+  pc1.addTransceiver('audio', { direction: 'recvonly' })
+  const offer = await pc1.createOffer();
+  await pc1.setLocalDescription(offer);
+  ws1.send(JSON.stringify({ type: 'offer', data: offer }));
 }
 
-ws.onmessage = async (message) => {
+ws1.onmessage = async (message) => {
   const msg = JSON.parse(message.data);
-
   if (msg.type === 'answer') {
-    await pc.setRemoteDescription(msg.data);
+    await pc1.setRemoteDescription(msg.data);
   }
-
   else if (msg.type === 'ice-candidate') {
-    await pc.addIceCandidate(msg.data);
+    await pc1.addIceCandidate(msg.data);
   }
 };
-
-;
\ No newline at end of file
diff --git a/src/ws.ts b/src/ws.ts
index 1cb1ce9..6c3c416 100644
--- a/src/ws.ts
+++ b/src/ws.ts
@@ -3,14 +3,14 @@ import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 import * as ws from 'ws';
 
 // Constants
-const VIDEO_DEVICE = '/dev/dvb/adapter0/dvr0'; // Video source device
 const WIDTH = 640; // Video width
 const HEIGHT = 480; // Video height
 const FRAME_SIZE = WIDTH * HEIGHT * 1.5; // YUV420p frame size (460800 bytes)
 
 export default class TVWebSocket {
-
-    public constructor(port: number) {    
+    videoDevice: string;
+    public constructor(port: number, videoDevice) { 
+        this.videoDevice = videoDevice   
         const ffmpegProcess = this.startFFmpeg();
         const videoTrack = this.createVideoTrack(ffmpegProcess);
         const audioTrack = this.createAudioTrack(ffmpegProcess);
@@ -62,7 +62,7 @@ export default class TVWebSocket {
     startFFmpeg = (): ChildProcessWithoutNullStreams => {
         const p = spawn('ffmpeg', [
             '-loglevel', 'debug',
-            '-i', VIDEO_DEVICE,
+            '-i', this.videoDevice,
 
             // Video
             '-map', '0:v:0',

From e8a007a4a9ef7b858698d1cddc24ce2043f75bde Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 18:33:17 -0700
Subject: [PATCH 12/15] dual tuners fully working

---
 src/server.ts |  4 ++--
 src/ws.ts     | 15 +++++++++++++++
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/server.ts b/src/server.ts
index 3c8c5be..39f6964 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -6,7 +6,7 @@ const HTTP_PORT = process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT, 10) :
 const WS_PORT = process.env.WS_PORT ? parseInt(process.env.WS_PORT, 10) : 3001;
 const STATIC_ROOT = process.cwd() + "/dist/static";
 const TV_DEV_0 = process.env.TV_DEV_0 ?? '/dev/dvb/adapter0/dvr0'
-const TV_DEV_1 = process.env.TV_DEV_1 ?? '/dev/dvb/adapter0/dvr1';
+const TV_DEV_1 = process.env.TV_DEV_1 ?? '/dev/dvb/adapter1/dvr0';
 
 const zap = new Zap();
 
@@ -25,7 +25,7 @@ const getChannels = () =>
 
 const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune, getChannels);
 const tvWebSocket0 = new TVWebSocket(WS_PORT, TV_DEV_0);
-// const tvWebSocket1 = new TVWebSocket(WS_PORT + 1, TV_DEV_1);
+const tvWebSocket1 = new TVWebSocket(WS_PORT + 1, TV_DEV_1);
 httpServer.start();
 
 
diff --git a/src/ws.ts b/src/ws.ts
index 6c3c416..4c0b0a3 100644
--- a/src/ws.ts
+++ b/src/ws.ts
@@ -15,6 +15,11 @@ export default class TVWebSocket {
         const videoTrack = this.createVideoTrack(ffmpegProcess);
         const audioTrack = this.createAudioTrack(ffmpegProcess);
 
+
+        ffmpegProcess.stdio[2].on('data',data=>{
+            // console.log("stdio[2] ",data.toString())
+        })
+
         // WebSocket signaling server
         const wss = new ws.WebSocketServer({ port });
 
@@ -70,6 +75,13 @@ export default class TVWebSocket {
             '-vcodec', 'rawvideo',
             '-pix_fmt', 'yuv420p',
             '-f', 'rawvideo',
+
+            //quality
+            '-fflags', '+discardcorrupt',
+            '-err_detect', 'ignore_err',
+            '-analyzeduration', '100M',
+            '-probesize', '100M',
+
             'pipe:3',
 
             // Audio
@@ -109,6 +121,9 @@ export default class TVWebSocket {
         // Start FFmpeg and pipe video frames to the source
         videoStream.on('data', (chunk: Buffer) => {
             videoBuffer = Buffer.concat([videoBuffer, chunk]);
+            if (videoBuffer.length > FRAME_SIZE * 2) {
+                console.warn('Video buffer overrun — possible freeze trigger');
+            }
             while (videoBuffer.length >= FRAME_SIZE) {
                 const frameData = videoBuffer.slice(0, FRAME_SIZE);
                 videoBuffer = videoBuffer.slice(FRAME_SIZE);

From 15f73327ee961c64123ca928e84b62e0ac8d2c46 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 19:09:11 -0700
Subject: [PATCH 13/15] signal feature prototype

---
 src/http.ts               |  7 +++++-
 src/server.ts             |  5 +++-
 src/static/css/index.scss |  4 +++-
 src/static/index.html     |  5 ++++
 src/static/js/doc.ts      | 50 +++++++++++++++++++++++----------------
 src/zap.ts                | 37 +++++++++++++++++++++++++++--
 6 files changed, 82 insertions(+), 26 deletions(-)

diff --git a/src/http.ts b/src/http.ts
index d4f7710..9d067c9 100644
--- a/src/http.ts
+++ b/src/http.ts
@@ -8,7 +8,7 @@ export default class HttpServer {
     private httpServer: http.Server;
     private port: number;
     private root: string;
-    public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void, getChannels: ()=>string[]) {
+    public constructor(port: number, root: string, tune: (ch: string, adp?: number) => void, getChannels: ()=>string[], getSignal: (adapter:number)=>object) {
         this.port = port;
         this.root = root;
         this.httpServer = http.createServer((req, res) => {
@@ -27,6 +27,11 @@ export default class HttpServer {
                                 body = JSON.stringify(getChannels());
                                 status = 200;
                                 break;
+                            case "signal":
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                body = JSON.stringify(getSignal(adapter));
+                                status = 200;
+                                break;
 
                         }
                         break;
diff --git a/src/server.ts b/src/server.ts
index 39f6964..17cecfc 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -23,7 +23,10 @@ const tune = (reqChannel: string, reqAdapter?: number) => {
 const getChannels = () =>
     zap.getChannels();
 
-const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune, getChannels);
+const getSignal = (adapter: number) =>
+    zap.getSignal(adapter)
+
+const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT, tune, getChannels, getSignal);
 const tvWebSocket0 = new TVWebSocket(WS_PORT, TV_DEV_0);
 const tvWebSocket1 = new TVWebSocket(WS_PORT + 1, TV_DEV_1);
 httpServer.start();
diff --git a/src/static/css/index.scss b/src/static/css/index.scss
index a2db5ac..700d609 100644
--- a/src/static/css/index.scss
+++ b/src/static/css/index.scss
@@ -26,6 +26,8 @@ body {
         display: flex;
         flex-direction: column;
         text-align: center;
+        align-items: center;
+        justify-content: center;
         h1 {}
 
         p {}
@@ -35,7 +37,7 @@ body {
         }
         .content{
             display: flex;
-            flex-direction: column;
+            flex-direction: row;
             gap: 1em;
             .player{
 
diff --git a/src/static/index.html b/src/static/index.html
index 516f991..6675c38 100644
--- a/src/static/index.html
+++ b/src/static/index.html
@@ -18,12 +18,17 @@
         <video id="video0" autoplay playsinline controls></video>
         <div id="channel-container-0" class="channel-group"></div>
         <button onClick="tune(0)">Tune</button>
+        <p id="signal-0">N/A</p>
+        <button onClick="getSignal(0)">Get Signal</button>
       </div>
 
       <div class="player">
         <video id="video1" autoplay playsinline controls></video>
         <div id="channel-container-1" class="channel-group"></div>
         <button onClick="tune(1)">Tune</button>
+        <p id="signal-1">N/A</p>
+        <button onClick="getSignal(1)">Get Signal</button>
+
       </div>
   </main>
   </div>
diff --git a/src/static/js/doc.ts b/src/static/js/doc.ts
index 4289e85..aeb66bc 100644
--- a/src/static/js/doc.ts
+++ b/src/static/js/doc.ts
@@ -1,53 +1,61 @@
 const PLAYERS = 2;
 
-const populateChannels = (players:number) => {
+const populateChannels = (players: number) => {
     fetch('/api/list').then(async (res) => {
         const channelNames: string[] = await res.json()
-        
- 
-        for(let i = 0; i < players; ++i){
+
+
+        for (let i = 0; i < players; ++i) {
             const radioGroup = document.getElementById(`channel-container-${i}`);
             if (!radioGroup) {
                 throw new Error("Radio group not found")
             }
             radioGroup.innerHTML = ''
-            channelNames.forEach((channelName,_) => {
-                const id = `radio-${channelName}`;
-    
+            channelNames.forEach((channelName, _) => {
+                const id = `radio-${i}-${channelName}`;
+
                 const input = document.createElement('input');
                 input.type = "radio"
                 input.name = `channel-radio-${i}`;
-                input.value = channelName;
+                input.value = `${channelName}`;
                 input.id = id
-    
-    
+
                 const lbl = document.createElement("label");
                 lbl.htmlFor = id;
                 lbl.textContent = channelName;
-          
-                // Wrap in a div or line
+
                 const wrapper = document.createElement("div");
                 wrapper.appendChild(input);
                 wrapper.appendChild(lbl);
-    
-    
-    
+
                 radioGroup.appendChild(wrapper)
             })
         }
-       
+
     }).catch(err => {
-        console.log("nope ",err)
+        console.log("nope ", err)
     })
 }
 
-const tune = (adapter=0) =>{
+const tune = (adapter = 0) => {
     const choice = document.querySelector<HTMLInputElement>(`input[name="channel-radio-${adapter}"]:checked`)
     const channel = choice?.value;
-    if(channel){
-        fetch(`/api/tune/${channel}?adapter=${adapter}`, {method:'PUT'})
+    if (channel) {
+        fetch(`/api/tune/${channel}?adapter=${adapter}`, { method: 'PUT' })
     }
-    
+
+}
+
+const getSignal = (adapter = 0) => {
+    const signalElement = document.getElementById(`signal-${adapter}`);
+    if (!signalElement) {
+        return;
+    }
+    fetch(`/api/signal?adapter=${adapter}`).then(res =>
+        res.json()
+    ).then((strength: any) => {
+        signalElement.innerHTML = `Signal: ${strength.signal} C/N: ${strength.cn}`
+    })
 }
 
 populateChannels(PLAYERS);
\ No newline at end of file
diff --git a/src/zap.ts b/src/zap.ts
index 686ebad..11397b0 100644
--- a/src/zap.ts
+++ b/src/zap.ts
@@ -5,6 +5,10 @@ export interface IZap {
     process: ChildProcessWithoutNullStreams | null,
     channel: string,
     adapter: 0 | 1
+    strength: {
+        signal: string;
+        cn: string;
+    },
 }
 
 export default class Zap {
@@ -12,16 +16,28 @@ export default class Zap {
     private zap1: IZap;
     private channelNameList: string[];
     private fileName: string;
+
+    private  regex = /Signal=\s*(-?\d+(\.\d+)?dBm)\s+C\/N=\s*(\d+(\.\d+)?dB)/;
+
+
     public constructor(fileName = "dvb_channel.conf", channel = "ION") {
         const zap0: IZap = {
             process: null,
             channel,
-            adapter: 0
+            adapter: 0,
+            strength: {
+                signal: "None", 
+                cn: "None"
+            }
         }
         const zap1: IZap = {
             process: null,
             channel,
-            adapter: 1
+            adapter: 1,
+            strength: {
+                signal: "None", 
+                cn: "None"
+            }
         }
         this.zap0 = zap0;
         this.zap1 = zap1;
@@ -37,6 +53,18 @@ export default class Zap {
         return this.channelNameList;
     }
 
+    public getSignal(adapter: number) {
+        if(adapter == 0){
+            return this.zap0.strength;
+        }
+        else if (adapter == 1){
+            return this.zap1.strength;
+        }
+        else {
+            return {signal: 'N/A', cn: 'N/A'}
+        }
+    }
+
     private nextChannel(channel: string) :string {
         const size = this.channelNameList.length;
         const currentIndex = this.channelNameList.indexOf(channel);
@@ -108,7 +136,12 @@ export default class Zap {
 
                 if (/Lock/.test(output)) {
                     clearTimeout(lockTimer);
+                    const match = output.match(this.regex);
                     zap.channel = verifiedChannel;
+                    zap.strength = {
+                        signal: match[1],
+                        cn: match[3]
+                    }
                     resolve(zap);
                 }
 

From 865e2019c39e7b23dcbe3a473acda9f5ada59d9c Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Tue, 1 Apr 2025 19:37:28 -0700
Subject: [PATCH 14/15] url decode issue fix; channel scan update

---
 dvb_channel.conf | 3 ++-
 src/http.ts      | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/dvb_channel.conf b/dvb_channel.conf
index 2617fe6..fee2bf8 100644
--- a/dvb_channel.conf
+++ b/dvb_channel.conf
@@ -1,6 +1,7 @@
+FOX 12:207028615:8VSB:49:52:3
 ION:521028615:8VSB:49:52:3
 KATU:533028615:8VSB:49:52:3
 KOIN-HD:539028615:8VSB:49:52:3
 KGW:545028615:8VSB:49:52:3
 KBLN-DT:575028615:8VSB:49:52:1
-TBN HD:581028615:8VSB:49:52:3
+TBN HD:581028615:8VSB:49:52:3
\ No newline at end of file
diff --git a/src/http.ts b/src/http.ts
index 9d067c9..4f41483 100644
--- a/src/http.ts
+++ b/src/http.ts
@@ -38,7 +38,7 @@ export default class HttpServer {
                     case "PUT":
                         switch (api) {
                             case "tune":
-                                const channel = query[3];
+                                const channel = decodeURIComponent(query[3]);
                                 const adapter = parseInt(url.searchParams.get('adapter'));
                                 tune(channel, adapter);
                                 status = 202;

From f0d5af522001ce0abdece4e93a9320608b2f1608 Mon Sep 17 00:00:00 2001
From: david <david@pop-os.localdomain>
Date: Thu, 3 Apr 2025 21:32:14 -0700
Subject: [PATCH 15/15] add gitea deploy

---
 .gitea/workflows/deploy.yml | 33 +++++++++++++++++++++++++++++++++
 .vscode/settings.json       |  3 +++
 2 files changed, 36 insertions(+)
 create mode 100644 .gitea/workflows/deploy.yml
 create mode 100644 .vscode/settings.json

diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml
new file mode 100644
index 0000000..9758d5c
--- /dev/null
+++ b/.gitea/workflows/deploy.yml
@@ -0,0 +1,33 @@
+name: Personal Website - Run Python HTTP Server
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: self-hosted
+
+    steps:
+      - name: Checkout code
+        run: |
+          cd ~/ota-tv-web
+          git fetch
+          git checkout main
+          git pull origin main
+
+      - name: Stop existing screen session, if running
+        run: |
+          if screen -list | grep -q "ota_tv_web_server"; then
+            echo "Stopping existing screen session..."
+            screen -S ota_tv_web -X quit
+          fi
+
+      - name: Start server in screen session
+        run: |
+          cd ~/ota-tv-web
+          chmod +x ./start.sh
+          sassc css/style.scss css/style.css
+          setsid screen -dmS ota_tv_web bash -c 'HTTP_PORT=8081 WS_PORT=3001 npm start > server.log 2>&1'
+          echo "Server started in detached screen session"
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..55712c1
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}
\ No newline at end of file