diff options
Diffstat (limited to 'apps/codecs/libFLAC/stream_encoder.c')
-rw-r--r-- | apps/codecs/libFLAC/stream_encoder.c | 3394 |
1 files changed, 3394 insertions, 0 deletions
diff --git a/apps/codecs/libFLAC/stream_encoder.c b/apps/codecs/libFLAC/stream_encoder.c new file mode 100644 index 0000000000..33debfc06a --- /dev/null +++ b/apps/codecs/libFLAC/stream_encoder.c | |||
@@ -0,0 +1,3394 @@ | |||
1 | /* libFLAC - Free Lossless Audio Codec library | ||
2 | * Copyright (C) 2000,2001,2002,2003,2004,2005 Josh Coalson | ||
3 | * | ||
4 | * Redistribution and use in source and binary forms, with or without | ||
5 | * modification, are permitted provided that the following conditions | ||
6 | * are met: | ||
7 | * | ||
8 | * - Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * | ||
11 | * - Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * | ||
15 | * - Neither the name of the Xiph.org Foundation nor the names of its | ||
16 | * contributors may be used to endorse or promote products derived from | ||
17 | * this software without specific prior written permission. | ||
18 | * | ||
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
20 | * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
22 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR | ||
23 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
24 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
25 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
26 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
27 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
28 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
29 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
30 | */ | ||
31 | |||
32 | #include <limits.h> | ||
33 | #include <stdio.h> | ||
34 | #include <stdlib.h> /* for malloc() */ | ||
35 | #include <string.h> /* for memcpy() */ | ||
36 | #include "FLAC/assert.h" | ||
37 | #include "FLAC/stream_decoder.h" | ||
38 | #include "protected/stream_encoder.h" | ||
39 | #include "private/bitbuffer.h" | ||
40 | #include "private/bitmath.h" | ||
41 | #include "private/crc.h" | ||
42 | #include "private/cpu.h" | ||
43 | #include "private/fixed.h" | ||
44 | #include "private/format.h" | ||
45 | #include "private/lpc.h" | ||
46 | #include "private/md5.h" | ||
47 | #include "private/memory.h" | ||
48 | #include "private/stream_encoder_framing.h" | ||
49 | |||
50 | #ifdef HAVE_CONFIG_H | ||
51 | #include <config.h> | ||
52 | #endif | ||
53 | |||
54 | #ifdef min | ||
55 | #undef min | ||
56 | #endif | ||
57 | #define min(x,y) ((x)<(y)?(x):(y)) | ||
58 | |||
59 | #ifdef max | ||
60 | #undef max | ||
61 | #endif | ||
62 | #define max(x,y) ((x)>(y)?(x):(y)) | ||
63 | |||
64 | typedef struct { | ||
65 | FLAC__int32 *data[FLAC__MAX_CHANNELS]; | ||
66 | unsigned size; /* of each data[] in samples */ | ||
67 | unsigned tail; | ||
68 | } verify_input_fifo; | ||
69 | |||
70 | typedef struct { | ||
71 | const FLAC__byte *data; | ||
72 | unsigned capacity; | ||
73 | unsigned bytes; | ||
74 | } verify_output; | ||
75 | |||
76 | typedef enum { | ||
77 | ENCODER_IN_MAGIC = 0, | ||
78 | ENCODER_IN_METADATA = 1, | ||
79 | ENCODER_IN_AUDIO = 2 | ||
80 | } EncoderStateHint; | ||
81 | |||
82 | /*********************************************************************** | ||
83 | * | ||
84 | * Private class method prototypes | ||
85 | * | ||
86 | ***********************************************************************/ | ||
87 | |||
88 | static void set_defaults_(FLAC__StreamEncoder *encoder); | ||
89 | static void free_(FLAC__StreamEncoder *encoder); | ||
90 | static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size); | ||
91 | static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples); | ||
92 | static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame); | ||
93 | static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame); | ||
94 | |||
95 | static FLAC__bool process_subframe_( | ||
96 | FLAC__StreamEncoder *encoder, | ||
97 | unsigned min_partition_order, | ||
98 | unsigned max_partition_order, | ||
99 | FLAC__bool precompute_partition_sums, | ||
100 | const FLAC__FrameHeader *frame_header, | ||
101 | unsigned subframe_bps, | ||
102 | const FLAC__int32 integer_signal[], | ||
103 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
104 | const FLAC__real real_signal[], | ||
105 | #endif | ||
106 | FLAC__Subframe *subframe[2], | ||
107 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2], | ||
108 | FLAC__int32 *residual[2], | ||
109 | unsigned *best_subframe, | ||
110 | unsigned *best_bits | ||
111 | ); | ||
112 | |||
113 | static FLAC__bool add_subframe_( | ||
114 | FLAC__StreamEncoder *encoder, | ||
115 | const FLAC__FrameHeader *frame_header, | ||
116 | unsigned subframe_bps, | ||
117 | const FLAC__Subframe *subframe, | ||
118 | FLAC__BitBuffer *frame | ||
119 | ); | ||
120 | |||
121 | static unsigned evaluate_constant_subframe_( | ||
122 | const FLAC__int32 signal, | ||
123 | unsigned subframe_bps, | ||
124 | FLAC__Subframe *subframe | ||
125 | ); | ||
126 | |||
127 | static unsigned evaluate_fixed_subframe_( | ||
128 | FLAC__StreamEncoder *encoder, | ||
129 | const FLAC__int32 signal[], | ||
130 | FLAC__int32 residual[], | ||
131 | FLAC__uint32 abs_residual[], | ||
132 | FLAC__uint64 abs_residual_partition_sums[], | ||
133 | unsigned raw_bits_per_partition[], | ||
134 | unsigned blocksize, | ||
135 | unsigned subframe_bps, | ||
136 | unsigned order, | ||
137 | unsigned rice_parameter, | ||
138 | unsigned min_partition_order, | ||
139 | unsigned max_partition_order, | ||
140 | FLAC__bool precompute_partition_sums, | ||
141 | FLAC__bool do_escape_coding, | ||
142 | unsigned rice_parameter_search_dist, | ||
143 | FLAC__Subframe *subframe, | ||
144 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents | ||
145 | ); | ||
146 | |||
147 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
148 | static unsigned evaluate_lpc_subframe_( | ||
149 | FLAC__StreamEncoder *encoder, | ||
150 | const FLAC__int32 signal[], | ||
151 | FLAC__int32 residual[], | ||
152 | FLAC__uint32 abs_residual[], | ||
153 | FLAC__uint64 abs_residual_partition_sums[], | ||
154 | unsigned raw_bits_per_partition[], | ||
155 | const FLAC__real lp_coeff[], | ||
156 | unsigned blocksize, | ||
157 | unsigned subframe_bps, | ||
158 | unsigned order, | ||
159 | unsigned qlp_coeff_precision, | ||
160 | unsigned rice_parameter, | ||
161 | unsigned min_partition_order, | ||
162 | unsigned max_partition_order, | ||
163 | FLAC__bool precompute_partition_sums, | ||
164 | FLAC__bool do_escape_coding, | ||
165 | unsigned rice_parameter_search_dist, | ||
166 | FLAC__Subframe *subframe, | ||
167 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents | ||
168 | ); | ||
169 | #endif | ||
170 | |||
171 | static unsigned evaluate_verbatim_subframe_( | ||
172 | const FLAC__int32 signal[], | ||
173 | unsigned blocksize, | ||
174 | unsigned subframe_bps, | ||
175 | FLAC__Subframe *subframe | ||
176 | ); | ||
177 | |||
178 | static unsigned find_best_partition_order_( | ||
179 | struct FLAC__StreamEncoderPrivate *private_, | ||
180 | const FLAC__int32 residual[], | ||
181 | FLAC__uint32 abs_residual[], | ||
182 | FLAC__uint64 abs_residual_partition_sums[], | ||
183 | unsigned raw_bits_per_partition[], | ||
184 | unsigned residual_samples, | ||
185 | unsigned predictor_order, | ||
186 | unsigned rice_parameter, | ||
187 | unsigned min_partition_order, | ||
188 | unsigned max_partition_order, | ||
189 | FLAC__bool precompute_partition_sums, | ||
190 | FLAC__bool do_escape_coding, | ||
191 | unsigned rice_parameter_search_dist, | ||
192 | FLAC__EntropyCodingMethod_PartitionedRice *best_partitioned_rice | ||
193 | ); | ||
194 | |||
195 | static void precompute_partition_info_sums_( | ||
196 | const FLAC__uint32 abs_residual[], | ||
197 | FLAC__uint64 abs_residual_partition_sums[], | ||
198 | unsigned residual_samples, | ||
199 | unsigned predictor_order, | ||
200 | unsigned min_partition_order, | ||
201 | unsigned max_partition_order | ||
202 | ); | ||
203 | |||
204 | static void precompute_partition_info_escapes_( | ||
205 | const FLAC__int32 residual[], | ||
206 | unsigned raw_bits_per_partition[], | ||
207 | unsigned residual_samples, | ||
208 | unsigned predictor_order, | ||
209 | unsigned min_partition_order, | ||
210 | unsigned max_partition_order | ||
211 | ); | ||
212 | |||
213 | #ifdef DONT_ESTIMATE_RICE_BITS | ||
214 | static FLAC__bool set_partitioned_rice_( | ||
215 | const FLAC__uint32 abs_residual[], | ||
216 | const FLAC__int32 residual[], | ||
217 | const unsigned residual_samples, | ||
218 | const unsigned predictor_order, | ||
219 | const unsigned suggested_rice_parameter, | ||
220 | const unsigned rice_parameter_search_dist, | ||
221 | const unsigned partition_order, | ||
222 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
223 | unsigned *bits | ||
224 | ); | ||
225 | |||
226 | static FLAC__bool set_partitioned_rice_with_precompute_( | ||
227 | const FLAC__int32 residual[], | ||
228 | const FLAC__uint64 abs_residual_partition_sums[], | ||
229 | const unsigned raw_bits_per_partition[], | ||
230 | const unsigned residual_samples, | ||
231 | const unsigned predictor_order, | ||
232 | const unsigned suggested_rice_parameter, | ||
233 | const unsigned rice_parameter_search_dist, | ||
234 | const unsigned partition_order, | ||
235 | const FLAC__bool search_for_escapes, | ||
236 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
237 | unsigned *bits | ||
238 | ); | ||
239 | #else | ||
240 | static FLAC__bool set_partitioned_rice_( | ||
241 | const FLAC__uint32 abs_residual[], | ||
242 | const unsigned residual_samples, | ||
243 | const unsigned predictor_order, | ||
244 | const unsigned suggested_rice_parameter, | ||
245 | const unsigned rice_parameter_search_dist, | ||
246 | const unsigned partition_order, | ||
247 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
248 | unsigned *bits | ||
249 | ); | ||
250 | |||
251 | static FLAC__bool set_partitioned_rice_with_precompute_( | ||
252 | const FLAC__uint32 abs_residual[], | ||
253 | const FLAC__uint64 abs_residual_partition_sums[], | ||
254 | const unsigned raw_bits_per_partition[], | ||
255 | const unsigned residual_samples, | ||
256 | const unsigned predictor_order, | ||
257 | const unsigned suggested_rice_parameter, | ||
258 | const unsigned rice_parameter_search_dist, | ||
259 | const unsigned partition_order, | ||
260 | const FLAC__bool search_for_escapes, | ||
261 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
262 | unsigned *bits | ||
263 | ); | ||
264 | #endif | ||
265 | |||
266 | static unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples); | ||
267 | |||
268 | /* verify-related routines: */ | ||
269 | static void append_to_verify_fifo_( | ||
270 | verify_input_fifo *fifo, | ||
271 | const FLAC__int32 * const input[], | ||
272 | unsigned input_offset, | ||
273 | unsigned channels, | ||
274 | unsigned wide_samples | ||
275 | ); | ||
276 | |||
277 | static void append_to_verify_fifo_interleaved_( | ||
278 | verify_input_fifo *fifo, | ||
279 | const FLAC__int32 input[], | ||
280 | unsigned input_offset, | ||
281 | unsigned channels, | ||
282 | unsigned wide_samples | ||
283 | ); | ||
284 | |||
285 | static FLAC__StreamDecoderReadStatus verify_read_callback_( | ||
286 | const FLAC__StreamDecoder *decoder, | ||
287 | FLAC__byte buffer[], | ||
288 | unsigned *bytes, | ||
289 | void *client_data | ||
290 | ); | ||
291 | |||
292 | static FLAC__StreamDecoderWriteStatus verify_write_callback_( | ||
293 | const FLAC__StreamDecoder *decoder, | ||
294 | const FLAC__Frame *frame, | ||
295 | const FLAC__int32 * const buffer[], | ||
296 | void *client_data | ||
297 | ); | ||
298 | |||
299 | static void verify_metadata_callback_( | ||
300 | const FLAC__StreamDecoder *decoder, | ||
301 | const FLAC__StreamMetadata *metadata, | ||
302 | void *client_data | ||
303 | ); | ||
304 | |||
305 | static void verify_error_callback_( | ||
306 | const FLAC__StreamDecoder *decoder, | ||
307 | FLAC__StreamDecoderErrorStatus status, | ||
308 | void *client_data | ||
309 | ); | ||
310 | |||
311 | |||
312 | /*********************************************************************** | ||
313 | * | ||
314 | * Private class data | ||
315 | * | ||
316 | ***********************************************************************/ | ||
317 | |||
318 | typedef struct FLAC__StreamEncoderPrivate { | ||
319 | unsigned input_capacity; /* current size (in samples) of the signal and residual buffers */ | ||
320 | FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS]; /* the integer version of the input signal */ | ||
321 | FLAC__int32 *integer_signal_mid_side[2]; /* the integer version of the mid-side input signal (stereo only) */ | ||
322 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
323 | FLAC__real *real_signal[FLAC__MAX_CHANNELS]; /* the floating-point version of the input signal */ | ||
324 | FLAC__real *real_signal_mid_side[2]; /* the floating-point version of the mid-side input signal (stereo only) */ | ||
325 | #endif | ||
326 | unsigned subframe_bps[FLAC__MAX_CHANNELS]; /* the effective bits per sample of the input signal (stream bps - wasted bits) */ | ||
327 | unsigned subframe_bps_mid_side[2]; /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */ | ||
328 | FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */ | ||
329 | FLAC__int32 *residual_workspace_mid_side[2][2]; | ||
330 | FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2]; | ||
331 | FLAC__Subframe subframe_workspace_mid_side[2][2]; | ||
332 | FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2]; | ||
333 | FLAC__Subframe *subframe_workspace_ptr_mid_side[2][2]; | ||
334 | FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace[FLAC__MAX_CHANNELS][2]; | ||
335 | FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace_mid_side[FLAC__MAX_CHANNELS][2]; | ||
336 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr[FLAC__MAX_CHANNELS][2]; | ||
337 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr_mid_side[FLAC__MAX_CHANNELS][2]; | ||
338 | unsigned best_subframe[FLAC__MAX_CHANNELS]; /* index into the above workspaces */ | ||
339 | unsigned best_subframe_mid_side[2]; | ||
340 | unsigned best_subframe_bits[FLAC__MAX_CHANNELS]; /* size in bits of the best subframe for each channel */ | ||
341 | unsigned best_subframe_bits_mid_side[2]; | ||
342 | FLAC__uint32 *abs_residual; /* workspace where abs(candidate residual) is stored */ | ||
343 | FLAC__uint64 *abs_residual_partition_sums; /* workspace where the sum of abs(candidate residual) for each partition is stored */ | ||
344 | unsigned *raw_bits_per_partition; /* workspace where the sum of silog2(candidate residual) for each partition is stored */ | ||
345 | FLAC__BitBuffer *frame; /* the current frame being worked on */ | ||
346 | unsigned loose_mid_side_stereo_frames; /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */ | ||
347 | unsigned loose_mid_side_stereo_frame_count; /* number of frames using the current channel assignment */ | ||
348 | FLAC__ChannelAssignment last_channel_assignment; | ||
349 | FLAC__StreamMetadata metadata; | ||
350 | unsigned current_sample_number; | ||
351 | unsigned current_frame_number; | ||
352 | struct FLAC__MD5Context md5context; | ||
353 | FLAC__CPUInfo cpuinfo; | ||
354 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
355 | unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]); | ||
356 | #else | ||
357 | unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]); | ||
358 | #endif | ||
359 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
360 | void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); | ||
361 | void (*local_lpc_compute_residual_from_qlp_coefficients)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]); | ||
362 | void (*local_lpc_compute_residual_from_qlp_coefficients_64bit)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]); | ||
363 | void (*local_lpc_compute_residual_from_qlp_coefficients_16bit)(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]); | ||
364 | #endif | ||
365 | FLAC__bool use_wide_by_block; /* use slow 64-bit versions of some functions because of the block size */ | ||
366 | FLAC__bool use_wide_by_partition; /* use slow 64-bit versions of some functions because of the min partition order and blocksize */ | ||
367 | FLAC__bool use_wide_by_order; /* use slow 64-bit versions of some functions because of the lpc order */ | ||
368 | FLAC__bool precompute_partition_sums; /* our initial guess as to whether precomputing the partitions sums will be a speed improvement */ | ||
369 | FLAC__bool disable_constant_subframes; | ||
370 | FLAC__bool disable_fixed_subframes; | ||
371 | FLAC__bool disable_verbatim_subframes; | ||
372 | FLAC__StreamEncoderWriteCallback write_callback; | ||
373 | FLAC__StreamEncoderMetadataCallback metadata_callback; | ||
374 | void *client_data; | ||
375 | /* unaligned (original) pointers to allocated data */ | ||
376 | FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS]; | ||
377 | FLAC__int32 *integer_signal_mid_side_unaligned[2]; | ||
378 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
379 | FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS]; | ||
380 | FLAC__real *real_signal_mid_side_unaligned[2]; | ||
381 | #endif | ||
382 | FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2]; | ||
383 | FLAC__int32 *residual_workspace_mid_side_unaligned[2][2]; | ||
384 | FLAC__uint32 *abs_residual_unaligned; | ||
385 | FLAC__uint64 *abs_residual_partition_sums_unaligned; | ||
386 | unsigned *raw_bits_per_partition_unaligned; | ||
387 | /* | ||
388 | * These fields have been moved here from private function local | ||
389 | * declarations merely to save stack space during encoding. | ||
390 | */ | ||
391 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
392 | FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER]; /* from process_subframe_() */ | ||
393 | #endif | ||
394 | FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_extra[2]; /* from find_best_partition_order_() */ | ||
395 | /* | ||
396 | * The data for the verify section | ||
397 | */ | ||
398 | struct { | ||
399 | FLAC__StreamDecoder *decoder; | ||
400 | EncoderStateHint state_hint; | ||
401 | FLAC__bool needs_magic_hack; | ||
402 | verify_input_fifo input_fifo; | ||
403 | verify_output output; | ||
404 | struct { | ||
405 | FLAC__uint64 absolute_sample; | ||
406 | unsigned frame_number; | ||
407 | unsigned channel; | ||
408 | unsigned sample; | ||
409 | FLAC__int32 expected; | ||
410 | FLAC__int32 got; | ||
411 | } error_stats; | ||
412 | } verify; | ||
413 | FLAC__bool is_being_deleted; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */ | ||
414 | } FLAC__StreamEncoderPrivate; | ||
415 | |||
416 | /*********************************************************************** | ||
417 | * | ||
418 | * Public static class data | ||
419 | * | ||
420 | ***********************************************************************/ | ||
421 | |||
422 | FLAC_API const char * const FLAC__StreamEncoderStateString[] = { | ||
423 | "FLAC__STREAM_ENCODER_OK", | ||
424 | "FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR", | ||
425 | "FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA", | ||
426 | "FLAC__STREAM_ENCODER_INVALID_CALLBACK", | ||
427 | "FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS", | ||
428 | "FLAC__STREAM_ENCODER_INVALID_BITS_PER_SAMPLE", | ||
429 | "FLAC__STREAM_ENCODER_INVALID_SAMPLE_RATE", | ||
430 | "FLAC__STREAM_ENCODER_INVALID_BLOCK_SIZE", | ||
431 | "FLAC__STREAM_ENCODER_INVALID_MAX_LPC_ORDER", | ||
432 | "FLAC__STREAM_ENCODER_INVALID_QLP_COEFF_PRECISION", | ||
433 | "FLAC__STREAM_ENCODER_MID_SIDE_CHANNELS_MISMATCH", | ||
434 | "FLAC__STREAM_ENCODER_MID_SIDE_SAMPLE_SIZE_MISMATCH", | ||
435 | "FLAC__STREAM_ENCODER_ILLEGAL_MID_SIDE_FORCE", | ||
436 | "FLAC__STREAM_ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER", | ||
437 | "FLAC__STREAM_ENCODER_NOT_STREAMABLE", | ||
438 | "FLAC__STREAM_ENCODER_FRAMING_ERROR", | ||
439 | "FLAC__STREAM_ENCODER_INVALID_METADATA", | ||
440 | "FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING", | ||
441 | "FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_WRITING", | ||
442 | "FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR", | ||
443 | "FLAC__STREAM_ENCODER_ALREADY_INITIALIZED", | ||
444 | "FLAC__STREAM_ENCODER_UNINITIALIZED" | ||
445 | }; | ||
446 | |||
447 | FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[] = { | ||
448 | "FLAC__STREAM_ENCODER_WRITE_STATUS_OK", | ||
449 | "FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR" | ||
450 | }; | ||
451 | |||
452 | /*********************************************************************** | ||
453 | * | ||
454 | * Class constructor/destructor | ||
455 | * | ||
456 | */ | ||
457 | FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new() | ||
458 | { | ||
459 | FLAC__StreamEncoder *encoder; | ||
460 | unsigned i; | ||
461 | |||
462 | FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ | ||
463 | |||
464 | encoder = (FLAC__StreamEncoder*)calloc(1, sizeof(FLAC__StreamEncoder)); | ||
465 | if(encoder == 0) { | ||
466 | return 0; | ||
467 | } | ||
468 | |||
469 | encoder->protected_ = (FLAC__StreamEncoderProtected*)calloc(1, sizeof(FLAC__StreamEncoderProtected)); | ||
470 | if(encoder->protected_ == 0) { | ||
471 | free(encoder); | ||
472 | return 0; | ||
473 | } | ||
474 | |||
475 | encoder->private_ = (FLAC__StreamEncoderPrivate*)calloc(1, sizeof(FLAC__StreamEncoderPrivate)); | ||
476 | if(encoder->private_ == 0) { | ||
477 | free(encoder->protected_); | ||
478 | free(encoder); | ||
479 | return 0; | ||
480 | } | ||
481 | |||
482 | encoder->private_->frame = FLAC__bitbuffer_new(); | ||
483 | if(encoder->private_->frame == 0) { | ||
484 | free(encoder->private_); | ||
485 | free(encoder->protected_); | ||
486 | free(encoder); | ||
487 | return 0; | ||
488 | } | ||
489 | |||
490 | set_defaults_(encoder); | ||
491 | |||
492 | encoder->private_->is_being_deleted = false; | ||
493 | |||
494 | for(i = 0; i < FLAC__MAX_CHANNELS; i++) { | ||
495 | encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0]; | ||
496 | encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1]; | ||
497 | } | ||
498 | for(i = 0; i < 2; i++) { | ||
499 | encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0]; | ||
500 | encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1]; | ||
501 | } | ||
502 | for(i = 0; i < FLAC__MAX_CHANNELS; i++) { | ||
503 | encoder->private_->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_contents_workspace[i][0]; | ||
504 | encoder->private_->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_contents_workspace[i][1]; | ||
505 | } | ||
506 | for(i = 0; i < 2; i++) { | ||
507 | encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]; | ||
508 | encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]; | ||
509 | } | ||
510 | |||
511 | for(i = 0; i < FLAC__MAX_CHANNELS; i++) { | ||
512 | FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][0]); | ||
513 | FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][1]); | ||
514 | } | ||
515 | for(i = 0; i < 2; i++) { | ||
516 | FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]); | ||
517 | FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]); | ||
518 | } | ||
519 | for(i = 0; i < 2; i++) | ||
520 | FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]); | ||
521 | |||
522 | encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; | ||
523 | |||
524 | return encoder; | ||
525 | } | ||
526 | |||
527 | FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder) | ||
528 | { | ||
529 | unsigned i; | ||
530 | |||
531 | FLAC__ASSERT(0 != encoder); | ||
532 | FLAC__ASSERT(0 != encoder->protected_); | ||
533 | FLAC__ASSERT(0 != encoder->private_); | ||
534 | FLAC__ASSERT(0 != encoder->private_->frame); | ||
535 | |||
536 | encoder->private_->is_being_deleted = true; | ||
537 | |||
538 | FLAC__stream_encoder_finish(encoder); | ||
539 | |||
540 | if(0 != encoder->private_->verify.decoder) | ||
541 | FLAC__stream_decoder_delete(encoder->private_->verify.decoder); | ||
542 | |||
543 | for(i = 0; i < FLAC__MAX_CHANNELS; i++) { | ||
544 | FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][0]); | ||
545 | FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][1]); | ||
546 | } | ||
547 | for(i = 0; i < 2; i++) { | ||
548 | FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]); | ||
549 | FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]); | ||
550 | } | ||
551 | for(i = 0; i < 2; i++) | ||
552 | FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]); | ||
553 | |||
554 | FLAC__bitbuffer_delete(encoder->private_->frame); | ||
555 | free(encoder->private_); | ||
556 | free(encoder->protected_); | ||
557 | free(encoder); | ||
558 | } | ||
559 | |||
560 | /*********************************************************************** | ||
561 | * | ||
562 | * Public class methods | ||
563 | * | ||
564 | ***********************************************************************/ | ||
565 | |||
566 | FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_init(FLAC__StreamEncoder *encoder) | ||
567 | { | ||
568 | unsigned i; | ||
569 | FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment; | ||
570 | |||
571 | FLAC__ASSERT(0 != encoder); | ||
572 | |||
573 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
574 | return encoder->protected_->state = FLAC__STREAM_ENCODER_ALREADY_INITIALIZED; | ||
575 | |||
576 | encoder->protected_->state = FLAC__STREAM_ENCODER_OK; | ||
577 | |||
578 | if(0 == encoder->private_->write_callback || 0 == encoder->private_->metadata_callback) | ||
579 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_CALLBACK; | ||
580 | |||
581 | if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS) | ||
582 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_NUMBER_OF_CHANNELS; | ||
583 | |||
584 | if(encoder->protected_->do_mid_side_stereo && encoder->protected_->channels != 2) | ||
585 | return encoder->protected_->state = FLAC__STREAM_ENCODER_MID_SIDE_CHANNELS_MISMATCH; | ||
586 | |||
587 | if(encoder->protected_->loose_mid_side_stereo && !encoder->protected_->do_mid_side_stereo) | ||
588 | return encoder->protected_->state = FLAC__STREAM_ENCODER_ILLEGAL_MID_SIDE_FORCE; | ||
589 | |||
590 | if(encoder->protected_->bits_per_sample >= 32) | ||
591 | encoder->protected_->do_mid_side_stereo = false; /* since we do 32-bit math, the side channel would have 33 bps and overflow */ | ||
592 | |||
593 | if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE) | ||
594 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_BITS_PER_SAMPLE; | ||
595 | |||
596 | if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate)) | ||
597 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_SAMPLE_RATE; | ||
598 | |||
599 | if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE) | ||
600 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_BLOCK_SIZE; | ||
601 | |||
602 | if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER) | ||
603 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_MAX_LPC_ORDER; | ||
604 | |||
605 | if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order) | ||
606 | return encoder->protected_->state = FLAC__STREAM_ENCODER_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER; | ||
607 | |||
608 | if(encoder->protected_->qlp_coeff_precision == 0) { | ||
609 | if(encoder->protected_->bits_per_sample < 16) { | ||
610 | /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */ | ||
611 | /* @@@ until then we'll make a guess */ | ||
612 | encoder->protected_->qlp_coeff_precision = max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2); | ||
613 | } | ||
614 | else if(encoder->protected_->bits_per_sample == 16) { | ||
615 | if(encoder->protected_->blocksize <= 192) | ||
616 | encoder->protected_->qlp_coeff_precision = 7; | ||
617 | else if(encoder->protected_->blocksize <= 384) | ||
618 | encoder->protected_->qlp_coeff_precision = 8; | ||
619 | else if(encoder->protected_->blocksize <= 576) | ||
620 | encoder->protected_->qlp_coeff_precision = 9; | ||
621 | else if(encoder->protected_->blocksize <= 1152) | ||
622 | encoder->protected_->qlp_coeff_precision = 10; | ||
623 | else if(encoder->protected_->blocksize <= 2304) | ||
624 | encoder->protected_->qlp_coeff_precision = 11; | ||
625 | else if(encoder->protected_->blocksize <= 4608) | ||
626 | encoder->protected_->qlp_coeff_precision = 12; | ||
627 | else | ||
628 | encoder->protected_->qlp_coeff_precision = 13; | ||
629 | } | ||
630 | else { | ||
631 | if(encoder->protected_->blocksize <= 384) | ||
632 | encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2; | ||
633 | else if(encoder->protected_->blocksize <= 1152) | ||
634 | encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1; | ||
635 | else | ||
636 | encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; | ||
637 | } | ||
638 | FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION); | ||
639 | } | ||
640 | else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION) | ||
641 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_QLP_COEFF_PRECISION; | ||
642 | |||
643 | if(encoder->protected_->streamable_subset) { | ||
644 | if( | ||
645 | encoder->protected_->blocksize != 192 && | ||
646 | encoder->protected_->blocksize != 576 && | ||
647 | encoder->protected_->blocksize != 1152 && | ||
648 | encoder->protected_->blocksize != 2304 && | ||
649 | encoder->protected_->blocksize != 4608 && | ||
650 | encoder->protected_->blocksize != 256 && | ||
651 | encoder->protected_->blocksize != 512 && | ||
652 | encoder->protected_->blocksize != 1024 && | ||
653 | encoder->protected_->blocksize != 2048 && | ||
654 | encoder->protected_->blocksize != 4096 && | ||
655 | encoder->protected_->blocksize != 8192 && | ||
656 | encoder->protected_->blocksize != 16384 | ||
657 | ) | ||
658 | return encoder->protected_->state = FLAC__STREAM_ENCODER_NOT_STREAMABLE; | ||
659 | if( | ||
660 | encoder->protected_->sample_rate != 8000 && | ||
661 | encoder->protected_->sample_rate != 16000 && | ||
662 | encoder->protected_->sample_rate != 22050 && | ||
663 | encoder->protected_->sample_rate != 24000 && | ||
664 | encoder->protected_->sample_rate != 32000 && | ||
665 | encoder->protected_->sample_rate != 44100 && | ||
666 | encoder->protected_->sample_rate != 48000 && | ||
667 | encoder->protected_->sample_rate != 96000 | ||
668 | ) | ||
669 | return encoder->protected_->state = FLAC__STREAM_ENCODER_NOT_STREAMABLE; | ||
670 | if( | ||
671 | encoder->protected_->bits_per_sample != 8 && | ||
672 | encoder->protected_->bits_per_sample != 12 && | ||
673 | encoder->protected_->bits_per_sample != 16 && | ||
674 | encoder->protected_->bits_per_sample != 20 && | ||
675 | encoder->protected_->bits_per_sample != 24 | ||
676 | ) | ||
677 | return encoder->protected_->state = FLAC__STREAM_ENCODER_NOT_STREAMABLE; | ||
678 | if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER) | ||
679 | return encoder->protected_->state = FLAC__STREAM_ENCODER_NOT_STREAMABLE; | ||
680 | } | ||
681 | |||
682 | if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) | ||
683 | encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1; | ||
684 | if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order) | ||
685 | encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order; | ||
686 | |||
687 | /* validate metadata */ | ||
688 | if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) | ||
689 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA; | ||
690 | metadata_has_seektable = false; | ||
691 | metadata_has_vorbis_comment = false; | ||
692 | for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { | ||
693 | if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_STREAMINFO) | ||
694 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA; | ||
695 | else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_SEEKTABLE) { | ||
696 | if(metadata_has_seektable) /* only one is allowed */ | ||
697 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA; | ||
698 | metadata_has_seektable = true; | ||
699 | if(!FLAC__format_seektable_is_legal(&encoder->protected_->metadata[i]->data.seek_table)) | ||
700 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA; | ||
701 | } | ||
702 | else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { | ||
703 | if(metadata_has_vorbis_comment) /* only one is allowed */ | ||
704 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA; | ||
705 | metadata_has_vorbis_comment = true; | ||
706 | } | ||
707 | else if(encoder->protected_->metadata[i]->type == FLAC__METADATA_TYPE_CUESHEET) { | ||
708 | if(!FLAC__format_cuesheet_is_legal(&encoder->protected_->metadata[i]->data.cue_sheet, encoder->protected_->metadata[i]->data.cue_sheet.is_cd, /*violation=*/0)) | ||
709 | return encoder->protected_->state = FLAC__STREAM_ENCODER_INVALID_METADATA; | ||
710 | } | ||
711 | } | ||
712 | |||
713 | encoder->private_->input_capacity = 0; | ||
714 | for(i = 0; i < encoder->protected_->channels; i++) { | ||
715 | encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0; | ||
716 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
717 | encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0; | ||
718 | #endif | ||
719 | } | ||
720 | for(i = 0; i < 2; i++) { | ||
721 | encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0; | ||
722 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
723 | encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0; | ||
724 | #endif | ||
725 | } | ||
726 | for(i = 0; i < encoder->protected_->channels; i++) { | ||
727 | encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0; | ||
728 | encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0; | ||
729 | encoder->private_->best_subframe[i] = 0; | ||
730 | } | ||
731 | for(i = 0; i < 2; i++) { | ||
732 | encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0; | ||
733 | encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0; | ||
734 | encoder->private_->best_subframe_mid_side[i] = 0; | ||
735 | } | ||
736 | encoder->private_->abs_residual_unaligned = encoder->private_->abs_residual = 0; | ||
737 | encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0; | ||
738 | encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0; | ||
739 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
740 | encoder->private_->loose_mid_side_stereo_frames = (unsigned)((FLAC__double)encoder->protected_->sample_rate * 0.4 / (FLAC__double)encoder->protected_->blocksize + 0.5); | ||
741 | #else | ||
742 | /* 26214 is the approximate fixed-point equivalent to 0.4 (0.4 * 2^16) */ | ||
743 | /* sample rate can be up to 655350 Hz, and thus use 20 bits, so we do the multiply÷ by hand */ | ||
744 | FLAC__ASSERT(FLAC__MAX_SAMPLE_RATE <= 655350); | ||
745 | FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535); | ||
746 | FLAC__ASSERT(encoder->protected_->sample_rate <= 655350); | ||
747 | FLAC__ASSERT(encoder->protected_->blocksize <= 65535); | ||
748 | encoder->private_->loose_mid_side_stereo_frames = (unsigned)FLAC__fixedpoint_trunc((((FLAC__uint64)(encoder->protected_->sample_rate) * (FLAC__uint64)(26214)) << 16) / (encoder->protected_->blocksize<<16) + FLAC__FP_ONE_HALF); | ||
749 | #endif | ||
750 | if(encoder->private_->loose_mid_side_stereo_frames == 0) | ||
751 | encoder->private_->loose_mid_side_stereo_frames = 1; | ||
752 | encoder->private_->loose_mid_side_stereo_frame_count = 0; | ||
753 | encoder->private_->current_sample_number = 0; | ||
754 | encoder->private_->current_frame_number = 0; | ||
755 | |||
756 | encoder->private_->use_wide_by_block = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(encoder->protected_->blocksize)+1 > 30); | ||
757 | encoder->private_->use_wide_by_order = (encoder->protected_->bits_per_sample + FLAC__bitmath_ilog2(max(encoder->protected_->max_lpc_order, FLAC__MAX_FIXED_ORDER))+1 > 30); /*@@@ need to use this? */ | ||
758 | encoder->private_->use_wide_by_partition = (false); /*@@@ need to set this */ | ||
759 | |||
760 | /* | ||
761 | * get the CPU info and set the function pointers | ||
762 | */ | ||
763 | FLAC__cpu_info(&encoder->private_->cpuinfo); | ||
764 | /* first default to the non-asm routines */ | ||
765 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
766 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; | ||
767 | #endif | ||
768 | encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor; | ||
769 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
770 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients; | ||
771 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide; | ||
772 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients; | ||
773 | #endif | ||
774 | /* now override with asm where appropriate */ | ||
775 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
776 | # ifndef FLAC__NO_ASM | ||
777 | if(encoder->private_->cpuinfo.use_asm) { | ||
778 | # ifdef FLAC__CPU_IA32 | ||
779 | FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); | ||
780 | # ifdef FLAC__HAS_NASM | ||
781 | # ifdef FLAC__SSE_OS | ||
782 | if(encoder->private_->cpuinfo.data.ia32.sse) { | ||
783 | if(encoder->protected_->max_lpc_order < 4) | ||
784 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4; | ||
785 | else if(encoder->protected_->max_lpc_order < 8) | ||
786 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8; | ||
787 | else if(encoder->protected_->max_lpc_order < 12) | ||
788 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12; | ||
789 | else | ||
790 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32; | ||
791 | } | ||
792 | else | ||
793 | # endif /* FLAC__SSE_OS */ | ||
794 | if(encoder->private_->cpuinfo.data.ia32._3dnow) | ||
795 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow; | ||
796 | else | ||
797 | encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32; | ||
798 | if(encoder->private_->cpuinfo.data.ia32.mmx) { | ||
799 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32; | ||
800 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx; | ||
801 | } | ||
802 | else { | ||
803 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32; | ||
804 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32; | ||
805 | } | ||
806 | if(encoder->private_->cpuinfo.data.ia32.mmx && encoder->private_->cpuinfo.data.ia32.cmov) | ||
807 | encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov; | ||
808 | # endif /* FLAC__HAS_NASM */ | ||
809 | # endif /* FLAC__CPU_IA32 */ | ||
810 | } | ||
811 | # endif /* !FLAC__NO_ASM */ | ||
812 | #endif /* !FLAC__INTEGER_ONLY_LIBRARY */ | ||
813 | /* finally override based on wide-ness if necessary */ | ||
814 | if(encoder->private_->use_wide_by_block) { | ||
815 | encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_wide; | ||
816 | } | ||
817 | |||
818 | /* we require precompute_partition_sums if do_escape_coding because of their intertwined nature */ | ||
819 | encoder->private_->precompute_partition_sums = (encoder->protected_->max_residual_partition_order > encoder->protected_->min_residual_partition_order) || encoder->protected_->do_escape_coding; | ||
820 | |||
821 | if(!resize_buffers_(encoder, encoder->protected_->blocksize)) { | ||
822 | /* the above function sets the state for us in case of an error */ | ||
823 | return encoder->protected_->state; | ||
824 | } | ||
825 | |||
826 | if(!FLAC__bitbuffer_init(encoder->private_->frame)) | ||
827 | return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
828 | |||
829 | /* | ||
830 | * Set up the verify stuff if necessary | ||
831 | */ | ||
832 | if(encoder->protected_->verify) { | ||
833 | /* | ||
834 | * First, set up the fifo which will hold the | ||
835 | * original signal to compare against | ||
836 | */ | ||
837 | encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize; | ||
838 | for(i = 0; i < encoder->protected_->channels; i++) { | ||
839 | if(0 == (encoder->private_->verify.input_fifo.data[i] = (FLAC__int32*)malloc(sizeof(FLAC__int32) * encoder->private_->verify.input_fifo.size))) | ||
840 | return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
841 | } | ||
842 | encoder->private_->verify.input_fifo.tail = 0; | ||
843 | |||
844 | /* | ||
845 | * Now set up a stream decoder for verification | ||
846 | */ | ||
847 | encoder->private_->verify.decoder = FLAC__stream_decoder_new(); | ||
848 | if(0 == encoder->private_->verify.decoder) | ||
849 | return encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; | ||
850 | |||
851 | FLAC__stream_decoder_set_read_callback(encoder->private_->verify.decoder, verify_read_callback_); | ||
852 | FLAC__stream_decoder_set_write_callback(encoder->private_->verify.decoder, verify_write_callback_); | ||
853 | FLAC__stream_decoder_set_metadata_callback(encoder->private_->verify.decoder, verify_metadata_callback_); | ||
854 | FLAC__stream_decoder_set_error_callback(encoder->private_->verify.decoder, verify_error_callback_); | ||
855 | FLAC__stream_decoder_set_client_data(encoder->private_->verify.decoder, encoder); | ||
856 | if(FLAC__stream_decoder_init(encoder->private_->verify.decoder) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA) | ||
857 | return encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; | ||
858 | } | ||
859 | encoder->private_->verify.error_stats.absolute_sample = 0; | ||
860 | encoder->private_->verify.error_stats.frame_number = 0; | ||
861 | encoder->private_->verify.error_stats.channel = 0; | ||
862 | encoder->private_->verify.error_stats.sample = 0; | ||
863 | encoder->private_->verify.error_stats.expected = 0; | ||
864 | encoder->private_->verify.error_stats.got = 0; | ||
865 | |||
866 | /* | ||
867 | * write the stream header | ||
868 | */ | ||
869 | if(encoder->protected_->verify) | ||
870 | encoder->private_->verify.state_hint = ENCODER_IN_MAGIC; | ||
871 | if(!FLAC__bitbuffer_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) | ||
872 | return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; | ||
873 | if(!write_bitbuffer_(encoder, 0)) { | ||
874 | /* the above function sets the state for us in case of an error */ | ||
875 | return encoder->protected_->state; | ||
876 | } | ||
877 | |||
878 | /* | ||
879 | * write the STREAMINFO metadata block | ||
880 | */ | ||
881 | if(encoder->protected_->verify) | ||
882 | encoder->private_->verify.state_hint = ENCODER_IN_METADATA; | ||
883 | encoder->private_->metadata.type = FLAC__METADATA_TYPE_STREAMINFO; | ||
884 | encoder->private_->metadata.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */ | ||
885 | encoder->private_->metadata.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; | ||
886 | encoder->private_->metadata.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */ | ||
887 | encoder->private_->metadata.data.stream_info.max_blocksize = encoder->protected_->blocksize; | ||
888 | encoder->private_->metadata.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */ | ||
889 | encoder->private_->metadata.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */ | ||
890 | encoder->private_->metadata.data.stream_info.sample_rate = encoder->protected_->sample_rate; | ||
891 | encoder->private_->metadata.data.stream_info.channels = encoder->protected_->channels; | ||
892 | encoder->private_->metadata.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample; | ||
893 | encoder->private_->metadata.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */ | ||
894 | memset(encoder->private_->metadata.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */ | ||
895 | FLAC__MD5Init(&encoder->private_->md5context); | ||
896 | if(!FLAC__bitbuffer_clear(encoder->private_->frame)) | ||
897 | return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
898 | if(!FLAC__add_metadata_block(&encoder->private_->metadata, encoder->private_->frame)) | ||
899 | return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; | ||
900 | if(!write_bitbuffer_(encoder, 0)) { | ||
901 | /* the above function sets the state for us in case of an error */ | ||
902 | return encoder->protected_->state; | ||
903 | } | ||
904 | |||
905 | /* | ||
906 | * Now that the STREAMINFO block is written, we can init this to an | ||
907 | * absurdly-high value... | ||
908 | */ | ||
909 | encoder->private_->metadata.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1; | ||
910 | /* ... and clear this to 0 */ | ||
911 | encoder->private_->metadata.data.stream_info.total_samples = 0; | ||
912 | |||
913 | /* | ||
914 | * Check to see if the supplied metadata contains a VORBIS_COMMENT; | ||
915 | * if not, we will write an empty one (FLAC__add_metadata_block() | ||
916 | * automatically supplies the vendor string). | ||
917 | * | ||
918 | * WATCHOUT: libOggFLAC depends on us to write this block after the | ||
919 | * STREAMINFO since that's what the mapping requires. (In the case | ||
920 | * that metadata_has_vorbis_comment is true it will have already | ||
921 | * insured that the metadata list is properly ordered.) | ||
922 | */ | ||
923 | if(!metadata_has_vorbis_comment) { | ||
924 | FLAC__StreamMetadata vorbis_comment; | ||
925 | vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT; | ||
926 | vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0); | ||
927 | vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */ | ||
928 | vorbis_comment.data.vorbis_comment.vendor_string.length = 0; | ||
929 | vorbis_comment.data.vorbis_comment.vendor_string.entry = 0; | ||
930 | vorbis_comment.data.vorbis_comment.num_comments = 0; | ||
931 | vorbis_comment.data.vorbis_comment.comments = 0; | ||
932 | if(!FLAC__bitbuffer_clear(encoder->private_->frame)) | ||
933 | return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
934 | if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame)) | ||
935 | return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; | ||
936 | if(!write_bitbuffer_(encoder, 0)) { | ||
937 | /* the above function sets the state for us in case of an error */ | ||
938 | return encoder->protected_->state; | ||
939 | } | ||
940 | } | ||
941 | |||
942 | /* | ||
943 | * write the user's metadata blocks | ||
944 | */ | ||
945 | for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { | ||
946 | encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1); | ||
947 | if(!FLAC__bitbuffer_clear(encoder->private_->frame)) | ||
948 | return encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
949 | if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame)) | ||
950 | return encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; | ||
951 | if(!write_bitbuffer_(encoder, 0)) { | ||
952 | /* the above function sets the state for us in case of an error */ | ||
953 | return encoder->protected_->state; | ||
954 | } | ||
955 | } | ||
956 | |||
957 | if(encoder->protected_->verify) | ||
958 | encoder->private_->verify.state_hint = ENCODER_IN_AUDIO; | ||
959 | |||
960 | return encoder->protected_->state; | ||
961 | } | ||
962 | |||
963 | FLAC_API void FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder) | ||
964 | { | ||
965 | FLAC__ASSERT(0 != encoder); | ||
966 | |||
967 | if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
968 | return; | ||
969 | |||
970 | if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) { | ||
971 | if(encoder->private_->current_sample_number != 0) { | ||
972 | encoder->protected_->blocksize = encoder->private_->current_sample_number; | ||
973 | process_frame_(encoder, true); /* true => is last frame */ | ||
974 | } | ||
975 | } | ||
976 | |||
977 | FLAC__MD5Final(encoder->private_->metadata.data.stream_info.md5sum, &encoder->private_->md5context); | ||
978 | |||
979 | if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) { | ||
980 | encoder->private_->metadata_callback(encoder, &encoder->private_->metadata, encoder->private_->client_data); | ||
981 | } | ||
982 | |||
983 | if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder) | ||
984 | FLAC__stream_decoder_finish(encoder->private_->verify.decoder); | ||
985 | |||
986 | free_(encoder); | ||
987 | set_defaults_(encoder); | ||
988 | |||
989 | encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; | ||
990 | } | ||
991 | |||
992 | FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
993 | { | ||
994 | FLAC__ASSERT(0 != encoder); | ||
995 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
996 | return false; | ||
997 | #ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING | ||
998 | encoder->protected_->verify = value; | ||
999 | #endif | ||
1000 | return true; | ||
1001 | } | ||
1002 | |||
1003 | FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1004 | { | ||
1005 | FLAC__ASSERT(0 != encoder); | ||
1006 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1007 | return false; | ||
1008 | encoder->protected_->streamable_subset = value; | ||
1009 | return true; | ||
1010 | } | ||
1011 | |||
1012 | FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1013 | { | ||
1014 | FLAC__ASSERT(0 != encoder); | ||
1015 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1016 | return false; | ||
1017 | encoder->protected_->do_mid_side_stereo = value; | ||
1018 | return true; | ||
1019 | } | ||
1020 | |||
1021 | FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1022 | { | ||
1023 | FLAC__ASSERT(0 != encoder); | ||
1024 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1025 | return false; | ||
1026 | encoder->protected_->loose_mid_side_stereo = value; | ||
1027 | return true; | ||
1028 | } | ||
1029 | |||
1030 | FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value) | ||
1031 | { | ||
1032 | FLAC__ASSERT(0 != encoder); | ||
1033 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1034 | return false; | ||
1035 | encoder->protected_->channels = value; | ||
1036 | return true; | ||
1037 | } | ||
1038 | |||
1039 | FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value) | ||
1040 | { | ||
1041 | FLAC__ASSERT(0 != encoder); | ||
1042 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1043 | return false; | ||
1044 | encoder->protected_->bits_per_sample = value; | ||
1045 | return true; | ||
1046 | } | ||
1047 | |||
1048 | FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value) | ||
1049 | { | ||
1050 | FLAC__ASSERT(0 != encoder); | ||
1051 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1052 | return false; | ||
1053 | encoder->protected_->sample_rate = value; | ||
1054 | return true; | ||
1055 | } | ||
1056 | |||
1057 | FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value) | ||
1058 | { | ||
1059 | FLAC__ASSERT(0 != encoder); | ||
1060 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1061 | return false; | ||
1062 | encoder->protected_->blocksize = value; | ||
1063 | return true; | ||
1064 | } | ||
1065 | |||
1066 | FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value) | ||
1067 | { | ||
1068 | FLAC__ASSERT(0 != encoder); | ||
1069 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1070 | return false; | ||
1071 | encoder->protected_->max_lpc_order = value; | ||
1072 | return true; | ||
1073 | } | ||
1074 | |||
1075 | FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value) | ||
1076 | { | ||
1077 | FLAC__ASSERT(0 != encoder); | ||
1078 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1079 | return false; | ||
1080 | encoder->protected_->qlp_coeff_precision = value; | ||
1081 | return true; | ||
1082 | } | ||
1083 | |||
1084 | FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1085 | { | ||
1086 | FLAC__ASSERT(0 != encoder); | ||
1087 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1088 | return false; | ||
1089 | encoder->protected_->do_qlp_coeff_prec_search = value; | ||
1090 | return true; | ||
1091 | } | ||
1092 | |||
1093 | FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1094 | { | ||
1095 | FLAC__ASSERT(0 != encoder); | ||
1096 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1097 | return false; | ||
1098 | #if 0 | ||
1099 | /*@@@ deprecated: */ | ||
1100 | encoder->protected_->do_escape_coding = value; | ||
1101 | #else | ||
1102 | (void)value; | ||
1103 | #endif | ||
1104 | return true; | ||
1105 | } | ||
1106 | |||
1107 | FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1108 | { | ||
1109 | FLAC__ASSERT(0 != encoder); | ||
1110 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1111 | return false; | ||
1112 | encoder->protected_->do_exhaustive_model_search = value; | ||
1113 | return true; | ||
1114 | } | ||
1115 | |||
1116 | FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value) | ||
1117 | { | ||
1118 | FLAC__ASSERT(0 != encoder); | ||
1119 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1120 | return false; | ||
1121 | encoder->protected_->min_residual_partition_order = value; | ||
1122 | return true; | ||
1123 | } | ||
1124 | |||
1125 | FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value) | ||
1126 | { | ||
1127 | FLAC__ASSERT(0 != encoder); | ||
1128 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1129 | return false; | ||
1130 | encoder->protected_->max_residual_partition_order = value; | ||
1131 | return true; | ||
1132 | } | ||
1133 | |||
1134 | FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value) | ||
1135 | { | ||
1136 | FLAC__ASSERT(0 != encoder); | ||
1137 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1138 | return false; | ||
1139 | #if 0 | ||
1140 | /*@@@ deprecated: */ | ||
1141 | encoder->protected_->rice_parameter_search_dist = value; | ||
1142 | #else | ||
1143 | (void)value; | ||
1144 | #endif | ||
1145 | return true; | ||
1146 | } | ||
1147 | |||
1148 | FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value) | ||
1149 | { | ||
1150 | FLAC__ASSERT(0 != encoder); | ||
1151 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1152 | return false; | ||
1153 | encoder->protected_->total_samples_estimate = value; | ||
1154 | return true; | ||
1155 | } | ||
1156 | |||
1157 | FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks) | ||
1158 | { | ||
1159 | FLAC__ASSERT(0 != encoder); | ||
1160 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1161 | return false; | ||
1162 | encoder->protected_->metadata = metadata; | ||
1163 | encoder->protected_->num_metadata_blocks = num_blocks; | ||
1164 | return true; | ||
1165 | } | ||
1166 | |||
1167 | FLAC_API FLAC__bool FLAC__stream_encoder_set_write_callback(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderWriteCallback value) | ||
1168 | { | ||
1169 | FLAC__ASSERT(0 != encoder); | ||
1170 | FLAC__ASSERT(0 != value); | ||
1171 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1172 | return false; | ||
1173 | encoder->private_->write_callback = value; | ||
1174 | return true; | ||
1175 | } | ||
1176 | |||
1177 | FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata_callback(FLAC__StreamEncoder *encoder, FLAC__StreamEncoderMetadataCallback value) | ||
1178 | { | ||
1179 | FLAC__ASSERT(0 != encoder); | ||
1180 | FLAC__ASSERT(0 != value); | ||
1181 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1182 | return false; | ||
1183 | encoder->private_->metadata_callback = value; | ||
1184 | return true; | ||
1185 | } | ||
1186 | |||
1187 | FLAC_API FLAC__bool FLAC__stream_encoder_set_client_data(FLAC__StreamEncoder *encoder, void *value) | ||
1188 | { | ||
1189 | FLAC__ASSERT(0 != encoder); | ||
1190 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1191 | return false; | ||
1192 | encoder->private_->client_data = value; | ||
1193 | return true; | ||
1194 | } | ||
1195 | |||
1196 | /* | ||
1197 | * These three functions are not static, but not publically exposed in | ||
1198 | * include/FLAC/ either. They are used by the test suite. | ||
1199 | */ | ||
1200 | FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1201 | { | ||
1202 | FLAC__ASSERT(0 != encoder); | ||
1203 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1204 | return false; | ||
1205 | encoder->private_->disable_constant_subframes = value; | ||
1206 | return true; | ||
1207 | } | ||
1208 | |||
1209 | FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1210 | { | ||
1211 | FLAC__ASSERT(0 != encoder); | ||
1212 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1213 | return false; | ||
1214 | encoder->private_->disable_fixed_subframes = value; | ||
1215 | return true; | ||
1216 | } | ||
1217 | |||
1218 | FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value) | ||
1219 | { | ||
1220 | FLAC__ASSERT(0 != encoder); | ||
1221 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) | ||
1222 | return false; | ||
1223 | encoder->private_->disable_verbatim_subframes = value; | ||
1224 | return true; | ||
1225 | } | ||
1226 | |||
1227 | FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder) | ||
1228 | { | ||
1229 | FLAC__ASSERT(0 != encoder); | ||
1230 | return encoder->protected_->state; | ||
1231 | } | ||
1232 | |||
1233 | FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder) | ||
1234 | { | ||
1235 | FLAC__ASSERT(0 != encoder); | ||
1236 | if(encoder->protected_->verify) | ||
1237 | return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder); | ||
1238 | else | ||
1239 | return FLAC__STREAM_DECODER_UNINITIALIZED; | ||
1240 | } | ||
1241 | |||
1242 | FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder) | ||
1243 | { | ||
1244 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) | ||
1245 | return FLAC__StreamEncoderStateString[encoder->protected_->state]; | ||
1246 | else | ||
1247 | return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder); | ||
1248 | } | ||
1249 | |||
1250 | FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got) | ||
1251 | { | ||
1252 | FLAC__ASSERT(0 != encoder); | ||
1253 | if(0 != absolute_sample) | ||
1254 | *absolute_sample = encoder->private_->verify.error_stats.absolute_sample; | ||
1255 | if(0 != frame_number) | ||
1256 | *frame_number = encoder->private_->verify.error_stats.frame_number; | ||
1257 | if(0 != channel) | ||
1258 | *channel = encoder->private_->verify.error_stats.channel; | ||
1259 | if(0 != sample) | ||
1260 | *sample = encoder->private_->verify.error_stats.sample; | ||
1261 | if(0 != expected) | ||
1262 | *expected = encoder->private_->verify.error_stats.expected; | ||
1263 | if(0 != got) | ||
1264 | *got = encoder->private_->verify.error_stats.got; | ||
1265 | } | ||
1266 | |||
1267 | FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder) | ||
1268 | { | ||
1269 | FLAC__ASSERT(0 != encoder); | ||
1270 | return encoder->protected_->verify; | ||
1271 | } | ||
1272 | |||
1273 | FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder) | ||
1274 | { | ||
1275 | FLAC__ASSERT(0 != encoder); | ||
1276 | return encoder->protected_->streamable_subset; | ||
1277 | } | ||
1278 | |||
1279 | FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder) | ||
1280 | { | ||
1281 | FLAC__ASSERT(0 != encoder); | ||
1282 | return encoder->protected_->do_mid_side_stereo; | ||
1283 | } | ||
1284 | |||
1285 | FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder) | ||
1286 | { | ||
1287 | FLAC__ASSERT(0 != encoder); | ||
1288 | return encoder->protected_->loose_mid_side_stereo; | ||
1289 | } | ||
1290 | |||
1291 | FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder) | ||
1292 | { | ||
1293 | FLAC__ASSERT(0 != encoder); | ||
1294 | return encoder->protected_->channels; | ||
1295 | } | ||
1296 | |||
1297 | FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder) | ||
1298 | { | ||
1299 | FLAC__ASSERT(0 != encoder); | ||
1300 | return encoder->protected_->bits_per_sample; | ||
1301 | } | ||
1302 | |||
1303 | FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder) | ||
1304 | { | ||
1305 | FLAC__ASSERT(0 != encoder); | ||
1306 | return encoder->protected_->sample_rate; | ||
1307 | } | ||
1308 | |||
1309 | FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder) | ||
1310 | { | ||
1311 | FLAC__ASSERT(0 != encoder); | ||
1312 | return encoder->protected_->blocksize; | ||
1313 | } | ||
1314 | |||
1315 | FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder) | ||
1316 | { | ||
1317 | FLAC__ASSERT(0 != encoder); | ||
1318 | return encoder->protected_->max_lpc_order; | ||
1319 | } | ||
1320 | |||
1321 | FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder) | ||
1322 | { | ||
1323 | FLAC__ASSERT(0 != encoder); | ||
1324 | return encoder->protected_->qlp_coeff_precision; | ||
1325 | } | ||
1326 | |||
1327 | FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder) | ||
1328 | { | ||
1329 | FLAC__ASSERT(0 != encoder); | ||
1330 | return encoder->protected_->do_qlp_coeff_prec_search; | ||
1331 | } | ||
1332 | |||
1333 | FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder) | ||
1334 | { | ||
1335 | FLAC__ASSERT(0 != encoder); | ||
1336 | return encoder->protected_->do_escape_coding; | ||
1337 | } | ||
1338 | |||
1339 | FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder) | ||
1340 | { | ||
1341 | FLAC__ASSERT(0 != encoder); | ||
1342 | return encoder->protected_->do_exhaustive_model_search; | ||
1343 | } | ||
1344 | |||
1345 | FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder) | ||
1346 | { | ||
1347 | FLAC__ASSERT(0 != encoder); | ||
1348 | return encoder->protected_->min_residual_partition_order; | ||
1349 | } | ||
1350 | |||
1351 | FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder) | ||
1352 | { | ||
1353 | FLAC__ASSERT(0 != encoder); | ||
1354 | return encoder->protected_->max_residual_partition_order; | ||
1355 | } | ||
1356 | |||
1357 | FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder) | ||
1358 | { | ||
1359 | FLAC__ASSERT(0 != encoder); | ||
1360 | return encoder->protected_->rice_parameter_search_dist; | ||
1361 | } | ||
1362 | |||
1363 | FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder) | ||
1364 | { | ||
1365 | FLAC__ASSERT(0 != encoder); | ||
1366 | return encoder->protected_->total_samples_estimate; | ||
1367 | } | ||
1368 | |||
1369 | FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples) | ||
1370 | { | ||
1371 | unsigned i, j, channel; | ||
1372 | FLAC__int32 x, mid, side; | ||
1373 | const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize; | ||
1374 | |||
1375 | FLAC__ASSERT(0 != encoder); | ||
1376 | FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); | ||
1377 | |||
1378 | j = 0; | ||
1379 | /* | ||
1380 | * we have several flavors of the same basic loop, optimized for | ||
1381 | * different conditions: | ||
1382 | */ | ||
1383 | if(encoder->protected_->max_lpc_order > 0) { | ||
1384 | if(encoder->protected_->do_mid_side_stereo && channels == 2) { | ||
1385 | /* | ||
1386 | * stereo coding: unroll channel loop | ||
1387 | * with LPC: calculate floating point version of signal | ||
1388 | */ | ||
1389 | do { | ||
1390 | if(encoder->protected_->verify) | ||
1391 | append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1392 | |||
1393 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1394 | x = mid = side = buffer[0][j]; | ||
1395 | encoder->private_->integer_signal[0][i] = x; | ||
1396 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1397 | encoder->private_->real_signal[0][i] = (FLAC__real)x; | ||
1398 | #endif | ||
1399 | x = buffer[1][j]; | ||
1400 | encoder->private_->integer_signal[1][i] = x; | ||
1401 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1402 | encoder->private_->real_signal[1][i] = (FLAC__real)x; | ||
1403 | #endif | ||
1404 | mid += x; | ||
1405 | side -= x; | ||
1406 | mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */ | ||
1407 | encoder->private_->integer_signal_mid_side[1][i] = side; | ||
1408 | encoder->private_->integer_signal_mid_side[0][i] = mid; | ||
1409 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1410 | encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side; | ||
1411 | encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid; | ||
1412 | #endif | ||
1413 | encoder->private_->current_sample_number++; | ||
1414 | } | ||
1415 | if(i == blocksize) { | ||
1416 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1417 | return false; | ||
1418 | } | ||
1419 | } while(j < samples); | ||
1420 | } | ||
1421 | else { | ||
1422 | /* | ||
1423 | * independent channel coding: buffer each channel in inner loop | ||
1424 | * with LPC: calculate floating point version of signal | ||
1425 | */ | ||
1426 | do { | ||
1427 | if(encoder->protected_->verify) | ||
1428 | append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1429 | |||
1430 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1431 | for(channel = 0; channel < channels; channel++) { | ||
1432 | x = buffer[channel][j]; | ||
1433 | encoder->private_->integer_signal[channel][i] = x; | ||
1434 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1435 | encoder->private_->real_signal[channel][i] = (FLAC__real)x; | ||
1436 | #endif | ||
1437 | } | ||
1438 | encoder->private_->current_sample_number++; | ||
1439 | } | ||
1440 | if(i == blocksize) { | ||
1441 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1442 | return false; | ||
1443 | } | ||
1444 | } while(j < samples); | ||
1445 | } | ||
1446 | } | ||
1447 | else { | ||
1448 | if(encoder->protected_->do_mid_side_stereo && channels == 2) { | ||
1449 | /* | ||
1450 | * stereo coding: unroll channel loop | ||
1451 | * without LPC: no need to calculate floating point version of signal | ||
1452 | */ | ||
1453 | do { | ||
1454 | if(encoder->protected_->verify) | ||
1455 | append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1456 | |||
1457 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1458 | encoder->private_->integer_signal[0][i] = mid = side = buffer[0][j]; | ||
1459 | x = buffer[1][j]; | ||
1460 | encoder->private_->integer_signal[1][i] = x; | ||
1461 | mid += x; | ||
1462 | side -= x; | ||
1463 | mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */ | ||
1464 | encoder->private_->integer_signal_mid_side[1][i] = side; | ||
1465 | encoder->private_->integer_signal_mid_side[0][i] = mid; | ||
1466 | encoder->private_->current_sample_number++; | ||
1467 | } | ||
1468 | if(i == blocksize) { | ||
1469 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1470 | return false; | ||
1471 | } | ||
1472 | } while(j < samples); | ||
1473 | } | ||
1474 | else { | ||
1475 | /* | ||
1476 | * independent channel coding: buffer each channel in inner loop | ||
1477 | * without LPC: no need to calculate floating point version of signal | ||
1478 | */ | ||
1479 | do { | ||
1480 | if(encoder->protected_->verify) | ||
1481 | append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1482 | |||
1483 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1484 | for(channel = 0; channel < channels; channel++) | ||
1485 | encoder->private_->integer_signal[channel][i] = buffer[channel][j]; | ||
1486 | encoder->private_->current_sample_number++; | ||
1487 | } | ||
1488 | if(i == blocksize) { | ||
1489 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1490 | return false; | ||
1491 | } | ||
1492 | } while(j < samples); | ||
1493 | } | ||
1494 | } | ||
1495 | |||
1496 | return true; | ||
1497 | } | ||
1498 | |||
1499 | FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples) | ||
1500 | { | ||
1501 | unsigned i, j, k, channel; | ||
1502 | FLAC__int32 x, mid, side; | ||
1503 | const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize; | ||
1504 | |||
1505 | FLAC__ASSERT(0 != encoder); | ||
1506 | FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); | ||
1507 | |||
1508 | j = k = 0; | ||
1509 | /* | ||
1510 | * we have several flavors of the same basic loop, optimized for | ||
1511 | * different conditions: | ||
1512 | */ | ||
1513 | if(encoder->protected_->max_lpc_order > 0) { | ||
1514 | if(encoder->protected_->do_mid_side_stereo && channels == 2) { | ||
1515 | /* | ||
1516 | * stereo coding: unroll channel loop | ||
1517 | * with LPC: calculate floating point version of signal | ||
1518 | */ | ||
1519 | do { | ||
1520 | if(encoder->protected_->verify) | ||
1521 | append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1522 | |||
1523 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1524 | x = mid = side = buffer[k++]; | ||
1525 | encoder->private_->integer_signal[0][i] = x; | ||
1526 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1527 | encoder->private_->real_signal[0][i] = (FLAC__real)x; | ||
1528 | #endif | ||
1529 | x = buffer[k++]; | ||
1530 | encoder->private_->integer_signal[1][i] = x; | ||
1531 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1532 | encoder->private_->real_signal[1][i] = (FLAC__real)x; | ||
1533 | #endif | ||
1534 | mid += x; | ||
1535 | side -= x; | ||
1536 | mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */ | ||
1537 | encoder->private_->integer_signal_mid_side[1][i] = side; | ||
1538 | encoder->private_->integer_signal_mid_side[0][i] = mid; | ||
1539 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1540 | encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side; | ||
1541 | encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid; | ||
1542 | #endif | ||
1543 | encoder->private_->current_sample_number++; | ||
1544 | } | ||
1545 | if(i == blocksize) { | ||
1546 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1547 | return false; | ||
1548 | } | ||
1549 | } while(j < samples); | ||
1550 | } | ||
1551 | else { | ||
1552 | /* | ||
1553 | * independent channel coding: buffer each channel in inner loop | ||
1554 | * with LPC: calculate floating point version of signal | ||
1555 | */ | ||
1556 | do { | ||
1557 | if(encoder->protected_->verify) | ||
1558 | append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1559 | |||
1560 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1561 | for(channel = 0; channel < channels; channel++) { | ||
1562 | x = buffer[k++]; | ||
1563 | encoder->private_->integer_signal[channel][i] = x; | ||
1564 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1565 | encoder->private_->real_signal[channel][i] = (FLAC__real)x; | ||
1566 | #endif | ||
1567 | } | ||
1568 | encoder->private_->current_sample_number++; | ||
1569 | } | ||
1570 | if(i == blocksize) { | ||
1571 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1572 | return false; | ||
1573 | } | ||
1574 | } while(j < samples); | ||
1575 | } | ||
1576 | } | ||
1577 | else { | ||
1578 | if(encoder->protected_->do_mid_side_stereo && channels == 2) { | ||
1579 | /* | ||
1580 | * stereo coding: unroll channel loop | ||
1581 | * without LPC: no need to calculate floating point version of signal | ||
1582 | */ | ||
1583 | do { | ||
1584 | if(encoder->protected_->verify) | ||
1585 | append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1586 | |||
1587 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1588 | encoder->private_->integer_signal[0][i] = mid = side = buffer[k++]; | ||
1589 | x = buffer[k++]; | ||
1590 | encoder->private_->integer_signal[1][i] = x; | ||
1591 | mid += x; | ||
1592 | side -= x; | ||
1593 | mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */ | ||
1594 | encoder->private_->integer_signal_mid_side[1][i] = side; | ||
1595 | encoder->private_->integer_signal_mid_side[0][i] = mid; | ||
1596 | encoder->private_->current_sample_number++; | ||
1597 | } | ||
1598 | if(i == blocksize) { | ||
1599 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1600 | return false; | ||
1601 | } | ||
1602 | } while(j < samples); | ||
1603 | } | ||
1604 | else { | ||
1605 | /* | ||
1606 | * independent channel coding: buffer each channel in inner loop | ||
1607 | * without LPC: no need to calculate floating point version of signal | ||
1608 | */ | ||
1609 | do { | ||
1610 | if(encoder->protected_->verify) | ||
1611 | append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j)); | ||
1612 | |||
1613 | for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) { | ||
1614 | for(channel = 0; channel < channels; channel++) | ||
1615 | encoder->private_->integer_signal[channel][i] = buffer[k++]; | ||
1616 | encoder->private_->current_sample_number++; | ||
1617 | } | ||
1618 | if(i == blocksize) { | ||
1619 | if(!process_frame_(encoder, false)) /* false => not last frame */ | ||
1620 | return false; | ||
1621 | } | ||
1622 | } while(j < samples); | ||
1623 | } | ||
1624 | } | ||
1625 | |||
1626 | return true; | ||
1627 | } | ||
1628 | |||
1629 | /*********************************************************************** | ||
1630 | * | ||
1631 | * Private class methods | ||
1632 | * | ||
1633 | ***********************************************************************/ | ||
1634 | |||
1635 | void set_defaults_(FLAC__StreamEncoder *encoder) | ||
1636 | { | ||
1637 | FLAC__ASSERT(0 != encoder); | ||
1638 | |||
1639 | #ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING | ||
1640 | encoder->protected_->verify = true; | ||
1641 | #else | ||
1642 | encoder->protected_->verify = false; | ||
1643 | #endif | ||
1644 | encoder->protected_->streamable_subset = true; | ||
1645 | encoder->protected_->do_mid_side_stereo = false; | ||
1646 | encoder->protected_->loose_mid_side_stereo = false; | ||
1647 | encoder->protected_->channels = 2; | ||
1648 | encoder->protected_->bits_per_sample = 16; | ||
1649 | encoder->protected_->sample_rate = 44100; | ||
1650 | encoder->protected_->blocksize = 1152; | ||
1651 | encoder->protected_->max_lpc_order = 0; | ||
1652 | encoder->protected_->qlp_coeff_precision = 0; | ||
1653 | encoder->protected_->do_qlp_coeff_prec_search = false; | ||
1654 | encoder->protected_->do_exhaustive_model_search = false; | ||
1655 | encoder->protected_->do_escape_coding = false; | ||
1656 | encoder->protected_->min_residual_partition_order = 0; | ||
1657 | encoder->protected_->max_residual_partition_order = 0; | ||
1658 | encoder->protected_->rice_parameter_search_dist = 0; | ||
1659 | encoder->protected_->total_samples_estimate = 0; | ||
1660 | encoder->protected_->metadata = 0; | ||
1661 | encoder->protected_->num_metadata_blocks = 0; | ||
1662 | |||
1663 | encoder->private_->disable_constant_subframes = false; | ||
1664 | encoder->private_->disable_fixed_subframes = false; | ||
1665 | encoder->private_->disable_verbatim_subframes = false; | ||
1666 | encoder->private_->write_callback = 0; | ||
1667 | encoder->private_->metadata_callback = 0; | ||
1668 | encoder->private_->client_data = 0; | ||
1669 | } | ||
1670 | |||
1671 | void free_(FLAC__StreamEncoder *encoder) | ||
1672 | { | ||
1673 | unsigned i, channel; | ||
1674 | |||
1675 | FLAC__ASSERT(0 != encoder); | ||
1676 | for(i = 0; i < encoder->protected_->channels; i++) { | ||
1677 | if(0 != encoder->private_->integer_signal_unaligned[i]) { | ||
1678 | free(encoder->private_->integer_signal_unaligned[i]); | ||
1679 | encoder->private_->integer_signal_unaligned[i] = 0; | ||
1680 | } | ||
1681 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1682 | if(0 != encoder->private_->real_signal_unaligned[i]) { | ||
1683 | free(encoder->private_->real_signal_unaligned[i]); | ||
1684 | encoder->private_->real_signal_unaligned[i] = 0; | ||
1685 | } | ||
1686 | #endif | ||
1687 | } | ||
1688 | for(i = 0; i < 2; i++) { | ||
1689 | if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) { | ||
1690 | free(encoder->private_->integer_signal_mid_side_unaligned[i]); | ||
1691 | encoder->private_->integer_signal_mid_side_unaligned[i] = 0; | ||
1692 | } | ||
1693 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1694 | if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) { | ||
1695 | free(encoder->private_->real_signal_mid_side_unaligned[i]); | ||
1696 | encoder->private_->real_signal_mid_side_unaligned[i] = 0; | ||
1697 | } | ||
1698 | #endif | ||
1699 | } | ||
1700 | for(channel = 0; channel < encoder->protected_->channels; channel++) { | ||
1701 | for(i = 0; i < 2; i++) { | ||
1702 | if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) { | ||
1703 | free(encoder->private_->residual_workspace_unaligned[channel][i]); | ||
1704 | encoder->private_->residual_workspace_unaligned[channel][i] = 0; | ||
1705 | } | ||
1706 | } | ||
1707 | } | ||
1708 | for(channel = 0; channel < 2; channel++) { | ||
1709 | for(i = 0; i < 2; i++) { | ||
1710 | if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) { | ||
1711 | free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]); | ||
1712 | encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0; | ||
1713 | } | ||
1714 | } | ||
1715 | } | ||
1716 | if(0 != encoder->private_->abs_residual_unaligned) { | ||
1717 | free(encoder->private_->abs_residual_unaligned); | ||
1718 | encoder->private_->abs_residual_unaligned = 0; | ||
1719 | } | ||
1720 | if(0 != encoder->private_->abs_residual_partition_sums_unaligned) { | ||
1721 | free(encoder->private_->abs_residual_partition_sums_unaligned); | ||
1722 | encoder->private_->abs_residual_partition_sums_unaligned = 0; | ||
1723 | } | ||
1724 | if(0 != encoder->private_->raw_bits_per_partition_unaligned) { | ||
1725 | free(encoder->private_->raw_bits_per_partition_unaligned); | ||
1726 | encoder->private_->raw_bits_per_partition_unaligned = 0; | ||
1727 | } | ||
1728 | if(encoder->protected_->verify) { | ||
1729 | for(i = 0; i < encoder->protected_->channels; i++) { | ||
1730 | if(0 != encoder->private_->verify.input_fifo.data[i]) { | ||
1731 | free(encoder->private_->verify.input_fifo.data[i]); | ||
1732 | encoder->private_->verify.input_fifo.data[i] = 0; | ||
1733 | } | ||
1734 | } | ||
1735 | } | ||
1736 | FLAC__bitbuffer_free(encoder->private_->frame); | ||
1737 | } | ||
1738 | |||
1739 | FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size) | ||
1740 | { | ||
1741 | FLAC__bool ok; | ||
1742 | unsigned i, channel; | ||
1743 | |||
1744 | FLAC__ASSERT(new_size > 0); | ||
1745 | FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); | ||
1746 | FLAC__ASSERT(encoder->private_->current_sample_number == 0); | ||
1747 | |||
1748 | /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */ | ||
1749 | if(new_size <= encoder->private_->input_capacity) | ||
1750 | return true; | ||
1751 | |||
1752 | ok = true; | ||
1753 | |||
1754 | /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx() | ||
1755 | * requires that the input arrays (in our case the integer signals) | ||
1756 | * have a buffer of up to 3 zeroes in front (at negative indices) for | ||
1757 | * alignment purposes; we use 4 to keep the data well-aligned. | ||
1758 | */ | ||
1759 | |||
1760 | for(i = 0; ok && i < encoder->protected_->channels; i++) { | ||
1761 | ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size+4, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]); | ||
1762 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1763 | if(encoder->protected_->max_lpc_order > 0) | ||
1764 | ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->real_signal_unaligned[i], &encoder->private_->real_signal[i]); | ||
1765 | #endif | ||
1766 | memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4); | ||
1767 | encoder->private_->integer_signal[i] += 4; | ||
1768 | } | ||
1769 | for(i = 0; ok && i < 2; i++) { | ||
1770 | ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size+4, &encoder->private_->integer_signal_mid_side_unaligned[i], &encoder->private_->integer_signal_mid_side[i]); | ||
1771 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1772 | if(encoder->protected_->max_lpc_order > 0) | ||
1773 | ok = ok && FLAC__memory_alloc_aligned_real_array(new_size, &encoder->private_->real_signal_mid_side_unaligned[i], &encoder->private_->real_signal_mid_side[i]); | ||
1774 | #endif | ||
1775 | memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4); | ||
1776 | encoder->private_->integer_signal_mid_side[i] += 4; | ||
1777 | } | ||
1778 | for(channel = 0; ok && channel < encoder->protected_->channels; channel++) { | ||
1779 | for(i = 0; ok && i < 2; i++) { | ||
1780 | ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]); | ||
1781 | } | ||
1782 | } | ||
1783 | for(channel = 0; ok && channel < 2; channel++) { | ||
1784 | for(i = 0; ok && i < 2; i++) { | ||
1785 | ok = ok && FLAC__memory_alloc_aligned_int32_array(new_size, &encoder->private_->residual_workspace_mid_side_unaligned[channel][i], &encoder->private_->residual_workspace_mid_side[channel][i]); | ||
1786 | } | ||
1787 | } | ||
1788 | ok = ok && FLAC__memory_alloc_aligned_uint32_array(new_size, &encoder->private_->abs_residual_unaligned, &encoder->private_->abs_residual); | ||
1789 | if(encoder->private_->precompute_partition_sums || encoder->protected_->do_escape_coding) /* we require precompute_partition_sums if do_escape_coding because of their intertwined nature */ | ||
1790 | ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_size * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums); | ||
1791 | if(encoder->protected_->do_escape_coding) | ||
1792 | ok = ok && FLAC__memory_alloc_aligned_unsigned_array(new_size * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition); | ||
1793 | |||
1794 | if(ok) | ||
1795 | encoder->private_->input_capacity = new_size; | ||
1796 | else | ||
1797 | encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
1798 | |||
1799 | return ok; | ||
1800 | } | ||
1801 | |||
1802 | FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples) | ||
1803 | { | ||
1804 | const FLAC__byte *buffer; | ||
1805 | unsigned bytes; | ||
1806 | |||
1807 | FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(encoder->private_->frame)); | ||
1808 | |||
1809 | FLAC__bitbuffer_get_buffer(encoder->private_->frame, &buffer, &bytes); | ||
1810 | |||
1811 | if(encoder->protected_->verify) { | ||
1812 | encoder->private_->verify.output.data = buffer; | ||
1813 | encoder->private_->verify.output.bytes = bytes; | ||
1814 | if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) { | ||
1815 | encoder->private_->verify.needs_magic_hack = true; | ||
1816 | } | ||
1817 | else { | ||
1818 | if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) { | ||
1819 | FLAC__bitbuffer_release_buffer(encoder->private_->frame); | ||
1820 | if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) | ||
1821 | encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; | ||
1822 | return false; | ||
1823 | } | ||
1824 | } | ||
1825 | } | ||
1826 | |||
1827 | if(encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { | ||
1828 | FLAC__bitbuffer_release_buffer(encoder->private_->frame); | ||
1829 | encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_WRITING; | ||
1830 | return false; | ||
1831 | } | ||
1832 | |||
1833 | FLAC__bitbuffer_release_buffer(encoder->private_->frame); | ||
1834 | |||
1835 | if(samples > 0) { | ||
1836 | encoder->private_->metadata.data.stream_info.min_framesize = min(bytes, encoder->private_->metadata.data.stream_info.min_framesize); | ||
1837 | encoder->private_->metadata.data.stream_info.max_framesize = max(bytes, encoder->private_->metadata.data.stream_info.max_framesize); | ||
1838 | } | ||
1839 | |||
1840 | return true; | ||
1841 | } | ||
1842 | |||
1843 | FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame) | ||
1844 | { | ||
1845 | FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); | ||
1846 | |||
1847 | /* | ||
1848 | * Accumulate raw signal to the MD5 signature | ||
1849 | */ | ||
1850 | if(!FLAC__MD5Accumulate(&encoder->private_->md5context, (const FLAC__int32 * const *)encoder->private_->integer_signal, encoder->protected_->channels, encoder->protected_->blocksize, (encoder->protected_->bits_per_sample+7) / 8)) { | ||
1851 | encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
1852 | return false; | ||
1853 | } | ||
1854 | |||
1855 | /* | ||
1856 | * Process the frame header and subframes into the frame bitbuffer | ||
1857 | */ | ||
1858 | if(!process_subframes_(encoder, is_last_frame)) { | ||
1859 | /* the above function sets the state for us in case of an error */ | ||
1860 | return false; | ||
1861 | } | ||
1862 | |||
1863 | /* | ||
1864 | * Zero-pad the frame to a byte_boundary | ||
1865 | */ | ||
1866 | if(!FLAC__bitbuffer_zero_pad_to_byte_boundary(encoder->private_->frame)) { | ||
1867 | encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
1868 | return false; | ||
1869 | } | ||
1870 | |||
1871 | /* | ||
1872 | * CRC-16 the whole thing | ||
1873 | */ | ||
1874 | FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(encoder->private_->frame)); | ||
1875 | FLAC__bitbuffer_write_raw_uint32(encoder->private_->frame, FLAC__bitbuffer_get_write_crc16(encoder->private_->frame), FLAC__FRAME_FOOTER_CRC_LEN); | ||
1876 | |||
1877 | /* | ||
1878 | * Write it | ||
1879 | */ | ||
1880 | if(!write_bitbuffer_(encoder, encoder->protected_->blocksize)) { | ||
1881 | /* the above function sets the state for us in case of an error */ | ||
1882 | return false; | ||
1883 | } | ||
1884 | |||
1885 | /* | ||
1886 | * Get ready for the next frame | ||
1887 | */ | ||
1888 | encoder->private_->current_sample_number = 0; | ||
1889 | encoder->private_->current_frame_number++; | ||
1890 | encoder->private_->metadata.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize; | ||
1891 | |||
1892 | return true; | ||
1893 | } | ||
1894 | |||
1895 | FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame) | ||
1896 | { | ||
1897 | FLAC__FrameHeader frame_header; | ||
1898 | unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order; | ||
1899 | FLAC__bool do_independent, do_mid_side, precompute_partition_sums; | ||
1900 | |||
1901 | /* | ||
1902 | * Calculate the min,max Rice partition orders | ||
1903 | */ | ||
1904 | if(is_last_frame) { | ||
1905 | max_partition_order = 0; | ||
1906 | } | ||
1907 | else { | ||
1908 | max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize); | ||
1909 | max_partition_order = min(max_partition_order, encoder->protected_->max_residual_partition_order); | ||
1910 | } | ||
1911 | min_partition_order = min(min_partition_order, max_partition_order); | ||
1912 | |||
1913 | precompute_partition_sums = encoder->private_->precompute_partition_sums && ((max_partition_order > min_partition_order) || encoder->protected_->do_escape_coding); | ||
1914 | |||
1915 | /* | ||
1916 | * Setup the frame | ||
1917 | */ | ||
1918 | if(!FLAC__bitbuffer_clear(encoder->private_->frame)) { | ||
1919 | encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; | ||
1920 | return false; | ||
1921 | } | ||
1922 | frame_header.blocksize = encoder->protected_->blocksize; | ||
1923 | frame_header.sample_rate = encoder->protected_->sample_rate; | ||
1924 | frame_header.channels = encoder->protected_->channels; | ||
1925 | frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */ | ||
1926 | frame_header.bits_per_sample = encoder->protected_->bits_per_sample; | ||
1927 | frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; | ||
1928 | frame_header.number.frame_number = encoder->private_->current_frame_number; | ||
1929 | |||
1930 | /* | ||
1931 | * Figure out what channel assignments to try | ||
1932 | */ | ||
1933 | if(encoder->protected_->do_mid_side_stereo) { | ||
1934 | if(encoder->protected_->loose_mid_side_stereo) { | ||
1935 | if(encoder->private_->loose_mid_side_stereo_frame_count == 0) { | ||
1936 | do_independent = true; | ||
1937 | do_mid_side = true; | ||
1938 | } | ||
1939 | else { | ||
1940 | do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT); | ||
1941 | do_mid_side = !do_independent; | ||
1942 | } | ||
1943 | } | ||
1944 | else { | ||
1945 | do_independent = true; | ||
1946 | do_mid_side = true; | ||
1947 | } | ||
1948 | } | ||
1949 | else { | ||
1950 | do_independent = true; | ||
1951 | do_mid_side = false; | ||
1952 | } | ||
1953 | |||
1954 | FLAC__ASSERT(do_independent || do_mid_side); | ||
1955 | |||
1956 | /* | ||
1957 | * Check for wasted bits; set effective bps for each subframe | ||
1958 | */ | ||
1959 | if(do_independent) { | ||
1960 | for(channel = 0; channel < encoder->protected_->channels; channel++) { | ||
1961 | const unsigned w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize); | ||
1962 | encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w; | ||
1963 | encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w; | ||
1964 | } | ||
1965 | } | ||
1966 | if(do_mid_side) { | ||
1967 | FLAC__ASSERT(encoder->protected_->channels == 2); | ||
1968 | for(channel = 0; channel < 2; channel++) { | ||
1969 | const unsigned w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize); | ||
1970 | encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w; | ||
1971 | encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1); | ||
1972 | } | ||
1973 | } | ||
1974 | |||
1975 | /* | ||
1976 | * First do a normal encoding pass of each independent channel | ||
1977 | */ | ||
1978 | if(do_independent) { | ||
1979 | for(channel = 0; channel < encoder->protected_->channels; channel++) { | ||
1980 | if(! | ||
1981 | process_subframe_( | ||
1982 | encoder, | ||
1983 | min_partition_order, | ||
1984 | max_partition_order, | ||
1985 | precompute_partition_sums, | ||
1986 | &frame_header, | ||
1987 | encoder->private_->subframe_bps[channel], | ||
1988 | encoder->private_->integer_signal[channel], | ||
1989 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
1990 | encoder->private_->real_signal[channel], | ||
1991 | #endif | ||
1992 | encoder->private_->subframe_workspace_ptr[channel], | ||
1993 | encoder->private_->partitioned_rice_contents_workspace_ptr[channel], | ||
1994 | encoder->private_->residual_workspace[channel], | ||
1995 | encoder->private_->best_subframe+channel, | ||
1996 | encoder->private_->best_subframe_bits+channel | ||
1997 | ) | ||
1998 | ) | ||
1999 | return false; | ||
2000 | } | ||
2001 | } | ||
2002 | |||
2003 | /* | ||
2004 | * Now do mid and side channels if requested | ||
2005 | */ | ||
2006 | if(do_mid_side) { | ||
2007 | FLAC__ASSERT(encoder->protected_->channels == 2); | ||
2008 | |||
2009 | for(channel = 0; channel < 2; channel++) { | ||
2010 | if(! | ||
2011 | process_subframe_( | ||
2012 | encoder, | ||
2013 | min_partition_order, | ||
2014 | max_partition_order, | ||
2015 | precompute_partition_sums, | ||
2016 | &frame_header, | ||
2017 | encoder->private_->subframe_bps_mid_side[channel], | ||
2018 | encoder->private_->integer_signal_mid_side[channel], | ||
2019 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2020 | encoder->private_->real_signal_mid_side[channel], | ||
2021 | #endif | ||
2022 | encoder->private_->subframe_workspace_ptr_mid_side[channel], | ||
2023 | encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[channel], | ||
2024 | encoder->private_->residual_workspace_mid_side[channel], | ||
2025 | encoder->private_->best_subframe_mid_side+channel, | ||
2026 | encoder->private_->best_subframe_bits_mid_side+channel | ||
2027 | ) | ||
2028 | ) | ||
2029 | return false; | ||
2030 | } | ||
2031 | } | ||
2032 | |||
2033 | /* | ||
2034 | * Compose the frame bitbuffer | ||
2035 | */ | ||
2036 | if(do_mid_side) { | ||
2037 | unsigned left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */ | ||
2038 | FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */ | ||
2039 | FLAC__ChannelAssignment channel_assignment; | ||
2040 | |||
2041 | FLAC__ASSERT(encoder->protected_->channels == 2); | ||
2042 | |||
2043 | if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) { | ||
2044 | channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE); | ||
2045 | } | ||
2046 | else { | ||
2047 | unsigned bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */ | ||
2048 | unsigned min_bits; | ||
2049 | FLAC__ChannelAssignment ca; | ||
2050 | |||
2051 | FLAC__ASSERT(do_independent && do_mid_side); | ||
2052 | |||
2053 | /* We have to figure out which channel assignent results in the smallest frame */ | ||
2054 | bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits [1]; | ||
2055 | bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE ] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits_mid_side[1]; | ||
2056 | bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits [1] + encoder->private_->best_subframe_bits_mid_side[1]; | ||
2057 | bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1]; | ||
2058 | |||
2059 | for(channel_assignment = (FLAC__ChannelAssignment)0, min_bits = bits[0], ca = (FLAC__ChannelAssignment)1; (int)ca <= 3; ca = (FLAC__ChannelAssignment)((int)ca + 1)) { | ||
2060 | if(bits[ca] < min_bits) { | ||
2061 | min_bits = bits[ca]; | ||
2062 | channel_assignment = ca; | ||
2063 | } | ||
2064 | } | ||
2065 | } | ||
2066 | |||
2067 | frame_header.channel_assignment = channel_assignment; | ||
2068 | |||
2069 | if(!FLAC__frame_add_header(&frame_header, encoder->protected_->streamable_subset, encoder->private_->frame)) { | ||
2070 | encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; | ||
2071 | return false; | ||
2072 | } | ||
2073 | |||
2074 | switch(channel_assignment) { | ||
2075 | case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: | ||
2076 | left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]]; | ||
2077 | right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]]; | ||
2078 | break; | ||
2079 | case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: | ||
2080 | left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]]; | ||
2081 | right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]]; | ||
2082 | break; | ||
2083 | case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: | ||
2084 | left_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]]; | ||
2085 | right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]]; | ||
2086 | break; | ||
2087 | case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: | ||
2088 | left_subframe = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]]; | ||
2089 | right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]]; | ||
2090 | break; | ||
2091 | default: | ||
2092 | FLAC__ASSERT(0); | ||
2093 | } | ||
2094 | |||
2095 | switch(channel_assignment) { | ||
2096 | case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: | ||
2097 | left_bps = encoder->private_->subframe_bps [0]; | ||
2098 | right_bps = encoder->private_->subframe_bps [1]; | ||
2099 | break; | ||
2100 | case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: | ||
2101 | left_bps = encoder->private_->subframe_bps [0]; | ||
2102 | right_bps = encoder->private_->subframe_bps_mid_side[1]; | ||
2103 | break; | ||
2104 | case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: | ||
2105 | left_bps = encoder->private_->subframe_bps_mid_side[1]; | ||
2106 | right_bps = encoder->private_->subframe_bps [1]; | ||
2107 | break; | ||
2108 | case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: | ||
2109 | left_bps = encoder->private_->subframe_bps_mid_side[0]; | ||
2110 | right_bps = encoder->private_->subframe_bps_mid_side[1]; | ||
2111 | break; | ||
2112 | default: | ||
2113 | FLAC__ASSERT(0); | ||
2114 | } | ||
2115 | |||
2116 | /* note that encoder_add_subframe_ sets the state for us in case of an error */ | ||
2117 | if(!add_subframe_(encoder, &frame_header, left_bps , left_subframe , encoder->private_->frame)) | ||
2118 | return false; | ||
2119 | if(!add_subframe_(encoder, &frame_header, right_bps, right_subframe, encoder->private_->frame)) | ||
2120 | return false; | ||
2121 | } | ||
2122 | else { | ||
2123 | if(!FLAC__frame_add_header(&frame_header, encoder->protected_->streamable_subset, encoder->private_->frame)) { | ||
2124 | encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; | ||
2125 | return false; | ||
2126 | } | ||
2127 | |||
2128 | for(channel = 0; channel < encoder->protected_->channels; channel++) { | ||
2129 | if(!add_subframe_(encoder, &frame_header, encoder->private_->subframe_bps[channel], &encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]], encoder->private_->frame)) { | ||
2130 | /* the above function sets the state for us in case of an error */ | ||
2131 | return false; | ||
2132 | } | ||
2133 | } | ||
2134 | } | ||
2135 | |||
2136 | if(encoder->protected_->loose_mid_side_stereo) { | ||
2137 | encoder->private_->loose_mid_side_stereo_frame_count++; | ||
2138 | if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames) | ||
2139 | encoder->private_->loose_mid_side_stereo_frame_count = 0; | ||
2140 | } | ||
2141 | |||
2142 | encoder->private_->last_channel_assignment = frame_header.channel_assignment; | ||
2143 | |||
2144 | return true; | ||
2145 | } | ||
2146 | |||
2147 | FLAC__bool process_subframe_( | ||
2148 | FLAC__StreamEncoder *encoder, | ||
2149 | unsigned min_partition_order, | ||
2150 | unsigned max_partition_order, | ||
2151 | FLAC__bool precompute_partition_sums, | ||
2152 | const FLAC__FrameHeader *frame_header, | ||
2153 | unsigned subframe_bps, | ||
2154 | const FLAC__int32 integer_signal[], | ||
2155 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2156 | const FLAC__real real_signal[], | ||
2157 | #endif | ||
2158 | FLAC__Subframe *subframe[2], | ||
2159 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2], | ||
2160 | FLAC__int32 *residual[2], | ||
2161 | unsigned *best_subframe, | ||
2162 | unsigned *best_bits | ||
2163 | ) | ||
2164 | { | ||
2165 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2166 | FLAC__float fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]; | ||
2167 | #else | ||
2168 | FLAC__fixedpoint fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]; | ||
2169 | #endif | ||
2170 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2171 | FLAC__double lpc_residual_bits_per_sample; | ||
2172 | FLAC__real autoc[FLAC__MAX_LPC_ORDER+1]; /* WATCHOUT: the size is important even though encoder->protected_->max_lpc_order might be less; some asm routines need all the space */ | ||
2173 | FLAC__double lpc_error[FLAC__MAX_LPC_ORDER]; | ||
2174 | unsigned min_lpc_order, max_lpc_order, lpc_order; | ||
2175 | unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision; | ||
2176 | #endif | ||
2177 | unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order; | ||
2178 | unsigned rice_parameter; | ||
2179 | unsigned _candidate_bits, _best_bits; | ||
2180 | unsigned _best_subframe; | ||
2181 | |||
2182 | /* verbatim subframe is the baseline against which we measure other compressed subframes */ | ||
2183 | _best_subframe = 0; | ||
2184 | if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) | ||
2185 | _best_bits = UINT_MAX; | ||
2186 | else | ||
2187 | _best_bits = evaluate_verbatim_subframe_(integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); | ||
2188 | |||
2189 | if(frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) { | ||
2190 | unsigned signal_is_constant = false; | ||
2191 | guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor(integer_signal+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); | ||
2192 | /* check for constant subframe */ | ||
2193 | if( | ||
2194 | !encoder->private_->disable_constant_subframes && | ||
2195 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2196 | fixed_residual_bits_per_sample[1] == 0.0 | ||
2197 | #else | ||
2198 | fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO | ||
2199 | #endif | ||
2200 | ) { | ||
2201 | /* the above means it's possible all samples are the same value; now double-check it: */ | ||
2202 | unsigned i; | ||
2203 | signal_is_constant = true; | ||
2204 | for(i = 1; i < frame_header->blocksize; i++) { | ||
2205 | if(integer_signal[0] != integer_signal[i]) { | ||
2206 | signal_is_constant = false; | ||
2207 | break; | ||
2208 | } | ||
2209 | } | ||
2210 | } | ||
2211 | if(signal_is_constant) { | ||
2212 | _candidate_bits = evaluate_constant_subframe_(integer_signal[0], subframe_bps, subframe[!_best_subframe]); | ||
2213 | if(_candidate_bits < _best_bits) { | ||
2214 | _best_subframe = !_best_subframe; | ||
2215 | _best_bits = _candidate_bits; | ||
2216 | } | ||
2217 | } | ||
2218 | else { | ||
2219 | if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) { | ||
2220 | /* encode fixed */ | ||
2221 | if(encoder->protected_->do_exhaustive_model_search) { | ||
2222 | min_fixed_order = 0; | ||
2223 | max_fixed_order = FLAC__MAX_FIXED_ORDER; | ||
2224 | } | ||
2225 | else { | ||
2226 | min_fixed_order = max_fixed_order = guess_fixed_order; | ||
2227 | } | ||
2228 | for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) { | ||
2229 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2230 | if(fixed_residual_bits_per_sample[fixed_order] >= (FLAC__float)subframe_bps) | ||
2231 | continue; /* don't even try */ | ||
2232 | rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > 0.0)? (unsigned)(fixed_residual_bits_per_sample[fixed_order]+0.5) : 0; /* 0.5 is for rounding */ | ||
2233 | #else | ||
2234 | if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]) >= (int)subframe_bps) | ||
2235 | continue; /* don't even try */ | ||
2236 | rice_parameter = (fixed_residual_bits_per_sample[fixed_order] > FLAC__FP_ZERO)? (unsigned)FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]+FLAC__FP_ONE_HALF) : 0; /* 0.5 is for rounding */ | ||
2237 | #endif | ||
2238 | #ifndef FLAC__SYMMETRIC_RICE | ||
2239 | rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */ | ||
2240 | #endif | ||
2241 | if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
2242 | #ifdef DEBUG_VERBOSE | ||
2243 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @0\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
2244 | #endif | ||
2245 | rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
2246 | } | ||
2247 | _candidate_bits = | ||
2248 | evaluate_fixed_subframe_( | ||
2249 | encoder, | ||
2250 | integer_signal, | ||
2251 | residual[!_best_subframe], | ||
2252 | encoder->private_->abs_residual, | ||
2253 | encoder->private_->abs_residual_partition_sums, | ||
2254 | encoder->private_->raw_bits_per_partition, | ||
2255 | frame_header->blocksize, | ||
2256 | subframe_bps, | ||
2257 | fixed_order, | ||
2258 | rice_parameter, | ||
2259 | min_partition_order, | ||
2260 | max_partition_order, | ||
2261 | precompute_partition_sums, | ||
2262 | encoder->protected_->do_escape_coding, | ||
2263 | encoder->protected_->rice_parameter_search_dist, | ||
2264 | subframe[!_best_subframe], | ||
2265 | partitioned_rice_contents[!_best_subframe] | ||
2266 | ); | ||
2267 | if(_candidate_bits < _best_bits) { | ||
2268 | _best_subframe = !_best_subframe; | ||
2269 | _best_bits = _candidate_bits; | ||
2270 | } | ||
2271 | } | ||
2272 | } | ||
2273 | |||
2274 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2275 | /* encode lpc */ | ||
2276 | if(encoder->protected_->max_lpc_order > 0) { | ||
2277 | if(encoder->protected_->max_lpc_order >= frame_header->blocksize) | ||
2278 | max_lpc_order = frame_header->blocksize-1; | ||
2279 | else | ||
2280 | max_lpc_order = encoder->protected_->max_lpc_order; | ||
2281 | if(max_lpc_order > 0) { | ||
2282 | encoder->private_->local_lpc_compute_autocorrelation(real_signal, frame_header->blocksize, max_lpc_order+1, autoc); | ||
2283 | /* if autoc[0] == 0.0, the signal is constant and we usually won't get here, but it can happen */ | ||
2284 | if(autoc[0] != 0.0) { | ||
2285 | FLAC__lpc_compute_lp_coefficients(autoc, max_lpc_order, encoder->private_->lp_coeff, lpc_error); | ||
2286 | if(encoder->protected_->do_exhaustive_model_search) { | ||
2287 | min_lpc_order = 1; | ||
2288 | } | ||
2289 | else { | ||
2290 | unsigned guess_lpc_order = FLAC__lpc_compute_best_order(lpc_error, max_lpc_order, frame_header->blocksize, subframe_bps); | ||
2291 | min_lpc_order = max_lpc_order = guess_lpc_order; | ||
2292 | } | ||
2293 | for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) { | ||
2294 | lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order); | ||
2295 | if(lpc_residual_bits_per_sample >= (FLAC__double)subframe_bps) | ||
2296 | continue; /* don't even try */ | ||
2297 | rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+0.5) : 0; /* 0.5 is for rounding */ | ||
2298 | #ifndef FLAC__SYMMETRIC_RICE | ||
2299 | rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */ | ||
2300 | #endif | ||
2301 | if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
2302 | #ifdef DEBUG_VERBOSE | ||
2303 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @1\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
2304 | #endif | ||
2305 | rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
2306 | } | ||
2307 | if(encoder->protected_->do_qlp_coeff_prec_search) { | ||
2308 | min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION; | ||
2309 | /* ensure a 32-bit datapath throughout for 16bps or less */ | ||
2310 | if(subframe_bps <= 16) | ||
2311 | max_qlp_coeff_precision = min(32 - subframe_bps - lpc_order, FLAC__MAX_QLP_COEFF_PRECISION); | ||
2312 | else | ||
2313 | max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; | ||
2314 | } | ||
2315 | else { | ||
2316 | min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision; | ||
2317 | } | ||
2318 | for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) { | ||
2319 | _candidate_bits = | ||
2320 | evaluate_lpc_subframe_( | ||
2321 | encoder, | ||
2322 | integer_signal, | ||
2323 | residual[!_best_subframe], | ||
2324 | encoder->private_->abs_residual, | ||
2325 | encoder->private_->abs_residual_partition_sums, | ||
2326 | encoder->private_->raw_bits_per_partition, | ||
2327 | encoder->private_->lp_coeff[lpc_order-1], | ||
2328 | frame_header->blocksize, | ||
2329 | subframe_bps, | ||
2330 | lpc_order, | ||
2331 | qlp_coeff_precision, | ||
2332 | rice_parameter, | ||
2333 | min_partition_order, | ||
2334 | max_partition_order, | ||
2335 | precompute_partition_sums, | ||
2336 | encoder->protected_->do_escape_coding, | ||
2337 | encoder->protected_->rice_parameter_search_dist, | ||
2338 | subframe[!_best_subframe], | ||
2339 | partitioned_rice_contents[!_best_subframe] | ||
2340 | ); | ||
2341 | if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */ | ||
2342 | if(_candidate_bits < _best_bits) { | ||
2343 | _best_subframe = !_best_subframe; | ||
2344 | _best_bits = _candidate_bits; | ||
2345 | } | ||
2346 | } | ||
2347 | } | ||
2348 | } | ||
2349 | } | ||
2350 | } | ||
2351 | } | ||
2352 | #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */ | ||
2353 | } | ||
2354 | } | ||
2355 | |||
2356 | /* under rare circumstances this can happen when all but lpc subframe types are disabled: */ | ||
2357 | if(_best_bits == UINT_MAX) { | ||
2358 | FLAC__ASSERT(_best_subframe == 0); | ||
2359 | _best_bits = evaluate_verbatim_subframe_(integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); | ||
2360 | } | ||
2361 | |||
2362 | *best_subframe = _best_subframe; | ||
2363 | *best_bits = _best_bits; | ||
2364 | |||
2365 | return true; | ||
2366 | } | ||
2367 | |||
2368 | FLAC__bool add_subframe_( | ||
2369 | FLAC__StreamEncoder *encoder, | ||
2370 | const FLAC__FrameHeader *frame_header, | ||
2371 | unsigned subframe_bps, | ||
2372 | const FLAC__Subframe *subframe, | ||
2373 | FLAC__BitBuffer *frame | ||
2374 | ) | ||
2375 | { | ||
2376 | switch(subframe->type) { | ||
2377 | case FLAC__SUBFRAME_TYPE_CONSTANT: | ||
2378 | if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) { | ||
2379 | encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING; | ||
2380 | return false; | ||
2381 | } | ||
2382 | break; | ||
2383 | case FLAC__SUBFRAME_TYPE_FIXED: | ||
2384 | if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), frame_header->blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) { | ||
2385 | encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING; | ||
2386 | return false; | ||
2387 | } | ||
2388 | break; | ||
2389 | case FLAC__SUBFRAME_TYPE_LPC: | ||
2390 | if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), frame_header->blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) { | ||
2391 | encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING; | ||
2392 | return false; | ||
2393 | } | ||
2394 | break; | ||
2395 | case FLAC__SUBFRAME_TYPE_VERBATIM: | ||
2396 | if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), frame_header->blocksize, subframe_bps, subframe->wasted_bits, frame)) { | ||
2397 | encoder->protected_->state = FLAC__STREAM_ENCODER_FATAL_ERROR_WHILE_ENCODING; | ||
2398 | return false; | ||
2399 | } | ||
2400 | break; | ||
2401 | default: | ||
2402 | FLAC__ASSERT(0); | ||
2403 | } | ||
2404 | |||
2405 | return true; | ||
2406 | } | ||
2407 | |||
2408 | unsigned evaluate_constant_subframe_( | ||
2409 | const FLAC__int32 signal, | ||
2410 | unsigned subframe_bps, | ||
2411 | FLAC__Subframe *subframe | ||
2412 | ) | ||
2413 | { | ||
2414 | subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT; | ||
2415 | subframe->data.constant.value = signal; | ||
2416 | |||
2417 | return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe_bps; | ||
2418 | } | ||
2419 | |||
2420 | unsigned evaluate_fixed_subframe_( | ||
2421 | FLAC__StreamEncoder *encoder, | ||
2422 | const FLAC__int32 signal[], | ||
2423 | FLAC__int32 residual[], | ||
2424 | FLAC__uint32 abs_residual[], | ||
2425 | FLAC__uint64 abs_residual_partition_sums[], | ||
2426 | unsigned raw_bits_per_partition[], | ||
2427 | unsigned blocksize, | ||
2428 | unsigned subframe_bps, | ||
2429 | unsigned order, | ||
2430 | unsigned rice_parameter, | ||
2431 | unsigned min_partition_order, | ||
2432 | unsigned max_partition_order, | ||
2433 | FLAC__bool precompute_partition_sums, | ||
2434 | FLAC__bool do_escape_coding, | ||
2435 | unsigned rice_parameter_search_dist, | ||
2436 | FLAC__Subframe *subframe, | ||
2437 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents | ||
2438 | ) | ||
2439 | { | ||
2440 | unsigned i, residual_bits; | ||
2441 | const unsigned residual_samples = blocksize - order; | ||
2442 | |||
2443 | FLAC__fixed_compute_residual(signal+order, residual_samples, order, residual); | ||
2444 | |||
2445 | subframe->type = FLAC__SUBFRAME_TYPE_FIXED; | ||
2446 | |||
2447 | subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; | ||
2448 | subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; | ||
2449 | subframe->data.fixed.residual = residual; | ||
2450 | |||
2451 | residual_bits = | ||
2452 | find_best_partition_order_( | ||
2453 | encoder->private_, | ||
2454 | residual, | ||
2455 | abs_residual, | ||
2456 | abs_residual_partition_sums, | ||
2457 | raw_bits_per_partition, | ||
2458 | residual_samples, | ||
2459 | order, | ||
2460 | rice_parameter, | ||
2461 | min_partition_order, | ||
2462 | max_partition_order, | ||
2463 | precompute_partition_sums, | ||
2464 | do_escape_coding, | ||
2465 | rice_parameter_search_dist, | ||
2466 | &subframe->data.fixed.entropy_coding_method.data.partitioned_rice | ||
2467 | ); | ||
2468 | |||
2469 | subframe->data.fixed.order = order; | ||
2470 | for(i = 0; i < order; i++) | ||
2471 | subframe->data.fixed.warmup[i] = signal[i]; | ||
2472 | |||
2473 | return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (order * subframe_bps) + residual_bits; | ||
2474 | } | ||
2475 | |||
2476 | #ifndef FLAC__INTEGER_ONLY_LIBRARY | ||
2477 | unsigned evaluate_lpc_subframe_( | ||
2478 | FLAC__StreamEncoder *encoder, | ||
2479 | const FLAC__int32 signal[], | ||
2480 | FLAC__int32 residual[], | ||
2481 | FLAC__uint32 abs_residual[], | ||
2482 | FLAC__uint64 abs_residual_partition_sums[], | ||
2483 | unsigned raw_bits_per_partition[], | ||
2484 | const FLAC__real lp_coeff[], | ||
2485 | unsigned blocksize, | ||
2486 | unsigned subframe_bps, | ||
2487 | unsigned order, | ||
2488 | unsigned qlp_coeff_precision, | ||
2489 | unsigned rice_parameter, | ||
2490 | unsigned min_partition_order, | ||
2491 | unsigned max_partition_order, | ||
2492 | FLAC__bool precompute_partition_sums, | ||
2493 | FLAC__bool do_escape_coding, | ||
2494 | unsigned rice_parameter_search_dist, | ||
2495 | FLAC__Subframe *subframe, | ||
2496 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents | ||
2497 | ) | ||
2498 | { | ||
2499 | FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; | ||
2500 | unsigned i, residual_bits; | ||
2501 | int quantization, ret; | ||
2502 | const unsigned residual_samples = blocksize - order; | ||
2503 | |||
2504 | /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps streams */ | ||
2505 | if(subframe_bps <= 16) { | ||
2506 | FLAC__ASSERT(order > 0); | ||
2507 | FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER); | ||
2508 | qlp_coeff_precision = min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order)); | ||
2509 | } | ||
2510 | |||
2511 | ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization); | ||
2512 | if(ret != 0) | ||
2513 | return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */ | ||
2514 | |||
2515 | if(subframe_bps + qlp_coeff_precision + FLAC__bitmath_ilog2(order) <= 32) | ||
2516 | if(subframe_bps <= 16 && qlp_coeff_precision <= 16) | ||
2517 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual); | ||
2518 | else | ||
2519 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual); | ||
2520 | else | ||
2521 | encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual); | ||
2522 | |||
2523 | subframe->type = FLAC__SUBFRAME_TYPE_LPC; | ||
2524 | |||
2525 | subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; | ||
2526 | subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; | ||
2527 | subframe->data.lpc.residual = residual; | ||
2528 | |||
2529 | residual_bits = | ||
2530 | find_best_partition_order_( | ||
2531 | encoder->private_, | ||
2532 | residual, | ||
2533 | abs_residual, | ||
2534 | abs_residual_partition_sums, | ||
2535 | raw_bits_per_partition, | ||
2536 | residual_samples, | ||
2537 | order, | ||
2538 | rice_parameter, | ||
2539 | min_partition_order, | ||
2540 | max_partition_order, | ||
2541 | precompute_partition_sums, | ||
2542 | do_escape_coding, | ||
2543 | rice_parameter_search_dist, | ||
2544 | &subframe->data.fixed.entropy_coding_method.data.partitioned_rice | ||
2545 | ); | ||
2546 | |||
2547 | subframe->data.lpc.order = order; | ||
2548 | subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision; | ||
2549 | subframe->data.lpc.quantization_level = quantization; | ||
2550 | memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER); | ||
2551 | for(i = 0; i < order; i++) | ||
2552 | subframe->data.lpc.warmup[i] = signal[i]; | ||
2553 | |||
2554 | return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN + (order * (qlp_coeff_precision + subframe_bps)) + residual_bits; | ||
2555 | } | ||
2556 | #endif | ||
2557 | |||
2558 | unsigned evaluate_verbatim_subframe_( | ||
2559 | const FLAC__int32 signal[], | ||
2560 | unsigned blocksize, | ||
2561 | unsigned subframe_bps, | ||
2562 | FLAC__Subframe *subframe | ||
2563 | ) | ||
2564 | { | ||
2565 | subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM; | ||
2566 | |||
2567 | subframe->data.verbatim.data = signal; | ||
2568 | |||
2569 | return FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + (blocksize * subframe_bps); | ||
2570 | } | ||
2571 | |||
2572 | unsigned find_best_partition_order_( | ||
2573 | FLAC__StreamEncoderPrivate *private_, | ||
2574 | const FLAC__int32 residual[], | ||
2575 | FLAC__uint32 abs_residual[], | ||
2576 | FLAC__uint64 abs_residual_partition_sums[], | ||
2577 | unsigned raw_bits_per_partition[], | ||
2578 | unsigned residual_samples, | ||
2579 | unsigned predictor_order, | ||
2580 | unsigned rice_parameter, | ||
2581 | unsigned min_partition_order, | ||
2582 | unsigned max_partition_order, | ||
2583 | FLAC__bool precompute_partition_sums, | ||
2584 | FLAC__bool do_escape_coding, | ||
2585 | unsigned rice_parameter_search_dist, | ||
2586 | FLAC__EntropyCodingMethod_PartitionedRice *best_partitioned_rice | ||
2587 | ) | ||
2588 | { | ||
2589 | FLAC__int32 r; | ||
2590 | unsigned residual_bits, best_residual_bits = 0; | ||
2591 | unsigned residual_sample; | ||
2592 | unsigned best_parameters_index = 0; | ||
2593 | const unsigned blocksize = residual_samples + predictor_order; | ||
2594 | |||
2595 | /* compute abs(residual) for use later */ | ||
2596 | for(residual_sample = 0; residual_sample < residual_samples; residual_sample++) { | ||
2597 | r = residual[residual_sample]; | ||
2598 | abs_residual[residual_sample] = (FLAC__uint32)(r<0? -r : r); | ||
2599 | } | ||
2600 | |||
2601 | max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order); | ||
2602 | min_partition_order = min(min_partition_order, max_partition_order); | ||
2603 | |||
2604 | if(precompute_partition_sums) { | ||
2605 | int partition_order; | ||
2606 | unsigned sum; | ||
2607 | |||
2608 | precompute_partition_info_sums_(abs_residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order); | ||
2609 | |||
2610 | if(do_escape_coding) | ||
2611 | precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order); | ||
2612 | |||
2613 | for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) { | ||
2614 | #ifdef DONT_ESTIMATE_RICE_BITS | ||
2615 | if(! | ||
2616 | set_partitioned_rice_with_precompute_( | ||
2617 | residual, | ||
2618 | abs_residual_partition_sums+sum, | ||
2619 | raw_bits_per_partition+sum, | ||
2620 | residual_samples, | ||
2621 | predictor_order, | ||
2622 | rice_parameter, | ||
2623 | rice_parameter_search_dist, | ||
2624 | (unsigned)partition_order, | ||
2625 | do_escape_coding, | ||
2626 | &private_->partitioned_rice_contents_extra[!best_parameters_index], | ||
2627 | &residual_bits | ||
2628 | ) | ||
2629 | ) | ||
2630 | #else | ||
2631 | if(! | ||
2632 | set_partitioned_rice_with_precompute_( | ||
2633 | abs_residual, | ||
2634 | abs_residual_partition_sums+sum, | ||
2635 | raw_bits_per_partition+sum, | ||
2636 | residual_samples, | ||
2637 | predictor_order, | ||
2638 | rice_parameter, | ||
2639 | rice_parameter_search_dist, | ||
2640 | (unsigned)partition_order, | ||
2641 | do_escape_coding, | ||
2642 | &private_->partitioned_rice_contents_extra[!best_parameters_index], | ||
2643 | &residual_bits | ||
2644 | ) | ||
2645 | ) | ||
2646 | #endif | ||
2647 | { | ||
2648 | FLAC__ASSERT(best_residual_bits != 0); | ||
2649 | break; | ||
2650 | } | ||
2651 | sum += 1u << partition_order; | ||
2652 | if(best_residual_bits == 0 || residual_bits < best_residual_bits) { | ||
2653 | best_residual_bits = residual_bits; | ||
2654 | best_parameters_index = !best_parameters_index; | ||
2655 | best_partitioned_rice->order = partition_order; | ||
2656 | } | ||
2657 | } | ||
2658 | } | ||
2659 | else { | ||
2660 | unsigned partition_order; | ||
2661 | for(partition_order = min_partition_order; partition_order <= max_partition_order; partition_order++) { | ||
2662 | #ifdef DONT_ESTIMATE_RICE_BITS | ||
2663 | if(! | ||
2664 | set_partitioned_rice_( | ||
2665 | abs_residual, | ||
2666 | residual, | ||
2667 | residual_samples, | ||
2668 | predictor_order, | ||
2669 | rice_parameter, | ||
2670 | rice_parameter_search_dist, | ||
2671 | partition_order, | ||
2672 | &private_->partitioned_rice_contents_extra[!best_parameters_index], | ||
2673 | &residual_bits | ||
2674 | ) | ||
2675 | ) | ||
2676 | #else | ||
2677 | if(! | ||
2678 | set_partitioned_rice_( | ||
2679 | abs_residual, | ||
2680 | residual_samples, | ||
2681 | predictor_order, | ||
2682 | rice_parameter, | ||
2683 | rice_parameter_search_dist, | ||
2684 | partition_order, | ||
2685 | &private_->partitioned_rice_contents_extra[!best_parameters_index], | ||
2686 | &residual_bits | ||
2687 | ) | ||
2688 | ) | ||
2689 | #endif | ||
2690 | { | ||
2691 | FLAC__ASSERT(best_residual_bits != 0); | ||
2692 | break; | ||
2693 | } | ||
2694 | if(best_residual_bits == 0 || residual_bits < best_residual_bits) { | ||
2695 | best_residual_bits = residual_bits; | ||
2696 | best_parameters_index = !best_parameters_index; | ||
2697 | best_partitioned_rice->order = partition_order; | ||
2698 | } | ||
2699 | } | ||
2700 | } | ||
2701 | |||
2702 | /* | ||
2703 | * We are allowed to de-const the pointer based on our special knowledge; | ||
2704 | * it is const to the outside world. | ||
2705 | */ | ||
2706 | { | ||
2707 | FLAC__EntropyCodingMethod_PartitionedRiceContents* best_partitioned_rice_contents = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_partitioned_rice->contents; | ||
2708 | FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(best_partitioned_rice_contents, max(6, best_partitioned_rice->order)); | ||
2709 | memcpy(best_partitioned_rice_contents->parameters, private_->partitioned_rice_contents_extra[best_parameters_index].parameters, sizeof(unsigned)*(1<<(best_partitioned_rice->order))); | ||
2710 | memcpy(best_partitioned_rice_contents->raw_bits, private_->partitioned_rice_contents_extra[best_parameters_index].raw_bits, sizeof(unsigned)*(1<<(best_partitioned_rice->order))); | ||
2711 | } | ||
2712 | |||
2713 | return best_residual_bits; | ||
2714 | } | ||
2715 | |||
2716 | void precompute_partition_info_sums_( | ||
2717 | const FLAC__uint32 abs_residual[], | ||
2718 | FLAC__uint64 abs_residual_partition_sums[], | ||
2719 | unsigned residual_samples, | ||
2720 | unsigned predictor_order, | ||
2721 | unsigned min_partition_order, | ||
2722 | unsigned max_partition_order | ||
2723 | ) | ||
2724 | { | ||
2725 | int partition_order; | ||
2726 | unsigned from_partition, to_partition = 0; | ||
2727 | const unsigned blocksize = residual_samples + predictor_order; | ||
2728 | |||
2729 | /* first do max_partition_order */ | ||
2730 | for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) { | ||
2731 | FLAC__uint64 abs_residual_partition_sum; | ||
2732 | FLAC__uint32 abs_r; | ||
2733 | unsigned partition, partition_sample, partition_samples, residual_sample; | ||
2734 | const unsigned partitions = 1u << partition_order; | ||
2735 | const unsigned default_partition_samples = blocksize >> partition_order; | ||
2736 | |||
2737 | FLAC__ASSERT(default_partition_samples > predictor_order); | ||
2738 | |||
2739 | for(partition = residual_sample = 0; partition < partitions; partition++) { | ||
2740 | partition_samples = default_partition_samples; | ||
2741 | if(partition == 0) | ||
2742 | partition_samples -= predictor_order; | ||
2743 | abs_residual_partition_sum = 0; | ||
2744 | for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) { | ||
2745 | abs_r = abs_residual[residual_sample]; | ||
2746 | abs_residual_partition_sum += abs_r; | ||
2747 | residual_sample++; | ||
2748 | } | ||
2749 | abs_residual_partition_sums[partition] = abs_residual_partition_sum; | ||
2750 | } | ||
2751 | to_partition = partitions; | ||
2752 | break; | ||
2753 | } | ||
2754 | |||
2755 | /* now merge partitions for lower orders */ | ||
2756 | for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) { | ||
2757 | FLAC__uint64 s; | ||
2758 | unsigned i; | ||
2759 | const unsigned partitions = 1u << partition_order; | ||
2760 | for(i = 0; i < partitions; i++) { | ||
2761 | s = abs_residual_partition_sums[from_partition]; | ||
2762 | from_partition++; | ||
2763 | abs_residual_partition_sums[to_partition] = s + abs_residual_partition_sums[from_partition]; | ||
2764 | from_partition++; | ||
2765 | to_partition++; | ||
2766 | } | ||
2767 | } | ||
2768 | } | ||
2769 | |||
2770 | void precompute_partition_info_escapes_( | ||
2771 | const FLAC__int32 residual[], | ||
2772 | unsigned raw_bits_per_partition[], | ||
2773 | unsigned residual_samples, | ||
2774 | unsigned predictor_order, | ||
2775 | unsigned min_partition_order, | ||
2776 | unsigned max_partition_order | ||
2777 | ) | ||
2778 | { | ||
2779 | int partition_order; | ||
2780 | unsigned from_partition, to_partition = 0; | ||
2781 | const unsigned blocksize = residual_samples + predictor_order; | ||
2782 | |||
2783 | /* first do max_partition_order */ | ||
2784 | for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) { | ||
2785 | FLAC__int32 r, residual_partition_min, residual_partition_max; | ||
2786 | unsigned silog2_min, silog2_max; | ||
2787 | unsigned partition, partition_sample, partition_samples, residual_sample; | ||
2788 | const unsigned partitions = 1u << partition_order; | ||
2789 | const unsigned default_partition_samples = blocksize >> partition_order; | ||
2790 | |||
2791 | FLAC__ASSERT(default_partition_samples > predictor_order); | ||
2792 | |||
2793 | for(partition = residual_sample = 0; partition < partitions; partition++) { | ||
2794 | partition_samples = default_partition_samples; | ||
2795 | if(partition == 0) | ||
2796 | partition_samples -= predictor_order; | ||
2797 | residual_partition_min = residual_partition_max = 0; | ||
2798 | for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) { | ||
2799 | r = residual[residual_sample]; | ||
2800 | if(r < residual_partition_min) | ||
2801 | residual_partition_min = r; | ||
2802 | else if(r > residual_partition_max) | ||
2803 | residual_partition_max = r; | ||
2804 | residual_sample++; | ||
2805 | } | ||
2806 | silog2_min = FLAC__bitmath_silog2(residual_partition_min); | ||
2807 | silog2_max = FLAC__bitmath_silog2(residual_partition_max); | ||
2808 | raw_bits_per_partition[partition] = max(silog2_min, silog2_max); | ||
2809 | } | ||
2810 | to_partition = partitions; | ||
2811 | break; | ||
2812 | } | ||
2813 | |||
2814 | /* now merge partitions for lower orders */ | ||
2815 | for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) { | ||
2816 | unsigned m; | ||
2817 | unsigned i; | ||
2818 | const unsigned partitions = 1u << partition_order; | ||
2819 | for(i = 0; i < partitions; i++) { | ||
2820 | m = raw_bits_per_partition[from_partition]; | ||
2821 | from_partition++; | ||
2822 | raw_bits_per_partition[to_partition] = max(m, raw_bits_per_partition[from_partition]); | ||
2823 | from_partition++; | ||
2824 | to_partition++; | ||
2825 | } | ||
2826 | } | ||
2827 | } | ||
2828 | |||
2829 | #ifdef VARIABLE_RICE_BITS | ||
2830 | #undef VARIABLE_RICE_BITS | ||
2831 | #endif | ||
2832 | #ifndef DONT_ESTIMATE_RICE_BITS | ||
2833 | #define VARIABLE_RICE_BITS(value, parameter) ((value) >> (parameter)) | ||
2834 | #endif | ||
2835 | |||
2836 | #ifdef DONT_ESTIMATE_RICE_BITS | ||
2837 | FLAC__bool set_partitioned_rice_( | ||
2838 | const FLAC__uint32 abs_residual[], | ||
2839 | const FLAC__int32 residual[], | ||
2840 | const unsigned residual_samples, | ||
2841 | const unsigned predictor_order, | ||
2842 | const unsigned suggested_rice_parameter, | ||
2843 | const unsigned rice_parameter_search_dist, | ||
2844 | const unsigned partition_order, | ||
2845 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
2846 | unsigned *bits | ||
2847 | ) | ||
2848 | #else | ||
2849 | FLAC__bool set_partitioned_rice_( | ||
2850 | const FLAC__uint32 abs_residual[], | ||
2851 | const unsigned residual_samples, | ||
2852 | const unsigned predictor_order, | ||
2853 | const unsigned suggested_rice_parameter, | ||
2854 | const unsigned rice_parameter_search_dist, | ||
2855 | const unsigned partition_order, | ||
2856 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
2857 | unsigned *bits | ||
2858 | ) | ||
2859 | #endif | ||
2860 | { | ||
2861 | unsigned rice_parameter, partition_bits; | ||
2862 | #ifndef NO_RICE_SEARCH | ||
2863 | unsigned best_partition_bits; | ||
2864 | unsigned min_rice_parameter, max_rice_parameter, best_rice_parameter = 0; | ||
2865 | #endif | ||
2866 | unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; | ||
2867 | unsigned *parameters; | ||
2868 | |||
2869 | FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER); | ||
2870 | |||
2871 | FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, max(6, partition_order)); | ||
2872 | parameters = partitioned_rice_contents->parameters; | ||
2873 | |||
2874 | if(partition_order == 0) { | ||
2875 | unsigned i; | ||
2876 | |||
2877 | #ifndef NO_RICE_SEARCH | ||
2878 | if(rice_parameter_search_dist) { | ||
2879 | if(suggested_rice_parameter < rice_parameter_search_dist) | ||
2880 | min_rice_parameter = 0; | ||
2881 | else | ||
2882 | min_rice_parameter = suggested_rice_parameter - rice_parameter_search_dist; | ||
2883 | max_rice_parameter = suggested_rice_parameter + rice_parameter_search_dist; | ||
2884 | if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
2885 | #ifdef DEBUG_VERBOSE | ||
2886 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @2\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
2887 | #endif | ||
2888 | max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
2889 | } | ||
2890 | } | ||
2891 | else | ||
2892 | min_rice_parameter = max_rice_parameter = suggested_rice_parameter; | ||
2893 | |||
2894 | best_partition_bits = 0xffffffff; | ||
2895 | for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { | ||
2896 | #endif | ||
2897 | #ifdef VARIABLE_RICE_BITS | ||
2898 | #ifdef FLAC__SYMMETRIC_RICE | ||
2899 | partition_bits = (2+rice_parameter) * residual_samples; | ||
2900 | #else | ||
2901 | const unsigned rice_parameter_estimate = rice_parameter-1; | ||
2902 | partition_bits = (1+rice_parameter) * residual_samples; | ||
2903 | #endif | ||
2904 | #else | ||
2905 | partition_bits = 0; | ||
2906 | #endif | ||
2907 | partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; | ||
2908 | for(i = 0; i < residual_samples; i++) { | ||
2909 | #ifdef VARIABLE_RICE_BITS | ||
2910 | #ifdef FLAC__SYMMETRIC_RICE | ||
2911 | partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter); | ||
2912 | #else | ||
2913 | partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter_estimate); | ||
2914 | #endif | ||
2915 | #else | ||
2916 | partition_bits += FLAC__bitbuffer_rice_bits(residual[i], rice_parameter); /* NOTE: we will need to pass in residual[] in addition to abs_residual[] */ | ||
2917 | #endif | ||
2918 | } | ||
2919 | #ifndef NO_RICE_SEARCH | ||
2920 | if(partition_bits < best_partition_bits) { | ||
2921 | best_rice_parameter = rice_parameter; | ||
2922 | best_partition_bits = partition_bits; | ||
2923 | } | ||
2924 | } | ||
2925 | #endif | ||
2926 | parameters[0] = best_rice_parameter; | ||
2927 | bits_ += best_partition_bits; | ||
2928 | } | ||
2929 | else { | ||
2930 | unsigned partition, residual_sample, save_residual_sample, partition_sample; | ||
2931 | unsigned partition_samples; | ||
2932 | FLAC__uint64 mean, k; | ||
2933 | const unsigned partitions = 1u << partition_order; | ||
2934 | for(partition = residual_sample = 0; partition < partitions; partition++) { | ||
2935 | partition_samples = (residual_samples+predictor_order) >> partition_order; | ||
2936 | if(partition == 0) { | ||
2937 | if(partition_samples <= predictor_order) | ||
2938 | return false; | ||
2939 | else | ||
2940 | partition_samples -= predictor_order; | ||
2941 | } | ||
2942 | mean = 0; | ||
2943 | save_residual_sample = residual_sample; | ||
2944 | for(partition_sample = 0; partition_sample < partition_samples; residual_sample++, partition_sample++) | ||
2945 | mean += abs_residual[residual_sample]; | ||
2946 | residual_sample = save_residual_sample; | ||
2947 | #ifdef FLAC__SYMMETRIC_RICE | ||
2948 | mean += partition_samples >> 1; /* for rounding effect */ | ||
2949 | mean /= partition_samples; | ||
2950 | |||
2951 | /* calc rice_parameter = floor(log2(mean)) */ | ||
2952 | rice_parameter = 0; | ||
2953 | mean>>=1; | ||
2954 | while(mean) { | ||
2955 | rice_parameter++; | ||
2956 | mean >>= 1; | ||
2957 | } | ||
2958 | #else | ||
2959 | /* we are basically calculating the size in bits of the | ||
2960 | * average residual magnitude in the partition: | ||
2961 | * rice_parameter = floor(log2(mean/partition_samples)) | ||
2962 | * 'mean' is not a good name for the variable, it is | ||
2963 | * actually the sum of magnitudes of all residual values | ||
2964 | * in the partition, so the actual mean is | ||
2965 | * mean/partition_samples | ||
2966 | */ | ||
2967 | for(rice_parameter = 0, k = partition_samples; k < mean; rice_parameter++, k <<= 1) | ||
2968 | ; | ||
2969 | #endif | ||
2970 | if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
2971 | #ifdef DEBUG_VERBOSE | ||
2972 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @3\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
2973 | #endif | ||
2974 | rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
2975 | } | ||
2976 | |||
2977 | #ifndef NO_RICE_SEARCH | ||
2978 | if(rice_parameter_search_dist) { | ||
2979 | if(rice_parameter < rice_parameter_search_dist) | ||
2980 | min_rice_parameter = 0; | ||
2981 | else | ||
2982 | min_rice_parameter = rice_parameter - rice_parameter_search_dist; | ||
2983 | max_rice_parameter = rice_parameter + rice_parameter_search_dist; | ||
2984 | if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
2985 | #ifdef DEBUG_VERBOSE | ||
2986 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @4\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
2987 | #endif | ||
2988 | max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
2989 | } | ||
2990 | } | ||
2991 | else | ||
2992 | min_rice_parameter = max_rice_parameter = rice_parameter; | ||
2993 | |||
2994 | best_partition_bits = 0xffffffff; | ||
2995 | for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { | ||
2996 | #endif | ||
2997 | #ifdef VARIABLE_RICE_BITS | ||
2998 | #ifdef FLAC__SYMMETRIC_RICE | ||
2999 | partition_bits = (2+rice_parameter) * partition_samples; | ||
3000 | #else | ||
3001 | const unsigned rice_parameter_estimate = rice_parameter-1; | ||
3002 | partition_bits = (1+rice_parameter) * partition_samples; | ||
3003 | #endif | ||
3004 | #else | ||
3005 | partition_bits = 0; | ||
3006 | #endif | ||
3007 | partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; | ||
3008 | save_residual_sample = residual_sample; | ||
3009 | for(partition_sample = 0; partition_sample < partition_samples; residual_sample++, partition_sample++) { | ||
3010 | #ifdef VARIABLE_RICE_BITS | ||
3011 | #ifdef FLAC__SYMMETRIC_RICE | ||
3012 | partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter); | ||
3013 | #else | ||
3014 | partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter_estimate); | ||
3015 | #endif | ||
3016 | #else | ||
3017 | partition_bits += FLAC__bitbuffer_rice_bits(residual[residual_sample], rice_parameter); /* NOTE: we will need to pass in residual[] in addition to abs_residual[] */ | ||
3018 | #endif | ||
3019 | } | ||
3020 | #ifndef NO_RICE_SEARCH | ||
3021 | if(rice_parameter != max_rice_parameter) | ||
3022 | residual_sample = save_residual_sample; | ||
3023 | if(partition_bits < best_partition_bits) { | ||
3024 | best_rice_parameter = rice_parameter; | ||
3025 | best_partition_bits = partition_bits; | ||
3026 | } | ||
3027 | } | ||
3028 | #endif | ||
3029 | parameters[partition] = best_rice_parameter; | ||
3030 | bits_ += best_partition_bits; | ||
3031 | } | ||
3032 | } | ||
3033 | |||
3034 | *bits = bits_; | ||
3035 | return true; | ||
3036 | } | ||
3037 | |||
3038 | #ifdef DONT_ESTIMATE_RICE_BITS | ||
3039 | FLAC__bool set_partitioned_rice_with_precompute_( | ||
3040 | const FLAC__int32 residual[], | ||
3041 | const FLAC__uint64 abs_residual_partition_sums[], | ||
3042 | const unsigned raw_bits_per_partition[], | ||
3043 | const unsigned residual_samples, | ||
3044 | const unsigned predictor_order, | ||
3045 | const unsigned suggested_rice_parameter, | ||
3046 | const unsigned rice_parameter_search_dist, | ||
3047 | const unsigned partition_order, | ||
3048 | const FLAC__bool search_for_escapes, | ||
3049 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
3050 | unsigned *bits | ||
3051 | ) | ||
3052 | #else | ||
3053 | FLAC__bool set_partitioned_rice_with_precompute_( | ||
3054 | const FLAC__uint32 abs_residual[], | ||
3055 | const FLAC__uint64 abs_residual_partition_sums[], | ||
3056 | const unsigned raw_bits_per_partition[], | ||
3057 | const unsigned residual_samples, | ||
3058 | const unsigned predictor_order, | ||
3059 | const unsigned suggested_rice_parameter, | ||
3060 | const unsigned rice_parameter_search_dist, | ||
3061 | const unsigned partition_order, | ||
3062 | const FLAC__bool search_for_escapes, | ||
3063 | FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, | ||
3064 | unsigned *bits | ||
3065 | ) | ||
3066 | #endif | ||
3067 | { | ||
3068 | unsigned rice_parameter, partition_bits; | ||
3069 | #ifndef NO_RICE_SEARCH | ||
3070 | unsigned best_partition_bits; | ||
3071 | unsigned min_rice_parameter, max_rice_parameter, best_rice_parameter = 0; | ||
3072 | #endif | ||
3073 | unsigned flat_bits; | ||
3074 | unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; | ||
3075 | unsigned *parameters, *raw_bits; | ||
3076 | |||
3077 | FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER); | ||
3078 | |||
3079 | FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, max(6, partition_order)); | ||
3080 | parameters = partitioned_rice_contents->parameters; | ||
3081 | raw_bits = partitioned_rice_contents->raw_bits; | ||
3082 | |||
3083 | if(partition_order == 0) { | ||
3084 | unsigned i; | ||
3085 | |||
3086 | #ifndef NO_RICE_SEARCH | ||
3087 | if(rice_parameter_search_dist) { | ||
3088 | if(suggested_rice_parameter < rice_parameter_search_dist) | ||
3089 | min_rice_parameter = 0; | ||
3090 | else | ||
3091 | min_rice_parameter = suggested_rice_parameter - rice_parameter_search_dist; | ||
3092 | max_rice_parameter = suggested_rice_parameter + rice_parameter_search_dist; | ||
3093 | if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
3094 | #ifdef DEBUG_VERBOSE | ||
3095 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @5\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
3096 | #endif | ||
3097 | max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
3098 | } | ||
3099 | } | ||
3100 | else | ||
3101 | min_rice_parameter = max_rice_parameter = suggested_rice_parameter; | ||
3102 | |||
3103 | best_partition_bits = 0xffffffff; | ||
3104 | for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { | ||
3105 | #endif | ||
3106 | #ifdef VARIABLE_RICE_BITS | ||
3107 | #ifdef FLAC__SYMMETRIC_RICE | ||
3108 | partition_bits = (2+rice_parameter) * residual_samples; | ||
3109 | #else | ||
3110 | const unsigned rice_parameter_estimate = rice_parameter-1; | ||
3111 | partition_bits = (1+rice_parameter) * residual_samples; | ||
3112 | #endif | ||
3113 | #else | ||
3114 | partition_bits = 0; | ||
3115 | #endif | ||
3116 | partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; | ||
3117 | for(i = 0; i < residual_samples; i++) { | ||
3118 | #ifdef VARIABLE_RICE_BITS | ||
3119 | #ifdef FLAC__SYMMETRIC_RICE | ||
3120 | partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter); | ||
3121 | #else | ||
3122 | partition_bits += VARIABLE_RICE_BITS(abs_residual[i], rice_parameter_estimate); | ||
3123 | #endif | ||
3124 | #else | ||
3125 | partition_bits += FLAC__bitbuffer_rice_bits(residual[i], rice_parameter); /* NOTE: we will need to pass in residual[] instead of abs_residual[] */ | ||
3126 | #endif | ||
3127 | } | ||
3128 | #ifndef NO_RICE_SEARCH | ||
3129 | if(partition_bits < best_partition_bits) { | ||
3130 | best_rice_parameter = rice_parameter; | ||
3131 | best_partition_bits = partition_bits; | ||
3132 | } | ||
3133 | } | ||
3134 | #endif | ||
3135 | if(search_for_escapes) { | ||
3136 | flat_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[0] * residual_samples; | ||
3137 | if(flat_bits <= best_partition_bits) { | ||
3138 | raw_bits[0] = raw_bits_per_partition[0]; | ||
3139 | best_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; | ||
3140 | best_partition_bits = flat_bits; | ||
3141 | } | ||
3142 | } | ||
3143 | parameters[0] = best_rice_parameter; | ||
3144 | bits_ += best_partition_bits; | ||
3145 | } | ||
3146 | else { | ||
3147 | unsigned partition, residual_sample, save_residual_sample, partition_sample; | ||
3148 | unsigned partition_samples; | ||
3149 | FLAC__uint64 mean, k; | ||
3150 | const unsigned partitions = 1u << partition_order; | ||
3151 | for(partition = residual_sample = 0; partition < partitions; partition++) { | ||
3152 | partition_samples = (residual_samples+predictor_order) >> partition_order; | ||
3153 | if(partition == 0) { | ||
3154 | if(partition_samples <= predictor_order) | ||
3155 | return false; | ||
3156 | else | ||
3157 | partition_samples -= predictor_order; | ||
3158 | } | ||
3159 | mean = abs_residual_partition_sums[partition]; | ||
3160 | #ifdef FLAC__SYMMETRIC_RICE | ||
3161 | mean += partition_samples >> 1; /* for rounding effect */ | ||
3162 | mean /= partition_samples; | ||
3163 | |||
3164 | /* calc rice_parameter = floor(log2(mean)) */ | ||
3165 | rice_parameter = 0; | ||
3166 | mean>>=1; | ||
3167 | while(mean) { | ||
3168 | rice_parameter++; | ||
3169 | mean >>= 1; | ||
3170 | } | ||
3171 | #else | ||
3172 | /* we are basically calculating the size in bits of the | ||
3173 | * average residual magnitude in the partition: | ||
3174 | * rice_parameter = floor(log2(mean/partition_samples)) | ||
3175 | * 'mean' is not a good name for the variable, it is | ||
3176 | * actually the sum of magnitudes of all residual values | ||
3177 | * in the partition, so the actual mean is | ||
3178 | * mean/partition_samples | ||
3179 | */ | ||
3180 | for(rice_parameter = 0, k = partition_samples; k < mean; rice_parameter++, k <<= 1) | ||
3181 | ; | ||
3182 | #endif | ||
3183 | if(rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
3184 | #ifdef DEBUG_VERBOSE | ||
3185 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @6\n", rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
3186 | #endif | ||
3187 | rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
3188 | } | ||
3189 | |||
3190 | #ifndef NO_RICE_SEARCH | ||
3191 | if(rice_parameter_search_dist) { | ||
3192 | if(rice_parameter < rice_parameter_search_dist) | ||
3193 | min_rice_parameter = 0; | ||
3194 | else | ||
3195 | min_rice_parameter = rice_parameter - rice_parameter_search_dist; | ||
3196 | max_rice_parameter = rice_parameter + rice_parameter_search_dist; | ||
3197 | if(max_rice_parameter >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
3198 | #ifdef DEBUG_VERBOSE | ||
3199 | fprintf(stderr, "clipping rice_parameter (%u -> %u) @7\n", max_rice_parameter, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1); | ||
3200 | #endif | ||
3201 | max_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER - 1; | ||
3202 | } | ||
3203 | } | ||
3204 | else | ||
3205 | min_rice_parameter = max_rice_parameter = rice_parameter; | ||
3206 | |||
3207 | best_partition_bits = 0xffffffff; | ||
3208 | for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { | ||
3209 | #endif | ||
3210 | #ifdef VARIABLE_RICE_BITS | ||
3211 | #ifdef FLAC__SYMMETRIC_RICE | ||
3212 | partition_bits = (2+rice_parameter) * partition_samples; | ||
3213 | #else | ||
3214 | const unsigned rice_parameter_estimate = rice_parameter-1; | ||
3215 | partition_bits = (1+rice_parameter) * partition_samples; | ||
3216 | #endif | ||
3217 | #else | ||
3218 | partition_bits = 0; | ||
3219 | #endif | ||
3220 | partition_bits += FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; | ||
3221 | save_residual_sample = residual_sample; | ||
3222 | for(partition_sample = 0; partition_sample < partition_samples; residual_sample++, partition_sample++) { | ||
3223 | #ifdef VARIABLE_RICE_BITS | ||
3224 | #ifdef FLAC__SYMMETRIC_RICE | ||
3225 | partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter); | ||
3226 | #else | ||
3227 | partition_bits += VARIABLE_RICE_BITS(abs_residual[residual_sample], rice_parameter_estimate); | ||
3228 | #endif | ||
3229 | #else | ||
3230 | partition_bits += FLAC__bitbuffer_rice_bits(residual[residual_sample], rice_parameter); /* NOTE: we will need to pass in residual[] instead of abs_residual[] */ | ||
3231 | #endif | ||
3232 | } | ||
3233 | #ifndef NO_RICE_SEARCH | ||
3234 | if(rice_parameter != max_rice_parameter) | ||
3235 | residual_sample = save_residual_sample; | ||
3236 | if(partition_bits < best_partition_bits) { | ||
3237 | best_rice_parameter = rice_parameter; | ||
3238 | best_partition_bits = partition_bits; | ||
3239 | } | ||
3240 | } | ||
3241 | #endif | ||
3242 | if(search_for_escapes) { | ||
3243 | flat_bits = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN + raw_bits_per_partition[partition] * partition_samples; | ||
3244 | if(flat_bits <= best_partition_bits) { | ||
3245 | raw_bits[partition] = raw_bits_per_partition[partition]; | ||
3246 | best_rice_parameter = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; | ||
3247 | best_partition_bits = flat_bits; | ||
3248 | } | ||
3249 | } | ||
3250 | parameters[partition] = best_rice_parameter; | ||
3251 | bits_ += best_partition_bits; | ||
3252 | } | ||
3253 | } | ||
3254 | |||
3255 | *bits = bits_; | ||
3256 | return true; | ||
3257 | } | ||
3258 | |||
3259 | unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples) | ||
3260 | { | ||
3261 | unsigned i, shift; | ||
3262 | FLAC__int32 x = 0; | ||
3263 | |||
3264 | for(i = 0; i < samples && !(x&1); i++) | ||
3265 | x |= signal[i]; | ||
3266 | |||
3267 | if(x == 0) { | ||
3268 | shift = 0; | ||
3269 | } | ||
3270 | else { | ||
3271 | for(shift = 0; !(x&1); shift++) | ||
3272 | x >>= 1; | ||
3273 | } | ||
3274 | |||
3275 | if(shift > 0) { | ||
3276 | for(i = 0; i < samples; i++) | ||
3277 | signal[i] >>= shift; | ||
3278 | } | ||
3279 | |||
3280 | return shift; | ||
3281 | } | ||
3282 | |||
3283 | void append_to_verify_fifo_(verify_input_fifo *fifo, const FLAC__int32 * const input[], unsigned input_offset, unsigned channels, unsigned wide_samples) | ||
3284 | { | ||
3285 | unsigned channel; | ||
3286 | |||
3287 | for(channel = 0; channel < channels; channel++) | ||
3288 | memcpy(&fifo->data[channel][fifo->tail], &input[channel][input_offset], sizeof(FLAC__int32) * wide_samples); | ||
3289 | |||
3290 | fifo->tail += wide_samples; | ||
3291 | |||
3292 | FLAC__ASSERT(fifo->tail <= fifo->size); | ||
3293 | } | ||
3294 | |||
3295 | void append_to_verify_fifo_interleaved_(verify_input_fifo *fifo, const FLAC__int32 input[], unsigned input_offset, unsigned channels, unsigned wide_samples) | ||
3296 | { | ||
3297 | unsigned channel; | ||
3298 | unsigned sample, wide_sample; | ||
3299 | unsigned tail = fifo->tail; | ||
3300 | |||
3301 | sample = input_offset * channels; | ||
3302 | for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) { | ||
3303 | for(channel = 0; channel < channels; channel++) | ||
3304 | fifo->data[channel][tail] = input[sample++]; | ||
3305 | tail++; | ||
3306 | } | ||
3307 | fifo->tail = tail; | ||
3308 | |||
3309 | FLAC__ASSERT(fifo->tail <= fifo->size); | ||
3310 | } | ||
3311 | |||
3312 | FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data) | ||
3313 | { | ||
3314 | FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data; | ||
3315 | const unsigned encoded_bytes = encoder->private_->verify.output.bytes; | ||
3316 | (void)decoder; | ||
3317 | |||
3318 | if(encoder->private_->verify.needs_magic_hack) { | ||
3319 | FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH); | ||
3320 | *bytes = FLAC__STREAM_SYNC_LENGTH; | ||
3321 | memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes); | ||
3322 | encoder->private_->verify.needs_magic_hack = false; | ||
3323 | } | ||
3324 | else { | ||
3325 | if(encoded_bytes == 0) { | ||
3326 | /* | ||
3327 | * If we get here, a FIFO underflow has occurred, | ||
3328 | * which means there is a bug somewhere. | ||
3329 | */ | ||
3330 | FLAC__ASSERT(0); | ||
3331 | return FLAC__STREAM_DECODER_READ_STATUS_ABORT; | ||
3332 | } | ||
3333 | else if(encoded_bytes < *bytes) | ||
3334 | *bytes = encoded_bytes; | ||
3335 | memcpy(buffer, encoder->private_->verify.output.data, *bytes); | ||
3336 | encoder->private_->verify.output.data += *bytes; | ||
3337 | encoder->private_->verify.output.bytes -= *bytes; | ||
3338 | } | ||
3339 | |||
3340 | return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; | ||
3341 | } | ||
3342 | |||
3343 | FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data) | ||
3344 | { | ||
3345 | FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data; | ||
3346 | unsigned channel; | ||
3347 | const unsigned channels = FLAC__stream_decoder_get_channels(decoder); | ||
3348 | const unsigned blocksize = frame->header.blocksize; | ||
3349 | const unsigned bytes_per_block = sizeof(FLAC__int32) * blocksize; | ||
3350 | |||
3351 | for(channel = 0; channel < channels; channel++) { | ||
3352 | if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) { | ||
3353 | unsigned i, sample = 0; | ||
3354 | FLAC__int32 expect = 0, got = 0; | ||
3355 | |||
3356 | for(i = 0; i < blocksize; i++) { | ||
3357 | if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) { | ||
3358 | sample = i; | ||
3359 | expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i]; | ||
3360 | got = (FLAC__int32)buffer[channel][i]; | ||
3361 | break; | ||
3362 | } | ||
3363 | } | ||
3364 | FLAC__ASSERT(i < blocksize); | ||
3365 | FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); | ||
3366 | encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample; | ||
3367 | encoder->private_->verify.error_stats.frame_number = (unsigned)(frame->header.number.sample_number / blocksize); | ||
3368 | encoder->private_->verify.error_stats.channel = channel; | ||
3369 | encoder->private_->verify.error_stats.sample = sample; | ||
3370 | encoder->private_->verify.error_stats.expected = expect; | ||
3371 | encoder->private_->verify.error_stats.got = got; | ||
3372 | encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA; | ||
3373 | return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; | ||
3374 | } | ||
3375 | } | ||
3376 | /* dequeue the frame from the fifo */ | ||
3377 | for(channel = 0; channel < channels; channel++) { | ||
3378 | memmove(&encoder->private_->verify.input_fifo.data[channel][0], &encoder->private_->verify.input_fifo.data[channel][blocksize], encoder->private_->verify.input_fifo.tail - blocksize); | ||
3379 | } | ||
3380 | encoder->private_->verify.input_fifo.tail -= blocksize; | ||
3381 | return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; | ||
3382 | } | ||
3383 | |||
3384 | void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) | ||
3385 | { | ||
3386 | (void)decoder, (void)metadata, (void)client_data; | ||
3387 | } | ||
3388 | |||
3389 | void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) | ||
3390 | { | ||
3391 | FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data; | ||
3392 | (void)decoder, (void)status; | ||
3393 | encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; | ||
3394 | } | ||