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
little2u(unsigned char * ptr)39 static unsigned little2u(unsigned char *ptr)
40 {
41 return (ptr[1] << 8) + ptr[0];
42 }
43
little4u(unsigned char * ptr)44 static unsigned little4u(unsigned char *ptr)
45 {
46 return (ptr[3] << 24) + (ptr[2] << 16) + (ptr[1] << 8) + ptr[0];
47 }
48
isLittleEndian(void)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>
my_swab(short * ptr,size_t numToSwap)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
sf_open_read(const char * path,SF_INFO * info)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_LIMIT)) {
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
write4u(unsigned char * ptr,unsigned u)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
sf_open_write(const char * path,SF_INFO * info)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
sf_open(const char * path,int mode,SF_INFO * info)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
sf_close(SNDFILE * handle)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
sf_readf_short(SNDFILE * handle,short * ptr,sf_count_t desiredFrames)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
sf_readf_float(SNDFILE * handle,float * ptr,sf_count_t desiredFrames)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 memcpy_to_float_from_u8(ptr, (const unsigned char *) temp,
493 actualFrames * handle->info.channels);
494 free(temp);
495 break;
496 case SF_FORMAT_PCM_16:
497 memcpy_to_float_from_i16(ptr, (const short *) temp, actualFrames * handle->info.channels);
498 free(temp);
499 break;
500 case SF_FORMAT_PCM_32:
501 memcpy_to_float_from_i32(ptr, (const int *) ptr, actualFrames * handle->info.channels);
502 break;
503 case SF_FORMAT_FLOAT:
504 break;
505 case SF_FORMAT_PCM_24:
506 memcpy_to_float_from_p24(ptr, (const uint8_t *) temp, actualFrames * handle->info.channels);
507 free(temp);
508 break;
509 default:
510 memset(ptr, 0, actualFrames * handle->info.channels * sizeof(float));
511 break;
512 }
513 return actualFrames;
514 }
515
sf_readf_int(SNDFILE * handle,int * ptr,sf_count_t desiredFrames)516 sf_count_t sf_readf_int(SNDFILE *handle, int *ptr, sf_count_t desiredFrames)
517 {
518 if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
519 desiredFrames <= 0) {
520 return 0;
521 }
522 if (handle->remaining < (size_t) desiredFrames) {
523 desiredFrames = handle->remaining;
524 }
525 // does not check for numeric overflow
526 size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
527 void *temp = NULL;
528 unsigned format = handle->info.format & SF_FORMAT_SUBMASK;
529 size_t actualBytes;
530 if (format == SF_FORMAT_PCM_16 || format == SF_FORMAT_PCM_U8 || format == SF_FORMAT_PCM_24) {
531 temp = malloc(desiredBytes);
532 actualBytes = fread(temp, sizeof(char), desiredBytes, handle->stream);
533 } else {
534 actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
535 }
536 size_t actualFrames = actualBytes / handle->bytesPerFrame;
537 handle->remaining -= actualFrames;
538 switch (format) {
539 case SF_FORMAT_PCM_U8:
540 memcpy_to_i32_from_u8(ptr, (const unsigned char *) temp,
541 actualFrames * handle->info.channels);
542 free(temp);
543 break;
544 case SF_FORMAT_PCM_16:
545 memcpy_to_i32_from_i16(ptr, (const short *) temp, actualFrames * handle->info.channels);
546 free(temp);
547 break;
548 case SF_FORMAT_PCM_32:
549 break;
550 case SF_FORMAT_FLOAT:
551 memcpy_to_i32_from_float(ptr, (const float *) ptr, actualFrames * handle->info.channels);
552 break;
553 case SF_FORMAT_PCM_24:
554 memcpy_to_i32_from_p24(ptr, (const uint8_t *) temp, actualFrames * handle->info.channels);
555 free(temp);
556 break;
557 default:
558 memset(ptr, 0, actualFrames * handle->info.channels * sizeof(int));
559 break;
560 }
561 return actualFrames;
562 }
563
sf_writef_short(SNDFILE * handle,const short * ptr,sf_count_t desiredFrames)564 sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desiredFrames)
565 {
566 if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
567 return 0;
568 size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
569 size_t actualBytes = 0;
570 switch (handle->info.format & SF_FORMAT_SUBMASK) {
571 case SF_FORMAT_PCM_U8:
572 handle->temp = realloc(handle->temp, desiredBytes);
573 memcpy_to_u8_from_i16(handle->temp, ptr, desiredBytes);
574 actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
575 break;
576 case SF_FORMAT_PCM_16:
577 // does not check for numeric overflow
578 if (isLittleEndian()) {
579 actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
580 } else {
581 handle->temp = realloc(handle->temp, desiredBytes);
582 memcpy(handle->temp, ptr, desiredBytes);
583 my_swab((short *) handle->temp, desiredFrames * handle->info.channels);
584 actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
585 }
586 break;
587 case SF_FORMAT_FLOAT:
588 handle->temp = realloc(handle->temp, desiredBytes);
589 memcpy_to_float_from_i16((float *) handle->temp, ptr,
590 desiredFrames * handle->info.channels);
591 actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
592 break;
593 default:
594 break;
595 }
596 size_t actualFrames = actualBytes / handle->bytesPerFrame;
597 handle->remaining += actualFrames;
598 return actualFrames;
599 }
600
sf_writef_float(SNDFILE * handle,const float * ptr,sf_count_t desiredFrames)601 sf_count_t sf_writef_float(SNDFILE *handle, const float *ptr, sf_count_t desiredFrames)
602 {
603 if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
604 return 0;
605 size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
606 size_t actualBytes = 0;
607 switch (handle->info.format & SF_FORMAT_SUBMASK) {
608 case SF_FORMAT_FLOAT:
609 actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
610 break;
611 case SF_FORMAT_PCM_16:
612 handle->temp = realloc(handle->temp, desiredBytes);
613 memcpy_to_i16_from_float((short *) handle->temp, ptr,
614 desiredFrames * handle->info.channels);
615 actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
616 break;
617 case SF_FORMAT_PCM_U8: // transcoding from float to byte not yet implemented
618 default:
619 break;
620 }
621 size_t actualFrames = actualBytes / handle->bytesPerFrame;
622 handle->remaining += actualFrames;
623 return actualFrames;
624 }
625
sf_writef_int(SNDFILE * handle,const int * ptr,sf_count_t desiredFrames)626 sf_count_t sf_writef_int(SNDFILE *handle, const int *ptr, sf_count_t desiredFrames)
627 {
628 if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
629 return 0;
630 size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
631 size_t actualBytes = 0;
632 switch (handle->info.format & SF_FORMAT_SUBMASK) {
633 case SF_FORMAT_PCM_32:
634 actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
635 break;
636 default: // transcoding from other formats not yet implemented
637 break;
638 }
639 size_t actualFrames = actualBytes / handle->bytesPerFrame;
640 handle->remaining += actualFrames;
641 return actualFrames;
642 }
643