apps/codecs/wav_enc.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Antonius Hellmann
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #ifndef SIMULATOR
  23
  24 #include <inttypes.h>
  25 #include "codeclib.h"
  26
  27 CODEC_ENC_HEADER
  28
  29 struct riff_header
  30 {
  31     uint8_t  riff_id[4];      /* 00h - "RIFF"                            */
  32     uint32_t riff_size;       /* 04h - sz following headers + data_size  */
  33     /* format header */
  34     uint8_t  format[4];       /* 08h - "WAVE"                            */
  35     uint8_t  format_id[4];    /* 0Ch - "fmt "                            */
  36     uint32_t format_size;     /* 10h - 16 for PCM (sz format data)       */
  37     /* format data */
  38     uint16_t audio_format;    /* 14h - 1=PCM                             */
  39     uint16_t num_channels;    /* 16h - 1=M, 2=S, etc.                    */
  40     uint32_t sample_rate;     /* 18h - HZ                                */
  41     uint32_t byte_rate;       /* 1Ch - num_channels*sample_rate*bits_per_sample/8 */
  42     uint16_t block_align;     /* 20h - num_channels*bits_per_samples/8   */
  43     uint16_t bits_per_sample; /* 22h - 8=8 bits, 16=16 bits, etc.        */
  44     /* Not for audio_format=1 (PCM) */
  45 /*  unsigned short extra_param_size;   24h - size of extra data          */
  46 /*  unsigned char  *extra_params; */
  47     /* data header */
  48     uint8_t  data_id[4];      /* 24h - "data" */
  49     uint32_t data_size;       /* 28h - num_samples*num_channels*bits_per_sample/8 */
  50 /*  unsigned char  *data;              2ch - actual sound data */
  51 } __attribute__((packed));
  52
  53 #define RIFF_FMT_HEADER_SIZE       12 /* format -> format_size */
  54 #define RIFF_FMT_DATA_SIZE         16 /* audio_format -> bits_per_sample */
  55 #define RIFF_DATA_HEADER_SIZE       8 /* data_id -> data_size */
  56
  57 #define PCM_DEPTH_BYTES             2
  58 #define PCM_DEPTH_BITS             16
  59 #define PCM_SAMP_PER_CHUNK       2048
  60 #define PCM_CHUNK_SIZE          (PCM_SAMP_PER_CHUNK*4)
  61
  62 static int      num_channels IBSS_ATTR;
  63 static int      rec_mono_mode IBSS_ATTR;
  64 static uint32_t sample_rate;
  65 static uint32_t enc_size;
  66 static int32_t  err          IBSS_ATTR;
  67
  68 static const struct riff_header riff_header =
  69 {
  70     /* "RIFF" header */
  71     { 'R', 'I', 'F', 'F' },         /* riff_id          */
  72     0,                              /* riff_size   (*)  */
  73     /* format header */
  74     { 'W', 'A', 'V', 'E' },         /* format           */
  75     { 'f', 'm', 't', ' ' },         /* format_id        */
  76     H_TO_LE32(16),                  /* format_size      */
  77     /* format data */
  78     H_TO_LE16(1),                   /* audio_format     */
  79     0,                              /* num_channels (*) */
  80     0,                              /* sample_rate  (*) */
  81     0,                              /* byte_rate    (*) */
  82     0,                              /* block_align  (*) */
  83     H_TO_LE16(PCM_DEPTH_BITS),      /* bits_per_sample  */
  84     /* data header */
  85     { 'd', 'a', 't', 'a' },         /* data_id          */
  86     0                               /* data_size    (*) */
  87     /* (*) updated during ENC_END_FILE event */
  88 };
  89
  90 /* called version often - inline */
  91 static inline bool is_file_data_ok(struct enc_file_event_data *data) ICODE_ATTR;
  92 static inline bool is_file_data_ok(struct enc_file_event_data *data)
  93 {
  94     return data->rec_file >= 0 && (long)data->chunk->flags >= 0;
  95 } /* is_file_data_ok */
  96
  97 /* called version often - inline */
  98 static inline bool on_write_chunk(struct enc_file_event_data *data) ICODE_ATTR;
  99 static inline bool on_write_chunk(struct enc_file_event_data *data)
 100 {
 101     if (!is_file_data_ok(data))
 102         return false;
 103
 104     if (data->chunk->enc_data == NULL)
 105     {
 106 #ifdef ROCKBOX_HAS_LOGF
 107         ci->logf("wav enc: NULL data");
 108 #endif
 109         return true;
 110     }
 111
 112     if (ci->write(data->rec_file, data->chunk->enc_data,
 113                   data->chunk->enc_size) != (ssize_t)data->chunk->enc_size)
 114         return false;
 115
 116     data->num_pcm_samples += data->chunk->num_pcm;
 117     return true;
 118 } /* on_write_chunk */
 119
 120 static bool on_start_file(struct enc_file_event_data *data)
 121 {
 122     if ((data->chunk->flags & CHUNKF_ERROR) || *data->filename == '\0')
 123         return false;
 124
 125     data->rec_file = ci->open(data->filename, O_RDWR|O_CREAT|O_TRUNC);
 126
 127     if (data->rec_file < 0)
 128         return false;
 129
 130     /* reset sample count */
 131     data->num_pcm_samples = 0;
 132
 133     /* write template header */
 134     if (ci->write(data->rec_file, &riff_header, sizeof (riff_header))
 135             != sizeof (riff_header))
 136     {
 137         return false;
 138     }
 139
 140     data->new_enc_size += sizeof (riff_header);
 141     return true;
 142 } /* on_start_file */
 143
 144 static bool on_end_file(struct enc_file_event_data *data)
 145 {
 146     /* update template header */
 147     struct riff_header hdr;
 148     uint32_t data_size;
 149
 150     if (data->rec_file < 0)
 151         return false; /* file already closed, nothing more we can do */
 152
 153     /* always _try_ to write the file header, even on error */
 154     if ((ci->lseek(data->rec_file, 0, SEEK_SET)) ||
 155         (ci->read(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr)))
 156     {
 157         return false;
 158     }
 159
 160     data_size = data->num_pcm_samples*num_channels*PCM_DEPTH_BYTES;
 161
 162     /* "RIFF" header */
 163     hdr.riff_size    = htole32(RIFF_FMT_HEADER_SIZE + RIFF_FMT_DATA_SIZE
 164                                + RIFF_DATA_HEADER_SIZE + data_size);
 165
 166     /* format data */
 167     hdr.num_channels = htole16(num_channels);
 168     hdr.sample_rate  = htole32(sample_rate);
 169     hdr.byte_rate    = htole32(sample_rate*num_channels* PCM_DEPTH_BYTES);
 170     hdr.block_align  = htole16(num_channels*PCM_DEPTH_BYTES);
 171
 172     /* data header */
 173     hdr.data_size    = htole32(data_size);
 174
 175     if (ci->lseek(data->rec_file, 0, SEEK_SET) != 0 ||
 176         ci->write(data->rec_file, &hdr, sizeof (hdr)) != sizeof (hdr) ||
 177         ci->close(data->rec_file) != 0)
 178     {
 179         return false;
 180     }
 181
 182     data->rec_file = -1;
 183
 184     return true;
 185 } /* on_end_file */
 186
 187 STATICIRAM void enc_events_callback(enum enc_events event, void *data)
 188                                     ICODE_ATTR;
 189 STATICIRAM void enc_events_callback(enum enc_events event, void *data)
 190 {
 191     switch (event)
 192     {
 193     case ENC_WRITE_CHUNK:
 194         if (on_write_chunk((struct enc_file_event_data *)data))
 195             return;
 196
 197         break;
 198
 199     case ENC_START_FILE:
 200         if (on_start_file((struct enc_file_event_data *)data))
 201             return;
 202
 203         break;
 204
 205     case ENC_END_FILE:
 206         if (on_end_file((struct enc_file_event_data *)data))
 207             return;
 208
 209         break;
 210
 211     default:
 212         return;
 213     }
 214
 215     /* Something failed above. Signal error back to core. */
 216     ((struct enc_file_event_data *)data)->chunk->flags |= CHUNKF_ERROR;
 217 } /* enc_events_callback */
 218
 219 /* convert native pcm samples to wav format samples */
 220 static inline void sample_to_mono(uint32_t **src, uint32_t **dst)
 221 {
 222     int32_t lr1, lr2;
 223
 224     switch(rec_mono_mode)
 225     {
 226         case 1:
 227             /* mono = L */
 228             lr1 = *(*src)++;
 229             lr1 = lr1 >> 16;
 230             lr2 = *(*src)++;
 231             lr2 = lr2 >> 16;
 232             break;
 233         case 2:
 234             /* mono = R */
 235             lr1 = *(*src)++;
 236             lr1 = (uint16_t)lr1;
 237             lr2 = *(*src)++;
 238             lr2 = (uint16_t)lr2;
 239             break;
 240         case 0:
 241         default:
 242             /* mono = (L+R)/2 */
 243             lr1 = *(*src)++;
 244             lr1 = (int16_t)lr1 + (lr1 >> 16) + err;
 245             err = lr1 & 1;
 246             lr1 >>= 1;
 247
 248             lr2 = *(*src)++;
 249             lr2 = (int16_t)lr2 + (lr2 >> 16) + err;
 250             err = lr2 & 1;
 251             lr2 >>= 1;
 252             break;
 253     }
 254     *(*dst)++ = htole32((lr2 << 16) | (uint16_t)lr1);
 255 } /* sample_to_mono */
 256
 257 STATICIRAM void chunk_to_wav_format(uint32_t *src, uint32_t *dst) ICODE_ATTR;
 258 STATICIRAM void chunk_to_wav_format(uint32_t *src, uint32_t *dst)
 259 {
 260     if (num_channels == 1)
 261     {
 262         /* On big endian:
 263          *  |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr|
 264          *  |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| =>
 265          *  |mmmmmmmmMMMMMMMM|mmmmmmmmMMMMMMMM|
 266          *
 267          * On little endian:
 268          *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
 269          *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
 270          *  |mmmmmmmmMMMMMMMM|mmmmmmmmMMMMMMMM|
 271          */
 272         uint32_t *src_end = src + PCM_SAMP_PER_CHUNK;
 273
 274         do
 275         {
 276             sample_to_mono(&src, &dst);
 277             sample_to_mono(&src, &dst);
 278             sample_to_mono(&src, &dst);
 279             sample_to_mono(&src, &dst);
 280             sample_to_mono(&src, &dst);
 281             sample_to_mono(&src, &dst);
 282             sample_to_mono(&src, &dst);
 283             sample_to_mono(&src, &dst);
 284         }
 285         while (src < src_end);
 286     }
 287     else
 288     {
 289 #ifdef ROCKBOX_BIG_ENDIAN
 290         /*  |LLLLLLLLllllllll|RRRRRRRRrrrrrrrr| =>
 291          *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
 292          */
 293         uint32_t *src_end = src + PCM_SAMP_PER_CHUNK;
 294
 295         do
 296         {
 297             *dst++ = swap_odd_even32(*src++);
 298             *dst++ = swap_odd_even32(*src++);
 299             *dst++ = swap_odd_even32(*src++);
 300             *dst++ = swap_odd_even32(*src++);
 301             *dst++ = swap_odd_even32(*src++);
 302             *dst++ = swap_odd_even32(*src++);
 303             *dst++ = swap_odd_even32(*src++);
 304             *dst++ = swap_odd_even32(*src++);
 305         }
 306         while (src < src_end);
 307 #else
 308         /*  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR| =>
 309          *  |llllllllLLLLLLLL|rrrrrrrrRRRRRRRR|
 310          */
 311         ci->memcpy(dst, src, PCM_CHUNK_SIZE);
 312 #endif
 313     }
 314 } /* chunk_to_wav_format */
 315
 316 static bool init_encoder(void)
 317 {
 318     struct enc_inputs     inputs;
 319     struct enc_parameters params;
 320
 321     if (ci->enc_get_inputs         == NULL ||
 322         ci->enc_set_parameters     == NULL ||
 323         ci->enc_get_chunk          == NULL ||
 324         ci->enc_finish_chunk       == NULL ||
 325         ci->enc_get_pcm_data       == NULL )
 326         return false;
 327
 328     ci->enc_get_inputs(&inputs);
 329
 330     if (inputs.config->afmt != AFMT_PCM_WAV)
 331         return false;
 332
 333     sample_rate  = inputs.sample_rate;
 334     num_channels = inputs.num_channels;
 335     rec_mono_mode = inputs.rec_mono_mode;
 336     err          = 0;
 337
 338     /* configure the buffer system */
 339     params.afmt            = AFMT_PCM_WAV;
 340     enc_size               = PCM_CHUNK_SIZE*inputs.num_channels / 2;
 341     params.chunk_size      = enc_size;
 342     params.enc_sample_rate = sample_rate;
 343     params.reserve_bytes   = 0;
 344     params.events_callback = enc_events_callback;
 345     ci->enc_set_parameters(&params);
 346
 347     return true;
 348 } /* init_encoder */
 349
 350 /* main codec entry point */
 351 enum codec_status codec_main(void)
 352 {
 353     if (!init_encoder())
 354     {
 355         ci->enc_codec_loaded = -1;
 356         return CODEC_ERROR;
 357     }
 358
 359     /* main application waits for this flag during encoder loading */
 360     ci->enc_codec_loaded = 1;
 361
 362     /* main encoding loop */
 363     while(!ci->stop_encoder)
 364     {
 365         uint32_t *src;
 366
 367         while ((src = (uint32_t *)ci->enc_get_pcm_data(PCM_CHUNK_SIZE)) != NULL)
 368         {
 369             struct enc_chunk_hdr *chunk;
 370
 371             if (ci->stop_encoder)
 372                 break;
 373
 374             chunk           = ci->enc_get_chunk();
 375             chunk->enc_size = enc_size;
 376             chunk->num_pcm  = PCM_SAMP_PER_CHUNK;
 377             chunk->enc_data = ENC_CHUNK_SKIP_HDR(chunk->enc_data, chunk);
 378
 379             chunk_to_wav_format(src, (uint32_t *)chunk->enc_data);
 380
 381             ci->enc_finish_chunk();
 382             ci->yield();
 383         }
 384
 385         ci->yield();
 386     }
 387
 388     /* reset parameters to initial state */
 389     ci->enc_set_parameters(NULL);
 390
 391     /* main application waits for this flag during encoder removing */
 392     ci->enc_codec_loaded = 0;
 393
 394     return CODEC_OK;
 395 } /* codec_start */
 396
 397 #endif /* ndef SIMULATOR */