Adding audio and actually have it work required a major refactor to have mp4 recording be its own reader/writer that closes per file.

Author: matteius

Diff for: include/video/mp4_recording.h

@@ -1,35 +1,54 @@
+/**
+ * MP4 Recording Module
+ * 
+ * This module is responsible for managing MP4 recording threads.
+ * Each recording thread is responsible for starting and stopping an MP4 recorder
+ * for a specific stream. The actual RTSP interaction is contained within the
+ * MP4 writer module.
+ */
+
 #ifndef MP4_RECORDING_H
 #define MP4_RECORDING_H
 
 #include <pthread.h>
 #include "core/config.h"
 #include "video/mp4_writer.h"
-#include "video/stream_reader.h"
 
-// Structure for MP4 recording context
+/**
+ * Structure for MP4 recording context
+ * 
+ * This structure represents a single recording thread that manages
+ * an MP4 writer for a specific stream. The MP4 writer handles all
+ * RTSP interaction internally.
+ */
 typedef struct {
-    stream_config_t config;
-    int running;
-    pthread_t thread;
-    char output_path[MAX_PATH_LENGTH];
-    mp4_writer_t *mp4_writer;
-    // CRITICAL FIX: Removed reader_ctx field since we now use the HLS streaming thread
-    // to write packets to the MP4 file instead of a dedicated stream reader
+    stream_config_t config;    // Stream configuration
+    int running;               // Flag indicating if the thread is running
+    pthread_t thread;          // Recording thread
+    char output_path[MAX_PATH_LENGTH]; // Path to the output MP4 file
+    mp4_writer_t *mp4_writer;  // MP4 writer instance
 } mp4_recording_ctx_t;
 
 /**
  * Initialize MP4 recording backend
+ * 
+ * This function initializes the recording contexts array and resets the shutdown flag.
  */
 void init_mp4_recording_backend(void);
 
 /**
  * Cleanup MP4 recording backend
+ * 
+ * This function stops all recording threads and frees all recording contexts.
  */
 void cleanup_mp4_recording_backend(void);
 
 /**
  * Start MP4 recording for a stream
  * 
+ * This function creates a new recording thread for the specified stream.
+ * The recording thread will create an MP4 writer and start the RTSP recording.
+ * 
  * @param stream_name Name of the stream to record
  * @return 0 on success, non-zero on failure
  */
@@ -38,6 +57,8 @@ int start_mp4_recording(const char *stream_name);
 /**
  * Stop MP4 recording for a stream
  * 
+ * This function stops the recording thread for the specified stream.
+ * 
  * @param stream_name Name of the stream to stop recording
  * @return 0 on success, non-zero on failure
  */
@@ -72,7 +93,4 @@ void unregister_mp4_writer_for_stream(const char *stream_name);
  */
 void close_all_mp4_writers(void);
 
-// The get_recording_state function is already defined in src/video/recording.c
-// We'll use that implementation instead of defining it here
-
 #endif /* MP4_RECORDING_H */

Diff for: include/video/mp4_recording_internal.h

@@ -1,44 +1,34 @@
+/**
+ * MP4 Recording Internal Header
+ * 
+ * This header contains internal declarations for the MP4 recording module.
+ * It is not intended to be used by external modules.
+ */
+
 #ifndef MP4_RECORDING_INTERNAL_H
 #define MP4_RECORDING_INTERNAL_H
 
-#include <libavformat/avformat.h>
 #include "video/mp4_recording.h"
-
-// Maximum number of frames to pre-buffer (about 2 seconds at 30fps)
-#define MAX_PREBUFFER_FRAMES 60
-
-// Structure for buffered packet
-typedef struct {
-    AVPacket *packet;
-    AVRational time_base;
-} buffered_packet_t;
-
-// Structure for frame buffer
-typedef struct {
-    buffered_packet_t *frames;
-    int capacity;
-    int count;
-    int head;
-    int tail;
-    pthread_mutex_t mutex;
-} frame_buffer_t;
-
-// External declarations for shared variables
+#include "video/thread_utils.h"
+
+/**
+ * External declarations for shared variables
+ * 
+ * These variables are defined in mp4_recording_core.c and are used
+ * by other files in the MP4 recording module.
+ */
 extern mp4_recording_ctx_t *recording_contexts[MAX_STREAMS];
