add gitea deploy

.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"

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}

dvb_channel.conf

@@ -0,0 +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

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"
   }
-}
+}

src/http.ts

@@ -8,20 +8,62 @@ 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, getChannels: ()=>string[], getSignal: (adapter:number)=>object) {
         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 (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;
+                            case "signal":
+                                const adapter = parseInt(url.searchParams.get('adapter'));
+                                body = JSON.stringify(getSignal(adapter));
+                                status = 200;
+                                break;
+
+                        }
+                        break;
+                    case "PUT":
+                        switch (api) {
+                            case "tune":
+                                const channel = decodeURIComponent(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);
+                    status = 200;
+                }
+                catch (err) {
+                    body = "Invalid File"
+                }
+            }
+            else {
+                body = "Invalid Request"
+            }
+            res.writeHead(status);
+            res.end(body);
+
         });
     }
     public start() {
@@ -34,5 +76,7 @@ export default class HttpServer {
 
 
 
+
+
 }
 

src/server.ts

@@ -1,15 +1,56 @@
 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;
+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/adapter1/dvr0';
 
-const httpServer = new HttpServer(HTTP_PORT, STATIC_ROOT);
-const tvWebSocket = new TVWebSocket(WS_PORT);
+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 getChannels = () =>
+    zap.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();
 
 
+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);
+    });
+
+});
+
+
+
+
 
 

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 {}
@@ -33,6 +35,20 @@ body {
             width: 20em;
             border-radius: 50%;
         }
+        .content{
+            display: flex;
+            flex-direction: row;
+            gap: 1em;
+            .player{
+
+                .channel-group{
+                    display: flex;
+                    align-self: center;
+                    justify-self: center;
+                }
+            }
+        }
+        
     }
 
 

src/static/index.html

@@ -9,11 +9,32 @@
 </head>
 
 <body>
-  <h1>Video streams</h1>
-  <h2>WebRTC</h2>
-  <video id="video" autoplay playsinline controls></video>
+  <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>
+        <p id="signal-0">N/A</p>
+        <button onClick="getSignal(0)">Get Signal</button>
+      </div>
 
-  <script src="js/index.js"></script>
+      <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>
+
+  <script src="js/video.js"></script>
+  <script src="js/doc.js"></script>
 </body>
 
 </html>

src/static/js/doc.ts

@@ -0,0 +1,61 @@
+const PLAYERS = 2;
+
+const populateChannels = (players: number) => {
+    fetch('/api/list').then(async (res) => {
+        const channelNames: string[] = await res.json()
+
+
+        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-${i}-${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;
+
+                const wrapper = document.createElement("div");
+                wrapper.appendChild(input);
+                wrapper.appendChild(lbl);
+
+                radioGroup.appendChild(wrapper)
+            })
+        }
+
+    }).catch(err => {
+        console.log("nope ", err)
+    })
+}
+
+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' })
+    }
+
+}
+
+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);

src/static/js/index.ts

@@ -1,48 +0,0 @@
-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);
-  }
-};
-
-;

src/static/js/video.ts

@@ -0,0 +1,67 @@
+const host = window.location.hostname
+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;
+
+// 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];
+};
+
+pc1.onicecandidate = ({ candidate }) => {
+  if (candidate) {
+    ws1.send(JSON.stringify({ type: 'ice-candidate', data: candidate }));
+  }
+};
+
+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 }));
+}
+
+ws1.onmessage = async (message) => {
+  const msg = JSON.parse(message.data);
+  if (msg.type === 'answer') {
+    await pc1.setRemoteDescription(msg.data);
+  }
+  else if (msg.type === 'ice-candidate') {
+    await pc1.addIceCandidate(msg.data);
+  }
+};

src/ws.ts

@@ -3,18 +3,23 @@ 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);
 
+
+        ffmpegProcess.stdio[2].on('data',data=>{
+            // console.log("stdio[2] ",data.toString())
+        })
+
         // WebSocket signaling server
         const wss = new ws.WebSocketServer({ port });
 
@@ -62,7 +67,7 @@ export default class TVWebSocket {
     startFFmpeg = (): ChildProcessWithoutNullStreams => {
         const p = spawn('ffmpeg', [
             '-loglevel', 'debug',
-            '-i', VIDEO_DEVICE,
+            '-i', this.videoDevice,
 
             // Video
             '-map', '0:v:0',
@@ -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);

src/zap.ts

@@ -0,0 +1,164 @@
+import { spawn, ChildProcessWithoutNullStreams } from "child_process";
+import * as fs from "fs";
+
+export interface IZap {
+    process: ChildProcessWithoutNullStreams | null,
+    channel: string,
+    adapter: 0 | 1
+    strength: {
+        signal: string;
+        cn: string;
+    },
+}
+
+export default class Zap {
+    private zap0: IZap;
+    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,
+            strength: {
+                signal: "None", 
+                cn: "None"
+            }
+        }
+        const zap1: IZap = {
+            process: null,
+            channel,
+            adapter: 1,
+            strength: {
+                signal: "None", 
+                cn: "None"
+            }
+        }
+        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;
+
+    }
+
+    public getChannels(): string[] {
+        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);
+        if (currentIndex >= 0) {
+            return this.channelNameList[this.mod(currentIndex + 1, size)];
+        }
+        else {
+            return channel;
+        }
+    }
+
+    private mod(n: number, m: number) :number{
+        return ((n % m) + m) % m;
+    }
+
+    private previousChannel(channel: string):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);
+                    const match = output.match(this.regex);
+                    zap.channel = verifiedChannel;
+                    zap.strength = {
+                        signal: match[1],
+                        cn: match[3]
+                    }
+                    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);
+        })
+
+    }
+}