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 || sub == SF_FORMAT_PCM_32)
 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     case SF_FORMAT_PCM_32:
 347         bitsPerSample = 32;
 348         break;
 349     default:    // not reachable
 350         bitsPerSample = 0;
 351         break;
 352     }
 353     unsigned blockAlignment = (bitsPerSample >> 3) * info->channels;
 354     unsigned byteRate = info->samplerate * blockAlignment;
 355     write4u(&wav[28], byteRate);
 356     wav[32] = blockAlignment;
 357     wav[34] = bitsPerSample;
 358     size_t extra = 0;
 359     if (sub == SF_FORMAT_FLOAT) {
 360         memcpy(&wav[38], "fact", 4);
 361         wav[42] = 4;
 362         memcpy(&wav[50], "data", 4);
 363         extra = 14;
 364     } else
 365         memcpy(&wav[36], "data", 4);
 366     // dataSize is initially zero
 367     (void) fwrite(wav, 44 + extra, 1, stream);
 368     SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
 369     handle->mode = SFM_WRITE;
 370     handle->temp = NULL;
 371     handle->stream = stream;
 372     handle->bytesPerFrame = blockAlignment;
 373     handle->remaining = 0;
 374     handle->info = *info;
 375     return handle;
 376 }
 377
 378 SNDFILE *sf_open(const char *path, int mode, SF_INFO *info)
 379 {
 380     if (path == NULL || info == NULL) {
 381 #ifdef HAVE_STDERR
 382         fprintf(stderr, "path=%p info=%p\n", path, info);
 383 #endif
 384         return NULL;
 385     }
 386     switch (mode) {
 387     case SFM_READ:
 388         return sf_open_read(path, info);
 389     case SFM_WRITE:
 390         return sf_open_write(path, info);
 391     default:
 392 #ifdef HAVE_STDERR
 393         fprintf(stderr, "mode=%d\n", mode);
 394 #endif
 395         return NULL;
 396     }
 397 }
 398
 399 void sf_close(SNDFILE *handle)
 400 {
 401     if (handle == NULL)
 402         return;
 403     free(handle->temp);
 404     if (handle->mode == SFM_WRITE) {
 405         (void) fflush(handle->stream);
 406         rewind(handle->stream);
 407         unsigned char wav[58];
 408         size_t extra = (handle->info.format & SF_FORMAT_SUBMASK) == SF_FORMAT_FLOAT ? 14 : 0;
 409         (void) fread(wav, 44 + extra, 1, handle->stream);
 410         unsigned dataSize = handle->remaining * handle->bytesPerFrame;
 411         write4u(&wav[4], dataSize + 36 + extra);    // riffSize
 412         write4u(&wav[40 + extra], dataSize);        // dataSize
 413         rewind(handle->stream);
 414         (void) fwrite(wav, 44 + extra, 1, handle->stream);
 415     }
 416     (void) fclose(handle->stream);
 417     free(handle);
 418 }
 419
 420 sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desiredFrames)
 421 {
 422     if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
 423             desiredFrames <= 0) {
 424         return 0;
 425     }
 426     if (handle->remaining < (size_t) desiredFrames) {
 427         desiredFrames = handle->remaining;
 428     }
 429     // does not check for numeric overflow
 430     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
 431     size_t actualBytes;
 432     void *temp = NULL;
 433     unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
 434     if (format == SF_FORMAT_PCM_32 || format == SF_FORMAT_FLOAT || format == SF_FORMAT_PCM_24) {
 435         temp = malloc(desiredBytes);
 436         actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
 437     } else {
 438         actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
 439     }
 440     size_t actualFrames = actualBytes / handle->bytesPerFrame;
 441     handle->remaining -= actualFrames;
 442     switch (format) {
 443     case SF_FORMAT_PCM_U8:
 444         memcpy_to_i16_from_u8(ptr, (unsigned char *) ptr, actualFrames * handle->info.channels);
 445         break;
 446     case SF_FORMAT_PCM_16:
 447         if (!isLittleEndian())
 448             my_swab(ptr, actualFrames * handle->info.channels);
 449         break;
 450     case SF_FORMAT_PCM_32:
 451         memcpy_to_i16_from_i32(ptr, (const int *) temp, actualFrames * handle->info.channels);
 452         free(temp);
 453         break;
 454     case SF_FORMAT_FLOAT:
 455         memcpy_to_i16_from_float(ptr, (const float *) temp, actualFrames * handle->info.channels);
 456         free(temp);
 457         break;
 458     case SF_FORMAT_PCM_24:
 459         memcpy_to_i16_from_p24(ptr, (const uint8_t *) temp, actualFrames * handle->info.channels);
 460         free(temp);
 461         break;
 462     default:
 463         memset(ptr, 0, actualFrames * handle->info.channels * sizeof(short));
 464         break;
 465     }
 466     return actualFrames;
 467 }
 468
 469 sf_count_t sf_readf_float(SNDFILE *handle, float *ptr, sf_count_t desiredFrames)
 470 {
 471     if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
 472             desiredFrames <= 0) {
 473         return 0;
 474     }
 475     if (handle->remaining < (size_t) desiredFrames) {
 476         desiredFrames = handle->remaining;
 477     }
 478     // does not check for numeric overflow
 479     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
 480     size_t actualBytes;
 481     void *temp = NULL;
 482     unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
 483     if (format == SF_FORMAT_PCM_16 || format == SF_FORMAT_PCM_U8 || format == SF_FORMAT_PCM_24) {
 484         temp = malloc(desiredBytes);
 485         actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
 486     } else {
 487         actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
 488     }
 489     size_t actualFrames = actualBytes / handle->bytesPerFrame;
 490     handle->remaining -= actualFrames;
 491     switch (format) {
 492     case SF_FORMAT_PCM_U8:
 493 #if 0
 494         // TODO - implement
 495         memcpy_to_float_from_u8(ptr, (const unsigned char *) temp,
 496                 actualFrames * handle->info.channels);
 497 #endif
 498         free(temp);
 499         break;
 500     case SF_FORMAT_PCM_16:
 501         memcpy_to_float_from_i16(ptr, (const short *) temp, actualFrames * handle->info.channels);
 502         free(temp);
 503         break;
 504     case SF_FORMAT_PCM_32:
 505         memcpy_to_float_from_i32(ptr, (const int *) ptr, actualFrames * handle->info.channels);
 506         break;
 507     case SF_FORMAT_FLOAT:
 508         break;
 509     case SF_FORMAT_PCM_24:
 510         memcpy_to_float_from_p24(ptr, (const uint8_t *) temp, actualFrames * handle->info.channels);
 511         free(temp);
 512         break;
 513     default:
 514         memset(ptr, 0, actualFrames * handle->info.channels * sizeof(float));
 515         break;
 516     }
 517     return actualFrames;
 518 }
 519
 520 sf_count_t sf_readf_int(SNDFILE *handle, int *ptr, sf_count_t desiredFrames)
 521 {
 522     if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
 523             desiredFrames <= 0) {
 524         return 0;
 525     }
 526     if (handle->remaining < (size_t) desiredFrames) {
 527         desiredFrames = handle->remaining;
 528     }
 529     // does not check for numeric overflow
 530     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
 531     void *temp = NULL;
 532     unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
 533     size_t actualBytes;
 534     if (format == SF_FORMAT_PCM_16 || format == SF_FORMAT_PCM_U8 || format == SF_FORMAT_PCM_24) {
 535         temp = malloc(desiredBytes);
 536         actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
 537     } else {
 538         actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
 539     }
 540     size_t actualFrames = actualBytes / handle->bytesPerFrame;
 541     handle->remaining -= actualFrames;
 542     switch (format) {
 543     case SF_FORMAT_PCM_U8:
 544 #if 0
 545         // TODO - implement
 546         memcpy_to_i32_from_u8(ptr, (const unsigned char *) temp,
 547                 actualFrames * handle->info.channels);
 548 #endif
 549         free(temp);
 550         break;
 551     case SF_FORMAT_PCM_16:
 552         memcpy_to_i32_from_i16(ptr, (const short *) temp, actualFrames * handle->info.channels);
 553         free(temp);
 554         break;
 555     case SF_FORMAT_PCM_32:
 556         break;
 557     case SF_FORMAT_FLOAT:
 558         memcpy_to_i32_from_float(ptr, (const float *) ptr, actualFrames * handle->info.channels);
 559         break;
 560     case SF_FORMAT_PCM_24:
 561         memcpy_to_i32_from_p24(ptr, (const uint8_t *) temp, actualFrames * handle->info.channels);
 562         free(temp);
 563         break;
 564     default:
 565         memset(ptr, 0, actualFrames * handle->info.channels * sizeof(int));
 566         break;
 567     }
 568     return actualFrames;
 569 }
 570
 571 sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desiredFrames)
 572 {
 573     if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
 574         return 0;
 575     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
 576     size_t actualBytes = 0;
 577     switch (handle->info.format & SF_FORMAT_SUBMASK) {
 578     case SF_FORMAT_PCM_U8:
 579         handle->temp = realloc(handle->temp, desiredBytes);
 580         memcpy_to_u8_from_i16(handle->temp, ptr, desiredBytes);
 581         actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
 582         break;
 583     case SF_FORMAT_PCM_16:
 584         // does not check for numeric overflow
 585         if (isLittleEndian()) {
 586             actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
 587         } else {
 588             handle->temp = realloc(handle->temp, desiredBytes);
 589             memcpy(handle->temp, ptr, desiredBytes);
 590             my_swab((short *) handle->temp, desiredFrames * handle->info.channels);
 591             actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
 592         }
 593         break;
 594     case SF_FORMAT_FLOAT:
 595         handle->temp = realloc(handle->temp, desiredBytes);
 596         memcpy_to_float_from_i16((float *) handle->temp, ptr,
 597                 desiredFrames * handle->info.channels);
 598         actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
 599         break;
 600     default:
 601         break;
 602     }
 603     size_t actualFrames = actualBytes / handle->bytesPerFrame;
 604     handle->remaining += actualFrames;
 605     return actualFrames;
 606 }
 607
 608 sf_count_t sf_writef_float(SNDFILE *handle, const float *ptr, sf_count_t desiredFrames)
 609 {
 610     if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
 611         return 0;
 612     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
 613     size_t actualBytes = 0;
 614     switch (handle->info.format & SF_FORMAT_SUBMASK) {
 615     case SF_FORMAT_FLOAT:
 616         actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
 617         break;
 618     case SF_FORMAT_PCM_16:
 619         handle->temp = realloc(handle->temp, desiredBytes);
 620         memcpy_to_i16_from_float((short *) handle->temp, ptr,
 621                 desiredFrames * handle->info.channels);
 622         actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
 623         break;
 624     case SF_FORMAT_PCM_U8:  // transcoding from float to byte not yet implemented
 625     default:
 626         break;
 627     }
 628     size_t actualFrames = actualBytes / handle->bytesPerFrame;
 629     handle->remaining += actualFrames;
 630     return actualFrames;
 631 }
 632
 633 sf_count_t sf_writef_int(SNDFILE *handle, const int *ptr, sf_count_t desiredFrames)
 634 {
 635     if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
 636         return 0;
 637     size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
 638     size_t actualBytes = 0;
 639     switch (handle->info.format & SF_FORMAT_SUBMASK) {
 640     case SF_FORMAT_PCM_32:
 641         actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
 642         break;
 643     default:    // transcoding from other formats not yet implemented
 644         break;
 645     }
 646     size_t actualFrames = actualBytes / handle->bytesPerFrame;
 647     handle->remaining += actualFrames;
 648     return actualFrames;
 649 }