Fix memory leak in DVR queue (#9)

The DVR queue was written into, even with DVR disabled.

Author: seriyps

README.md

@@ -68,3 +68,39 @@ pixelpilot --help
 
 1. Video is cropped when the fpv feed resolution is bigger than the screen mode.
 1. Crashes when video feed resolution is higher than the screen resolution.
+
+## The way it works
+
+It uses `mpp` library to decode MPEG frames using Rockchip hardware decoder.
+It uses `gstreamer` to read the RTP media stream from video UDP.
+It uses `mavlink` decoder to read Mavlink telemetry from telemetry UDP (if enabled), see `mavlink.c`
+It uses `cairo` library to draw OSD elements (if enabled), see `osd.c`.
+It uses [Direct Rendering Manager (DRM)](https://en.wikipedia.org/wiki/Direct_Rendering_Manager) to
+display video on the screen, see `drm.c`.
+It writes raw MPEG stream to file as DVR (if enabled) using `minimp4.h` library.
+
+Pixelpilot starts several threads:
+
+* main thread
+  controls gstreamer which reads RTP, extracts MPEG frames and
+  - feeds them to MPP hardware decoder
+  - sends them to DVR thread via mutex-protected `std::queue` (if enabled)
+* DVR_THREAD (if enabled)
+  reads frames from main thread via `std::queue` and writes them to disk using `minimp4` library
+  it yields on a condition variable for DVR queue or `kill` signal variable
+* FRAME_THREAD
+  reads decoded video frames from MPP hardware decoder and forwards them to `DISPLAY_THREAD`
+  through DRM `output_list` protected by `video_mutex`
+  Seems that thread vields on `mpi->decode_get_frame()` call waiting for HW decoder to return a new frame
+* DISPLAY_THREAD
+  reads frames and OSD from `video_mutex`-protected `output_list` and calls `drm*` functions to
+  render them on the screen
+  The loop yields on `video_mutex` and `video_cond` waiting for a new frame to
+  display from FRAME_THREAD
+* MAVLINK_THREAD (if OSD and mavlink configured)
+  reads mavlink packets from UDP, decodes and updates `osd_vars` (without any mutex)
+  The loop yields on UDP read
+* OSD_THREAD (if OSD is enabled)
+  takes `drm_fd` and `output_list` as thread parameters
+  draws telemetry on a buffer inside `output_list` based on `osd_vars` using Cairo library
+  The loop yelds on explicit `sleep` to control refresh rate

src/main.cpp

@@ -415,11 +415,11 @@ bool feed_packet_to_decoder(MppPacket *packet,void* data_p,int data_len){
 }
 
 uint64_t first_frame_ms=0;
-void read_gstreamerpipe_stream(MppPacket *packet, int gst_udp_port, const VideoCodec& codec){
+void read_gstreamerpipe_stream(MppPacket *packet, int gst_udp_port, int dvr_enabled, const VideoCodec& codec){
     GstRtpReceiver receiver(gst_udp_port, codec);
 	long long bytes_received = 0; 
 	uint64_t period_start=0;
-    auto cb=[&packet,&decoder_stalled_count, &bytes_received, &period_start](std::shared_ptr<std::vector<uint8_t>> frame){
+    auto cb=[&packet,&decoder_stalled_count, &bytes_received, &period_start, &dvr_enabled](std::shared_ptr<std::vector<uint8_t>> frame){
         // Let the gst pull thread run at quite high priority
         static bool first= false;
         if(first){
@@ -436,7 +436,9 @@ void read_gstreamerpipe_stream(MppPacket *packet, int gst_udp_port, const VideoC
 		}
         feed_packet_to_decoder(packet,frame->data(),frame->size());
 
-		enqueueDvrPacket(frame);
+        if (dvr_enabled) {
+            enqueueDvrPacket(frame);
+        }
     };
     receiver.start_receiving(cb);
     while (!signal_flag){
@@ -727,7 +729,7 @@ int main(int argc, char **argv)
 	}
 
 	////////////////////////////////////////////// MAIN LOOP
-    read_gstreamerpipe_stream((void**)packet, listen_port, codec);
+    read_gstreamerpipe_stream((void**)packet, listen_port, dvr_file != NULL, codec);
 
 	////////////////////////////////////////////// MPI CLEANUP