minor comments
[flac.git] / 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 }