1/* 2** Copyright (C) 2003-2011 Erik de Castro Lopo <erikd@mega-nerd.com> 3** 4** This program is free software; you can redistribute it and/or modify 5** it under the terms of the GNU Lesser General Public License as published by 6** the Free Software Foundation; either version 2.1 of the License, or 7** (at your option) any later version. 8** 9** This program is distributed in the hope that it will be useful, 10** but WITHOUT ANY WARRANTY; without even the implied warranty of 11** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12** GNU Lesser General Public License for more details. 13** 14** You should have received a copy of the GNU Lesser General Public License 15** along with this program; if not, write to the Free Software 16** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 17*/ 18 19#include "sfconfig.h" 20 21#include <stdlib.h> 22 23#include "sndfile.h" 24#include "sfendian.h" 25#include "common.h" 26 27/*============================================================================ 28** Rule number 1 is to only apply dither when going from a larger bitwidth 29** to a smaller bitwidth. This can happen on both read and write. 30** 31** Need to apply dither on all conversions marked X below. 32** 33** Dither on write: 34** 35** Input 36** | short int float double 37** --------+----------------------------------------------- 38** O 8 bit | X X X X 39** u 16 bit | none X X X 40** t 24 bit | none X X X 41** p 32 bit | none none X X 42** u float | none none none none 43** t double | none none none none 44** 45** Dither on read: 46** 47** Input 48** O | 8 bit 16 bit 24 bit 32 bit float double 49** u --------+------------------------------------------------- 50** t short | none none X X X X 51** p int | none none none X X X 52** u float | none none none none none none 53** t double | none none none none none none 54*/ 55 56#define SFE_DITHER_BAD_PTR 666 57#define SFE_DITHER_BAD_TYPE 667 58 59typedef struct 60{ int read_short_dither_bits, read_int_dither_bits ; 61 int write_short_dither_bits, write_int_dither_bits ; 62 double read_float_dither_scale, read_double_dither_bits ; 63 double write_float_dither_scale, write_double_dither_bits ; 64 65 sf_count_t (*read_short) (SF_PRIVATE *psf, short *ptr, sf_count_t len) ; 66 sf_count_t (*read_int) (SF_PRIVATE *psf, int *ptr, sf_count_t len) ; 67 sf_count_t (*read_float) (SF_PRIVATE *psf, float *ptr, sf_count_t len) ; 68 sf_count_t (*read_double) (SF_PRIVATE *psf, double *ptr, sf_count_t len) ; 69 70 sf_count_t (*write_short) (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ; 71 sf_count_t (*write_int) (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ; 72 sf_count_t (*write_float) (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ; 73 sf_count_t (*write_double) (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ; 74 75 double buffer [SF_BUFFER_LEN / sizeof (double)] ; 76} DITHER_DATA ; 77 78static sf_count_t dither_read_short (SF_PRIVATE *psf, short *ptr, sf_count_t len) ; 79static sf_count_t dither_read_int (SF_PRIVATE *psf, int *ptr, sf_count_t len) ; 80 81static sf_count_t dither_write_short (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ; 82static sf_count_t dither_write_int (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ; 83static sf_count_t dither_write_float (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ; 84static sf_count_t dither_write_double (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ; 85 86int 87dither_init (SF_PRIVATE *psf, int mode) 88{ DITHER_DATA *pdither ; 89 90 pdither = psf->dither ; /* This may be NULL. */ 91 92 /* Turn off dither on read. */ 93 if (mode == SFM_READ && psf->read_dither.type == SFD_NO_DITHER) 94 { if (pdither == NULL) 95 return 0 ; /* Dither is already off, so just return. */ 96 97 if (pdither->read_short) 98 psf->read_short = pdither->read_short ; 99 if (pdither->read_int) 100 psf->read_int = pdither->read_int ; 101 if (pdither->read_float) 102 psf->read_float = pdither->read_float ; 103 if (pdither->read_double) 104 psf->read_double = pdither->read_double ; 105 return 0 ; 106 } ; 107 108 /* Turn off dither on write. */ 109 if (mode == SFM_WRITE && psf->write_dither.type == SFD_NO_DITHER) 110 { if (pdither == NULL) 111 return 0 ; /* Dither is already off, so just return. */ 112 113 if (pdither->write_short) 114 psf->write_short = pdither->write_short ; 115 if (pdither->write_int) 116 psf->write_int = pdither->write_int ; 117 if (pdither->write_float) 118 psf->write_float = pdither->write_float ; 119 if (pdither->write_double) 120 psf->write_double = pdither->write_double ; 121 return 0 ; 122 } ; 123 124 /* Turn on dither on read if asked. */ 125 if (mode == SFM_READ && psf->read_dither.type != 0) 126 { if (pdither == NULL) 127 pdither = psf->dither = calloc (1, sizeof (DITHER_DATA)) ; 128 if (pdither == NULL) 129 return SFE_MALLOC_FAILED ; 130 131 switch (SF_CODEC (psf->sf.format)) 132 { case SF_FORMAT_DOUBLE : 133 case SF_FORMAT_FLOAT : 134 pdither->read_int = psf->read_int ; 135 psf->read_int = dither_read_int ; 136 break ; 137 138 case SF_FORMAT_PCM_32 : 139 case SF_FORMAT_PCM_24 : 140 case SF_FORMAT_PCM_16 : 141 case SF_FORMAT_PCM_S8 : 142 case SF_FORMAT_PCM_U8 : 143 pdither->read_short = psf->read_short ; 144 psf->read_short = dither_read_short ; 145 break ; 146 147 default : break ; 148 } ; 149 } ; 150 151 /* Turn on dither on write if asked. */ 152 if (mode == SFM_WRITE && psf->write_dither.type != 0) 153 { if (pdither == NULL) 154 pdither = psf->dither = calloc (1, sizeof (DITHER_DATA)) ; 155 if (pdither == NULL) 156 return SFE_MALLOC_FAILED ; 157 158 switch (SF_CODEC (psf->sf.format)) 159 { case SF_FORMAT_DOUBLE : 160 case SF_FORMAT_FLOAT : 161 pdither->write_int = psf->write_int ; 162 psf->write_int = dither_write_int ; 163 break ; 164 165 case SF_FORMAT_PCM_32 : 166 case SF_FORMAT_PCM_24 : 167 case SF_FORMAT_PCM_16 : 168 case SF_FORMAT_PCM_S8 : 169 case SF_FORMAT_PCM_U8 : 170 break ; 171 172 default : break ; 173 } ; 174 175 pdither->write_short = psf->write_short ; 176 psf->write_short = dither_write_short ; 177 178 pdither->write_int = psf->write_int ; 179 psf->write_int = dither_write_int ; 180 181 pdither->write_float = psf->write_float ; 182 psf->write_float = dither_write_float ; 183 184 pdither->write_double = psf->write_double ; 185 psf->write_double = dither_write_double ; 186 } ; 187 188 return 0 ; 189} /* dither_init */ 190 191/*============================================================================== 192*/ 193 194static void dither_short (const short *in, short *out, int frames, int channels) ; 195static void dither_int (const int *in, int *out, int frames, int channels) ; 196 197static void dither_float (const float *in, float *out, int frames, int channels) ; 198static void dither_double (const double *in, double *out, int frames, int channels) ; 199 200static sf_count_t 201dither_read_short (SF_PRIVATE * UNUSED (psf), short * UNUSED (ptr), sf_count_t len) 202{ 203 return len ; 204} /* dither_read_short */ 205 206static sf_count_t 207dither_read_int (SF_PRIVATE * UNUSED (psf), int * UNUSED (ptr), sf_count_t len) 208{ 209 return len ; 210} /* dither_read_int */ 211 212/*------------------------------------------------------------------------------ 213*/ 214 215static sf_count_t 216dither_write_short (SF_PRIVATE *psf, const short *ptr, sf_count_t len) 217{ DITHER_DATA *pdither ; 218 int bufferlen, writecount, thiswrite ; 219 sf_count_t total = 0 ; 220 221 if ((pdither = psf->dither) == NULL) 222 { psf->error = SFE_DITHER_BAD_PTR ; 223 return 0 ; 224 } ; 225 226 switch (SF_CODEC (psf->sf.format)) 227 { case SF_FORMAT_PCM_S8 : 228 case SF_FORMAT_PCM_U8 : 229 case SF_FORMAT_DPCM_8 : 230 break ; 231 232 default : 233 return pdither->write_short (psf, ptr, len) ; 234 } ; 235 236 bufferlen = sizeof (pdither->buffer) / (sizeof (short)) ; 237 238 while (len > 0) 239 { writecount = (len >= bufferlen) ? bufferlen : (int) len ; 240 writecount /= psf->sf.channels ; 241 writecount *= psf->sf.channels ; 242 243 dither_short (ptr, (short*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ; 244 245 thiswrite = (int) pdither->write_short (psf, (short*) pdither->buffer, writecount) ; 246 total += thiswrite ; 247 len -= thiswrite ; 248 if (thiswrite < writecount) 249 break ; 250 } ; 251 252 return total ; 253} /* dither_write_short */ 254 255static sf_count_t 256dither_write_int (SF_PRIVATE *psf, const int *ptr, sf_count_t len) 257{ DITHER_DATA *pdither ; 258 int bufferlen, writecount, thiswrite ; 259 sf_count_t total = 0 ; 260 261 if ((pdither = psf->dither) == NULL) 262 { psf->error = SFE_DITHER_BAD_PTR ; 263 return 0 ; 264 } ; 265 266 switch (SF_CODEC (psf->sf.format)) 267 { case SF_FORMAT_PCM_S8 : 268 case SF_FORMAT_PCM_U8 : 269 case SF_FORMAT_PCM_16 : 270 case SF_FORMAT_PCM_24 : 271 break ; 272 273 case SF_FORMAT_DPCM_8 : 274 case SF_FORMAT_DPCM_16 : 275 break ; 276 277 default : 278 return pdither->write_int (psf, ptr, len) ; 279 } ; 280 281 282 bufferlen = sizeof (pdither->buffer) / (sizeof (int)) ; 283 284 while (len > 0) 285 { writecount = (len >= bufferlen) ? bufferlen : (int) len ; 286 writecount /= psf->sf.channels ; 287 writecount *= psf->sf.channels ; 288 289 dither_int (ptr, (int*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ; 290 291 thiswrite = (int) pdither->write_int (psf, (int*) pdither->buffer, writecount) ; 292 total += thiswrite ; 293 len -= thiswrite ; 294 if (thiswrite < writecount) 295 break ; 296 } ; 297 298 return total ; 299} /* dither_write_int */ 300 301static sf_count_t 302dither_write_float (SF_PRIVATE *psf, const float *ptr, sf_count_t len) 303{ DITHER_DATA *pdither ; 304 int bufferlen, writecount, thiswrite ; 305 sf_count_t total = 0 ; 306 307 if ((pdither = psf->dither) == NULL) 308 { psf->error = SFE_DITHER_BAD_PTR ; 309 return 0 ; 310 } ; 311 312 switch (SF_CODEC (psf->sf.format)) 313 { case SF_FORMAT_PCM_S8 : 314 case SF_FORMAT_PCM_U8 : 315 case SF_FORMAT_PCM_16 : 316 case SF_FORMAT_PCM_24 : 317 break ; 318 319 case SF_FORMAT_DPCM_8 : 320 case SF_FORMAT_DPCM_16 : 321 break ; 322 323 default : 324 return pdither->write_float (psf, ptr, len) ; 325 } ; 326 327 bufferlen = sizeof (pdither->buffer) / (sizeof (float)) ; 328 329 while (len > 0) 330 { writecount = (len >= bufferlen) ? bufferlen : (int) len ; 331 writecount /= psf->sf.channels ; 332 writecount *= psf->sf.channels ; 333 334 dither_float (ptr, (float*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ; 335 336 thiswrite = (int) pdither->write_float (psf, (float*) pdither->buffer, writecount) ; 337 total += thiswrite ; 338 len -= thiswrite ; 339 if (thiswrite < writecount) 340 break ; 341 } ; 342 343 return total ; 344} /* dither_write_float */ 345 346static sf_count_t 347dither_write_double (SF_PRIVATE *psf, const double *ptr, sf_count_t len) 348{ DITHER_DATA *pdither ; 349 int bufferlen, writecount, thiswrite ; 350 sf_count_t total = 0 ; 351 352 if ((pdither = psf->dither) == NULL) 353 { psf->error = SFE_DITHER_BAD_PTR ; 354 return 0 ; 355 } ; 356 357 switch (SF_CODEC (psf->sf.format)) 358 { case SF_FORMAT_PCM_S8 : 359 case SF_FORMAT_PCM_U8 : 360 case SF_FORMAT_PCM_16 : 361 case SF_FORMAT_PCM_24 : 362 break ; 363 364 case SF_FORMAT_DPCM_8 : 365 case SF_FORMAT_DPCM_16 : 366 break ; 367 368 default : 369 return pdither->write_double (psf, ptr, len) ; 370 } ; 371 372 373 bufferlen = sizeof (pdither->buffer) / sizeof (double) ; 374 375 while (len > 0) 376 { writecount = (len >= bufferlen) ? bufferlen : (int) len ; 377 writecount /= psf->sf.channels ; 378 writecount *= psf->sf.channels ; 379 380 dither_double (ptr, (double*) pdither->buffer, writecount / psf->sf.channels, psf->sf.channels) ; 381 382 thiswrite = (int) pdither->write_double (psf, (double*) pdither->buffer, writecount) ; 383 total += thiswrite ; 384 len -= thiswrite ; 385 if (thiswrite < writecount) 386 break ; 387 } ; 388 389 return total ; 390} /* dither_write_double */ 391 392/*============================================================================== 393*/ 394 395static void 396dither_short (const short *in, short *out, int frames, int channels) 397{ int ch, k ; 398 399 for (ch = 0 ; ch < channels ; ch++) 400 for (k = ch ; k < channels * frames ; k += channels) 401 out [k] = in [k] ; 402 403} /* dither_short */ 404 405static void 406dither_int (const int *in, int *out, int frames, int channels) 407{ int ch, k ; 408 409 for (ch = 0 ; ch < channels ; ch++) 410 for (k = ch ; k < channels * frames ; k += channels) 411 out [k] = in [k] ; 412 413} /* dither_int */ 414 415static void 416dither_float (const float *in, float *out, int frames, int channels) 417{ int ch, k ; 418 419 for (ch = 0 ; ch < channels ; ch++) 420 for (k = ch ; k < channels * frames ; k += channels) 421 out [k] = in [k] ; 422 423} /* dither_float */ 424 425static void 426dither_double (const double *in, double *out, int frames, int channels) 427{ int ch, k ; 428 429 for (ch = 0 ; ch < channels ; ch++) 430 for (k = ch ; k < channels * frames ; k += channels) 431 out [k] = in [k] ; 432 433} /* dither_double */ 434 435/*============================================================================== 436*/ 437#if 0 438 439/* 440** Not made public because this (maybe) requires storage of state information. 441** 442** Also maybe need separate state info for each channel!!!! 443*/ 444 445int 446DO_NOT_USE_sf_dither_short (const SF_DITHER_INFO *dither, const short *in, short *out, int frames, int channels) 447{ int ch, k ; 448 449 if (! dither) 450 return SFE_DITHER_BAD_PTR ; 451 452 switch (dither->type & SFD_TYPEMASK) 453 { case SFD_WHITE : 454 case SFD_TRIANGULAR_PDF : 455 for (ch = 0 ; ch < channels ; ch++) 456 for (k = ch ; k < channels * frames ; k += channels) 457 out [k] = in [k] ; 458 break ; 459 460 default : 461 return SFE_DITHER_BAD_TYPE ; 462 } ; 463 464 return 0 ; 465} /* DO_NOT_USE_sf_dither_short */ 466 467int 468DO_NOT_USE_sf_dither_int (const SF_DITHER_INFO *dither, const int *in, int *out, int frames, int channels) 469{ int ch, k ; 470 471 if (! dither) 472 return SFE_DITHER_BAD_PTR ; 473 474 switch (dither->type & SFD_TYPEMASK) 475 { case SFD_WHITE : 476 case SFD_TRIANGULAR_PDF : 477 for (ch = 0 ; ch < channels ; ch++) 478 for (k = ch ; k < channels * frames ; k += channels) 479 out [k] = in [k] ; 480 break ; 481 482 default : 483 return SFE_DITHER_BAD_TYPE ; 484 } ; 485 486 return 0 ; 487} /* DO_NOT_USE_sf_dither_int */ 488 489int 490DO_NOT_USE_sf_dither_float (const SF_DITHER_INFO *dither, const float *in, float *out, int frames, int channels) 491{ int ch, k ; 492 493 if (! dither) 494 return SFE_DITHER_BAD_PTR ; 495 496 switch (dither->type & SFD_TYPEMASK) 497 { case SFD_WHITE : 498 case SFD_TRIANGULAR_PDF : 499 for (ch = 0 ; ch < channels ; ch++) 500 for (k = ch ; k < channels * frames ; k += channels) 501 out [k] = in [k] ; 502 break ; 503 504 default : 505 return SFE_DITHER_BAD_TYPE ; 506 } ; 507 508 return 0 ; 509} /* DO_NOT_USE_sf_dither_float */ 510 511int 512DO_NOT_USE_sf_dither_double (const SF_DITHER_INFO *dither, const double *in, double *out, int frames, int channels) 513{ int ch, k ; 514 515 if (! dither) 516 return SFE_DITHER_BAD_PTR ; 517 518 switch (dither->type & SFD_TYPEMASK) 519 { case SFD_WHITE : 520 case SFD_TRIANGULAR_PDF : 521 for (ch = 0 ; ch < channels ; ch++) 522 for (k = ch ; k < channels * frames ; k += channels) 523 out [k] = in [k] ; 524 break ; 525 526 default : 527 return SFE_DITHER_BAD_TYPE ; 528 } ; 529 530 return 0 ; 531} /* DO_NOT_USE_sf_dither_double */ 532 533#endif 534 535