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