-extern mp4_writer_t *mp4_writers[MAX_STREAMS];
-extern char mp4_writer_stream_names[MAX_STREAMS][64];
-extern frame_buffer_t frame_buffers[MAX_STREAMS];
-
-// Frame buffer functions
-int init_frame_buffer(const char *stream_name, int capacity);
-void add_to_frame_buffer(int buffer_idx, const AVPacket *pkt, const AVStream *stream);
-void flush_frame_buffer(int buffer_idx, mp4_writer_t *writer);
-void free_frame_buffer(int buffer_idx);
-
-// Add a packet to the pre-buffer for a stream
-void add_packet_to_prebuffer(const char *stream_name, const AVPacket *pkt, const AVStream *stream);
 
-// Flush the pre-buffered frames to the MP4 writer
-void flush_prebuffer_to_mp4(const char *stream_name);
+/**
+ * Update MP4 recording metadata in the database
+ * 
+ * This function is called periodically to update the recording metadata
+ * in the database.
+ * 
+ * @param stream_name Name of the stream
+ */
+void update_mp4_recording(const char *stream_name);
+
+// We'll use the pthread_join_with_timeout function from thread_utils.h
 
 #endif /* MP4_RECORDING_INTERNAL_H */

Diff for: include/video/mp4_writer.h

@@ -6,26 +6,53 @@
 #define MP4_WRITER_H
 
 #include <libavformat/avformat.h>
+#include <pthread.h>
 #include "core/config.h"  // For MAX_PATH_LENGTH and MAX_STREAM_NAME
 
 // Forward declaration of the MP4 writer structure
 typedef struct mp4_writer mp4_writer_t;
 
+// Audio stream state structure - completely separate from video
+typedef struct {
+    int stream_idx;           // Index of the audio stream in the output context
+    int64_t first_dts;        // First audio DTS for timestamp reference
+    int64_t last_pts;         // Last audio PTS written
+    int64_t last_dts;         // Last audio DTS written
+    int initialized;          // Flag to track if audio has been initialized
+    AVRational time_base;     // Audio stream timebase
+    pthread_mutex_t mutex;    // Mutex to protect audio state
+} mp4_audio_state_t;
+
 // Full definition of the MP4 writer structure
 struct mp4_writer {
     char output_path[MAX_PATH_LENGTH];
     char stream_name[MAX_STREAM_NAME];
     AVFormatContext *output_ctx;
     int video_stream_idx;
-    int audio_stream_idx;     // Index of the audio stream (-1 if none)
     int has_audio;            // Flag indicating if audio is enabled
-    int64_t first_dts;
-    int64_t first_pts;
-    int64_t last_dts;
-    AVRational time_base;
+    int64_t first_dts;        // First video DTS
+    int64_t first_pts;        // First video PTS
+    int64_t last_dts;         // Last video DTS
+    AVRational time_base;     // Video stream timebase
     int is_initialized;
     time_t creation_time;
     time_t last_packet_time;  // Time when the last packet was written
+    mp4_audio_state_t audio;  // Audio state - completely separate from video
+    pthread_mutex_t mutex;    // Mutex to protect video state
+    uint64_t current_recording_id; // ID of the current recording in the database
+    
+    // Segment-related fields
+    int segment_duration;     // Duration of each segment in seconds
+    time_t last_rotation_time;// Time of the last rotation
+    int waiting_for_keyframe; // Flag indicating if we're waiting for a keyframe to rotate
+    int is_rotating;          // Flag indicating if rotation is in progress
+    char output_dir[MAX_PATH_LENGTH]; // Directory where MP4 files are stored
+    
+    // RTSP thread context
+    void *thread_ctx;         // Opaque pointer to thread context
+    
+    // Shutdown coordination
+    int shutdown_component_id; // ID assigned by the shutdown coordinator
 };
 
 /**
@@ -39,6 +66,7 @@ mp4_writer_t *mp4_writer_create(const char *output_path, const char *stream_name
 
 /**
  * Write a packet to the MP4 file
+ * This function handles both video and audio packets
  *
  * @param writer The MP4 writer instance
  * @param pkt The packet to write
@@ -47,11 +75,58 @@ mp4_writer_t *mp4_writer_create(const char *output_path, const char *stream_name
  */
 int mp4_writer_write_packet(mp4_writer_t *writer, const AVPacket *pkt, const AVStream *input_stream);
 
