Resolve HKSV recording issues (#1496)

Author: donavanbecker

src/recordingDelegate.ts

@@ -101,44 +101,124 @@ export class RecordingDelegate implements CameraRecordingDelegate {
     return Promise.resolve()
   }
 
-  updateRecordingConfiguration(): Promise<void> {
+  updateRecordingConfiguration(configuration: CameraRecordingConfiguration | undefined): Promise<void> {
     this.log.info('Recording configuration updated', this.cameraName)
+    this.currentRecordingConfiguration = configuration
     return Promise.resolve()
   }
 
   async *handleRecordingStreamRequest(streamId: number): AsyncGenerator<RecordingPacket, any, any> {
     this.log.info(`Recording stream request received for stream ID: ${streamId}`, this.cameraName)
-    // Implement the logic to handle the recording stream request here
-    // For now, just yield an empty RecordingPacket
-    yield {} as RecordingPacket
+    
+    if (!this.currentRecordingConfiguration) {
+      this.log.error('No recording configuration available', this.cameraName)
+      return
+    }
+
+    // Create abort controller for this stream
+    const abortController = new AbortController()
+    this.streamAbortControllers.set(streamId, abortController)
+
+    try {
+      // Use existing handleFragmentsRequests method but track the process
+      const fragmentGenerator = this.handleFragmentsRequests(this.currentRecordingConfiguration, streamId)
+      
+      let fragmentCount = 0
+      let totalBytes = 0
+      
+      for await (const fragmentBuffer of fragmentGenerator) {
+        // Check if stream was aborted
+        if (abortController.signal.aborted) {
+          this.log.debug(`Recording stream ${streamId} aborted, stopping generator`, this.cameraName)
+          break
+        }
+        
+        fragmentCount++
+        totalBytes += fragmentBuffer.length
+        
+        // Enhanced logging for HKSV debugging
+        this.log.debug(`HKSV: Yielding fragment #${fragmentCount}, size: ${fragmentBuffer.length}, total: ${totalBytes} bytes`, this.cameraName)
+        
+        yield {
+          data: fragmentBuffer,
+          isLast: false // We'll handle the last fragment properly when the stream ends
+        }
+      }
+      
+      // Send final packet to indicate end of stream
+      this.log.info(`HKSV: Recording stream ${streamId} completed. Total fragments: ${fragmentCount}, total bytes: ${totalBytes}`, this.cameraName)
+      
+    } catch (error) {
+      this.log.error(`Recording stream error: ${error}`, this.cameraName)
+      // Send error indication
+      yield {
+        data: Buffer.alloc(0),
+        isLast: true
+      }
+    } finally {
+      // Cleanup
+      this.streamAbortControllers.delete(streamId)
+      this.log.debug(`Recording stream ${streamId} generator finished`, this.cameraName)
+    }
   }
 
   closeRecordingStream(streamId: number, reason: HDSProtocolSpecificErrorReason | undefined): void {
     this.log.info(`Recording stream closed for stream ID: ${streamId}, reason: ${reason}`, this.cameraName)
+    
+    // Abort the stream generator
+    const abortController = this.streamAbortControllers.get(streamId)
+    if (abortController) {
+      abortController.abort()
+      this.streamAbortControllers.delete(streamId)
+    }
+    
+    // Kill any active FFmpeg processes for this stream
+    const process = this.activeFFmpegProcesses.get(streamId)
+    if (process && !process.killed) {
+      this.log.debug(`Terminating FFmpeg process for stream ${streamId}`, this.cameraName)
+      process.kill('SIGTERM')
+      this.activeFFmpegProcesses.delete(streamId)
+    }
   }
 
   private readonly hap: HAP
   private readonly log: Logger
   private readonly cameraName: string
-  private readonly videoConfig?: VideoConfig
+  private readonly videoConfig: VideoConfig
   private process!: ChildProcess
 
   private readonly videoProcessor: string
   readonly controller?: CameraController
   private preBufferSession?: Mp4Session
   private preBuffer?: PreBuffer
+  
+  // Add fields for recording configuration and process management
+  private currentRecordingConfiguration?: CameraRecordingConfiguration
+  private activeFFmpegProcesses = new Map<number, ChildProcess>()
+  private streamAbortControllers = new Map<number, AbortController>()
 
   constructor(log: Logger, cameraName: string, videoConfig: VideoConfig, api: API, hap: HAP, videoProcessor?: string) {
     this.log = log
     this.hap = hap
     this.cameraName = cameraName
+    this.videoConfig = videoConfig
     this.videoProcessor = videoProcessor || ffmpegPathString || 'ffmpeg'
 
     api.on(APIEvent.SHUTDOWN, () => {
       if (this.preBufferSession) {
         this.preBufferSession.process?.kill()
         this.preBufferSession.server?.close()
       }
+      
+      // Cleanup active streams on shutdown
+      this.activeFFmpegProcesses.forEach((process, streamId) => {
+        if (!process.killed) {
+          this.log.debug(`Shutdown: Terminating FFmpeg process for stream ${streamId}`, this.cameraName)
+          process.kill('SIGTERM')
+        }
+      })
+      this.activeFFmpegProcesses.clear()
+      this.streamAbortControllers.clear()
     })
   }
 
@@ -155,8 +235,9 @@ export class RecordingDelegate implements CameraRecordingDelegate {
     }
   }
 
-  async * handleFragmentsRequests(configuration: CameraRecordingConfiguration): AsyncGenerator<Buffer, void, unknown> {
+  async * handleFragmentsRequests(configuration: CameraRecordingConfiguration, streamId: number): AsyncGenerator<Buffer, void, unknown> {
     this.log.debug('video fragments requested', this.cameraName)
+    this.log.debug(`DEBUG: handleFragmentsRequests called for stream ${streamId}`, this.cameraName)
 
     const iframeIntervalSeconds = 4
 
@@ -174,6 +255,7 @@ export class RecordingDelegate implements CameraRecordingDelegate {
       `${configuration.audioCodec.audioChannels}`,
     ]
 
+    // Use HomeKit provided codec parameters instead of hardcoded values
     const profile = configuration.videoCodec.parameters.profile === H264Profile.HIGH
       ? 'high'
       : configuration.videoCodec.parameters.profile === H264Profile.MAIN ? 'main' : 'baseline'
@@ -183,26 +265,43 @@ export class RecordingDelegate implements CameraRecordingDelegate {
       : configuration.videoCodec.parameters.level === H264Level.LEVEL3_2 ? '3.2' : '3.1'
 
     const videoArgs: Array<string> = [
-      '-an',
+      '-an', // Will be enabled later if audio is configured
       '-sn',
       '-dn',
       '-codec:v',
       'libx264',
       '-pix_fmt',
       'yuv420p',
-
       '-profile:v',
-      profile,
+      profile, // Use HomeKit provided profile
       '-level:v',
-      level,
+      level,   // Use HomeKit provided level
+      '-vf', 'scale=\'min(1280,iw)\':\'min(720,ih)\':force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2',
       '-b:v',
-      `${configuration.videoCodec.parameters.bitRate}k`,
+      '800k',
+      '-maxrate',
+      '1000k',
+      '-bufsize',
+      '1000k',
       '-force_key_frames',
-      `expr:eq(t,n_forced*${iframeIntervalSeconds})`,
-      '-r',
-      configuration.videoCodec.resolution[2].toString(),
+      'expr:gte(t,0)',
+      '-tune',
+      'zerolatency',
+      '-preset',
+      'ultrafast',
+      '-x264opts',
+      'no-scenecut:ref=1:bframes=0:cabac=0:no-deblock:intra-refresh=1',
     ]
 
+    // Enable audio if recording audio is active
+    if (this.currentRecordingConfiguration?.audioCodec) {
+      // Remove the '-an' flag to enable audio
+      const anIndex = videoArgs.indexOf('-an')
+      if (anIndex !== -1) {
+        videoArgs.splice(anIndex, 1)
+      }
+    }
+
     const ffmpegInput: Array<string> = []
 
     if (this.videoConfig?.prebuffer) {
@@ -218,24 +317,48 @@ export class RecordingDelegate implements CameraRecordingDelegate {
     this.log.info('Recording started', this.cameraName)
 
     const { socket, cp, generator } = session
+    
+    // Track the FFmpeg process for this stream
+    this.activeFFmpegProcesses.set(streamId, cp)
+
     let pending: Array<Buffer> = []
     let filebuffer: Buffer = Buffer.alloc(0)
+    let isFirstFragment = true
+    
     try {
       for await (const box of generator) {
         const { header, type, length, data } = box
 
         pending.push(header, data)
 
-        if (type === 'moov' || type === 'mdat') {
-          const fragment = Buffer.concat(pending)
-          filebuffer = Buffer.concat([filebuffer, Buffer.concat(pending)])
-          pending = []
-          yield fragment
+        // HKSV requires specific MP4 structure:
+        // 1. First packet: ftyp + moov (initialization data)
+        // 2. Subsequent packets: moof + mdat (media fragments)
+        if (isFirstFragment) {
+          // For initialization segment, wait for both ftyp and moov
+          if (type === 'moov') {
+            const fragment = Buffer.concat(pending)
+            filebuffer = Buffer.concat([filebuffer, fragment])
+            pending = []
+            isFirstFragment = false
+            this.log.debug(`HKSV: Sending initialization segment (ftyp+moov), size: ${fragment.length}`, this.cameraName)
+            yield fragment
+          }
+        } else {
+          // For media segments, send moof+mdat pairs
+          if (type === 'mdat') {
+            const fragment = Buffer.concat(pending)
+            filebuffer = Buffer.concat([filebuffer, fragment])
+            pending = []
+            this.log.debug(`HKSV: Sending media fragment (moof+mdat), size: ${fragment.length}`, this.cameraName)
+            yield fragment
+          }
         }
-        this.log.debug(`mp4 box type ${type} and lenght: ${length}`, this.cameraName)
+        
+        this.log.debug(`mp4 box type ${type} and length: ${length}`, this.cameraName)
       }
     } catch (e) {
-      this.log.info(`Recoding completed. ${e}`, this.cameraName)
+      this.log.info(`Recording completed. ${e}`, this.cameraName)
       /*
             const homedir = require('os').homedir();
             const path = require('path');
@@ -246,6 +369,8 @@ export class RecordingDelegate implements CameraRecordingDelegate {
     } finally {
       socket.destroy()
       cp.kill()
+      // Remove from active processes tracking
+      this.activeFFmpegProcesses.delete(streamId)
       // this.server.close;
     }
   }
@@ -282,33 +407,94 @@ export class RecordingDelegate implements CameraRecordingDelegate {
 
         args.push(...ffmpegInput)
 
-        // args.push(...audioOutputArgs);
+        // Include audio args if recording audio is active
+        if (this.currentRecordingConfiguration?.audioCodec) {
+          args.push(...audioOutputArgs)
+        }
 
         args.push('-f', 'mp4')
         args.push(...videoOutputArgs)
-        args.push('-fflags', '+genpts', '-reset_timestamps', '1')
+        
+        // Enhanced HKSV-specific flags for better compatibility
+        args.push('-err_detect', 'ignore_err')
+        args.push('-fflags', '+genpts+igndts+ignidx')
+        args.push('-reset_timestamps', '1')
+        args.push('-max_delay', '5000000')
+        
+        // HKSV requires specific fragmentation settings
         args.push(
           '-movflags',
-          'frag_keyframe+empty_moov+default_base_moof',
+          'frag_keyframe+empty_moov+default_base_moof+skip_sidx+skip_trailer+separate_moof',
           `tcp://127.0.0.1:${serverPort}`,
         )
 
         this.log.debug(`${ffmpegPath} ${args.join(' ')}`, this.cameraName)
 
-        const debug = false
+        // Enhanced debugging and logging for HomeKit Secure Video recording
+        this.log.debug(`DEBUG: startFFMPegFragmetedMP4Session called`, this.cameraName)
+        this.log.debug(`DEBUG: Video source: "${ffmpegInput.join(' ')}"`, this.cameraName)
+        this.log.debug(`DEBUG: FFmpeg input args: ${JSON.stringify(ffmpegInput)}`, this.cameraName)
+        this.log.debug(`DEBUG: Audio enabled: ${!!this.currentRecordingConfiguration?.audioCodec}`, this.cameraName)
+        this.log.debug(`DEBUG: Creating server`, this.cameraName)
+        this.log.debug(`DEBUG: Server listening on port ${serverPort}`, this.cameraName)
+        this.log.debug(`DEBUG: Complete FFmpeg command: ${ffmpegPath} ${args.join(' ')}`, this.cameraName)
+        this.log.debug(`DEBUG: Starting FFmpeg`, this.cameraName)
+
+        const debug = true // Enable debug for HKSV troubleshooting
 
         const stdioValue = debug ? 'pipe' : 'ignore'
         this.process = spawn(ffmpegPath, args, { env, stdio: stdioValue })
         const cp = this.process
 
+        this.log.debug(`DEBUG: FFmpeg started with PID ${cp.pid}`, this.cameraName)
+
         if (debug) {
+          let frameCount = 0
+          let lastLogTime = Date.now()
+          const logInterval = 5000 // Log every 5 seconds
+          
           if (cp.stdout) {
-            cp.stdout.on('data', (data: Buffer) => this.log.debug(data.toString(), this.cameraName))
+            cp.stdout.on('data', (data: Buffer) => {
+              const output = data.toString()
+              this.log.debug(`FFmpeg stdout: ${output}`, this.cameraName)
+            })
           }
           if (cp.stderr) {
-            cp.stderr.on('data', (data: Buffer) => this.log.debug(data.toString(), this.cameraName))
+            cp.stderr.on('data', (data: Buffer) => {
+              const output = data.toString()
+              
+              // Count frames for progress tracking
+              const frameMatch = output.match(/frame=\s*(\d+)/)
+              if (frameMatch) {
+                frameCount = parseInt(frameMatch[1])
+                const now = Date.now()
+                if (now - lastLogTime >= logInterval) {
+                  this.log.info(`Recording progress: ${frameCount} frames processed`, this.cameraName)
+                  lastLogTime = now
+                }
+              }
+              
+              // Check for HKSV specific errors
+              if (output.includes('invalid NAL unit size') || output.includes('decode_slice_header error')) {
+                this.log.warn(`HKSV: Potential stream compatibility issue detected: ${output.trim()}`, this.cameraName)
+              }
+              
+              this.log.debug(`FFmpeg stderr: ${output}`, this.cameraName)
+            })
           }
         }
+        
+        // Enhanced process cleanup and error handling
+        cp.on('exit', (code, signal) => {
+          this.log.debug(`DEBUG: FFmpeg process ${cp.pid} exited with code ${code}, signal ${signal}`, this.cameraName)
+          if (code !== 0 && code !== null) {
+            this.log.warn(`HKSV: FFmpeg exited with non-zero code ${code}, this may indicate stream issues`, this.cameraName)
+          }
+        })
+        
+        cp.on('error', (error) => {
+          this.log.error(`DEBUG: FFmpeg process error: ${error}`, this.cameraName)
+        })
       })
     })
   }

src/streamingDelegate.ts

@@ -114,7 +114,7 @@ export class StreamingDelegate implements CameraStreamingDelegate {
           ],
         },
       },
-      recording: /*! this.recording ? undefined : */ {
+      recording: !this.recording ? undefined : {
         options: {
           prebufferLength: PREBUFFER_LENGTH,
           overrideEventTriggerOptions: [hap.EventTriggerOption.MOTION, hap.EventTriggerOption.DOORBELL],