Home | History | Annotate | Download | only in audio_utils 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <audio_utils/sndfile.h>
     18 #include <audio_utils/primitives.h>
     19 #include <stdio.h>
     20 #include <string.h>
     21 #include <errno.h>
     22 
     23 #define WAVE_FORMAT_PCM         1
     24 #define WAVE_FORMAT_IEEE_FLOAT  3
     25 #define WAVE_FORMAT_EXTENSIBLE  0xFFFE
     26 
     27 struct SNDFILE_ {
     28     int mode;
     29     uint8_t *temp;  // realloc buffer used for shrinking 16 bits to 8 bits and byte-swapping
     30     FILE *stream;
     31     size_t bytesPerFrame;
     32     size_t remaining;   // frames unread for SFM_READ, frames written for SFM_WRITE
     33     SF_INFO info;
     34 };
     35 
     36 static unsigned little2u(unsigned char *ptr)
     37 {
     38     return (ptr[1] << 8) + ptr[0];
     39 }
     40 
     41 static unsigned little4u(unsigned char *ptr)
     42 {
     43     return (ptr[3] << 24) + (ptr[2] << 16) + (ptr[1] << 8) + ptr[0];
     44 }
     45 
     46 static int isLittleEndian(void)
     47 {
     48     static const short one = 1;
     49     return *((const char *) &one) == 1;
     50 }
     51 
     52 // "swab" conflicts with OS X <string.h>
     53 static void my_swab(short *ptr, size_t numToSwap)
     54 {
     55     while (numToSwap > 0) {
     56         *ptr = little2u((unsigned char *) ptr);
     57         --numToSwap;
     58         ++ptr;
     59     }
     60 }
     61 
     62 static SNDFILE *sf_open_read(const char *path, SF_INFO *info)
     63 {
     64     FILE *stream = fopen(path, "rb");
     65     if (stream == NULL) {
     66         fprintf(stderr, "fopen %s failed errno %d\n", path, errno);
     67         return NULL;
     68     }
     69 
     70     SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
     71     handle->mode = SFM_READ;
     72     handle->temp = NULL;
     73     handle->stream = stream;
     74     handle->info.format = SF_FORMAT_WAV;
     75 
     76     // don't attempt to parse all valid forms, just the most common ones
     77     unsigned char wav[12];
     78     size_t actual;
     79     actual = fread(wav, sizeof(char), sizeof(wav), stream);
     80     if (actual < 12) {
     81         fprintf(stderr, "actual %zu < 44\n", actual);
     82         goto close;
     83     }
     84     if (memcmp(wav, "RIFF", 4)) {
     85         fprintf(stderr, "wav != RIFF\n");
     86         goto close;
     87     }
     88     unsigned riffSize = little4u(&wav[4]);
     89     if (riffSize < 4) {
     90         fprintf(stderr, "riffSize %u < 4\n", riffSize);
     91         goto close;
     92     }
     93     if (memcmp(&wav[8], "WAVE", 4)) {
     94         fprintf(stderr, "missing WAVE\n");
     95         goto close;
     96     }
     97     size_t remaining = riffSize - 4;
     98     int hadFmt = 0;
     99     int hadData = 0;
    100     while (remaining >= 8) {
    101         unsigned char chunk[8];
    102         actual = fread(chunk, sizeof(char), sizeof(chunk), stream);
    103         if (actual != sizeof(chunk)) {
    104             fprintf(stderr, "actual %zu != %zu\n", actual, sizeof(chunk));
    105             goto close;
    106         }
    107         remaining -= 8;
    108         unsigned chunkSize = little4u(&chunk[4]);
    109         if (chunkSize > remaining) {
    110             fprintf(stderr, "chunkSize %u > remaining %zu\n", chunkSize, remaining);
    111             goto close;
    112         }
    113         if (!memcmp(&chunk[0], "fmt ", 4)) {
    114             if (hadFmt) {
    115                 fprintf(stderr, "multiple fmt\n");
    116                 goto close;
    117             }
    118             if (chunkSize < 2) {
    119                 fprintf(stderr, "chunkSize %u < 2\n", chunkSize);
    120                 goto close;
    121             }
    122             unsigned char fmt[40];
    123             actual = fread(fmt, sizeof(char), 2, stream);
    124             if (actual != 2) {
    125                 fprintf(stderr, "actual %zu != 2\n", actual);
    126                 goto close;
    127             }
    128             unsigned format = little2u(&fmt[0]);
    129             size_t minSize = 0;
    130             switch (format) {
    131             case WAVE_FORMAT_PCM:
    132             case WAVE_FORMAT_IEEE_FLOAT:
    133                 minSize = 16;
    134                 break;
    135             case WAVE_FORMAT_EXTENSIBLE:
    136                 minSize = 40;
    137                 break;
    138             default:
    139                 fprintf(stderr, "unsupported format %u\n", format);
    140                 goto close;
    141             }
    142             if (chunkSize < minSize) {
    143                 fprintf(stderr, "chunkSize %u < minSize %zu\n", chunkSize, minSize);
    144                 goto close;
    145             }
    146             actual = fread(&fmt[2], sizeof(char), minSize - 2, stream);
    147             if (actual != minSize - 2) {
    148                 fprintf(stderr, "actual %zu != %zu\n", actual, minSize - 16);
    149                 goto close;
    150             }
    151             if (chunkSize > minSize) {
    152                 fseek(stream, (long) (chunkSize - minSize), SEEK_CUR);
    153             }
    154             unsigned channels = little2u(&fmt[2]);
    155             if (channels != 1 && channels != 2 && channels != 4 && channels != 6 && channels != 8) {
    156                 fprintf(stderr, "unsupported channels %u\n", channels);
    157                 goto close;
    158             }
    159             unsigned samplerate = little4u(&fmt[4]);
    160             if (samplerate == 0) {
    161                 fprintf(stderr, "samplerate %u == 0\n", samplerate);
    162                 goto close;
    163             }
    164             // ignore byte rate
    165             // ignore block alignment
    166             unsigned bitsPerSample = little2u(&fmt[14]);
    167             if (bitsPerSample != 8 && bitsPerSample != 16 && bitsPerSample != 32) {
    168                 fprintf(stderr, "bitsPerSample %u != 8 or 16 or 32\n", bitsPerSample);
    169                 goto close;
    170             }
    171             unsigned bytesPerFrame = (bitsPerSample >> 3) * channels;
    172             handle->bytesPerFrame = bytesPerFrame;
    173             handle->info.samplerate = samplerate;
    174             handle->info.channels = channels;
    175             switch (bitsPerSample) {
    176             case 8:
    177                 handle->info.format |= SF_FORMAT_PCM_U8;
    178                 break;
    179             case 16:
    180                 handle->info.format |= SF_FORMAT_PCM_16;
    181                 break;
    182             case 32:
    183                 if (format == WAVE_FORMAT_IEEE_FLOAT)
    184                     handle->info.format |= SF_FORMAT_FLOAT;
    185                 else
    186                     handle->info.format |= SF_FORMAT_PCM_32;
    187                 break;
    188             }
    189             hadFmt = 1;
    190         } else if (!memcmp(&chunk[0], "data", 4)) {
    191             if (!hadFmt) {
    192                 fprintf(stderr, "data not preceded by fmt\n");
    193                 goto close;
    194             }
    195             if (hadData) {
    196                 fprintf(stderr, "multiple data\n");
    197                 goto close;
    198             }
    199             handle->remaining = chunkSize / handle->bytesPerFrame;
    200             handle->info.frames = handle->remaining;
    201             hadData = 1;
    202         } else if (!memcmp(&chunk[0], "fact", 4)) {
    203             // ignore fact
    204             if (chunkSize > 0) {
    205                 fseek(stream, (long) chunkSize, SEEK_CUR);
    206             }
    207         } else {
    208             // ignore unknown chunk
    209             fprintf(stderr, "ignoring unknown chunk %c%c%c%c\n",
    210                     chunk[0], chunk[1], chunk[2], chunk[3]);
    211             if (chunkSize > 0) {
    212                 fseek(stream, (long) chunkSize, SEEK_CUR);
    213             }
    214         }
    215         remaining -= chunkSize;
    216     }
    217     if (remaining > 0) {
    218         fprintf(stderr, "partial chunk at end of RIFF, remaining %zu\n", remaining);
    219         goto close;
    220     }
    221     if (!hadData) {
    222         fprintf(stderr, "missing data\n");
    223         goto close;
    224     }
    225     *info = handle->info;
    226     return handle;
    227 
    228 close:
    229     free(handle);
    230     fclose(stream);
    231     return NULL;
    232 }
    233 
    234 static void write4u(unsigned char *ptr, unsigned u)
    235 {
    236     ptr[0] = u;
    237     ptr[1] = u >> 8;
    238     ptr[2] = u >> 16;
    239     ptr[3] = u >> 24;
    240 }
    241 
    242 static SNDFILE *sf_open_write(const char *path, SF_INFO *info)
    243 {
    244     int sub = info->format & SF_FORMAT_SUBMASK;
    245     if (!(
    246             (info->samplerate > 0) &&
    247             (info->channels > 0 && info->channels <= 8) &&
    248             ((info->format & SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV) &&
    249             (sub == SF_FORMAT_PCM_16 || sub == SF_FORMAT_PCM_U8 || sub == SF_FORMAT_FLOAT)
    250           )) {
    251         return NULL;
    252     }
    253     FILE *stream = fopen(path, "w+b");
    254     if (stream == NULL) {
    255         fprintf(stderr, "fopen %s failed errno %d\n", path, errno);
    256         return NULL;
    257     }
    258     unsigned char wav[58];
    259     memset(wav, 0, sizeof(wav));
    260     memcpy(wav, "RIFF", 4);
    261     memcpy(&wav[8], "WAVEfmt ", 8);
    262     if (sub == SF_FORMAT_FLOAT) {
    263         wav[4] = 50;    // riffSize
    264         wav[16] = 18;   // fmtSize
    265         wav[20] = WAVE_FORMAT_IEEE_FLOAT;
    266     } else {
    267         wav[4] = 36;    // riffSize
    268         wav[16] = 16;   // fmtSize
    269         wav[20] = WAVE_FORMAT_PCM;
    270     }
    271     wav[22] = info->channels;
    272     write4u(&wav[24], info->samplerate);
    273     unsigned bitsPerSample;
    274     switch (sub) {
    275     case SF_FORMAT_PCM_16:
    276         bitsPerSample = 16;
    277         break;
    278     case SF_FORMAT_PCM_U8:
    279         bitsPerSample = 8;
    280         break;
    281     case SF_FORMAT_FLOAT:
    282         bitsPerSample = 32;
    283         break;
    284     default:    // not reachable
    285         bitsPerSample = 0;
    286         break;
    287     }
    288     unsigned blockAlignment = (bitsPerSample >> 3) * info->channels;
    289     unsigned byteRate = info->samplerate * blockAlignment;
    290     write4u(&wav[28], byteRate);
    291     wav[32] = blockAlignment;
    292     wav[34] = bitsPerSample;
    293     size_t extra = 0;
    294     if (sub == SF_FORMAT_FLOAT) {
    295         memcpy(&wav[38], "fact", 4);
    296         wav[42] = 4;
    297         memcpy(&wav[50], "data", 4);
    298         extra = 14;
    299     } else
    300         memcpy(&wav[36], "data", 4);
    301     // dataSize is initially zero
    302     (void) fwrite(wav, 44 + extra, 1, stream);
    303     SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
    304     handle->mode = SFM_WRITE;
    305     handle->temp = NULL;
    306     handle->stream = stream;
    307     handle->bytesPerFrame = blockAlignment;
    308     handle->remaining = 0;
    309     handle->info = *info;
    310     return handle;
    311 }
    312 
    313 SNDFILE *sf_open(const char *path, int mode, SF_INFO *info)
    314 {
    315     if (path == NULL || info == NULL) {
    316         fprintf(stderr, "path=%p info=%p\n", path, info);
    317         return NULL;
    318     }
    319     switch (mode) {
    320     case SFM_READ:
    321         return sf_open_read(path, info);
    322     case SFM_WRITE:
    323         return sf_open_write(path, info);
    324     default:
    325         fprintf(stderr, "mode=%d\n", mode);
    326         return NULL;
    327     }
    328 }
    329 
    330 void sf_close(SNDFILE *handle)
    331 {
    332     if (handle == NULL)
    333         return;
    334     free(handle->temp);
    335     if (handle->mode == SFM_WRITE) {
    336         (void) fflush(handle->stream);
    337         rewind(handle->stream);
    338         unsigned char wav[58];
    339         size_t extra = (handle->info.format & SF_FORMAT_SUBMASK) == SF_FORMAT_FLOAT ? 14 : 0;
    340         (void) fread(wav, 44 + extra, 1, handle->stream);
    341         unsigned dataSize = handle->remaining * handle->bytesPerFrame;
    342         write4u(&wav[4], dataSize + 36 + extra);    // riffSize
    343         write4u(&wav[40 + extra], dataSize);        // dataSize
    344         rewind(handle->stream);
    345         (void) fwrite(wav, 44 + extra, 1, handle->stream);
    346     }
    347     (void) fclose(handle->stream);
    348     free(handle);
    349 }
    350 
    351 sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desiredFrames)
    352 {
    353     if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
    354             desiredFrames <= 0) {
    355         return 0;
    356     }
    357     if (handle->remaining < (size_t) desiredFrames) {
    358         desiredFrames = handle->remaining;
    359     }
    360     // does not check for numeric overflow
    361     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
    362     size_t actualBytes;
    363     void *temp = NULL;
    364     unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
    365     if (format == SF_FORMAT_PCM_32 || format == SF_FORMAT_FLOAT) {
    366         temp = malloc(desiredBytes);
    367         actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
    368     } else {
    369         actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
    370     }
    371     size_t actualFrames = actualBytes / handle->bytesPerFrame;
    372     handle->remaining -= actualFrames;
    373     switch (format) {
    374     case SF_FORMAT_PCM_U8:
    375         memcpy_to_i16_from_u8(ptr, (unsigned char *) ptr, actualFrames * handle->info.channels);
    376         break;
    377     case SF_FORMAT_PCM_16:
    378         if (!isLittleEndian())
    379             my_swab(ptr, actualFrames * handle->info.channels);
    380         break;
    381     case SF_FORMAT_PCM_32:
    382         memcpy_to_i16_from_i32(ptr, (const int *) temp, actualFrames * handle->info.channels);
    383         free(temp);
    384         break;
    385     case SF_FORMAT_FLOAT:
    386         memcpy_to_i16_from_float(ptr, (const float *) temp, actualFrames * handle->info.channels);
    387         free(temp);
    388         break;
    389     default:
    390         memset(ptr, 0, actualFrames * handle->info.channels * sizeof(short));
    391         break;
    392     }
    393     return actualFrames;
    394 }
    395 
    396 sf_count_t sf_readf_float(SNDFILE *handle, float *ptr, sf_count_t desiredFrames)
    397 {
    398     if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
    399             desiredFrames <= 0) {
    400         return 0;
    401     }
    402     if (handle->remaining < (size_t) desiredFrames) {
    403         desiredFrames = handle->remaining;
    404     }
    405     // does not check for numeric overflow
    406     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
    407     size_t actualBytes;
    408     void *temp = NULL;
    409     unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
    410     if (format == SF_FORMAT_PCM_16 || format == SF_FORMAT_PCM_U8) {
    411         temp = malloc(desiredBytes);
    412         actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
    413     } else {
    414         actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
    415     }
    416     size_t actualFrames = actualBytes / handle->bytesPerFrame;
    417     handle->remaining -= actualFrames;
    418     switch (format) {
    419     case SF_FORMAT_PCM_U8:
    420 #if 0
    421         // TODO - implement
    422         memcpy_to_float_from_u8(ptr, (const unsigned char *) temp,
    423                 actualFrames * handle->info.channels);
    424 #endif
    425         free(temp);
    426         break;
    427     case SF_FORMAT_PCM_16:
    428         memcpy_to_float_from_i16(ptr, (const short *) temp, actualFrames * handle->info.channels);
    429         free(temp);
    430         break;
    431     case SF_FORMAT_PCM_32:
    432         memcpy_to_float_from_i32(ptr, (const int *) ptr, actualFrames * handle->info.channels);
    433         break;
    434     case SF_FORMAT_FLOAT:
    435         break;
    436     default:
    437         memset(ptr, 0, actualFrames * handle->info.channels * sizeof(float));
    438         break;
    439     }
    440     return actualFrames;
    441 }
    442 
    443 sf_count_t sf_readf_int(SNDFILE *handle, int *ptr, sf_count_t desiredFrames)
    444 {
    445     if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
    446             desiredFrames <= 0) {
    447         return 0;
    448     }
    449     if (handle->remaining < (size_t) desiredFrames) {
    450         desiredFrames = handle->remaining;
    451     }
    452     // does not check for numeric overflow
    453     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
    454     void *temp = NULL;
    455     unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
    456     size_t actualBytes;
    457     if (format == SF_FORMAT_PCM_16 || format == SF_FORMAT_PCM_U8) {
    458         temp = malloc(desiredBytes);
    459         actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
    460     } else {
    461         actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
    462     }
    463     size_t actualFrames = actualBytes / handle->bytesPerFrame;
    464     handle->remaining -= actualFrames;
    465     switch (format) {
    466     case SF_FORMAT_PCM_U8:
    467 #if 0
    468         // TODO - implement
    469         memcpy_to_i32_from_u8(ptr, (const unsigned char *) temp,
    470                 actualFrames * handle->info.channels);
    471 #endif
    472         free(temp);
    473         break;
    474     case SF_FORMAT_PCM_16:
    475         memcpy_to_i32_from_i16(ptr, (const short *) temp, actualFrames * handle->info.channels);
    476         free(temp);
    477         break;
    478     case SF_FORMAT_PCM_32:
    479         break;
    480     case SF_FORMAT_FLOAT:
    481         memcpy_to_i32_from_float(ptr, (const float *) ptr, actualFrames * handle->info.channels);
    482         break;
    483     default:
    484         memset(ptr, 0, actualFrames * handle->info.channels * sizeof(int));
    485         break;
    486     }
    487     return actualFrames;
    488 }
    489 
    490 sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desiredFrames)
    491 {
    492     if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
    493         return 0;
    494     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
    495     size_t actualBytes = 0;
    496     switch (handle->info.format & SF_FORMAT_SUBMASK) {
    497     case SF_FORMAT_PCM_U8:
    498         handle->temp = realloc(handle->temp, desiredBytes);
    499         memcpy_to_u8_from_i16(handle->temp, ptr, desiredBytes);
    500         actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
    501         break;
    502     case SF_FORMAT_PCM_16:
    503         // does not check for numeric overflow
    504         if (isLittleEndian()) {
    505             actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
    506         } else {
    507             handle->temp = realloc(handle->temp, desiredBytes);
    508             memcpy(handle->temp, ptr, desiredBytes);
    509             my_swab((short *) handle->temp, desiredFrames * handle->info.channels);
    510             actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
    511         }
    512         break;
    513     case SF_FORMAT_FLOAT:
    514         handle->temp = realloc(handle->temp, desiredBytes);
    515         memcpy_to_float_from_i16((float *) handle->temp, ptr,
    516                 desiredFrames * handle->info.channels);
    517         actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
    518         break;
    519     default:
    520         break;
    521     }
    522     size_t actualFrames = actualBytes / handle->bytesPerFrame;
    523     handle->remaining += actualFrames;
    524     return actualFrames;
    525 }
    526 
    527 sf_count_t sf_writef_float(SNDFILE *handle, const float *ptr, sf_count_t desiredFrames)
    528 {
    529     if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
    530         return 0;
    531     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
    532     size_t actualBytes = 0;
    533     switch (handle->info.format & SF_FORMAT_SUBMASK) {
    534     case SF_FORMAT_FLOAT:
    535         actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
    536         break;
    537     case SF_FORMAT_PCM_16:
    538         handle->temp = realloc(handle->temp, desiredBytes);
    539         memcpy_to_i16_from_float((short *) handle->temp, ptr,
    540                 desiredFrames * handle->info.channels);
    541         actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
    542         break;
    543     case SF_FORMAT_PCM_U8:  // transcoding from float to byte not yet implemented
    544     default:
    545         break;
    546     }
    547     size_t actualFrames = actualBytes / handle->bytesPerFrame;
    548     handle->remaining += actualFrames;
    549     return actualFrames;
    550 }
    551