1 files changed, 322 insertions, 97 deletions

diff --git a/apps/codecs/wav_enc.c b/apps/codecs/wav_enc.c
index 5aabb5d8e8..974a903310 100644
--- a/apps/codecs/wav_enc.c
+++ b/apps/codecs/wav_enc.c
@@ -19,140 +19,364 @@
 
 #ifndef SIMULATOR
 
+#include <inttypes.h>
 #include "codeclib.h"
 
-CODEC_HEADER
+CODEC_ENC_HEADER
+
+#ifdef USE_IRAM
+extern char iramcopy[];
+extern char iramstart[];
+extern char iramend[];
+extern char iedata[];
+extern char iend[];
+#endif
+
+struct riff_header
+{
+    uint8_t  riff_id[4];      /* 00h - "RIFF"                            */
+    uint32_t riff_size;       /* 04h - sz following headers + data_size  */
+    /* format header */
+    uint8_t  format[4];       /* 08h - "WAVE"                            */
+    uint8_t  format_id[4];    /* 0Ch - "fmt "                            */
+    uint32_t format_size;     /* 10h - 16 for PCM (sz format data)       */
+    /* format data */
+    uint16_t audio_format;    /* 14h - 1=PCM                             */
+    uint16_t num_channels;    /* 16h - 1=M, 2=S, etc.                    */
+    uint32_t sample_rate;     /* 18h - HZ                                */
+    uint32_t byte_rate;       /* 1Ch - num_channels*sample_rate*bits_per_sample/8 */
+    uint16_t block_align;     /* 20h - num_channels*bits_per_samples/8   */
+    uint16_t bits_per_sample; /* 22h - 8=8 bits, 16=16 bits, etc.        */
+    /* Not for audio_format=1 (PCM) */
+/*  unsigned short extra_param_size;   24h - size of extra data          */ 
+/*  unsigned char  *extra_params; */
+    /* data header */
+    uint8_t  data_id[4];      /* 24h - "data" */
+    uint32_t data_size;       /* 28h - num_samples*num_channels*bits_per_sample/8 */
+/*  unsigned char  *data;              2ch - actual sound data */
+};
+
+#define RIFF_FMT_HEADER_SIZE       12 /* format -> format_size */
+#define RIFF_FMT_DATA_SIZE         16 /* audio_format -> bits_per_sample */
+#define RIFF_DATA_HEADER_SIZE       8 /* data_id -> data_size */
+
+#define PCM_DEPTH_BYTES             2
+#define PCM_DEPTH_BITS             16
+#define PCM_SAMP_PER_CHUNK       2048
+#define PCM_CHUNK_SIZE          (PCM_SAMP_PER_CHUNK*4)
 
 static struct codec_api *ci;
-static    int enc_channels;
+static int    num_channels;
+uint32_t      sample_rate;
+uint32_t      enc_size;
 
-#define CHUNK_SIZE 8192
+static const struct riff_header riff_header =
+{
+    /* "RIFF" header */
+    { 'R', 'I', 'F', 'F' },         /* riff_id          */
+    0,                              /* riff_size   (*)  */
+    /* format header */ 
+    { 'W', 'A', 'V', 'E' },         /* format           */
+    { 'f', 'm', 't', ' ' },         /* format_id        */
+    H_TO_LE32(16),                  /* format_size      */
+    /* format data */
+    H_TO_LE16(1),                   /* audio_format     */
+    0,                              /* num_channels (*) */
+    0,                              /* sample_rate  (*) */
+    0,                              /* byte_rate    (*) */
+    0,                              /* block_align  (*) */
+    H_TO_LE16(PCM_DEPTH_BITS),      /* bits_per_sample  */
+    /* data header */
+    { 'd', 'a', 't', 'a' },         /* data_id          */
+    0                               /* data_size    (*) */
+    /* (*) updated during ENC_END_FILE event */
+};
 
-static unsigned char wav_header[44] =
-{'R','I','F','F',0,0,0,0,'W','A','V','E','f','m','t',' ',16,
- 0,0,0,1,0,2,0,0x44,0xac,0,0,0x10,0xb1,2,0,4,0,16,0,'d','a','t','a',0,0,0,0};
+/* called version often - inline */
+static inline bool is_file_data_ok(struct enc_file_event_data *data) ICODE_ATTR;
+static inline bool is_file_data_ok(struct enc_file_event_data *data)
+{
+    return data->rec_file >= 0 && (long)data->chunk->flags >= 0;
+} /* is_file_data_ok */
 
