1 files changed, 405 insertions, 246 deletions

diff --git a/firmware/pcm_record.c b/firmware/pcm_record.c
index 98473a3870..85ab7caafc 100644
--- a/firmware/pcm_record.c
+++ b/firmware/pcm_record.c
@@ -46,6 +46,7 @@
 
 /** These items may be implemented target specifically or need to
     be shared semi-privately **/
+extern struct thread_entry *codec_thread_p;
 
 /* the registered callback function for when more data is available */
 volatile pcm_more_callback_type2 pcm_callback_more_ready = NULL;
@@ -57,6 +58,14 @@ static bool is_recording;              /* We are recording                 */
 static bool is_paused;                 /* We have paused                   */
 static unsigned long errors;           /* An error has occured             */
 static unsigned long warnings;         /* Warning                          */
+static int flush_interrupts = 0;       /* Number of messages queued that
+                                          should interrupt a flush in
+                                          progress -
+                                          for a safety net and a prompt
+                                          response to stop, split and pause
+                                          requests -
+                                          only interrupts a flush initiated
+                                          by pcmrec_flush(0) */
 
 /** Stats on encoded data for current file **/
 static size_t        num_rec_bytes;      /* Num bytes recorded             */
@@ -179,31 +188,62 @@ static unsigned char *pcm_buffer;      /* circular recording buffer        */
 static unsigned char *enc_buffer;      /* circular encoding buffer         */
 static volatile int   dma_wr_pos;      /* current DMA write pos            */
 static int            pcm_rd_pos;      /* current PCM read pos             */
+static int            pcm_enc_pos;     /* position encoder is processing   */
 static volatile bool  dma_lock;        /* lock DMA write position          */
 static int            enc_wr_index;    /* encoder chunk write index        */
 static int            enc_rd_index;    /* encoder chunk read index         */
 static int            enc_num_chunks;  /* number of chunks in ringbuffer   */
 static size_t         enc_chunk_size;  /* maximum encoder chunk size       */
 static unsigned long  enc_sample_rate; /* sample rate used by encoder      */
-static bool           wav_queue_empty; /* all wav chunks processed?        */
+static bool           pcmrec_context = false;  /* called by pcmrec thread? */
+static bool           pcm_buffer_empty; /* all pcm chunks processed?       */
  
 /** file flushing **/
-static int            write_threshold; /* max chunk limit for data flush   */
-static int            spinup_time = -1;/* last ata_spinup_time             */
+static int            low_watermark;   /* Low watermark to stop flush      */
+static int            high_watermark;  /* max chunk limit for data flush   */
+static unsigned long  spinup_time = 35*HZ/10;  /* Fudged spinup time       */
+static int            last_ata_spinup_time = -1;/* previous spin time used */
 #ifdef HAVE_PRIORITY_SCHEDULING
-static int            panic_threshold; /* boost thread prio when here      */
+static int            flood_watermark; /* boost thread priority when here  */
 #endif
 
+/* Constants that control watermarks */
+#define LOW_SECONDS     1       /* low watermark time till empty           */
+#define MINI_CHUNKS    10       /* chunk count for mini flush              */
+#ifdef HAVE_PRIORITY_SCHEDULING
+#define PRIO_SECONDS   10       /* max flush time before priority boost    */
+#endif
+#if MEM <= 16
+#define PANIC_SECONDS   5       /* flood watermark time until full         */
+#define FLUSH_SECONDS   7       /* flush watermark time until full         */
+#else
+#define PANIC_SECONDS   8
+#define FLUSH_SECONDS  10
+#endif /* MEM */
+
 /** encoder events **/
 static void (*enc_events_callback)(enum enc_events event, void *data);
 
 /** Path queue for files to write **/
 #define FNQ_MIN_NUM_PATHS 16           /* minimum number of paths to hold  */
+#define FNQ_MAX_NUM_PATHS 64           /* maximum number of paths to hold  */
 static unsigned char *fn_queue;        /* pointer to first filename        */
 static ssize_t        fnq_size;        /* capacity of queue in bytes       */
 static int            fnq_rd_pos;      /* current read position            */
 static int            fnq_wr_pos;      /* current write position           */
 
+enum
+{
+    PCMREC_FLUSH_INTERRUPTABLE  = 0x8000000, /* Flush can be interrupted by
+                                                incoming messages - combine
+                                                with other constants       */
+    PCMREC_FLUSH_ALL            = 0x7ffffff, /* Flush all files            */
+    PCMREC_FLUSH_MINI           = 0x7fffffe, /* Flush a small number of
+                                                chunks                     */
+    PCMREC_FLUSH_IF_HIGH        = 0x0000000, /* Flush if high watermark
+                                                reached                    */
+};
+
 /** extra debugging info positioned away from other vars **/
 #ifdef PCMREC_PARANOID
 static unsigned long *wrap_id_p;       /* magic at end of encoding buffer  */
@@ -220,6 +260,7 @@ static struct event_queue       pcmrec_queue;
 static struct queue_sender_list pcmrec_queue_send;
 static long                pcmrec_stack[3*DEFAULT_STACK_SIZE/sizeof(long)];
 static const char          pcmrec_thread_name[] = "pcmrec";
+static struct thread_entry *pcmrec_thread_p;
 
 static void pcmrec_thread(void);
 
