Cross thread and timing issues with streams

Author: Mr-DaveDev

webu.c

@@ -85,6 +85,7 @@ static void webu_context_init(struct context **cntlst, struct context *cnt, stru
     webui->lang_full     = mymalloc(6);         /* lang code, e.g US_en */
     webui->resp_size     = WEBUI_LEN_RESP * 10; /* The size of the resp_page buffer.  May get adjusted */
     webui->resp_used     = 0;                   /* How many bytes used so far in resp_page*/
+    webui->stream_pos    = 0;                   /* Stream position of image being sent */
     webui->resp_page     = mymalloc(webui->resp_size);      /* The response being constructed */
     webui->cntlst        = cntlst;  /* The list of context's for all cameras */
     webui->cnt           = cnt;     /* The context pointer for a single camera */

webu.h

@@ -59,6 +59,8 @@ struct webui_ctx {
     char            *resp_page;        /* The response that will be sent */
     size_t          resp_size;         /* The allocated size of the response */
     size_t          resp_used;         /* The amount of the response page used */
+    uint64_t        stream_pos;        /* Stream position of sent image */
+    struct timeval  time_last;         /* Keep track of processing time for stream thread*/
     int             mhd_first;         /* Boolean for whether it is the first connection*/
 
     struct MHD_Connection  *connection; /* The MHD connection value from the client */

webu_stream.c

@@ -30,6 +30,39 @@ static void webu_stream_mjpeg_checkbuffers(struct webui_ctx *webui) {
 
 }
 
+static void webu_stream_mjpeg_delay(struct webui_ctx *webui) {
+    /* Sleep required time to get to the user requested frame
+     * rate for the stream
+     */
+
+    long   stream_rate;
+    struct timeval time_curr;
+    long   stream_delay;
+
+    gettimeofday(&time_curr, NULL);
+
+    /* The stream rate MUST be less than 1000000000 otherwise undefined behaviour
+     * will occur with the SLEEP function.
+     */
+    stream_delay = ((time_curr.tv_usec - webui->time_last.tv_usec)*1000000) -
+        ((time_curr.tv_sec - webui->time_last.tv_sec)*1000000000);
+    if (stream_delay < 0)  stream_delay = 0;
+    if (stream_delay > 1000000000 ) stream_delay = 1000000000;
+
+    if (webui->cnt->conf.stream_maxrate > 1){
+        stream_rate = ( (1000000000 / webui->cnt->conf.stream_maxrate) - stream_delay);
+        if ((stream_rate > 0) && (stream_rate < 1000000000)){
+            SLEEP(0,stream_rate);
+        } else if (stream_rate == 1000000000) {
+            SLEEP(1,0);
+        }
+    } else {
+        SLEEP(1,0);
+    }
+    gettimeofday(&webui->time_last, NULL);
+
+}
+
 static void webu_stream_mjpeg_getimg(struct webui_ctx *webui) {
     long jpeg_size;
     char resp_head[80];
@@ -84,52 +117,38 @@ static ssize_t webu_stream_mjpeg_response (void *cls, uint64_t pos, char *buf, s
      * browser.  We sleep the requested amount of time between fetching images to match
      * the user configuration parameters.  This function may be called multiple times for
      * a single image so we can write what we can to the buffer and pick up remaining bytes
-     * to send based upon the static variable of stream position
+     * to send based upon the stream position
      */
     struct webui_ctx *webui = cls;
-    static uint64_t stream_pos;
     size_t sent_bytes;
-    long   stream_rate;
-    static int indx_start;
 
     (void)pos;  /*Remove compiler warning */
 
     if (webui->cnt->webcontrol_finish) return -1;
 
-    /* We use indx_start to send a few extra images when the stream starts*/
-    if ((stream_pos == 0) || (webui->resp_used == 0)){
-        if (webui->resp_used == 0){
-            indx_start = 1;
-        } else if (indx_start < 4) {
-            indx_start++;
-        } else {
-            if (webui->cnt->conf.stream_maxrate > 1){
-                stream_rate =  (1000000000 / webui->cnt->conf.stream_maxrate);
-                SLEEP(0,stream_rate);
-            } else {
-                SLEEP(1,0);
-            }
-        }
+    if ((webui->stream_pos == 0) || (webui->resp_used == 0)){
 
-        stream_pos = 0;
+        webu_stream_mjpeg_delay(webui);
+
+        webui->stream_pos = 0;
         webui->resp_used = 0;
 
         webu_stream_mjpeg_getimg(webui);
 
         if (webui->resp_used == 0) return 0;
     }
 
-    if ((webui->resp_used - stream_pos) > max) {
+    if ((webui->resp_used - webui->stream_pos) > max) {
         sent_bytes = max;
     } else {
-        sent_bytes = webui->resp_used - stream_pos;
+        sent_bytes = webui->resp_used - webui->stream_pos;
     }
 
-    memcpy(buf, webui->resp_page + stream_pos, sent_bytes);
+    memcpy(buf, webui->resp_page + webui->stream_pos, sent_bytes);
 
-    stream_pos = stream_pos + sent_bytes;
-    if (stream_pos >= webui->resp_used){
-        stream_pos = 0;
+    webui->stream_pos = webui->stream_pos + sent_bytes;
+    if (webui->stream_pos >= webui->resp_used){
+        webui->stream_pos = 0;
     }
 
     return sent_bytes;
@@ -249,6 +268,8 @@ int webu_stream_mjpeg(struct webui_ctx *webui) {
 
     webu_stream_mjpeg_checkbuffers(webui);
 
+    gettimeofday(&webui->time_last, NULL);
+
     response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN, 1024
         ,&webu_stream_mjpeg_response, webui, NULL);
     if (!response){