src/plugin_common/dither.c

   1 /* plugin_common - Routines common to several plugins
   2  * Copyright (C) 2002,2003  Josh Coalson
   3  *
   4  * dithering routine derived from (other GPLed source):
   5  * mad - MPEG audio decoder
   6  * Copyright (C) 2000-2001 Robert Leslie
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  */
  22
  23 #include "dither.h"
  24 #include "FLAC/assert.h"
  25
  26 #ifdef max
  27 #undef max
  28 #endif
  29 #define max(a,b) ((a)>(b)?(a):(b))
  30
  31
  32 #if defined _MSC_VER
  33 #define FLAC__INLINE __inline
  34 #else
  35 #define FLAC__INLINE
  36 #endif
  37
  38 /* 32-bit pseudo-random number generator */
  39 static FLAC__INLINE FLAC__uint32 prng(FLAC__uint32 state)
  40 {
  41         return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
  42 }
  43
  44 /* dither routine derived from MAD winamp plugin */
  45
  46 typedef struct {
  47         FLAC__int32 error[3];
  48         FLAC__int32 random;
  49 } dither_state;
  50
  51 static FLAC__INLINE FLAC__int32 linear_dither(unsigned source_bps, unsigned target_bps, FLAC__int32 sample, dither_state *dither, const FLAC__int32 MIN, const FLAC__int32 MAX)
  52 {
  53         unsigned scalebits;
  54         FLAC__int32 output, mask, random;
  55
  56         FLAC__ASSERT(source_bps < 32);
  57         FLAC__ASSERT(target_bps <= 24);
  58         FLAC__ASSERT(target_bps <= source_bps);
  59
  60         /* noise shape */
  61         sample += dither->error[0] - dither->error[1] + dither->error[2];
  62
  63         dither->error[2] = dither->error[1];
  64         dither->error[1] = dither->error[0] / 2;
  65
  66         /* bias */
  67         output = sample + (1L << (source_bps - target_bps - 1));
  68
  69         scalebits = source_bps - target_bps;
  70         mask = (1L << scalebits) - 1;
  71
  72         /* dither */
  73         random = (FLAC__int32)prng(dither->random);
  74         output += (random & mask) - (dither->random & mask);
  75
  76         dither->random = random;
  77
  78         /* clip */
  79         if(output > MAX) {
  80                 output = MAX;
  81
  82                 if(sample > MAX)
  83                         sample = MAX;
  84         }
  85         else if(output < MIN) {
  86                 output = MIN;
  87
  88                 if(sample < MIN)
  89                         sample = MIN;
  90         }
  91
  92         /* quantize */
  93         output &= ~mask;
  94
  95         /* error feedback */
  96         dither->error[0] = sample - output;
  97
  98         /* scale */
  99         return output >> scalebits;
 100 }
 101
 102 unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, FLAC__int32 *input, unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps)
 103 {
 104         static dither_state dither[FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS];
 105         FLAC__byte * const start = data;
 106         FLAC__int32 sample;
 107         unsigned samples = wide_samples * channels;
 108         const unsigned bytes_per_sample = target_bps / 8;
 109
 110         FLAC__ASSERT(FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS == 2);
 111         FLAC__ASSERT(channels > 0 && channels <= FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS);
 112         FLAC__ASSERT(source_bps < 32);
 113         FLAC__ASSERT(target_bps <= 24);
 114         FLAC__ASSERT(target_bps <= source_bps);
 115         FLAC__ASSERT((source_bps & 7) == 0);
 116         FLAC__ASSERT((target_bps & 7) == 0);
 117
 118         if(source_bps != target_bps) {
 119                 const FLAC__int32 MIN = -(1L << source_bps);
 120                 const FLAC__int32 MAX = ~MIN; /*(1L << (source_bps-1)) - 1 */
 121                 const unsigned dither_twiggle = channels - 1;
 122                 unsigned dither_source = 0;
 123
 124                 while(samples--) {
 125                         sample = linear_dither(source_bps, target_bps, *input++, &dither[dither_source], MIN, MAX);
 126                         dither_source ^= dither_twiggle;
 127
 128                         switch(target_bps) {
 129                                 case 8:
 130                                         data[0] = sample ^ 0x80;
 131                                         break;
 132                                 case 24:
 133                                         data[2] = (FLAC__byte)(sample >> 16);
 134                                         /* fall through */
 135                                 case 16:
 136                                         data[1] = (FLAC__byte)(sample >> 8);
 137                                         data[0] = (FLAC__byte)sample;
 138                         }
 139
 140                         data += bytes_per_sample;
 141                 }
 142         }
 143         else {
 144                 while(samples--) {
 145                         sample = *input++;
 146
 147                         switch(target_bps) {
 148                                 case 8:
 149                                         data[0] = sample ^ 0x80;
 150                                         break;
 151                                 case 24:
 152                                         data[2] = (FLAC__byte)(sample >> 16);
 153                                         /* fall through */
 154                                 case 16:
 155                                         data[1] = (FLAC__byte)(sample >> 8);
 156                                         data[0] = (FLAC__byte)sample;
 157                         }
 158
 159                         data += bytes_per_sample;
 160                 }
 161         }
 162
 163         return data - start;
 164 }