@@ -261,8 +302,9 @@ static int pcm_rec_have_more(int status)
         /* advance write position */
         int next_pos = (dma_wr_pos + PCM_CHUNK_SIZE) & PCM_CHUNK_MASK;
 
-        /* set pcm ovf if read position is inside current write chunk */
-        if ((unsigned)(pcm_rd_pos - next_pos) < PCM_CHUNK_SIZE)
+        /* set pcm ovf if processing start position is inside current
+           write chunk */
+        if ((unsigned)(pcm_enc_pos - next_pos) < PCM_CHUNK_SIZE)
             warnings |= PCMREC_W_PCM_BUFFER_OVF;
 
 #ifdef PCMREC_PARANOID
@@ -374,16 +416,13 @@ void pcm_rec_init(void)
 {
     queue_init(&pcmrec_queue, true);
     queue_enable_queue_send(&pcmrec_queue, &pcmrec_queue_send);
-    create_thread(pcmrec_thread, pcmrec_stack, sizeof(pcmrec_stack),
-                  pcmrec_thread_name IF_PRIO(, PRIORITY_RECORDING));
+    pcmrec_thread_p =
+        create_thread(pcmrec_thread, pcmrec_stack, sizeof(pcmrec_stack),
+                      pcmrec_thread_name IF_PRIO(, PRIORITY_RECORDING));
 } /* pcm_rec_init */
 
 /** audio_* group **/
 
-/* NOTE: The following posting functions are really only single-thread safe
-         at the moment since a response to a particular message at a particular
-         position in the queue can't be distinguished */
-
 /**
  * Initializes recording - call before calling any other recording function
  */
@@ -421,6 +460,8 @@ void audio_set_recording_options(struct audio_recording_options *options)
 void audio_record(const char *filename)
 {
     logf("audio_record: %s", filename);
+    flush_interrupts++;
+    logf("flush int: %d", flush_interrupts);
     queue_send(&pcmrec_queue, PCMREC_RECORD, (intptr_t)filename);
     logf("audio_record_done");
 } /* audio_record */
@@ -431,6 +472,8 @@ void audio_record(const char *filename)
 void audio_stop_recording(void)
 {
     logf("audio_stop_recording");
+    flush_interrupts++;
+    logf("flush int: %d", flush_interrupts);
     queue_send(&pcmrec_queue, PCMREC_STOP, 0);
     logf("audio_stop_recording done");
 } /* audio_stop_recording */
@@ -441,6 +484,8 @@ void audio_stop_recording(void)
 void audio_pause_recording(void)
 {
     logf("audio_pause_recording");
+    flush_interrupts++;
+    logf("flush int: %d", flush_interrupts);
     queue_send(&pcmrec_queue, PCMREC_PAUSE, 0);
     logf("audio_pause_recording done");
 } /* audio_pause_recording */
