audio_utils/tinysndfile.c

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