summaryrefslogtreecommitdiff
path: root/apps/codecs/libFLAC/stream_encoder.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/codecs/libFLAC/stream_encoder.c')
-rw-r--r--apps/codecs/libFLAC/stream_encoder.c3394
1 files changed, 0 insertions, 3394 deletions
diff --git a/apps/codecs/libFLAC/stream_encoder.c b/apps/codecs/libFLAC/stream_encoder.c
deleted file mode 100644
index 14f0815b8a..0000000000
--- a/apps/codecs/libFLAC/stream_encoder.c
+++ /dev/null
@@ -1,3394 +0,0 @@
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 "global.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
64typedef struct {
65 FLAC__int32 *data[FLAC__MAX_CHANNELS];
66 unsigned size; /* of each data[] in samples */
67 unsigned tail;
68} verify_input_fifo;
69
70typedef struct {
71 const FLAC__byte *data;
72 unsigned capacity;
73 unsigned bytes;
74} verify_output;
75
76typedef 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
88static void set_defaults_(FLAC__StreamEncoder *encoder);
89static void free_(FLAC__StreamEncoder *encoder);
90static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_size);
91static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples);
92static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
93static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_last_frame);
94
95static 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
113static 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
121static unsigned evaluate_constant_subframe_(
122 const FLAC__int32 signal,
123 unsigned subframe_bps,
124 FLAC__Subframe *subframe
125);
126
127static 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
148static 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
171static unsigned evaluate_verbatim_subframe_(
172 const FLAC__int32 signal[],
173 unsigned blocksize,
174 unsigned subframe_bps,
175 FLAC__Subframe *subframe
176);
177
178static 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
195static 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
204static 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
214static 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
226static 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
240static 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
251static 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
266static unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples);
267
268/* verify-related routines: */
269static 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
277static 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
285static FLAC__StreamDecoderReadStatus verify_read_callback_(
286 const FLAC__StreamDecoder *decoder,
287 FLAC__byte buffer[],
288 unsigned *bytes,
289 void *client_data
290);
291
292static 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
299static void verify_metadata_callback_(
300 const FLAC__StreamDecoder *decoder,
301 const FLAC__StreamMetadata *metadata,
302 void *client_data
303);
304
305static 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
318typedef 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
422FLAC_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
447FLAC_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 */
457FLAC_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
527FLAC_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
566FLAC_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&divide 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
963FLAC_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
992FLAC_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
1003FLAC_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
1012FLAC_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
1021FLAC_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
1030FLAC_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
1039FLAC_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
1048FLAC_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
1057FLAC_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
1066FLAC_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
1075FLAC_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
1084FLAC_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
1093FLAC_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
1107FLAC_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
1116FLAC_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
1125FLAC_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
1134FLAC_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
1148FLAC_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
1157FLAC_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
1167FLAC_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
1177FLAC_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
1187FLAC_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 */
1200FLAC_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
1209FLAC_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
1218FLAC_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
1227FLAC_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
1233FLAC_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
1242FLAC_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
1250FLAC_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
1267FLAC_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
1273FLAC_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
1279FLAC_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
1285FLAC_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
1291FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
1292{
1293 FLAC__ASSERT(0 != encoder);
1294 return encoder->protected_->channels;
1295}
1296
1297FLAC_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
1303FLAC_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
1309FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
1310{
1311 FLAC__ASSERT(0 != encoder);
1312 return encoder->protected_->blocksize;
1313}
1314
1315FLAC_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
1321FLAC_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
1327FLAC_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
1333FLAC_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
1339FLAC_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
1345FLAC_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
1351FLAC_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
1357FLAC_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
1363FLAC_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
1369FLAC_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
1499FLAC_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
1635void 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
1671void 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
1739FLAC__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
1802FLAC__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
1843FLAC__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
1895FLAC__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
2147FLAC__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
2368FLAC__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
2408unsigned 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
2420unsigned 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
2477unsigned 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
2558unsigned 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
2572unsigned 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
2716void 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
2770void 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
2837FLAC__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
2849FLAC__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
3039FLAC__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
3053FLAC__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
3259unsigned 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
3283void 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
3295void 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
3312FLAC__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
3343FLAC__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
3384void 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
3389void 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}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-19 23:16:07 +0000