@@ -787,95 +832,166 @@ static void pcmrec_end_file(void)
 } /* pcmrec_end_file */
 
 /**
+ * Update buffer watermarks with spinup time compensation
+ *
+ * All this assumes reasonable data rates, chunk sizes and sufficient
+ * memory for the most part. Some dumb checks are included but perhaps
+ * are pointless since this all will break down at extreme limits that
+ * are currently not applicable to any supported device.
+ */
+static void pcmrec_refresh_watermarks(void)
+{
+    logf("ata spinup: %d", ata_spinup_time);
+
+    /* set the low mark for when flushing stops if automatic */
+    low_watermark = (LOW_SECONDS*4*sample_rate + (enc_chunk_size-1))
+                        / enc_chunk_size;
+    logf("low wmk: %d", low_watermark);
+
+#ifdef HAVE_PRIORITY_SCHEDULING
+    /* panic boost thread priority if 2 seconds of ground is lost -
+       this allows encoder to boost with just under a second of
+       pcm data (if not yet full enough to boost itself)
+       and not falsely trip the alarm. */
+    flood_watermark = enc_num_chunks -
+        (PANIC_SECONDS*4*sample_rate + (enc_chunk_size-1))
+             / enc_chunk_size;
+
+    if (flood_watermark < low_watermark)
+    {
+        logf("warning: panic < low");
+        flood_watermark = low_watermark;
+    }
+
+    logf("flood at: %d", flood_watermark);
+#endif
+    spinup_time = last_ata_spinup_time = ata_spinup_time;
+
+    /* write at 8s + st remaining in enc_buffer - range 12s to
+       20s total - default to 3.5s spinup. */
+    if (spinup_time == 0)
+        spinup_time = 35*HZ/10;  /* default - cozy                */
+    else if (spinup_time < 2*HZ)
+        spinup_time = 2*HZ;      /* ludicrous - ramdisk?          */
+    else if (spinup_time > 10*HZ)
+        spinup_time = 10*HZ;     /* do you have a functioning HD? */
+
+    /* try to start writing with 10s remaining after disk spinup */
+    high_watermark = enc_num_chunks -
+        ((FLUSH_SECONDS*HZ + spinup_time)*4*sample_rate +
+              (enc_chunk_size-1)*HZ) / (enc_chunk_size*HZ);
+
+    if (high_watermark < low_watermark)
+    {
+        high_watermark = low_watermark;
+        low_watermark /= 2;
+        logf("warning: low 'write at'");
+    }
+
+    logf("write at: %d", high_watermark);
+} /* pcmrec_refresh_watermarks */
+
+/**
  * Process the chunks
  *
  * This function is called when queue_get_w_tmo times out.
  *
- * Set flush_num to the number of files to flush to disk.
- * flush_num = -1 to flush all available chunks to disk.
- * flush_num =  0 normal write thresholding
- * flush_num =  1 or greater - all available chunks of current file plus
- *              flush_num file starts if first chunk has been processed.
- *
+ * Set flush_num to the number of files to flush to disk or to
+ * a PCMREC_FLUSH_* constant.
  */
 static void pcmrec_flush(unsigned flush_num)
 {
 #ifdef HAVE_PRIORITY_SCHEDULING
-    static unsigned long last_flush_tick = 0;
-    unsigned long start_tick;
-    int num;
-    int prio;
+    static unsigned long last_flush_tick; /* tick when function returned   */
+    unsigned long start_tick;      /* When flush started                   */
+    unsigned long prio_tick;       /* Timeout for auto boost               */
+    int           prio_pcmrec;     /* Current thread priority for pcmrec   */
+    int           prio_codec;      /* Current thread priority for codec    */
 #endif
-    int num_ready;
-    int i;
+    int           num_ready;       /* Number of chunks ready at start      */
+    unsigned      remaining;       /* Number of file starts remaining      */
+    unsigned      chunks_flushed;  /* Chunks flushed (for mini flush only) */
+    bool          interruptable;   /* Flush can be interupted              */
 
     num_ready = enc_wr_index - enc_rd_index;
     if (num_ready < 0)
         num_ready += enc_num_chunks;
 
-#ifdef HAVE_PRIORITY_SCHEDULING
-    num = num_ready;
-#endif
+    /* save interruptable flag and remove it to get the actual count */
+    interruptable = (flush_num & PCMREC_FLUSH_INTERRUPTABLE) != 0;
+    flush_num    &= ~PCMREC_FLUSH_INTERRUPTABLE;
 
     if (flush_num == 0)
     {
         if (!is_recording)
             return;
 
-        if (ata_spinup_time != spinup_time)
-        {
-            /* spinup time has changed, calculate new write threshold */
-            logf("new t spinup : %d", ata_spinup_time);
-            unsigned long st = spinup_time = ata_spinup_time;
-
-            /* write at 5s + st remaining in enc_buffer */
-            if (st < 2*HZ)
-                st = 2*HZ; /* my drive is usually < 250 ticks :) */
-            else if (st > 10*HZ)
-                st = 10*HZ;
-
-            write_threshold = enc_num_chunks -
-                (int)(((5ull*HZ + st)*4ull*sample_rate + (enc_chunk_size-1)) /
-                       (enc_chunk_size*HZ));
-
-            if (write_threshold < 0)
-                write_threshold = 0;
-#ifdef HAVE_PRIORITY_SCHEDULING
-            else if (write_threshold > panic_threshold)
-                write_threshold = panic_threshold;
-#endif
-            logf("new wr thresh: %d", write_threshold);
-        }
+        if (ata_spinup_time != last_ata_spinup_time)
+            pcmrec_refresh_watermarks();
 
-        if (num_ready < write_threshold)
+        /* enough available? no? then leave */
+        if (num_ready < high_watermark)
             return;
+    } /* endif (flush_num == 0) */
 
 #ifdef HAVE_PRIORITY_SCHEDULING
+    start_tick = current_tick;
+    prio_tick  = start_tick + PRIO_SECONDS*HZ + spinup_time;
+
+    if (flush_num == 0 && TIME_BEFORE(current_tick, last_flush_tick + HZ/2))
+    {
         /* if we're getting called too much and this isn't forced,
-           boost stat */
-        if (current_tick - last_flush_tick < HZ/2)
-            num = panic_threshold;
-#endif
+           boost stat by expiring timeout in advance */
+        logf("too frequent flush");
+        prio_tick = current_tick - 1;
     }
 
-#ifdef HAVE_PRIORITY_SCHEDULING
-    start_tick = current_tick;
-    prio = -1;
+    prio_pcmrec = -1;
+    prio_codec  = -1; /* GCC is too stoopid to figure out it doesn't
+                         need init */
 #endif
 
-    logf("writing: %d (%d)", num_ready, flush_num);
+    logf("writing:%d(%d):%s%s", num_ready, flush_num,
+         interruptable ? "i" : "",
+         flush_num == PCMREC_FLUSH_MINI ? "m" : "");
         
     cpu_boost(true);
 
-    for (i = 0; i < num_ready; i++)
+    remaining      = flush_num;
+    chunks_flushed = 0;
+
+    while (num_ready > 0)
     {
+        /* check current number of encoder chunks */
+        int num = enc_wr_index - enc_rd_index;
+        if (num < 0)
+            num += enc_num_chunks;
+
+        if (num <= low_watermark &&
+            (flush_num == PCMREC_FLUSH_IF_HIGH || num <= 0))
+        {
+            logf("low data: %d", num);
+            break; /* data remaining is below threshold */
+        }
+
+        if (interruptable && flush_interrupts > 0)
+        {
+            logf("int at: %d", num);
+            break; /* interrupted */
+        }
+
 #ifdef HAVE_PRIORITY_SCHEDULING
-        if (prio == -1 && (num >= panic_threshold ||
-                           current_tick - start_tick > 10*HZ))
+        if (prio_pcmrec == -1 && (num >= flood_watermark ||
+                                  TIME_AFTER(current_tick, prio_tick)))
         {
-            /* losing ground - boost priority until finished */
-            logf("pcmrec: boost priority");
-            prio = thread_set_priority(NULL, thread_get_priority(NULL)-1);
+            /* losing ground or holding without progress - boost
+               priority until finished */
+            logf("pcmrec: boost (%s)",
+                 num >= flood_watermark ? "num" : "time");
+            prio_pcmrec = thread_set_priority(NULL,
+                                thread_get_priority(NULL) - 1);
+            prio_codec  = thread_set_priority(codec_thread_p,
+                                thread_get_priority(codec_thread_p) - 1);
         }
 #endif
 
@@ -888,8 +1004,8 @@ static void pcmrec_flush(unsigned flush_num)
         if (rec_fdata.chunk->flags & CHUNKF_START_FILE)
         {
             pcmrec_start_file();
-            if (--flush_num == 0)
-                i = num_ready; /* stop on next loop - must write this
+            if (--remaining == 0)
+                num_ready = 0; /* stop on next loop - must write this
                                   chunk if it has data */
         }
 
@@ -903,16 +1019,15 @@ static void pcmrec_flush(unsigned flush_num)
         if (errors != 0)
             break;
 
-#ifdef HAVE_PRIORITY_SCHEDULING
-        if (prio == -1)
+        if (flush_num == PCMREC_FLUSH_MINI &&
+                ++chunks_flushed >= MINI_CHUNKS)
         {
-            num = enc_wr_index - enc_rd_index;
-            if (num < 0)
-                num += enc_num_chunks;
+            logf("mini flush break");
+            break;
         }
-#endif
-        /* no yielding, the file apis called in the codecs do that */
-    } /* end for */
+        /* no yielding; the file apis called in the codecs do that
+           sufficiently */
+    } /* end while */
 
     /* sync file */
     if (rec_fdata.rec_file >= 0)
