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  *
  40  * @@@ According to Miroslav, this one is poor quality, the one from the
  41  * @@@ original replaygain code is much better
  42  */
  43 static FLAC__INLINE FLAC__uint32 prng(FLAC__uint32 state)
  44 {
  45         return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
  46 }
  47
  48 /* dither routine derived from MAD winamp plugin */
  49
  50 typedef struct {
  51         FLAC__int32 error[3];
  52         FLAC__int32 random;
  53 } dither_state;
  54
  55 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)
  56 {
  57         unsigned scalebits;
  58         FLAC__int32 output, mask, random;
  59
  60         FLAC__ASSERT(source_bps < 32);
  61         FLAC__ASSERT(target_bps <= 24);
  62         FLAC__ASSERT(target_bps <= source_bps);
  63
  64         /* noise shape */
  65         sample += dither->error[0] - dither->error[1] + dither->error[2];
  66
  67         dither->error[2] = dither->error[1];
  68         dither->error[1] = dither->error[0] / 2;
  69
  70         /* bias */
  71         output = sample + (1L << (source_bps - target_bps - 1));
  72
  73         scalebits = source_bps - target_bps;
  74         mask = (1L << scalebits) - 1;
  75
  76         /* dither */
  77         random = (FLAC__int32)prng(dither->random);
  78         output += (random & mask) - (dither->random & mask);
  79
  80         dither->random = random;
  81
  82         /* clip */
  83         if(output > MAX) {
  84                 output = MAX;
  85
  86                 if(sample > MAX)
  87                         sample = MAX;
  88         }
  89         else if(output < MIN) {
  90                 output = MIN;
  91
  92                 if(sample < MIN)
  93                         sample = MIN;
  94         }
  95
  96         /* quantize */
  97         output &= ~mask;
  98
  99         /* error feedback */
 100         dither->error[0] = sample - output;
 101
 102         /* scale */
 103         return output >> scalebits;
 104 }
 105
 106 unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, const FLAC__int32 * const input[], unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps)
 107 {
 108         static dither_state dither[FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS];
 109         FLAC__byte * const start = data;
 110         FLAC__int32 sample;
 111         const FLAC__int32 *input_;
 112         unsigned samples, channel;
 113         const unsigned bytes_per_sample = target_bps / 8;
 114         unsigned inc = bytes_per_sample * channels;
 115
 116         FLAC__ASSERT(channels > 0 && channels <= FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS);
 117         FLAC__ASSERT(source_bps < 32);
 118         FLAC__ASSERT(target_bps <= 24);
 119         FLAC__ASSERT(target_bps <= source_bps);
 120         FLAC__ASSERT((source_bps & 7) == 0);
 121         FLAC__ASSERT((target_bps & 7) == 0);
 122
 123         if(source_bps != target_bps) {
 124                 const FLAC__int32 MIN = -(1L << (source_bps - 1));
 125                 const FLAC__int32 MAX = ~MIN; /*(1L << (source_bps-1)) - 1 */
 126
 127                 for(channel = 0; channel < channels; channel++) {
 128
 129                         samples = wide_samples;
 130                         data = start + bytes_per_sample * channel;
 131                         input_ = input[channel];
 132
 133                         while(samples--) {
 134                                 sample = linear_dither(source_bps, target_bps, *input_++, &dither[channel], MIN, MAX);
 135
 136                                 switch(target_bps) {
 137                                         case 8:
 138                                                 data[0] = sample ^ 0x80;
 139                                                 break;
 140                                         case 24:
 141                                                 data[2] = (FLAC__byte)(sample >> 16);
 142                                                 /* fall through */
 143                                         case 16:
 144                                                 data[1] = (FLAC__byte)(sample >> 8);
 145                                                 data[0] = (FLAC__byte)sample;
 146                                 }
 147
 148                                 data += inc;
 149                         }
 150                 }
 151         }
 152         else {
 153                 for(channel = 0; channel < channels; channel++) {
 154                         samples = wide_samples;
 155                         data = start + bytes_per_sample * channel;
 156                         input_ = input[channel];
 157
 158                         while(samples--) {
 159                                 sample = *input_++;
 160
 161                                 switch(target_bps) {
 162                                         case 8:
 163                                                 data[0] = sample ^ 0x80;
 164                                                 break;
 165                                         case 24:
 166                                                 data[2] = (FLAC__byte)(sample >> 16);
 167                                                 /* fall through */
 168                                         case 16:
 169                                                 data[1] = (FLAC__byte)(sample >> 8);
 170                                                 data[0] = (FLAC__byte)sample;
 171                                 }
 172
 173                                 data += inc;
 174                         }
 175                 }
 176         }
 177
 178         return data - start;
 179 }