+/**
+ * Safely add audio stream to MP4 writer
+ *
+ * @param writer The MP4 writer instance
+ * @param codec_params Codec parameters for the audio stream
+ * @param time_base Time base for the audio stream
+ * @return 0 on success, negative on error
+ */
+int mp4_writer_add_audio_stream(mp4_writer_t *writer, const AVCodecParameters *codec_params,
+                                const AVRational *time_base);
+
 /**
  * Close the MP4 writer and release resources
  *
  * @param writer The MP4 writer instance
  */
 void mp4_writer_close(mp4_writer_t *writer);
 
+/**
+ * Set the segment duration for MP4 rotation
+ *
+ * @param writer The MP4 writer instance
+ * @param segment_duration Duration of each segment in seconds
+ */
+void mp4_writer_set_segment_duration(mp4_writer_t *writer, int segment_duration);
+
+// Rotation is now handled entirely by the writer thread in mp4_writer_rtsp.c
+
+/**
+ * Start a recording thread that reads from the RTSP stream and writes to the MP4 file
+ * This function creates a new thread that handles all the recording logic
+ *
+ * @param writer The MP4 writer instance
+ * @param rtsp_url The URL of the RTSP stream to record
+ * @return 0 on success, negative on error
+ */
+int mp4_writer_start_recording_thread(mp4_writer_t *writer, const char *rtsp_url);
+
+/**
+ * Stop the recording thread
+ * This function signals the recording thread to stop and waits for it to exit
+ *
+ * @param writer The MP4 writer instance
+ */
+void mp4_writer_stop_recording_thread(mp4_writer_t *writer);
+
+/**
+ * Check if the recording thread is running
+ *
+ * @param writer The MP4 writer instance
+ * @return 1 if running, 0 if not
+ */
+int mp4_writer_is_recording(mp4_writer_t *writer);
+
 #endif /* MP4_WRITER_H */

Diff for: include/video/mp4_writer_internal.h

@@ -0,0 +1,42 @@
+/**
+ * Internal header file for MP4 writer implementation
+ */
+
+#ifndef MP4_WRITER_INTERNAL_H
+#define MP4_WRITER_INTERNAL_H
+
+#include <libavformat/avformat.h>
+#include "video/mp4_writer.h"
+
+/**
+ * Initialize the MP4 writer with the first packet
+ *
+ * @param writer The MP4 writer instance
+ * @param pkt The first packet to write
+ * @param input_stream The original input stream (for codec parameters)
+ * @return 0 on success, negative on error
+ */
+int mp4_writer_initialize(mp4_writer_t *writer, const AVPacket *pkt, const AVStream *input_stream);
+
+/**
+ * Apply h264_mp4toannexb bitstream filter to convert H.264 stream from MP4 format to Annex B format
+ * This is needed for some RTSP cameras that send H.264 in MP4 format instead of Annex B format
+ * 
+ * @param packet The packet to convert
+ * @param codec_id The codec ID of the stream
+ * @return 0 on success, negative on error
+ */
+int apply_h264_annexb_filter(AVPacket *packet, enum AVCodecID codec_id);
+
+/**
+ * Write a packet to the MP4 file
+ * This function handles both video and audio packets
+ *
+ * @param writer The MP4 writer instance
+ * @param in_pkt The packet to write
+ * @param input_stream The original input stream (for codec parameters)
+ * @return 0 on success, negative on error
+ */
+int mp4_writer_write_packet(mp4_writer_t *writer, const AVPacket *in_pkt, const AVStream *input_stream);
+
+#endif /* MP4_WRITER_INTERNAL_H */

Diff for: include/video/recording_types.h

@@ -0,0 +1,20 @@
+/**
+ * Header file for recording types
+ */
+
+#ifndef RECORDING_TYPES_H
+#define RECORDING_TYPES_H
+
+#include <time.h>
+#include <stdint.h>
+#include "../core/config.h"  // For MAX_PATH_LENGTH and MAX_STREAM_NAME
+
+// Structure for active recording tracking
+typedef struct {
+    uint64_t recording_id;                // Database ID of the recording
+    char stream_name[MAX_STREAM_NAME];    // Name of the stream being recorded
+    char output_path[MAX_PATH_LENGTH];    // Path where recording is stored
+    time_t start_time;                    // When the recording started
+} active_recording_t;
+
+#endif /* RECORDING_TYPES_H */