@@ -921,11 +1036,12 @@ static void pcmrec_flush(unsigned flush_num)
     cpu_boost(false);
 
 #ifdef HAVE_PRIORITY_SCHEDULING
-    if (prio != -1)
+    if (prio_pcmrec != -1)
     {
-        /* return to original priority */
+        /* return to original priorities */
         logf("pcmrec: unboost priority");
-        thread_set_priority(NULL, prio);
+        thread_set_priority(NULL, prio_pcmrec);
+        thread_set_priority(codec_thread_p, prio_codec);
     }
 
     last_flush_tick = current_tick; /* save tick when we left */
@@ -948,10 +1064,14 @@ static void pcmrec_new_stream(const char *filename, /* next file name */
                               int pre_index) /* index for prerecorded data */
 {
     logf("pcmrec_new_stream");
+    char path[MAX_PATH]; /* place to copy filename so sender can be released */
 
     struct enc_buffer_event_data data;
-    bool (*fnq_add_fn)(const char *) = NULL;
-    struct enc_chunk_hdr *start = NULL;
+    bool (*fnq_add_fn)(const char *) = NULL; /* function to use to add
+                                                new filename */
+    struct enc_chunk_hdr *start = NULL;      /* pointer to starting chunk of
+                                                stream */
+    bool did_flush = false;                  /* did a flush occurr? */
 
     int get_chunk_index(struct enc_chunk_hdr *chunk)
     {
@@ -967,6 +1087,10 @@ static void pcmrec_new_stream(const char *filename, /* next file name */
         return GET_ENC_CHUNK(index);
     }
 
+    if (filename)
+        strncpy(path, filename, MAX_PATH);
+    queue_reply(&pcmrec_queue, 0); /* We have all we need */
+
     data.pre_chunk = NULL;
     data.chunk = GET_ENC_CHUNK(enc_wr_index);
 
@@ -1039,7 +1163,9 @@ static void pcmrec_new_stream(const char *filename, /* next file name */
     }
 
     data.flags = flags;
+    pcmrec_context = true; /* switch encoder context */
     enc_events_callback(ENC_REC_NEW_STREAM, &data);
+    pcmrec_context = false; /* switch back */
 
     if (flags & CHUNKF_END_FILE)
     {
@@ -1049,11 +1175,10 @@ static void pcmrec_new_stream(const char *filename, /* next file name */
 
     if (start)
     {
-        char buf[MAX_PATH]; /* place to copy in case we're full */
-
         if (!(flags & CHUNKF_PRERECORD))
         {
-            /* get stats on data added to start - sort of a prerecord operation */
+            /* get stats on data added to start - sort of a prerecord
+               operation */
             int i = get_chunk_index(data.chunk);
 #ifdef PCMREC_PARANOID
             int i_last = i;
@@ -1083,16 +1208,16 @@ static void pcmrec_new_stream(const char *filename, /* next file name */
         if (fnq_add_fn == pcmrec_fnq_add_filename && pcmrec_fnq_is_full())
         {
             logf("fnq full");
-            /* make a local copy of filename and let sender go as this
-               flush will hang the screen for a bit otherwise */
-            strncpy(buf, filename, MAX_PATH);
-            filename = buf;
-            queue_reply(&pcmrec_queue, 0);
-            pcmrec_flush(-1);
+            pcmrec_flush(PCMREC_FLUSH_ALL);
+            did_flush = true;
         }
    
-        fnq_add_fn(filename);
+        fnq_add_fn(path);
     }
+
+    /* Make sure to complete any interrupted high watermark */
+    if (!did_flush)
+        pcmrec_flush(PCMREC_FLUSH_IF_HIGH);
 } /* pcmrec_new_stream */
 
 /** event handlers for pcmrec thread */
@@ -1102,6 +1227,7 @@ static void pcmrec_init(void)
 {
     unsigned char *buffer;
 
+    pcmrec_close_file(&rec_fdata.rec_file);
     rec_fdata.rec_file = -1;
 
     /* warings and errors */
@@ -1112,6 +1238,7 @@ static void pcmrec_init(void)
     dma_lock          = true;
     SET_PCM_POS(pcm_rd_pos, 0);
     SET_PCM_POS(dma_wr_pos, 0);
+    pcm_enc_pos       = 0;
 
     /* encoder FIFO */
     SET_ENC_INDEX(enc_wr_index, 0);
@@ -1137,7 +1264,7 @@ static void pcmrec_init(void)
     buffer = audio_get_recording_buffer(&rec_buffer_size);
 
     /* Line align pcm_buffer 2^4=16 bytes */
-    pcm_buffer = (unsigned char *)ALIGN_UP_P2((unsigned long)buffer, 4);
+    pcm_buffer = (unsigned char *)ALIGN_UP_P2((uintptr_t)buffer, 4);
     enc_buffer = pcm_buffer + ALIGN_UP_P2(PCM_NUM_CHUNKS*PCM_CHUNK_SIZE +
                                           PCM_MAX_FEED_SIZE, 2);
     /* Adjust available buffer for possible align advancement */
@@ -1158,7 +1285,8 @@ static void pcmrec_close(void)
 } /* pcmrec_close */
 
 /* PCMREC_OPTIONS */
-static void pcmrec_set_recording_options(struct audio_recording_options *options)
+static void pcmrec_set_recording_options(
+    struct audio_recording_options *options)
 {
     /* stop DMA transfer */
     dma_lock = true;
@@ -1222,97 +1350,111 @@ static void pcmrec_record(const char *filename)
 {
     unsigned long pre_sample_ticks;
     int           rd_start;
+    unsigned long flags;
+    int           pre_index;
 
     logf("pcmrec_record: %s", filename);
 
     /* reset stats */
-    num_rec_bytes     = 0;
-    num_rec_samples   = 0;
+    num_rec_bytes   = 0;
+    num_rec_samples = 0;
 
-    if (is_recording) 
+    if (!is_recording) 
     {
-        /* already recording, just split the stream */
-        logf("inserting split");
-        pcmrec_new_stream(filename,
-                          CHUNKF_START_FILE | CHUNKF_END_FILE,
-                          0);
-        goto record_done;
-    }
-
 #if 0
-    accum_rec_bytes   = 0;
-    accum_pcm_samples = 0;
+        accum_rec_bytes   = 0;
+        accum_pcm_samples = 0;
 #endif
-    spinup_time       = -1;
-    warnings          = 0; /* reset warnings */
+        warnings          = 0;  /* reset warnings */
 
-    rd_start  = enc_wr_index;
-    pre_sample_ticks = 0;
+        rd_start          = enc_wr_index;
+        pre_sample_ticks  = 0;
 
-    if (pre_record_ticks)
-    {
-        int i = rd_start;
+        pcmrec_refresh_watermarks();
+
+        if (pre_record_ticks)
+        {
+            int i = rd_start;
 #ifdef PCMREC_PARANOID
-        int i_last = i;
+            int i_last = i;
 #endif
-        /* calculate number of available chunks */
-        unsigned long avail_pre_chunks = (enc_wr_index - enc_rd_index +
-                        enc_num_chunks) % enc_num_chunks;
-        /* overflow at 974 seconds of prerecording at 44.1kHz */
-        unsigned long pre_record_sample_ticks = enc_sample_rate*pre_record_ticks;
-
-        /* Get exact measure of recorded data as number of samples aren't
-           nescessarily going to be the max for each chunk */
-        for (; avail_pre_chunks-- > 0;)
-        {
-            struct enc_chunk_hdr *chunk;
-            unsigned long chunk_sample_ticks;
+            /* calculate number of available chunks */
+            unsigned long avail_pre_chunks = (enc_wr_index - enc_rd_index +
+                            enc_num_chunks) % enc_num_chunks;
+            /* overflow at 974 seconds of prerecording at 44.1kHz */
+            unsigned long pre_record_sample_ticks =
+                                enc_sample_rate*pre_record_ticks;
+            int pre_chunks = 0; /* Counter to limit prerecorded time to
+                                   prevent flood state at outset */
+
+            logf("pre-st: %ld", pre_record_sample_ticks);
+
+            /* Get exact measure of recorded data as number of samples aren't
+               nescessarily going to be the max for each chunk */
+            for (; avail_pre_chunks-- > 0;)
+            {
+                struct enc_chunk_hdr *chunk;
+                unsigned long chunk_sample_ticks;
 
-            DEC_ENC_INDEX(i);
+                DEC_ENC_INDEX(i);
 
-            chunk = GET_ENC_CHUNK(i);
+                chunk = GET_ENC_CHUNK(i);
 
-            /* must have data to be counted */
-            if (chunk->enc_data == NULL)
-                continue;
+                /* must have data to be counted */
+                if (chunk->enc_data == NULL)
+                    continue;
 
-            chunk_sample_ticks = chunk->num_pcm*HZ;
+                chunk_sample_ticks = chunk->num_pcm*HZ;
 
-            rd_start           = i;
-            pre_sample_ticks  += chunk_sample_ticks;
-            num_rec_bytes     += chunk->enc_size;
-            num_rec_samples   += chunk->num_pcm;
+                rd_start           = i;
+                pre_sample_ticks  += chunk_sample_ticks;
+                num_rec_bytes     += chunk->enc_size;
+                num_rec_samples   += chunk->num_pcm;
+                pre_chunks++;
 
-            /* stop here if enough already */
-            if (pre_sample_ticks >= pre_record_sample_ticks)
-                break;
-        }
+                /* stop here if enough already */
+                if (pre_chunks >= high_watermark ||
+                    pre_sample_ticks >= pre_record_sample_ticks)
+                {
+                    logf("pre-chks: %d", pre_chunks);
+                    break;
+                }
+            }
 
 #if 0
-        accum_rec_bytes   = num_rec_bytes;
-        accum_pcm_samples = num_rec_samples;
+            accum_rec_bytes   = num_rec_bytes;
+            accum_pcm_samples = num_rec_samples;
 #endif
-    }
+        }
+
+        SET_ENC_INDEX(enc_rd_index, rd_start);
+
+        /* filename queue should be empty */
+        if (!pcmrec_fnq_is_empty())
+        {
+            logf("fnq: not empty!");
+            pcmrec_fnq_set_empty();
+        }
+
+        flags = CHUNKF_START_FILE;
+        if (pre_sample_ticks > 0)
+            flags |= CHUNKF_PRERECORD;
 
-    SET_ENC_INDEX(enc_rd_index, rd_start);
+        pre_index    = enc_rd_index;
 
-    /* filename queue should be empty */
-    if (!pcmrec_fnq_is_empty())
+        dma_lock     = false;
+        is_paused    = false;
+        is_recording = true;
+    }
+    else
     {
-        logf("fnq: not empty!");
-        pcmrec_fnq_set_empty();
+        /* already recording, just split the stream */
+        logf("inserting split");
+        flags     = CHUNKF_START_FILE | CHUNKF_END_FILE;
+        pre_index = 0;
     }
-    
-    dma_lock     = false;
-    is_paused    = false;
-    is_recording = true;
 
-    pcmrec_new_stream(filename,
-                      CHUNKF_START_FILE |
-                      (pre_sample_ticks > 0 ? CHUNKF_PRERECORD : 0),
-                      enc_rd_index);
-
-record_done:
+    pcmrec_new_stream(filename, flags, pre_index);
     logf("pcmrec_record done");
 } /* pcmrec_record */
 
@@ -1321,52 +1463,52 @@ static void pcmrec_stop(void)
 {
     logf("pcmrec_stop");
    
-    if (!is_recording)
+    if (is_recording)
     {
-        logf("not recording");
-        goto not_recording;
-    }
+        dma_lock = true;    /* lock dma write position */
+        queue_reply(&pcmrec_queue, 0);
 
-    dma_lock = true;    /* lock dma write position */
-    queue_reply(&pcmrec_queue, 0);
+        /* flush all available data first to avoid overflow while waiting
+           for encoding to finish */
+        pcmrec_flush(PCMREC_FLUSH_ALL);
 
-    /* flush all available data first to avoid overflow while waiting
-       for encoding to finish */
-    pcmrec_flush(-1);
-    
-    /* wait for encoder to finish remaining data */
-    while (errors == 0 && !wav_queue_empty)
-        yield();
-    
-    /* end stream at last data */
-    pcmrec_new_stream(NULL, CHUNKF_END_FILE, 0);
-    
-    /* flush anything else encoder added */
-    pcmrec_flush(-1);
-
-    /* remove any pending file start not yet processed - should be at
-       most one at enc_wr_index */
-    pcmrec_fnq_get_filename(NULL);
-    /* encoder should abort any chunk it was in midst of processing */
-    GET_ENC_CHUNK(enc_wr_index)->flags = CHUNKF_ABORT;
-    
-    /* filename queue should be empty */
-    if (!pcmrec_fnq_is_empty())
-    {
-        logf("fnq: not empty!");
-        pcmrec_fnq_set_empty();
-    }   
+        /* wait for encoder to finish remaining data */
+        while (errors == 0 && !pcm_buffer_empty)
+            yield();
 
-    /* be absolutely sure the file is closed */
-    if (errors != 0)
-        pcmrec_close_file(&rec_fdata.rec_file);
-    rec_fdata.rec_file = -1;
+        /* end stream at last data */
+        pcmrec_new_stream(NULL, CHUNKF_END_FILE, 0);
+
+        /* flush anything else encoder added */
+        pcmrec_flush(PCMREC_FLUSH_ALL);
 
-    is_recording = false;
-    is_paused    = false;
-    dma_lock     = pre_record_ticks == 0;
+        /* remove any pending file start not yet processed - should be at
+           most one at enc_wr_index */
+        pcmrec_fnq_get_filename(NULL);
+        /* encoder should abort any chunk it was in midst of processing */
+        GET_ENC_CHUNK(enc_wr_index)->flags = CHUNKF_ABORT;
+
+        /* filename queue should be empty */
+        if (!pcmrec_fnq_is_empty())
+        {
+            logf("fnq: not empty!");
+            pcmrec_fnq_set_empty();
+        }   
+
+        /* be absolutely sure the file is closed */
+        if (errors != 0)
+            pcmrec_close_file(&rec_fdata.rec_file);
+        rec_fdata.rec_file = -1;
+
+        is_recording = false;
+        is_paused    = false;
+        dma_lock     = pre_record_ticks == 0;
+    }
+    else
+    {
+        logf("not recording");
+    }
 
-not_recording:
     logf("pcmrec_stop done");
 } /* pcmrec_stop */
 
@@ -1378,18 +1520,17 @@ static void pcmrec_pause(void)
     if (!is_recording)
     {
         logf("not recording");
-        goto not_recording_or_paused;
     }
     else if (is_paused)
     {
         logf("already paused");
-        goto not_recording_or_paused;
     }
-    
-    dma_lock  = true;   /* fix DMA write pointer at current position */
-    is_paused = true;  
-    
-not_recording_or_paused:
+    else
+    {
+        dma_lock  = true;
+        is_paused = true;
+    }
+
     logf("pcmrec_pause done");
 } /* pcmrec_pause */
 
@@ -1401,19 +1542,18 @@ static void pcmrec_resume(void)
     if (!is_recording)
     {
         logf("not recording");
-        goto not_recording_or_not_paused;
     }
     else if (!is_paused)
     {
         logf("not paused");
-        goto not_recording_or_not_paused;
     }
-    
-    is_paused    = false;
-    is_recording = true;
-    dma_lock     = false;
-    
-not_recording_or_not_paused:
+    else
+    {
+        is_paused    = false;
+        is_recording = true;
+        dma_lock     = false;
+    }
+
     logf("pcmrec_resume done");
 } /* pcmrec_resume */
 
@@ -1424,6 +1564,12 @@ static void pcmrec_thread(void)
 
     logf("thread pcmrec start");
 
+    static void clear_flush_interrupt(void)
+    {
+        if (--flush_interrupts < 0)
+            flush_interrupts = 0;
+    }
+
     while(1)
     {
         if (is_recording)
@@ -1433,7 +1579,9 @@ static void pcmrec_thread(void)
 
             if (ev.id == SYS_TIMEOUT)
             {
-                pcmrec_flush(0); /* flush if getting full */
+                /* Messages that interrupt this will complete it */
+                pcmrec_flush(PCMREC_FLUSH_IF_HIGH |
+                             PCMREC_FLUSH_INTERRUPTABLE);
                 continue;
             }
         }
@@ -1459,14 +1607,17 @@ static void pcmrec_thread(void)
                 break;
 
             case PCMREC_RECORD:
+                clear_flush_interrupt();
                 pcmrec_record((const char *)ev.data);
                 break;
 
             case PCMREC_STOP:
+                clear_flush_interrupt();
                 pcmrec_stop();
                 break;
 
             case PCMREC_PAUSE:
+                clear_flush_interrupt();
                 pcmrec_pause();
                 break;
 
@@ -1483,6 +1634,9 @@ static void pcmrec_thread(void)
                     break;
                 pcmrec_close();
                 reset_hardware();
+                /* Be sure other threads are released if waiting */
+                queue_clear(&pcmrec_queue);
+                flush_interrupts = 0;
                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
                 usb_wait_for_disconnect(&pcmrec_queue);
                 break;
@@ -1495,6 +1649,7 @@ static void pcmrec_thread(void)
 /****************************************************************************/
 /*                                                                          */
 /*         following functions will be called by the encoder codec          */
+/*         in a free-threaded manner                                        */
 /*                                                                          */
 /****************************************************************************/
 
@@ -1527,6 +1682,7 @@ void enc_set_parameters(struct enc_parameters *params)
     logf("enc sampr:%d", enc_sample_rate);
 
     SET_PCM_POS(pcm_rd_pos, dma_wr_pos);
+    pcm_enc_pos = pcm_rd_pos;
 
     enc_config.afmt     = params->afmt;
     /* addition of the header is always implied - chunk size 4-byte aligned */
@@ -1568,16 +1724,6 @@ void enc_set_parameters(struct enc_parameters *params)
     *wrap_id_p = ENC_CHUNK_MAGIC;
 #endif /* PCMREC_PARANOID */
 
-#ifdef HAVE_PRIORITY_SCHEDULING
-    /* panic boost thread priority at 1 second remaining */
-    panic_threshold = enc_num_chunks -
-                      (4*sample_rate + (enc_chunk_size-1)) / enc_chunk_size;
-    if (panic_threshold < 0)
-        panic_threshold = 0;
-
-    logf("panic thr:%d", panic_threshold);
-#endif
-
     /** set OUT parameters **/
     params->enc_buffer     = enc_buffer;
     params->buf_chunk_size = enc_chunk_size;
@@ -1596,7 +1742,10 @@ void enc_set_parameters(struct enc_parameters *params)
     fnq_wr_pos = 0; /* reset */
     fn_queue   = enc_buffer + bufsize;
     fnq_size   = pcm_buffer + rec_buffer_size - fn_queue;
-    fnq_size   = ALIGN_DOWN(fnq_size, MAX_PATH);
+    fnq_size  /= MAX_PATH;
+    if (fnq_size > FNQ_MAX_NUM_PATHS)
+        fnq_size = FNQ_MAX_NUM_PATHS;
+    fnq_size  *= MAX_PATH;
     logf("fnq files: %d", fnq_size / MAX_PATH);
 
 #if 0
@@ -1626,7 +1775,8 @@ void enc_set_parameters(struct enc_parameters *params)
     logf("enc_set_parameters done");
 } /* enc_set_parameters */
 
-/* return encoder chunk at current write position */
+/* return encoder chunk at current write position  -
+   NOTE: can be called by pcmrec thread when splitting streams */
 struct enc_chunk_hdr * enc_get_chunk(void)
 {
     struct enc_chunk_hdr *chunk = GET_ENC_CHUNK(enc_wr_index);
@@ -1647,7 +1797,8 @@ struct enc_chunk_hdr * enc_get_chunk(void)
     return chunk;
 } /* enc_get_chunk */
 
-/* releases the current chunk into the available chunks */
+/* releases the current chunk into the available chunks - 
+   NOTE: can be called by pcmrec thread when splitting streams */
 void enc_finish_chunk(void)
 {
     struct enc_chunk_hdr *chunk = GET_ENC_CHUNK(enc_wr_index);
@@ -1675,10 +1826,19 @@ void enc_finish_chunk(void)
     }
     else if (is_recording)        /* buffer full */
     {
-        /* keep current position - but put up warning flag */
+        /* keep current position and put up warning flag */
         warnings |= PCMREC_W_ENC_BUFFER_OVF;
         logf("enc_buffer ovf");
         DEC_ENC_INDEX(enc_wr_index);
+        if (pcmrec_context)
+        {
+            /* if stream splitting, keep this out of circulation and
+               flush a small number, then readd - cannot risk losing
+               stream markers */
+            logf("mini flush");
+            pcmrec_flush(PCMREC_FLUSH_MINI);
+            INC_ENC_INDEX(enc_wr_index);
+        }
     }
     else
     {
@@ -1691,7 +1851,7 @@ void enc_finish_chunk(void)
 int enc_pcm_buf_near_empty(void)
 {
     /* less than 1sec raw data? => unboost encoder */
-    int wp       = dma_wr_pos;
+    int    wp    = dma_wr_pos;
     size_t avail = (wp - pcm_rd_pos) & PCM_CHUNK_MASK;
     return avail < (sample_rate << 2) ? 1 : 0;
 } /* enc_pcm_buf_near_empty */
@@ -1700,7 +1860,7 @@ int enc_pcm_buf_near_empty(void)
 /* TODO: this really should give the actual size returned */
 unsigned char * enc_get_pcm_data(size_t size)
 {
-    int wp       = dma_wr_pos;
+    int    wp    = dma_wr_pos;
     size_t avail = (wp - pcm_rd_pos) & PCM_CHUNK_MASK;
 
     /* limit the requested pcm data size */
@@ -1712,47 +1872,46 @@ unsigned char * enc_get_pcm_data(size_t size)
         unsigned char *ptr = pcm_buffer + pcm_rd_pos;
         int next_pos = (pcm_rd_pos + size) & PCM_CHUNK_MASK;
 
+        pcm_enc_pos = pcm_rd_pos;
+
         SET_PCM_POS(pcm_rd_pos, next_pos);
-        pcm_rd_pos = next_pos;
 
         /* ptr must point to continous data at wraparound position */
         if ((size_t)pcm_rd_pos < size)
             memcpy(pcm_buffer + PCM_NUM_CHUNKS*PCM_CHUNK_SIZE,
                    pcm_buffer, pcm_rd_pos);
 
-        wav_queue_empty = false;
+        pcm_buffer_empty = false;
         return ptr;
     }
 
     /* not enough data available - encoder should idle */
-    wav_queue_empty = true;
+    pcm_buffer_empty = true;
     return NULL;
 } /* enc_get_pcm_data */
 
 /* puts some pcm data back in the queue */
 size_t enc_unget_pcm_data(size_t size)
 {
-    /* can't let DMA advance write position when doing this */
-    int level = set_irq_level(HIGHEST_IRQ_LEVEL);
+    int    wp        = dma_wr_pos;
+    size_t old_avail = ((pcm_rd_pos - wp) & PCM_CHUNK_MASK) -
+                            2*PCM_CHUNK_SIZE;
 
-    if (pcm_rd_pos != dma_wr_pos)
+    /* allow one interrupt to occur during this call and not have the
+       new read position inside the DMA destination chunk */
+    if ((ssize_t)old_avail > 0)
     {
-        /* disallow backing up into current DMA write chunk  */
-        size_t old_avail = (pcm_rd_pos - dma_wr_pos - PCM_CHUNK_SIZE)
-                            & PCM_CHUNK_MASK;
-        int next_pos;
-
         /* limit size to amount of old data remaining */
         if (size > old_avail)
             size = old_avail;
 
-        next_pos = (pcm_rd_pos - size) & PCM_CHUNK_MASK;
-        SET_PCM_POS(pcm_rd_pos, next_pos);
-    }
+        pcm_enc_pos = (pcm_rd_pos - size) & PCM_CHUNK_MASK;
+        SET_PCM_POS(pcm_rd_pos, pcm_enc_pos);
 
-    set_irq_level(level);
+        return size;
+    }
 
-    return size;
+    return 0;
 } /* enc_unget_pcm_data */
 
 /** Low level pcm recording apis **/