-static unsigned char wav_header_mono[44] =
-{'R','I','F','F',0,0,0,0,'W','A','V','E','f','m','t',' ',16,
- 0,0,0,1,0,1,0,0x44,0xac,0,0,0x88,0x58,1,0,2,0,16,0,'d','a','t','a',0,0,0,0};
+/* called version often - inline */
+static inline bool on_write_chunk(struct enc_file_event_data *data) ICODE_ATTR;
+static inline bool on_write_chunk(struct enc_file_event_data *data)
+{
+    if (!is_file_data_ok(data))
+        return false;
 
-/* update file header info callback function (called by main application)  */
-void enc_set_header(void *head_buffer,  /* ptr to the file header data     */
-                   int head_size,       /* size of this header data        */
-                   int num_pcm_samples, /* amount of processed pcm samples */
-                   bool is_file_header)
+    if (data->chunk->enc_data == NULL)
+    {
+#ifdef ROCKBOX_HAS_LOGF
+        ci->logf("wav enc: NULL data");
+#endif
+        return true;
+    }
+
+    if (ci->write(data->rec_file, data->chunk->enc_data,
+                  data->chunk->enc_size) != (ssize_t)data->chunk->enc_size)
+        return false;
+
+    data->num_pcm_samples += data->chunk->num_pcm;
+    return true;
+} /* on_write_chunk */
+
+static bool on_start_file(struct enc_file_event_data *data)
 {
-    int num_file_bytes = num_pcm_samples * 2 * enc_channels;
+    if ((data->chunk->flags & CHUNKF_ERROR) || *data->filename == '\0')
+        return false;
+
+    data->rec_file = ci->open(data->filename, O_RDWR|O_CREAT|O_TRUNC);
+
+    if (data->rec_file < 0)
+        return false;
+
+    /* reset sample count */
+    data->num_pcm_samples = 0;
 
-    if(is_file_header)
+    /* write template header */
+    if (ci->write(data->rec_file, &riff_header, sizeof (riff_header))
+            != sizeof (riff_header))
     {
-        /* update file header before file closing */
-        if((int)sizeof(wav_header) < head_size)
+        return false;
+    }
+
+    data->new_enc_size += sizeof (riff_header);
+    return true;
+} /* on_start_file */
+
+static bool on_end_file(struct enc_file_event_data *data)
+{
+    /* update template header */
+    struct riff_header hdr;
+    uint32_t data_size;
+
+    if (!is_file_data_ok(data))
+        return false;
+
+    if (ci->lseek(data->rec_file, 0, SEEK_SET) != 0 ||
+        ci->read(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr))
+    {
+        return false;
+    }
+
+    data_size = data->num_pcm_samples*num_channels*PCM_DEPTH_BYTES;
+
+    /* "RIFF" header */
+    hdr.riff_size    = htole32(RIFF_FMT_HEADER_SIZE + RIFF_FMT_DATA_SIZE
+                               + RIFF_DATA_HEADER_SIZE + data_size);
+
+    /* format data */
+    hdr.num_channels = htole16(num_channels);
+    hdr.sample_rate  = htole32(sample_rate);
+    hdr.byte_rate    = htole32(sample_rate*num_channels* PCM_DEPTH_BYTES);
+    hdr.block_align  = htole16(num_channels*PCM_DEPTH_BYTES);
+
+    /* data header */
+    hdr.data_size    = htole32(data_size);
+
+    if (ci->lseek(data->rec_file, 0, SEEK_SET) != 0 ||
+        ci->write(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr))
+    {
+        return false;
+    }
+
+    ci->fsync(data->rec_file);
+    ci->close(data->rec_file);
+    data->rec_file = -1;
+
+    return true;
+} /* on_end_file */
+
+static void enc_events_callback(enum enc_events event, void *data) ICODE_ATTR;
+static void enc_events_callback(enum enc_events event, void *data)
+{
+    if (event == ENC_WRITE_CHUNK)
+    {
+        if (on_write_chunk((struct enc_file_event_data *)data))
+            return;
+    }
+    else if (event == ENC_START_FILE)
+    {
+        if (on_start_file((struct enc_file_event_data *)data))
+            return;
+    }
+    else if (event == ENC_END_FILE)
+    {
+        if (on_end_file((struct enc_file_event_data *)data))
+            return;
+    }
+    else
+    {
+        return;
+    }
+
+    ((struct enc_file_event_data *)data)->chunk->flags |= CHUNKF_ERROR;
+} /* enc_events_callback */
+
+/* convert native pcm samples to wav format samples */
+static void chunk_to_wav_format(uint32_t *src, uint32_t *dst) ICODE_ATTR;
+static void chunk_to_wav_format(uint32_t *src, uint32_t *dst)
+{
+    if (num_channels == 1)
+    {
+        /* On big endian:
+         *  |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr|
+         *  |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| =>
+         *  |mmmmmmmmMMMMMMMM|mmmmmmmmMMMMMMMM|
+         *
+         * On little endian:
+         *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
+         *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
+         *  |mmmmmmmmMMMMMMMM|mmmmmmmmMMMMMMMM|
+         */
+        uint32_t *src_end = src + PCM_SAMP_PER_CHUNK;
+
+        inline void to_mono(uint32_t **src, uint32_t **dst)
         {
-            /* update wave header size entries: special to WAV format */
-            *(long*)(head_buffer+ 4) = htole32(num_file_bytes + 36);
-            *(long*)(head_buffer+40) = htole32(num_file_bytes);
+            int32_t lr1, lr2;
+
+            lr1 = *(*src)++;
+            lr1 = ((int16_t)lr1 + (lr1 >> 16)) >> 1;
+
+            lr2 = *(*src)++;
+            lr2 = ((int16_t)lr2 + (lr2 >> 16)) >> 1;
+            *(*dst)++ = swap_odd_even_be32((lr1 << 16) | (uint16_t)lr2);
+        } /* to_mono */
+
+        do
+        {
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
+            to_mono(&src, &dst);
         }
+        while (src < src_end);
     }
-}
+    else
+    {
+#ifdef ROCKBOX_BIG_ENDIAN
+        /*  |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| =>
+         *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
+         */
+        uint32_t *src_end = src + PCM_SAMP_PER_CHUNK;
 
-/* main codec entry point */
-enum codec_status codec_start(struct codec_api* api)
+        do
+        {
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+            *dst++ = swap_odd_even32(*src++);
+        }
+        while (src < src_end);
+#else
+        /*  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
+         *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
+         */
+        ci->memcpy(dst, src, PCM_CHUNK_SIZE);
+#endif
+    }
+} /* chunk_to_wav_format */
+
+static bool init_encoder(void)
 {
-    int            i;
-    long           lr;
-    unsigned long  t;
-    unsigned long  *src;
-    unsigned long  *dst;
-    int            chunk_size, num_chunks, samp_per_chunk;
-    int            enc_buffer_size;
-    int            enc_quality;
-    bool           cpu_boosted = true; /* start boosted */
+    struct enc_inputs     inputs;
+    struct enc_parameters params;
 
-    ci = api; // copy to global api pointer
+    if (ci->enc_get_inputs         == NULL ||
+        ci->enc_set_parameters     == NULL ||
+        ci->enc_get_chunk          == NULL ||
+        ci->enc_finish_chunk       == NULL ||
+        ci->enc_pcm_buf_near_empty == NULL ||
+        ci->enc_get_pcm_data       == NULL )
+        return false;
 
-    if(ci->enc_get_inputs          == NULL ||
-       ci->enc_set_parameters      == NULL ||
-       ci->enc_alloc_chunk         == NULL ||
-       ci->enc_free_chunk          == NULL ||
-       ci->enc_wavbuf_near_empty   == NULL ||
-       ci->enc_get_wav_data        == NULL ||
-       ci->enc_set_header_callback == NULL )
-        return CODEC_ERROR;
+    ci->enc_get_inputs(&inputs);
 
-    ci->cpu_boost(true);
+    if (inputs.config->afmt != AFMT_PCM_WAV)
+        return false;
 
-    *ci->enc_set_header_callback = enc_set_header;
-    ci->enc_get_inputs(&enc_buffer_size, &enc_channels, &enc_quality);
+    sample_rate  = inputs.sample_rate;
+    num_channels = inputs.num_channels;
 
     /* configure the buffer system */
-    chunk_size     = sizeof(long) + CHUNK_SIZE * enc_channels / 2;
-    num_chunks     = enc_buffer_size / chunk_size;
-    samp_per_chunk = CHUNK_SIZE / 4;
+    params.afmt            = AFMT_PCM_WAV;
+    enc_size               = PCM_CHUNK_SIZE*inputs.num_channels / 2;
+    params.chunk_size      = enc_size;
+    params.enc_sample_rate = sample_rate;
+    params.reserve_bytes   = 0;
+    params.events_callback = enc_events_callback;
+    ci->enc_set_parameters(&params);
+
+    return true;
+} /* init_encoder */
+
+/* main codec entry point */
+enum codec_status codec_start(struct codec_api* api)
+{
+    bool cpu_boosted;
 
-    /* inform the main program about buffer dimensions and other params */
-    ci->enc_set_parameters(chunk_size, num_chunks, samp_per_chunk,
-        (enc_channels == 2) ? wav_header : wav_header_mono,
-        sizeof(wav_header), AFMT_PCM_WAV);
+    ci = api; // copy to global api pointer
+
+#ifdef USE_IRAM
+    ci->memcpy(iramstart, iramcopy, iramend - iramstart);
+    ci->memset(iedata, 0, iend - iedata);
+#endif
+
+    if (!init_encoder())
+    {
+        ci->enc_codec_loaded = -1;
+        return CODEC_ERROR;
+    }
 
     /* main application waits for this flag during encoder loading */
-    ci->enc_codec_loaded = true;
+    ci->enc_codec_loaded = 1;
+
+    ci->cpu_boost(true);
+    cpu_boosted = true;
 
     /* main encoding loop */
     while(!ci->stop_codec)
     {
-        while((src = (unsigned long*)ci->enc_get_wav_data(CHUNK_SIZE)) != NULL)
+        uint32_t *src;
+
+        while ((src = (uint32_t *)ci->enc_get_pcm_data(PCM_CHUNK_SIZE)) != NULL)
         {
-            if(ci->stop_codec)
+            struct enc_chunk_hdr *chunk;
+
+            if (ci->stop_codec)
                 break;
 
-            if(ci->enc_wavbuf_near_empty() == 0)
+            if (!cpu_boosted && ci->enc_pcm_buf_near_empty() == 0)
             {
-                if(!cpu_boosted)
-                {
-                    ci->cpu_boost(true);
-                    cpu_boosted = true;
-                }
+                ci->cpu_boost(true);
+                cpu_boosted = true;
             }
 
-            dst = (unsigned long*)ci->enc_alloc_chunk();
-            *dst++ = CHUNK_SIZE * enc_channels / 2; /* set size info */
+            chunk           = ci->enc_get_chunk();
+            chunk->enc_size = enc_size;
+            chunk->num_pcm  = PCM_SAMP_PER_CHUNK;
+            chunk->enc_data = ENC_CHUNK_SKIP_HDR(chunk->enc_data, chunk);
 
-            if(enc_channels == 2)
-            {
-                /* swap byte order & copy to destination */
-                for (i=0; i<CHUNK_SIZE/4; i++)
-                {
-                    t = *src++;
-                    *dst++ = ((t >> 8) & 0xff00ff) | ((t << 8) & 0xff00ff00);
-                }
-            }
-            else
-            {
-                /* mix left/right, swap byte order & copy to destination */
-                for (i=0; i<CHUNK_SIZE/8; i++)
-                {
-                    lr = (long)*src++;
-                    lr = (((lr<<16)>>16) + (lr>>16)) >> 1; /* left+right */
-                    t  = (lr << 16);
-                    lr = (long)*src++;
-                    lr = (((lr<<16)>>16) + (lr>>16)) >> 1; /* left+right */
-                    t |= lr & 0xffff;
-                    *dst++ = ((t >> 8) & 0xff00ff) | ((t << 8) & 0xff00ff00);
-                }
-            }
+            chunk_to_wav_format(src, (uint32_t *)chunk->enc_data);
 
-            ci->enc_free_chunk();
+            ci->enc_finish_chunk();
             ci->yield();
         }
 
-        if(ci->enc_wavbuf_near_empty())
+        if (cpu_boosted && ci->enc_pcm_buf_near_empty() != 0)
         {
-            if(cpu_boosted)
-            {
-                ci->cpu_boost(false);
-                cpu_boosted = false;
-            }
+            ci->cpu_boost(false);
+            cpu_boosted = false;
         }
 
         ci->yield();
@@ -162,11 +386,12 @@ enum codec_status codec_start(struct codec_api* api)
         ci->cpu_boost(false);
 
     /* reset parameters to initial state */
-    ci->enc_set_parameters(0, 0, 0, 0, 0, 0);
+    ci->enc_set_parameters(NULL);
  
     /* main application waits for this flag during encoder removing */
-    ci->enc_codec_loaded = false;
+    ci->enc_codec_loaded = 0;
 
     return CODEC_OK;
-}
-#endif
+} /* codec_start */
+
+#endif /* ndef SIMULATOR */