1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008,2009 Josh Coalson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
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.
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.
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.
38 #include <stdlib.h> /* for malloc() */
39 #include <string.h> /* for memcpy() */
40 #include <sys/types.h> /* for off_t */
41 #include "FLAC/assert.h"
42 #include "FLAC/stream_decoder.h"
43 #include "protected/stream_encoder.h"
44 #include "private/bitwriter.h"
45 #include "private/bitmath.h"
46 #include "private/crc.h"
47 #include "private/cpu.h"
48 #include "private/fixed.h"
49 #include "private/format.h"
50 #include "private/lpc.h"
51 #include "private/md5.h"
52 #include "private/memory.h"
53 #include "private/macros.h"
55 #include "private/ogg_helper.h"
56 #include "private/ogg_mapping.h"
58 #include "private/stream_encoder_framing.h"
59 #include "private/window.h"
60 #include "share/alloc.h"
61 #include "share/compat.h"
62 #include "share/private.h"
65 /* Exact Rice codeword length calculation is off by default. The simple
66 * (and fast) estimation (of how many bits a residual value will be
67 * encoded with) in this encoder is very good, almost always yielding
68 * compression within 0.1% of exact calculation.
70 #undef EXACT_RICE_BITS_CALCULATION
71 /* Rice parameter searching is off by default. The simple (and fast)
72 * parameter estimation in this encoder is very good, almost always
73 * yielding compression within 0.1% of the optimal parameters.
75 #undef ENABLE_RICE_PARAMETER_SEARCH
79 FLAC__int32
*data
[FLAC__MAX_CHANNELS
];
80 unsigned size
; /* of each data[] in samples */
85 const FLAC__byte
*data
;
92 ENCODER_IN_METADATA
= 1,
96 static struct CompressionLevels
{
97 FLAC__bool do_mid_side_stereo
;
98 FLAC__bool loose_mid_side_stereo
;
99 unsigned max_lpc_order
;
100 unsigned qlp_coeff_precision
;
101 FLAC__bool do_qlp_coeff_prec_search
;
102 FLAC__bool do_escape_coding
;
103 FLAC__bool do_exhaustive_model_search
;
104 unsigned min_residual_partition_order
;
105 unsigned max_residual_partition_order
;
106 unsigned rice_parameter_search_dist
;
107 } compression_levels_
[] = {
108 { false, false, 0, 0, false, false, false, 0, 3, 0 },
109 { true , true , 0, 0, false, false, false, 0, 3, 0 },
110 { true , false, 0, 0, false, false, false, 0, 3, 0 },
111 { false, false, 6, 0, false, false, false, 0, 4, 0 },
112 { true , true , 8, 0, false, false, false, 0, 4, 0 },
113 { true , false, 8, 0, false, false, false, 0, 5, 0 },
114 { true , false, 8, 0, false, false, false, 0, 6, 0 },
115 { true , false, 8, 0, false, false, true , 0, 6, 0 },
116 { true , false, 12, 0, false, false, true , 0, 6, 0 }
120 /***********************************************************************
122 * Private class method prototypes
124 ***********************************************************************/
126 static void set_defaults_(FLAC__StreamEncoder
*encoder
);
127 static void free_(FLAC__StreamEncoder
*encoder
);
128 static FLAC__bool
resize_buffers_(FLAC__StreamEncoder
*encoder
, unsigned new_blocksize
);
129 static FLAC__bool
write_bitbuffer_(FLAC__StreamEncoder
*encoder
, unsigned samples
, FLAC__bool is_last_block
);
130 static FLAC__StreamEncoderWriteStatus
write_frame_(FLAC__StreamEncoder
*encoder
, const FLAC__byte buffer
[], size_t bytes
, unsigned samples
, FLAC__bool is_last_block
);
131 static void update_metadata_(const FLAC__StreamEncoder
*encoder
);
133 static void update_ogg_metadata_(FLAC__StreamEncoder
*encoder
);
135 static FLAC__bool
process_frame_(FLAC__StreamEncoder
*encoder
, FLAC__bool is_fractional_block
, FLAC__bool is_last_block
);
136 static FLAC__bool
process_subframes_(FLAC__StreamEncoder
*encoder
, FLAC__bool is_fractional_block
);
138 static FLAC__bool
process_subframe_(
139 FLAC__StreamEncoder
*encoder
,
140 unsigned min_partition_order
,
141 unsigned max_partition_order
,
142 const FLAC__FrameHeader
*frame_header
,
143 unsigned subframe_bps
,
144 const FLAC__int32 integer_signal
[],
145 FLAC__Subframe
*subframe
[2],
146 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
[2],
147 FLAC__int32
*residual
[2],
148 unsigned *best_subframe
,
152 static FLAC__bool
add_subframe_(
153 FLAC__StreamEncoder
*encoder
,
155 unsigned subframe_bps
,
156 const FLAC__Subframe
*subframe
,
157 FLAC__BitWriter
*frame
160 static unsigned evaluate_constant_subframe_(
161 FLAC__StreamEncoder
*encoder
,
162 const FLAC__int32 signal
,
164 unsigned subframe_bps
,
165 FLAC__Subframe
*subframe
168 static unsigned evaluate_fixed_subframe_(
169 FLAC__StreamEncoder
*encoder
,
170 const FLAC__int32 signal
[],
171 FLAC__int32 residual
[],
172 FLAC__uint64 abs_residual_partition_sums
[],
173 unsigned raw_bits_per_partition
[],
175 unsigned subframe_bps
,
177 unsigned rice_parameter
,
178 unsigned rice_parameter_limit
,
179 unsigned min_partition_order
,
180 unsigned max_partition_order
,
181 FLAC__bool do_escape_coding
,
182 unsigned rice_parameter_search_dist
,
183 FLAC__Subframe
*subframe
,
184 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
187 #ifndef FLAC__INTEGER_ONLY_LIBRARY
188 static unsigned evaluate_lpc_subframe_(
189 FLAC__StreamEncoder
*encoder
,
190 const FLAC__int32 signal
[],
191 FLAC__int32 residual
[],
192 FLAC__uint64 abs_residual_partition_sums
[],
193 unsigned raw_bits_per_partition
[],
194 const FLAC__real lp_coeff
[],
196 unsigned subframe_bps
,
198 unsigned qlp_coeff_precision
,
199 unsigned rice_parameter
,
200 unsigned rice_parameter_limit
,
201 unsigned min_partition_order
,
202 unsigned max_partition_order
,
203 FLAC__bool do_escape_coding
,
204 unsigned rice_parameter_search_dist
,
205 FLAC__Subframe
*subframe
,
206 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
210 static unsigned evaluate_verbatim_subframe_(
211 FLAC__StreamEncoder
*encoder
,
212 const FLAC__int32 signal
[],
214 unsigned subframe_bps
,
215 FLAC__Subframe
*subframe
218 static unsigned find_best_partition_order_(
219 struct FLAC__StreamEncoderPrivate
*private_
,
220 const FLAC__int32 residual
[],
221 FLAC__uint64 abs_residual_partition_sums
[],
222 unsigned raw_bits_per_partition
[],
223 unsigned residual_samples
,
224 unsigned predictor_order
,
225 unsigned rice_parameter
,
226 unsigned rice_parameter_limit
,
227 unsigned min_partition_order
,
228 unsigned max_partition_order
,
230 FLAC__bool do_escape_coding
,
231 unsigned rice_parameter_search_dist
,
232 FLAC__EntropyCodingMethod
*best_ecm
235 static void precompute_partition_info_sums_(
236 const FLAC__int32 residual
[],
237 FLAC__uint64 abs_residual_partition_sums
[],
238 unsigned residual_samples
,
239 unsigned predictor_order
,
240 unsigned min_partition_order
,
241 unsigned max_partition_order
,
245 static void precompute_partition_info_escapes_(
246 const FLAC__int32 residual
[],
247 unsigned raw_bits_per_partition
[],
248 unsigned residual_samples
,
249 unsigned predictor_order
,
250 unsigned min_partition_order
,
251 unsigned max_partition_order
254 static FLAC__bool
set_partitioned_rice_(
255 #ifdef EXACT_RICE_BITS_CALCULATION
256 const FLAC__int32 residual
[],
258 const FLAC__uint64 abs_residual_partition_sums
[],
259 const unsigned raw_bits_per_partition
[],
260 const unsigned residual_samples
,
261 const unsigned predictor_order
,
262 const unsigned suggested_rice_parameter
,
263 const unsigned rice_parameter_limit
,
264 const unsigned rice_parameter_search_dist
,
265 const unsigned partition_order
,
266 const FLAC__bool search_for_escapes
,
267 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
,
271 static unsigned get_wasted_bits_(FLAC__int32 signal
[], unsigned samples
);
273 /* verify-related routines: */
274 static void append_to_verify_fifo_(
275 verify_input_fifo
*fifo
,
276 const FLAC__int32
* const input
[],
277 unsigned input_offset
,
279 unsigned wide_samples
282 static void append_to_verify_fifo_interleaved_(
283 verify_input_fifo
*fifo
,
284 const FLAC__int32 input
[],
285 unsigned input_offset
,
287 unsigned wide_samples
290 static FLAC__StreamDecoderReadStatus
verify_read_callback_(const FLAC__StreamDecoder
*decoder
, FLAC__byte buffer
[], size_t *bytes
, void *client_data
);
291 static FLAC__StreamDecoderWriteStatus
verify_write_callback_(const FLAC__StreamDecoder
*decoder
, const FLAC__Frame
*frame
, const FLAC__int32
* const buffer
[], void *client_data
);
292 static void verify_metadata_callback_(const FLAC__StreamDecoder
*decoder
, const FLAC__StreamMetadata
*metadata
, void *client_data
);
293 static void verify_error_callback_(const FLAC__StreamDecoder
*decoder
, FLAC__StreamDecoderErrorStatus status
, void *client_data
);
295 static FLAC__StreamEncoderReadStatus
file_read_callback_(const FLAC__StreamEncoder
*encoder
, FLAC__byte buffer
[], size_t *bytes
, void *client_data
);
296 static FLAC__StreamEncoderSeekStatus
file_seek_callback_(const FLAC__StreamEncoder
*encoder
, FLAC__uint64 absolute_byte_offset
, void *client_data
);
297 static FLAC__StreamEncoderTellStatus
file_tell_callback_(const FLAC__StreamEncoder
*encoder
, FLAC__uint64
*absolute_byte_offset
, void *client_data
);
298 static FLAC__StreamEncoderWriteStatus
file_write_callback_(const FLAC__StreamEncoder
*encoder
, const FLAC__byte buffer
[], size_t bytes
, unsigned samples
, unsigned current_frame
, void *client_data
);
299 static FILE *get_binary_stdout_(void);
302 /***********************************************************************
306 ***********************************************************************/
308 typedef struct FLAC__StreamEncoderPrivate
{
309 unsigned input_capacity
; /* current size (in samples) of the signal and residual buffers */
310 FLAC__int32
*integer_signal
[FLAC__MAX_CHANNELS
]; /* the integer version of the input signal */
311 FLAC__int32
*integer_signal_mid_side
[2]; /* the integer version of the mid-side input signal (stereo only) */
312 #ifndef FLAC__INTEGER_ONLY_LIBRARY
313 FLAC__real
*real_signal
[FLAC__MAX_CHANNELS
]; /* (@@@ currently unused) the floating-point version of the input signal */
314 FLAC__real
*real_signal_mid_side
[2]; /* (@@@ currently unused) the floating-point version of the mid-side input signal (stereo only) */
315 FLAC__real
*window
[FLAC__MAX_APODIZATION_FUNCTIONS
]; /* the pre-computed floating-point window for each apodization function */
316 FLAC__real
*windowed_signal
; /* the integer_signal[] * current window[] */
318 unsigned subframe_bps
[FLAC__MAX_CHANNELS
]; /* the effective bits per sample of the input signal (stream bps - wasted bits) */
319 unsigned subframe_bps_mid_side
[2]; /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */
320 FLAC__int32
*residual_workspace
[FLAC__MAX_CHANNELS
][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */
321 FLAC__int32
*residual_workspace_mid_side
[2][2];
322 FLAC__Subframe subframe_workspace
[FLAC__MAX_CHANNELS
][2];
323 FLAC__Subframe subframe_workspace_mid_side
[2][2];
324 FLAC__Subframe
*subframe_workspace_ptr
[FLAC__MAX_CHANNELS
][2];
325 FLAC__Subframe
*subframe_workspace_ptr_mid_side
[2][2];
326 FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace
[FLAC__MAX_CHANNELS
][2];
327 FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace_mid_side
[FLAC__MAX_CHANNELS
][2];
328 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents_workspace_ptr
[FLAC__MAX_CHANNELS
][2];
329 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents_workspace_ptr_mid_side
[FLAC__MAX_CHANNELS
][2];
330 unsigned best_subframe
[FLAC__MAX_CHANNELS
]; /* index (0 or 1) into 2nd dimension of the above workspaces */
331 unsigned best_subframe_mid_side
[2];
332 unsigned best_subframe_bits
[FLAC__MAX_CHANNELS
]; /* size in bits of the best subframe for each channel */
333 unsigned best_subframe_bits_mid_side
[2];
334 FLAC__uint64
*abs_residual_partition_sums
; /* workspace where the sum of abs(candidate residual) for each partition is stored */
335 unsigned *raw_bits_per_partition
; /* workspace where the sum of silog2(candidate residual) for each partition is stored */
336 FLAC__BitWriter
*frame
; /* the current frame being worked on */
337 unsigned loose_mid_side_stereo_frames
; /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
338 unsigned loose_mid_side_stereo_frame_count
; /* number of frames using the current channel assignment */
339 FLAC__ChannelAssignment last_channel_assignment
;
340 FLAC__StreamMetadata streaminfo
; /* scratchpad for STREAMINFO as it is built */
341 FLAC__StreamMetadata_SeekTable
*seek_table
; /* pointer into encoder->protected_->metadata_ where the seek table is */
342 unsigned current_sample_number
;
343 unsigned current_frame_number
;
344 FLAC__MD5Context md5context
;
345 FLAC__CPUInfo cpuinfo
;
346 #ifndef FLAC__INTEGER_ONLY_LIBRARY
347 unsigned (*local_fixed_compute_best_predictor
)(const FLAC__int32 data
[], unsigned data_len
, FLAC__float residual_bits_per_sample
[FLAC__MAX_FIXED_ORDER
+1]);
349 unsigned (*local_fixed_compute_best_predictor
)(const FLAC__int32 data
[], unsigned data_len
, FLAC__fixedpoint residual_bits_per_sample
[FLAC__MAX_FIXED_ORDER
+1]);
351 #ifndef FLAC__INTEGER_ONLY_LIBRARY
352 void (*local_lpc_compute_autocorrelation
)(const FLAC__real data
[], unsigned data_len
, unsigned lag
, FLAC__real autoc
[]);
353 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
[]);
354 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
[]);
355 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
[]);
357 FLAC__bool use_wide_by_block
; /* use slow 64-bit versions of some functions because of the block size */
358 FLAC__bool use_wide_by_partition
; /* use slow 64-bit versions of some functions because of the min partition order and blocksize */
359 FLAC__bool use_wide_by_order
; /* use slow 64-bit versions of some functions because of the lpc order */
360 FLAC__bool disable_constant_subframes
;
361 FLAC__bool disable_fixed_subframes
;
362 FLAC__bool disable_verbatim_subframes
;
366 FLAC__StreamEncoderReadCallback read_callback
; /* currently only needed for Ogg FLAC */
367 FLAC__StreamEncoderSeekCallback seek_callback
;
368 FLAC__StreamEncoderTellCallback tell_callback
;
369 FLAC__StreamEncoderWriteCallback write_callback
;
370 FLAC__StreamEncoderMetadataCallback metadata_callback
;
371 FLAC__StreamEncoderProgressCallback progress_callback
;
373 unsigned first_seekpoint_to_check
;
374 FILE *file
; /* only used when encoding to a file */
375 FLAC__uint64 bytes_written
;
376 FLAC__uint64 samples_written
;
377 unsigned frames_written
;
378 unsigned total_frames_estimate
;
379 /* unaligned (original) pointers to allocated data */
380 FLAC__int32
*integer_signal_unaligned
[FLAC__MAX_CHANNELS
];
381 FLAC__int32
*integer_signal_mid_side_unaligned
[2];
382 #ifndef FLAC__INTEGER_ONLY_LIBRARY
383 FLAC__real
*real_signal_unaligned
[FLAC__MAX_CHANNELS
]; /* (@@@ currently unused) */
384 FLAC__real
*real_signal_mid_side_unaligned
[2]; /* (@@@ currently unused) */
385 FLAC__real
*window_unaligned
[FLAC__MAX_APODIZATION_FUNCTIONS
];
386 FLAC__real
*windowed_signal_unaligned
;
388 FLAC__int32
*residual_workspace_unaligned
[FLAC__MAX_CHANNELS
][2];
389 FLAC__int32
*residual_workspace_mid_side_unaligned
[2][2];
390 FLAC__uint64
*abs_residual_partition_sums_unaligned
;
391 unsigned *raw_bits_per_partition_unaligned
;
393 * These fields have been moved here from private function local
394 * declarations merely to save stack space during encoding.
396 #ifndef FLAC__INTEGER_ONLY_LIBRARY
397 FLAC__real lp_coeff
[FLAC__MAX_LPC_ORDER
][FLAC__MAX_LPC_ORDER
]; /* from process_subframe_() */
399 FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_extra
[2]; /* from find_best_partition_order_() */
401 * The data for the verify section
404 FLAC__StreamDecoder
*decoder
;
405 EncoderStateHint state_hint
;
406 FLAC__bool needs_magic_hack
;
407 verify_input_fifo input_fifo
;
408 verify_output output
;
410 FLAC__uint64 absolute_sample
;
411 unsigned frame_number
;
414 FLAC__int32 expected
;
418 FLAC__bool is_being_deleted
; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */
419 } FLAC__StreamEncoderPrivate
;
421 /***********************************************************************
423 * Public static class data
425 ***********************************************************************/
427 FLAC_API
const char * const FLAC__StreamEncoderStateString
[] = {
428 "FLAC__STREAM_ENCODER_OK",
429 "FLAC__STREAM_ENCODER_UNINITIALIZED",
430 "FLAC__STREAM_ENCODER_OGG_ERROR",
431 "FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR",
432 "FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA",
433 "FLAC__STREAM_ENCODER_CLIENT_ERROR",
434 "FLAC__STREAM_ENCODER_IO_ERROR",
435 "FLAC__STREAM_ENCODER_FRAMING_ERROR",
436 "FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR"
439 FLAC_API
const char * const FLAC__StreamEncoderInitStatusString
[] = {
440 "FLAC__STREAM_ENCODER_INIT_STATUS_OK",
441 "FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR",
442 "FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER",
443 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS",
444 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS",
445 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE",
446 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE",
447 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE",
448 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER",
449 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION",
450 "FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER",
451 "FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE",
452 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA",
453 "FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED"
456 FLAC_API
const char * const FLAC__StreamEncoderReadStatusString
[] = {
457 "FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE",
458 "FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM",
459 "FLAC__STREAM_ENCODER_READ_STATUS_ABORT",
460 "FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED"
463 FLAC_API
const char * const FLAC__StreamEncoderWriteStatusString
[] = {
464 "FLAC__STREAM_ENCODER_WRITE_STATUS_OK",
465 "FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR"
468 FLAC_API
const char * const FLAC__StreamEncoderSeekStatusString
[] = {
469 "FLAC__STREAM_ENCODER_SEEK_STATUS_OK",
470 "FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR",
471 "FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED"
474 FLAC_API
const char * const FLAC__StreamEncoderTellStatusString
[] = {
475 "FLAC__STREAM_ENCODER_TELL_STATUS_OK",
476 "FLAC__STREAM_ENCODER_TELL_STATUS_ERROR",
477 "FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED"
480 /* Number of samples that will be overread to watch for end of stream. By
481 * 'overread', we mean that the FLAC__stream_encoder_process*() calls will
482 * always try to read blocksize+1 samples before encoding a block, so that
483 * even if the stream has a total sample count that is an integral multiple
484 * of the blocksize, we will still notice when we are encoding the last
485 * block. This is needed, for example, to correctly set the end-of-stream
486 * marker in Ogg FLAC.
488 * WATCHOUT: some parts of the code assert that OVERREAD_ == 1 and there's
489 * not really any reason to change it.
491 static const unsigned OVERREAD_
= 1;
493 /***********************************************************************
495 * Class constructor/destructor
498 FLAC_API FLAC__StreamEncoder
*FLAC__stream_encoder_new(void)
500 FLAC__StreamEncoder
*encoder
;
503 FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
505 encoder
= calloc(1, sizeof(FLAC__StreamEncoder
));
510 encoder
->protected_
= calloc(1, sizeof(FLAC__StreamEncoderProtected
));
511 if(encoder
->protected_
== 0) {
516 encoder
->private_
= calloc(1, sizeof(FLAC__StreamEncoderPrivate
));
517 if(encoder
->private_
== 0) {
518 free(encoder
->protected_
);
523 encoder
->private_
->frame
= FLAC__bitwriter_new();
524 if(encoder
->private_
->frame
== 0) {
525 free(encoder
->private_
);
526 free(encoder
->protected_
);
531 encoder
->private_
->file
= 0;
533 set_defaults_(encoder
);
535 encoder
->private_
->is_being_deleted
= false;
537 for(i
= 0; i
< FLAC__MAX_CHANNELS
; i
++) {
538 encoder
->private_
->subframe_workspace_ptr
[i
][0] = &encoder
->private_
->subframe_workspace
[i
][0];
539 encoder
->private_
->subframe_workspace_ptr
[i
][1] = &encoder
->private_
->subframe_workspace
[i
][1];
541 for(i
= 0; i
< 2; i
++) {
542 encoder
->private_
->subframe_workspace_ptr_mid_side
[i
][0] = &encoder
->private_
->subframe_workspace_mid_side
[i
][0];
543 encoder
->private_
->subframe_workspace_ptr_mid_side
[i
][1] = &encoder
->private_
->subframe_workspace_mid_side
[i
][1];
545 for(i
= 0; i
< FLAC__MAX_CHANNELS
; i
++) {
546 encoder
->private_
->partitioned_rice_contents_workspace_ptr
[i
][0] = &encoder
->private_
->partitioned_rice_contents_workspace
[i
][0];
547 encoder
->private_
->partitioned_rice_contents_workspace_ptr
[i
][1] = &encoder
->private_
->partitioned_rice_contents_workspace
[i
][1];
549 for(i
= 0; i
< 2; i
++) {
550 encoder
->private_
->partitioned_rice_contents_workspace_ptr_mid_side
[i
][0] = &encoder
->private_
->partitioned_rice_contents_workspace_mid_side
[i
][0];
551 encoder
->private_
->partitioned_rice_contents_workspace_ptr_mid_side
[i
][1] = &encoder
->private_
->partitioned_rice_contents_workspace_mid_side
[i
][1];
554 for(i
= 0; i
< FLAC__MAX_CHANNELS
; i
++) {
555 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder
->private_
->partitioned_rice_contents_workspace
[i
][0]);
556 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder
->private_
->partitioned_rice_contents_workspace
[i
][1]);
558 for(i
= 0; i
< 2; i
++) {
559 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder
->private_
->partitioned_rice_contents_workspace_mid_side
[i
][0]);
560 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder
->private_
->partitioned_rice_contents_workspace_mid_side
[i
][1]);
562 for(i
= 0; i
< 2; i
++)
563 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder
->private_
->partitioned_rice_contents_extra
[i
]);
565 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_UNINITIALIZED
;
570 FLAC_API
void FLAC__stream_encoder_delete(FLAC__StreamEncoder
*encoder
)
577 FLAC__ASSERT(0 != encoder
->protected_
);
578 FLAC__ASSERT(0 != encoder
->private_
);
579 FLAC__ASSERT(0 != encoder
->private_
->frame
);
581 encoder
->private_
->is_being_deleted
= true;
583 (void)FLAC__stream_encoder_finish(encoder
);
585 if(0 != encoder
->private_
->verify
.decoder
)
586 FLAC__stream_decoder_delete(encoder
->private_
->verify
.decoder
);
588 for(i
= 0; i
< FLAC__MAX_CHANNELS
; i
++) {
589 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder
->private_
->partitioned_rice_contents_workspace
[i
][0]);
590 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder
->private_
->partitioned_rice_contents_workspace
[i
][1]);
592 for(i
= 0; i
< 2; i
++) {
593 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder
->private_
->partitioned_rice_contents_workspace_mid_side
[i
][0]);
594 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder
->private_
->partitioned_rice_contents_workspace_mid_side
[i
][1]);
596 for(i
= 0; i
< 2; i
++)
597 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder
->private_
->partitioned_rice_contents_extra
[i
]);
599 FLAC__bitwriter_delete(encoder
->private_
->frame
);
600 free(encoder
->private_
);
601 free(encoder
->protected_
);
605 /***********************************************************************
607 * Public class methods
609 ***********************************************************************/
611 static FLAC__StreamEncoderInitStatus
init_stream_internal_(
612 FLAC__StreamEncoder
*encoder
,
613 FLAC__StreamEncoderReadCallback read_callback
,
614 FLAC__StreamEncoderWriteCallback write_callback
,
615 FLAC__StreamEncoderSeekCallback seek_callback
,
616 FLAC__StreamEncoderTellCallback tell_callback
,
617 FLAC__StreamEncoderMetadataCallback metadata_callback
,
623 FLAC__bool metadata_has_seektable
, metadata_has_vorbis_comment
, metadata_picture_has_type1
, metadata_picture_has_type2
;
625 FLAC__ASSERT(0 != encoder
);
627 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
628 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED
;
632 return FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER
;
635 if(0 == write_callback
|| (seek_callback
&& 0 == tell_callback
))
636 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS
;
638 if(encoder
->protected_
->channels
== 0 || encoder
->protected_
->channels
> FLAC__MAX_CHANNELS
)
639 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS
;
641 if(encoder
->protected_
->channels
!= 2) {
642 encoder
->protected_
->do_mid_side_stereo
= false;
643 encoder
->protected_
->loose_mid_side_stereo
= false;
645 else if(!encoder
->protected_
->do_mid_side_stereo
)
646 encoder
->protected_
->loose_mid_side_stereo
= false;
648 if(encoder
->protected_
->bits_per_sample
>= 32)
649 encoder
->protected_
->do_mid_side_stereo
= false; /* since we currenty do 32-bit math, the side channel would have 33 bps and overflow */
651 if(encoder
->protected_
->bits_per_sample
< FLAC__MIN_BITS_PER_SAMPLE
|| encoder
->protected_
->bits_per_sample
> FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE
)
652 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE
;
654 if(!FLAC__format_sample_rate_is_valid(encoder
->protected_
->sample_rate
))
655 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE
;
657 if(encoder
->protected_
->blocksize
== 0) {
658 if(encoder
->protected_
->max_lpc_order
== 0)
659 encoder
->protected_
->blocksize
= 1152;
661 encoder
->protected_
->blocksize
= 4096;
664 if(encoder
->protected_
->blocksize
< FLAC__MIN_BLOCK_SIZE
|| encoder
->protected_
->blocksize
> FLAC__MAX_BLOCK_SIZE
)
665 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE
;
667 if(encoder
->protected_
->max_lpc_order
> FLAC__MAX_LPC_ORDER
)
668 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER
;
670 if(encoder
->protected_
->blocksize
< encoder
->protected_
->max_lpc_order
)
671 return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER
;
673 if(encoder
->protected_
->qlp_coeff_precision
== 0) {
674 if(encoder
->protected_
->bits_per_sample
< 16) {
675 /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */
676 /* @@@ until then we'll make a guess */
677 encoder
->protected_
->qlp_coeff_precision
= flac_max(FLAC__MIN_QLP_COEFF_PRECISION
, 2 + encoder
->protected_
->bits_per_sample
/ 2);
679 else if(encoder
->protected_
->bits_per_sample
== 16) {
680 if(encoder
->protected_
->blocksize
<= 192)
681 encoder
->protected_
->qlp_coeff_precision
= 7;
682 else if(encoder
->protected_
->blocksize
<= 384)
683 encoder
->protected_
->qlp_coeff_precision
= 8;
684 else if(encoder
->protected_
->blocksize
<= 576)
685 encoder
->protected_
->qlp_coeff_precision
= 9;
686 else if(encoder
->protected_
->blocksize
<= 1152)
687 encoder
->protected_
->qlp_coeff_precision
= 10;
688 else if(encoder
->protected_
->blocksize
<= 2304)
689 encoder
->protected_
->qlp_coeff_precision
= 11;
690 else if(encoder
->protected_
->blocksize
<= 4608)
691 encoder
->protected_
->qlp_coeff_precision
= 12;
693 encoder
->protected_
->qlp_coeff_precision
= 13;
696 if(encoder
->protected_
->blocksize
<= 384)
697 encoder
->protected_
->qlp_coeff_precision
= FLAC__MAX_QLP_COEFF_PRECISION
-2;
698 else if(encoder
->protected_
->blocksize
<= 1152)
699 encoder
->protected_
->qlp_coeff_precision
= FLAC__MAX_QLP_COEFF_PRECISION
-1;
701 encoder
->protected_
->qlp_coeff_precision
= FLAC__MAX_QLP_COEFF_PRECISION
;
703 FLAC__ASSERT(encoder
->protected_
->qlp_coeff_precision
<= FLAC__MAX_QLP_COEFF_PRECISION
);
705 else if(encoder
->protected_
->qlp_coeff_precision
< FLAC__MIN_QLP_COEFF_PRECISION
|| encoder
->protected_
->qlp_coeff_precision
> FLAC__MAX_QLP_COEFF_PRECISION
)
706 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION
;
708 if(encoder
->protected_
->streamable_subset
) {
709 if(!FLAC__format_blocksize_is_subset(encoder
->protected_
->blocksize
, encoder
->protected_
->sample_rate
))
710 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE
;
711 if(!FLAC__format_sample_rate_is_subset(encoder
->protected_
->sample_rate
))
712 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE
;
714 encoder
->protected_
->bits_per_sample
!= 8 &&
715 encoder
->protected_
->bits_per_sample
!= 12 &&
716 encoder
->protected_
->bits_per_sample
!= 16 &&
717 encoder
->protected_
->bits_per_sample
!= 20 &&
718 encoder
->protected_
->bits_per_sample
!= 24
720 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE
;
721 if(encoder
->protected_
->max_residual_partition_order
> FLAC__SUBSET_MAX_RICE_PARTITION_ORDER
)
722 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE
;
724 encoder
->protected_
->sample_rate
<= 48000 &&
726 encoder
->protected_
->blocksize
> FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ
||
727 encoder
->protected_
->max_lpc_order
> FLAC__SUBSET_MAX_LPC_ORDER_48000HZ
730 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE
;
734 if(encoder
->protected_
->max_residual_partition_order
>= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN
))
735 encoder
->protected_
->max_residual_partition_order
= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN
) - 1;
736 if(encoder
->protected_
->min_residual_partition_order
>= encoder
->protected_
->max_residual_partition_order
)
737 encoder
->protected_
->min_residual_partition_order
= encoder
->protected_
->max_residual_partition_order
;
740 /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */
741 if(is_ogg
&& 0 != encoder
->protected_
->metadata
&& encoder
->protected_
->num_metadata_blocks
> 1) {
743 for(i1
= 1; i1
< encoder
->protected_
->num_metadata_blocks
; i1
++) {
744 if(0 != encoder
->protected_
->metadata
[i1
] && encoder
->protected_
->metadata
[i1
]->type
== FLAC__METADATA_TYPE_VORBIS_COMMENT
) {
745 FLAC__StreamMetadata
*vc
= encoder
->protected_
->metadata
[i1
];
747 encoder
->protected_
->metadata
[i1
] = encoder
->protected_
->metadata
[i1
-1];
748 encoder
->protected_
->metadata
[0] = vc
;
754 /* keep track of any SEEKTABLE block */
755 if(0 != encoder
->protected_
->metadata
&& encoder
->protected_
->num_metadata_blocks
> 0) {
757 for(i2
= 0; i2
< encoder
->protected_
->num_metadata_blocks
; i2
++) {
758 if(0 != encoder
->protected_
->metadata
[i2
] && encoder
->protected_
->metadata
[i2
]->type
== FLAC__METADATA_TYPE_SEEKTABLE
) {
759 encoder
->private_
->seek_table
= &encoder
->protected_
->metadata
[i2
]->data
.seek_table
;
760 break; /* take only the first one */
765 /* validate metadata */
766 if(0 == encoder
->protected_
->metadata
&& encoder
->protected_
->num_metadata_blocks
> 0)
767 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
768 metadata_has_seektable
= false;
769 metadata_has_vorbis_comment
= false;
770 metadata_picture_has_type1
= false;
771 metadata_picture_has_type2
= false;
772 for(i
= 0; i
< encoder
->protected_
->num_metadata_blocks
; i
++) {
773 const FLAC__StreamMetadata
*m
= encoder
->protected_
->metadata
[i
];
774 if(m
->type
== FLAC__METADATA_TYPE_STREAMINFO
)
775 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
776 else if(m
->type
== FLAC__METADATA_TYPE_SEEKTABLE
) {
777 if(metadata_has_seektable
) /* only one is allowed */
778 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
779 metadata_has_seektable
= true;
780 if(!FLAC__format_seektable_is_legal(&m
->data
.seek_table
))
781 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
783 else if(m
->type
== FLAC__METADATA_TYPE_VORBIS_COMMENT
) {
784 if(metadata_has_vorbis_comment
) /* only one is allowed */
785 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
786 metadata_has_vorbis_comment
= true;
788 else if(m
->type
== FLAC__METADATA_TYPE_CUESHEET
) {
789 if(!FLAC__format_cuesheet_is_legal(&m
->data
.cue_sheet
, m
->data
.cue_sheet
.is_cd
, /*violation=*/0))
790 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
792 else if(m
->type
== FLAC__METADATA_TYPE_PICTURE
) {
793 if(!FLAC__format_picture_is_legal(&m
->data
.picture
, /*violation=*/0))
794 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
795 if(m
->data
.picture
.type
== FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD
) {
796 if(metadata_picture_has_type1
) /* there should only be 1 per stream */
797 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
798 metadata_picture_has_type1
= true;
799 /* standard icon must be 32x32 pixel PNG */
801 m
->data
.picture
.type
== FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD
&&
803 (strcmp(m
->data
.picture
.mime_type
, "image/png") && strcmp(m
->data
.picture
.mime_type
, "-->")) ||
804 m
->data
.picture
.width
!= 32 ||
805 m
->data
.picture
.height
!= 32
808 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
810 else if(m
->data
.picture
.type
== FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON
) {
811 if(metadata_picture_has_type2
) /* there should only be 1 per stream */
812 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA
;
813 metadata_picture_has_type2
= true;
818 encoder
->private_
->input_capacity
= 0;
819 for(i
= 0; i
< encoder
->protected_
->channels
; i
++) {
820 encoder
->private_
->integer_signal_unaligned
[i
] = encoder
->private_
->integer_signal
[i
] = 0;
821 #ifndef FLAC__INTEGER_ONLY_LIBRARY
822 encoder
->private_
->real_signal_unaligned
[i
] = encoder
->private_
->real_signal
[i
] = 0;
825 for(i
= 0; i
< 2; i
++) {
826 encoder
->private_
->integer_signal_mid_side_unaligned
[i
] = encoder
->private_
->integer_signal_mid_side
[i
] = 0;
827 #ifndef FLAC__INTEGER_ONLY_LIBRARY
828 encoder
->private_
->real_signal_mid_side_unaligned
[i
] = encoder
->private_
->real_signal_mid_side
[i
] = 0;
831 #ifndef FLAC__INTEGER_ONLY_LIBRARY
832 for(i
= 0; i
< encoder
->protected_
->num_apodizations
; i
++)
833 encoder
->private_
->window_unaligned
[i
] = encoder
->private_
->window
[i
] = 0;
834 encoder
->private_
->windowed_signal_unaligned
= encoder
->private_
->windowed_signal
= 0;
836 for(i
= 0; i
< encoder
->protected_
->channels
; i
++) {
837 encoder
->private_
->residual_workspace_unaligned
[i
][0] = encoder
->private_
->residual_workspace
[i
][0] = 0;
838 encoder
->private_
->residual_workspace_unaligned
[i
][1] = encoder
->private_
->residual_workspace
[i
][1] = 0;
839 encoder
->private_
->best_subframe
[i
] = 0;
841 for(i
= 0; i
< 2; i
++) {
842 encoder
->private_
->residual_workspace_mid_side_unaligned
[i
][0] = encoder
->private_
->residual_workspace_mid_side
[i
][0] = 0;
843 encoder
->private_
->residual_workspace_mid_side_unaligned
[i
][1] = encoder
->private_
->residual_workspace_mid_side
[i
][1] = 0;
844 encoder
->private_
->best_subframe_mid_side
[i
] = 0;
846 encoder
->private_
->abs_residual_partition_sums_unaligned
= encoder
->private_
->abs_residual_partition_sums
= 0;
847 encoder
->private_
->raw_bits_per_partition_unaligned
= encoder
->private_
->raw_bits_per_partition
= 0;
848 #ifndef FLAC__INTEGER_ONLY_LIBRARY
849 encoder
->private_
->loose_mid_side_stereo_frames
= (unsigned)((FLAC__double
)encoder
->protected_
->sample_rate
* 0.4 / (FLAC__double
)encoder
->protected_
->blocksize
+ 0.5);
851 /* 26214 is the approximate fixed-point equivalent to 0.4 (0.4 * 2^16) */
852 /* sample rate can be up to 655350 Hz, and thus use 20 bits, so we do the multiply÷ by hand */
853 FLAC__ASSERT(FLAC__MAX_SAMPLE_RATE
<= 655350);
854 FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE
<= 65535);
855 FLAC__ASSERT(encoder
->protected_
->sample_rate
<= 655350);
856 FLAC__ASSERT(encoder
->protected_
->blocksize
<= 65535);
857 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
);
859 if(encoder
->private_
->loose_mid_side_stereo_frames
== 0)
860 encoder
->private_
->loose_mid_side_stereo_frames
= 1;
861 encoder
->private_
->loose_mid_side_stereo_frame_count
= 0;
862 encoder
->private_
->current_sample_number
= 0;
863 encoder
->private_
->current_frame_number
= 0;
865 encoder
->private_
->use_wide_by_block
= (encoder
->protected_
->bits_per_sample
+ FLAC__bitmath_ilog2(encoder
->protected_
->blocksize
)+1 > 30);
866 encoder
->private_
->use_wide_by_order
= (encoder
->protected_
->bits_per_sample
+ FLAC__bitmath_ilog2(flac_max(encoder
->protected_
->max_lpc_order
, FLAC__MAX_FIXED_ORDER
))+1 > 30); /*@@@ need to use this? */
867 encoder
->private_
->use_wide_by_partition
= (false); /*@@@ need to set this */
870 * get the CPU info and set the function pointers
872 FLAC__cpu_info(&encoder
->private_
->cpuinfo
);
873 /* first default to the non-asm routines */
874 #ifndef FLAC__INTEGER_ONLY_LIBRARY
875 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation
;
877 encoder
->private_
->local_fixed_compute_best_predictor
= FLAC__fixed_compute_best_predictor
;
878 #ifndef FLAC__INTEGER_ONLY_LIBRARY
879 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients
= FLAC__lpc_compute_residual_from_qlp_coefficients
;
880 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients_64bit
= FLAC__lpc_compute_residual_from_qlp_coefficients_wide
;
881 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients_16bit
= FLAC__lpc_compute_residual_from_qlp_coefficients
;
883 /* now override with asm where appropriate */
884 #ifndef FLAC__INTEGER_ONLY_LIBRARY
885 # ifndef FLAC__NO_ASM
886 if(encoder
->private_
->cpuinfo
.use_asm
) {
887 # ifdef FLAC__CPU_IA32
888 FLAC__ASSERT(encoder
->private_
->cpuinfo
.type
== FLAC__CPUINFO_TYPE_IA32
);
889 # ifdef FLAC__HAS_NASM
890 if(encoder
->private_
->cpuinfo
.data
.ia32
.sse
) {
891 if(encoder
->protected_
->max_lpc_order
< 4)
892 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4
;
893 else if(encoder
->protected_
->max_lpc_order
< 8)
894 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8
;
895 else if(encoder
->protected_
->max_lpc_order
< 12)
896 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12
;
898 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation_asm_ia32
;
900 else if(encoder
->private_
->cpuinfo
.data
.ia32
._3dnow
)
901 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow
;
903 encoder
->private_
->local_lpc_compute_autocorrelation
= FLAC__lpc_compute_autocorrelation_asm_ia32
;
904 if(encoder
->private_
->cpuinfo
.data
.ia32
.mmx
) {
905 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients
= FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32
;
906 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients_16bit
= FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx
;
909 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients
= FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32
;
910 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients_16bit
= FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32
;
912 if(encoder
->private_
->cpuinfo
.data
.ia32
.mmx
&& encoder
->private_
->cpuinfo
.data
.ia32
.cmov
)
913 encoder
->private_
->local_fixed_compute_best_predictor
= FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov
;
914 # endif /* FLAC__HAS_NASM */
915 # endif /* FLAC__CPU_IA32 */
917 # endif /* !FLAC__NO_ASM */
918 #endif /* !FLAC__INTEGER_ONLY_LIBRARY */
919 /* finally override based on wide-ness if necessary */
920 if(encoder
->private_
->use_wide_by_block
) {
921 encoder
->private_
->local_fixed_compute_best_predictor
= FLAC__fixed_compute_best_predictor_wide
;
924 /* set state to OK; from here on, errors are fatal and we'll override the state then */
925 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_OK
;
928 encoder
->private_
->is_ogg
= is_ogg
;
929 if(is_ogg
&& !FLAC__ogg_encoder_aspect_init(&encoder
->protected_
->ogg_encoder_aspect
)) {
930 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_OGG_ERROR
;
931 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
935 encoder
->private_
->read_callback
= read_callback
;
936 encoder
->private_
->write_callback
= write_callback
;
937 encoder
->private_
->seek_callback
= seek_callback
;
938 encoder
->private_
->tell_callback
= tell_callback
;
939 encoder
->private_
->metadata_callback
= metadata_callback
;
940 encoder
->private_
->client_data
= client_data
;
942 if(!resize_buffers_(encoder
, encoder
->protected_
->blocksize
)) {
943 /* the above function sets the state for us in case of an error */
944 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
947 if(!FLAC__bitwriter_init(encoder
->private_
->frame
)) {
948 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
949 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
953 * Set up the verify stuff if necessary
955 if(encoder
->protected_
->verify
) {
957 * First, set up the fifo which will hold the
958 * original signal to compare against
960 encoder
->private_
->verify
.input_fifo
.size
= encoder
->protected_
->blocksize
+OVERREAD_
;
961 for(i
= 0; i
< encoder
->protected_
->channels
; i
++) {
962 if(0 == (encoder
->private_
->verify
.input_fifo
.data
[i
] = safe_malloc_mul_2op_p(sizeof(FLAC__int32
), /*times*/encoder
->private_
->verify
.input_fifo
.size
))) {
963 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
964 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
967 encoder
->private_
->verify
.input_fifo
.tail
= 0;
970 * Now set up a stream decoder for verification
972 if(0 == encoder
->private_
->verify
.decoder
) {
973 encoder
->private_
->verify
.decoder
= FLAC__stream_decoder_new();
974 if(0 == encoder
->private_
->verify
.decoder
) {
975 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR
;
976 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
980 if(FLAC__stream_decoder_init_stream(encoder
->private_
->verify
.decoder
, verify_read_callback_
, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, verify_write_callback_
, verify_metadata_callback_
, verify_error_callback_
, /*client_data=*/encoder
) != FLAC__STREAM_DECODER_INIT_STATUS_OK
) {
981 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR
;
982 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
985 encoder
->private_
->verify
.error_stats
.absolute_sample
= 0;
986 encoder
->private_
->verify
.error_stats
.frame_number
= 0;
987 encoder
->private_
->verify
.error_stats
.channel
= 0;
988 encoder
->private_
->verify
.error_stats
.sample
= 0;
989 encoder
->private_
->verify
.error_stats
.expected
= 0;
990 encoder
->private_
->verify
.error_stats
.got
= 0;
993 * These must be done before we write any metadata, because that
994 * calls the write_callback, which uses these values.
996 encoder
->private_
->first_seekpoint_to_check
= 0;
997 encoder
->private_
->samples_written
= 0;
998 encoder
->protected_
->streaminfo_offset
= 0;
999 encoder
->protected_
->seektable_offset
= 0;
1000 encoder
->protected_
->audio_offset
= 0;
1003 * write the stream header
1005 if(encoder
->protected_
->verify
)
1006 encoder
->private_
->verify
.state_hint
= ENCODER_IN_MAGIC
;
1007 if(!FLAC__bitwriter_write_raw_uint32(encoder
->private_
->frame
, FLAC__STREAM_SYNC
, FLAC__STREAM_SYNC_LEN
)) {
1008 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
1009 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1011 if(!write_bitbuffer_(encoder
, 0, /*is_last_block=*/false)) {
1012 /* the above function sets the state for us in case of an error */
1013 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1017 * write the STREAMINFO metadata block
1019 if(encoder
->protected_
->verify
)
1020 encoder
->private_
->verify
.state_hint
= ENCODER_IN_METADATA
;
1021 encoder
->private_
->streaminfo
.type
= FLAC__METADATA_TYPE_STREAMINFO
;
1022 encoder
->private_
->streaminfo
.is_last
= false; /* we will have at a minimum a VORBIS_COMMENT afterwards */
1023 encoder
->private_
->streaminfo
.length
= FLAC__STREAM_METADATA_STREAMINFO_LENGTH
;
1024 encoder
->private_
->streaminfo
.data
.stream_info
.min_blocksize
= encoder
->protected_
->blocksize
; /* this encoder uses the same blocksize for the whole stream */
1025 encoder
->private_
->streaminfo
.data
.stream_info
.max_blocksize
= encoder
->protected_
->blocksize
;
1026 encoder
->private_
->streaminfo
.data
.stream_info
.min_framesize
= 0; /* we don't know this yet; have to fill it in later */
1027 encoder
->private_
->streaminfo
.data
.stream_info
.max_framesize
= 0; /* we don't know this yet; have to fill it in later */
1028 encoder
->private_
->streaminfo
.data
.stream_info
.sample_rate
= encoder
->protected_
->sample_rate
;
1029 encoder
->private_
->streaminfo
.data
.stream_info
.channels
= encoder
->protected_
->channels
;
1030 encoder
->private_
->streaminfo
.data
.stream_info
.bits_per_sample
= encoder
->protected_
->bits_per_sample
;
1031 encoder
->private_
->streaminfo
.data
.stream_info
.total_samples
= encoder
->protected_
->total_samples_estimate
; /* we will replace this later with the real total */
1032 memset(encoder
->private_
->streaminfo
.data
.stream_info
.md5sum
, 0, 16); /* we don't know this yet; have to fill it in later */
1033 if(encoder
->protected_
->do_md5
)
1034 FLAC__MD5Init(&encoder
->private_
->md5context
);
1035 if(!FLAC__add_metadata_block(&encoder
->private_
->streaminfo
, encoder
->private_
->frame
)) {
1036 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
1037 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1039 if(!write_bitbuffer_(encoder
, 0, /*is_last_block=*/false)) {
1040 /* the above function sets the state for us in case of an error */
1041 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1045 * Now that the STREAMINFO block is written, we can init this to an
1046 * absurdly-high value...
1048 encoder
->private_
->streaminfo
.data
.stream_info
.min_framesize
= (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN
) - 1;
1049 /* ... and clear this to 0 */
1050 encoder
->private_
->streaminfo
.data
.stream_info
.total_samples
= 0;
1053 * Check to see if the supplied metadata contains a VORBIS_COMMENT;
1054 * if not, we will write an empty one (FLAC__add_metadata_block()
1055 * automatically supplies the vendor string).
1057 * WATCHOUT: the Ogg FLAC mapping requires us to write this block after
1058 * the STREAMINFO. (In the case that metadata_has_vorbis_comment is
1059 * true it will have already insured that the metadata list is properly
1062 if(!metadata_has_vorbis_comment
) {
1063 FLAC__StreamMetadata vorbis_comment
;
1064 vorbis_comment
.type
= FLAC__METADATA_TYPE_VORBIS_COMMENT
;
1065 vorbis_comment
.is_last
= (encoder
->protected_
->num_metadata_blocks
== 0);
1066 vorbis_comment
.length
= 4 + 4; /* MAGIC NUMBER */
1067 vorbis_comment
.data
.vorbis_comment
.vendor_string
.length
= 0;
1068 vorbis_comment
.data
.vorbis_comment
.vendor_string
.entry
= 0;
1069 vorbis_comment
.data
.vorbis_comment
.num_comments
= 0;
1070 vorbis_comment
.data
.vorbis_comment
.comments
= 0;
1071 if(!FLAC__add_metadata_block(&vorbis_comment
, encoder
->private_
->frame
)) {
1072 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
1073 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1075 if(!write_bitbuffer_(encoder
, 0, /*is_last_block=*/false)) {
1076 /* the above function sets the state for us in case of an error */
1077 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1082 * write the user's metadata blocks
1084 for(i
= 0; i
< encoder
->protected_
->num_metadata_blocks
; i
++) {
1085 encoder
->protected_
->metadata
[i
]->is_last
= (i
== encoder
->protected_
->num_metadata_blocks
- 1);
1086 if(!FLAC__add_metadata_block(encoder
->protected_
->metadata
[i
], encoder
->private_
->frame
)) {
1087 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
1088 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1090 if(!write_bitbuffer_(encoder
, 0, /*is_last_block=*/false)) {
1091 /* the above function sets the state for us in case of an error */
1092 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1096 /* now that all the metadata is written, we save the stream offset */
1097 if(encoder
->private_
->tell_callback
&& encoder
->private_
->tell_callback(encoder
, &encoder
->protected_
->audio_offset
, encoder
->private_
->client_data
) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR
) { /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
1098 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
1099 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1102 if(encoder
->protected_
->verify
)
1103 encoder
->private_
->verify
.state_hint
= ENCODER_IN_AUDIO
;
1105 return FLAC__STREAM_ENCODER_INIT_STATUS_OK
;
1108 FLAC_API FLAC__StreamEncoderInitStatus
FLAC__stream_encoder_init_stream(
1109 FLAC__StreamEncoder
*encoder
,
1110 FLAC__StreamEncoderWriteCallback write_callback
,
1111 FLAC__StreamEncoderSeekCallback seek_callback
,
1112 FLAC__StreamEncoderTellCallback tell_callback
,
1113 FLAC__StreamEncoderMetadataCallback metadata_callback
,
1117 return init_stream_internal_(
1119 /*read_callback=*/0,
1129 FLAC_API FLAC__StreamEncoderInitStatus
FLAC__stream_encoder_init_ogg_stream(
1130 FLAC__StreamEncoder
*encoder
,
1131 FLAC__StreamEncoderReadCallback read_callback
,
1132 FLAC__StreamEncoderWriteCallback write_callback
,
1133 FLAC__StreamEncoderSeekCallback seek_callback
,
1134 FLAC__StreamEncoderTellCallback tell_callback
,
1135 FLAC__StreamEncoderMetadataCallback metadata_callback
,
1139 return init_stream_internal_(
1151 static FLAC__StreamEncoderInitStatus
init_FILE_internal_(
1152 FLAC__StreamEncoder
*encoder
,
1154 FLAC__StreamEncoderProgressCallback progress_callback
,
1159 FLAC__StreamEncoderInitStatus init_status
;
1161 FLAC__ASSERT(0 != encoder
);
1162 FLAC__ASSERT(0 != file
);
1164 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1165 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED
;
1167 /* double protection */
1169 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_IO_ERROR
;
1170 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1174 * To make sure that our file does not go unclosed after an error, we
1175 * must assign the FILE pointer before any further error can occur in
1179 file
= get_binary_stdout_(); /* just to be safe */
1181 encoder
->private_
->file
= file
;
1183 encoder
->private_
->progress_callback
= progress_callback
;
1184 encoder
->private_
->bytes_written
= 0;
1185 encoder
->private_
->samples_written
= 0;
1186 encoder
->private_
->frames_written
= 0;
1188 init_status
= init_stream_internal_(
1190 encoder
->private_
->file
== stdout
? 0 : is_ogg
? file_read_callback_
: 0,
1191 file_write_callback_
,
1192 encoder
->private_
->file
== stdout
? 0 : file_seek_callback_
,
1193 encoder
->private_
->file
== stdout
? 0 : file_tell_callback_
,
1194 /*metadata_callback=*/0,
1198 if(init_status
!= FLAC__STREAM_ENCODER_INIT_STATUS_OK
) {
1199 /* the above function sets the state for us in case of an error */
1204 unsigned blocksize
= FLAC__stream_encoder_get_blocksize(encoder
);
1206 FLAC__ASSERT(blocksize
!= 0);
1207 encoder
->private_
->total_frames_estimate
= (unsigned)((FLAC__stream_encoder_get_total_samples_estimate(encoder
) + blocksize
- 1) / blocksize
);
1213 FLAC_API FLAC__StreamEncoderInitStatus
FLAC__stream_encoder_init_FILE(
1214 FLAC__StreamEncoder
*encoder
,
1216 FLAC__StreamEncoderProgressCallback progress_callback
,
1220 return init_FILE_internal_(encoder
, file
, progress_callback
, client_data
, /*is_ogg=*/false);
1223 FLAC_API FLAC__StreamEncoderInitStatus
FLAC__stream_encoder_init_ogg_FILE(
1224 FLAC__StreamEncoder
*encoder
,
1226 FLAC__StreamEncoderProgressCallback progress_callback
,
1230 return init_FILE_internal_(encoder
, file
, progress_callback
, client_data
, /*is_ogg=*/true);
1233 static FLAC__StreamEncoderInitStatus
init_file_internal_(
1234 FLAC__StreamEncoder
*encoder
,
1235 const char *filename
,
1236 FLAC__StreamEncoderProgressCallback progress_callback
,
1243 FLAC__ASSERT(0 != encoder
);
1246 * To make sure that our file does not go unclosed after an error, we
1247 * have to do the same entrance checks here that are later performed
1248 * in FLAC__stream_encoder_init_FILE() before the FILE* is assigned.
1250 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1251 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED
;
1253 file
= filename
? fopen(filename
, "w+b") : stdout
;
1256 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_IO_ERROR
;
1257 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR
;
1260 return init_FILE_internal_(encoder
, file
, progress_callback
, client_data
, is_ogg
);
1263 FLAC_API FLAC__StreamEncoderInitStatus
FLAC__stream_encoder_init_file(
1264 FLAC__StreamEncoder
*encoder
,
1265 const char *filename
,
1266 FLAC__StreamEncoderProgressCallback progress_callback
,
1270 return init_file_internal_(encoder
, filename
, progress_callback
, client_data
, /*is_ogg=*/false);
1273 FLAC_API FLAC__StreamEncoderInitStatus
FLAC__stream_encoder_init_ogg_file(
1274 FLAC__StreamEncoder
*encoder
,
1275 const char *filename
,
1276 FLAC__StreamEncoderProgressCallback progress_callback
,
1280 return init_file_internal_(encoder
, filename
, progress_callback
, client_data
, /*is_ogg=*/true);
1283 FLAC_API FLAC__bool
FLAC__stream_encoder_finish(FLAC__StreamEncoder
*encoder
)
1285 FLAC__bool error
= false;
1287 FLAC__ASSERT(0 != encoder
);
1288 FLAC__ASSERT(0 != encoder
->private_
);
1289 FLAC__ASSERT(0 != encoder
->protected_
);
1291 if(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_UNINITIALIZED
)
1294 if(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_OK
&& !encoder
->private_
->is_being_deleted
) {
1295 if(encoder
->private_
->current_sample_number
!= 0) {
1296 const FLAC__bool is_fractional_block
= encoder
->protected_
->blocksize
!= encoder
->private_
->current_sample_number
;
1297 encoder
->protected_
->blocksize
= encoder
->private_
->current_sample_number
;
1298 if(!process_frame_(encoder
, is_fractional_block
, /*is_last_block=*/true))
1303 if(encoder
->protected_
->do_md5
)
1304 FLAC__MD5Final(encoder
->private_
->streaminfo
.data
.stream_info
.md5sum
, &encoder
->private_
->md5context
);
1306 if(!encoder
->private_
->is_being_deleted
) {
1307 if(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_OK
) {
1308 if(encoder
->private_
->seek_callback
) {
1310 if(encoder
->private_
->is_ogg
)
1311 update_ogg_metadata_(encoder
);
1314 update_metadata_(encoder
);
1316 /* check if an error occurred while updating metadata */
1317 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_OK
)
1320 if(encoder
->private_
->metadata_callback
)
1321 encoder
->private_
->metadata_callback(encoder
, &encoder
->private_
->streaminfo
, encoder
->private_
->client_data
);
1324 if(encoder
->protected_
->verify
&& 0 != encoder
->private_
->verify
.decoder
&& !FLAC__stream_decoder_finish(encoder
->private_
->verify
.decoder
)) {
1326 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
;
1331 if(0 != encoder
->private_
->file
) {
1332 if(encoder
->private_
->file
!= stdout
)
1333 fclose(encoder
->private_
->file
);
1334 encoder
->private_
->file
= 0;
1338 if(encoder
->private_
->is_ogg
)
1339 FLAC__ogg_encoder_aspect_finish(&encoder
->protected_
->ogg_encoder_aspect
);
1343 set_defaults_(encoder
);
1346 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_UNINITIALIZED
;
1351 FLAC_API FLAC__bool
FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder
*encoder
, long value
)
1353 FLAC__ASSERT(0 != encoder
);
1354 FLAC__ASSERT(0 != encoder
->private_
);
1355 FLAC__ASSERT(0 != encoder
->protected_
);
1356 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1359 /* can't check encoder->private_->is_ogg since that's not set until init time */
1360 FLAC__ogg_encoder_aspect_set_serial_number(&encoder
->protected_
->ogg_encoder_aspect
, value
);
1368 FLAC_API FLAC__bool
FLAC__stream_encoder_set_verify(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1370 FLAC__ASSERT(0 != encoder
);
1371 FLAC__ASSERT(0 != encoder
->private_
);
1372 FLAC__ASSERT(0 != encoder
->protected_
);
1373 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1375 #ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
1376 encoder
->protected_
->verify
= value
;
1381 FLAC_API FLAC__bool
FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1383 FLAC__ASSERT(0 != encoder
);
1384 FLAC__ASSERT(0 != encoder
->private_
);
1385 FLAC__ASSERT(0 != encoder
->protected_
);
1386 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1388 encoder
->protected_
->streamable_subset
= value
;
1392 FLAC_API FLAC__bool
FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1394 FLAC__ASSERT(0 != encoder
);
1395 FLAC__ASSERT(0 != encoder
->private_
);
1396 FLAC__ASSERT(0 != encoder
->protected_
);
1397 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1399 encoder
->protected_
->do_md5
= value
;
1403 FLAC_API FLAC__bool
FLAC__stream_encoder_set_channels(FLAC__StreamEncoder
*encoder
, unsigned value
)
1405 FLAC__ASSERT(0 != encoder
);
1406 FLAC__ASSERT(0 != encoder
->private_
);
1407 FLAC__ASSERT(0 != encoder
->protected_
);
1408 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1410 encoder
->protected_
->channels
= value
;
1414 FLAC_API FLAC__bool
FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder
*encoder
, unsigned value
)
1416 FLAC__ASSERT(0 != encoder
);
1417 FLAC__ASSERT(0 != encoder
->private_
);
1418 FLAC__ASSERT(0 != encoder
->protected_
);
1419 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1421 encoder
->protected_
->bits_per_sample
= value
;
1425 FLAC_API FLAC__bool
FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder
*encoder
, unsigned value
)
1427 FLAC__ASSERT(0 != encoder
);
1428 FLAC__ASSERT(0 != encoder
->private_
);
1429 FLAC__ASSERT(0 != encoder
->protected_
);
1430 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1432 encoder
->protected_
->sample_rate
= value
;
1436 FLAC_API FLAC__bool
FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder
*encoder
, unsigned value
)
1438 FLAC__bool ok
= true;
1439 FLAC__ASSERT(0 != encoder
);
1440 FLAC__ASSERT(0 != encoder
->private_
);
1441 FLAC__ASSERT(0 != encoder
->protected_
);
1442 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1444 if(value
>= sizeof(compression_levels_
)/sizeof(compression_levels_
[0]))
1445 value
= sizeof(compression_levels_
)/sizeof(compression_levels_
[0]) - 1;
1446 ok
&= FLAC__stream_encoder_set_do_mid_side_stereo (encoder
, compression_levels_
[value
].do_mid_side_stereo
);
1447 ok
&= FLAC__stream_encoder_set_loose_mid_side_stereo (encoder
, compression_levels_
[value
].loose_mid_side_stereo
);
1448 #ifndef FLAC__INTEGER_ONLY_LIBRARY
1451 ok
&= FLAC__stream_encoder_set_apodization (encoder
, compression_levels_
[value
].apodization
);
1452 /* but it's too hard to specify the string in a locale-specific way */
1454 encoder
->protected_
->num_apodizations
= 1;
1455 encoder
->protected_
->apodizations
[0].type
= FLAC__APODIZATION_TUKEY
;
1456 encoder
->protected_
->apodizations
[0].parameters
.tukey
.p
= 0.5;
1459 ok
&= FLAC__stream_encoder_set_max_lpc_order (encoder
, compression_levels_
[value
].max_lpc_order
);
1460 ok
&= FLAC__stream_encoder_set_qlp_coeff_precision (encoder
, compression_levels_
[value
].qlp_coeff_precision
);
1461 ok
&= FLAC__stream_encoder_set_do_qlp_coeff_prec_search (encoder
, compression_levels_
[value
].do_qlp_coeff_prec_search
);
1462 ok
&= FLAC__stream_encoder_set_do_escape_coding (encoder
, compression_levels_
[value
].do_escape_coding
);
1463 ok
&= FLAC__stream_encoder_set_do_exhaustive_model_search (encoder
, compression_levels_
[value
].do_exhaustive_model_search
);
1464 ok
&= FLAC__stream_encoder_set_min_residual_partition_order(encoder
, compression_levels_
[value
].min_residual_partition_order
);
1465 ok
&= FLAC__stream_encoder_set_max_residual_partition_order(encoder
, compression_levels_
[value
].max_residual_partition_order
);
1466 ok
&= FLAC__stream_encoder_set_rice_parameter_search_dist (encoder
, compression_levels_
[value
].rice_parameter_search_dist
);
1470 FLAC_API FLAC__bool
FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder
*encoder
, unsigned value
)
1472 FLAC__ASSERT(0 != encoder
);
1473 FLAC__ASSERT(0 != encoder
->private_
);
1474 FLAC__ASSERT(0 != encoder
->protected_
);
1475 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1477 encoder
->protected_
->blocksize
= value
;
1481 FLAC_API FLAC__bool
FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1483 FLAC__ASSERT(0 != encoder
);
1484 FLAC__ASSERT(0 != encoder
->private_
);
1485 FLAC__ASSERT(0 != encoder
->protected_
);
1486 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1488 encoder
->protected_
->do_mid_side_stereo
= value
;
1492 FLAC_API FLAC__bool
FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1494 FLAC__ASSERT(0 != encoder
);
1495 FLAC__ASSERT(0 != encoder
->private_
);
1496 FLAC__ASSERT(0 != encoder
->protected_
);
1497 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1499 encoder
->protected_
->loose_mid_side_stereo
= value
;
1503 /*@@@@add to tests*/
1504 FLAC_API FLAC__bool
FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder
*encoder
, const char *specification
)
1506 FLAC__ASSERT(0 != encoder
);
1507 FLAC__ASSERT(0 != encoder
->private_
);
1508 FLAC__ASSERT(0 != encoder
->protected_
);
1509 FLAC__ASSERT(0 != specification
);
1510 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1512 #ifdef FLAC__INTEGER_ONLY_LIBRARY
1513 (void)specification
; /* silently ignore since we haven't integerized; will always use a rectangular window */
1515 encoder
->protected_
->num_apodizations
= 0;
1517 const char *s
= strchr(specification
, ';');
1518 const size_t n
= s
? (size_t)(s
- specification
) : strlen(specification
);
1519 if (n
==8 && 0 == strncmp("bartlett" , specification
, n
))
1520 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_BARTLETT
;
1521 else if(n
==13 && 0 == strncmp("bartlett_hann", specification
, n
))
1522 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_BARTLETT_HANN
;
1523 else if(n
==8 && 0 == strncmp("blackman" , specification
, n
))
1524 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_BLACKMAN
;
1525 else if(n
==26 && 0 == strncmp("blackman_harris_4term_92db", specification
, n
))
1526 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE
;
1527 else if(n
==6 && 0 == strncmp("connes" , specification
, n
))
1528 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_CONNES
;
1529 else if(n
==7 && 0 == strncmp("flattop" , specification
, n
))
1530 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_FLATTOP
;
1531 else if(n
>7 && 0 == strncmp("gauss(" , specification
, 6)) {
1532 FLAC__real stddev
= (FLAC__real
)strtod(specification
+6, 0);
1533 if (stddev
> 0.0 && stddev
<= 0.5) {
1534 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
].parameters
.gauss
.stddev
= stddev
;
1535 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_GAUSS
;
1538 else if(n
==7 && 0 == strncmp("hamming" , specification
, n
))
1539 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_HAMMING
;
1540 else if(n
==4 && 0 == strncmp("hann" , specification
, n
))
1541 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_HANN
;
1542 else if(n
==13 && 0 == strncmp("kaiser_bessel", specification
, n
))
1543 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_KAISER_BESSEL
;
1544 else if(n
==7 && 0 == strncmp("nuttall" , specification
, n
))
1545 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_NUTTALL
;
1546 else if(n
==9 && 0 == strncmp("rectangle" , specification
, n
))
1547 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_RECTANGLE
;
1548 else if(n
==8 && 0 == strncmp("triangle" , specification
, n
))
1549 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_TRIANGLE
;
1550 else if(n
>7 && 0 == strncmp("tukey(" , specification
, 6)) {
1551 FLAC__real p
= (FLAC__real
)strtod(specification
+6, 0);
1552 if (p
>= 0.0 && p
<= 1.0) {
1553 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
].parameters
.tukey
.p
= p
;
1554 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_TUKEY
;
1557 else if(n
==5 && 0 == strncmp("welch" , specification
, n
))
1558 encoder
->protected_
->apodizations
[encoder
->protected_
->num_apodizations
++].type
= FLAC__APODIZATION_WELCH
;
1559 if (encoder
->protected_
->num_apodizations
== 32)
1562 specification
= s
+1;
1566 if(encoder
->protected_
->num_apodizations
== 0) {
1567 encoder
->protected_
->num_apodizations
= 1;
1568 encoder
->protected_
->apodizations
[0].type
= FLAC__APODIZATION_TUKEY
;
1569 encoder
->protected_
->apodizations
[0].parameters
.tukey
.p
= 0.5;
1575 FLAC_API FLAC__bool
FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder
*encoder
, unsigned value
)
1577 FLAC__ASSERT(0 != encoder
);
1578 FLAC__ASSERT(0 != encoder
->private_
);
1579 FLAC__ASSERT(0 != encoder
->protected_
);
1580 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1582 encoder
->protected_
->max_lpc_order
= value
;
1586 FLAC_API FLAC__bool
FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder
*encoder
, unsigned value
)
1588 FLAC__ASSERT(0 != encoder
);
1589 FLAC__ASSERT(0 != encoder
->private_
);
1590 FLAC__ASSERT(0 != encoder
->protected_
);
1591 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1593 encoder
->protected_
->qlp_coeff_precision
= value
;
1597 FLAC_API FLAC__bool
FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1599 FLAC__ASSERT(0 != encoder
);
1600 FLAC__ASSERT(0 != encoder
->private_
);
1601 FLAC__ASSERT(0 != encoder
->protected_
);
1602 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1604 encoder
->protected_
->do_qlp_coeff_prec_search
= value
;
1608 FLAC_API FLAC__bool
FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1610 FLAC__ASSERT(0 != encoder
);
1611 FLAC__ASSERT(0 != encoder
->private_
);
1612 FLAC__ASSERT(0 != encoder
->protected_
);
1613 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1616 /*@@@ deprecated: */
1617 encoder
->protected_
->do_escape_coding
= value
;
1624 FLAC_API FLAC__bool
FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1626 FLAC__ASSERT(0 != encoder
);
1627 FLAC__ASSERT(0 != encoder
->private_
);
1628 FLAC__ASSERT(0 != encoder
->protected_
);
1629 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1631 encoder
->protected_
->do_exhaustive_model_search
= value
;
1635 FLAC_API FLAC__bool
FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder
*encoder
, unsigned value
)
1637 FLAC__ASSERT(0 != encoder
);
1638 FLAC__ASSERT(0 != encoder
->private_
);
1639 FLAC__ASSERT(0 != encoder
->protected_
);
1640 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1642 encoder
->protected_
->min_residual_partition_order
= value
;
1646 FLAC_API FLAC__bool
FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder
*encoder
, unsigned value
)
1648 FLAC__ASSERT(0 != encoder
);
1649 FLAC__ASSERT(0 != encoder
->private_
);
1650 FLAC__ASSERT(0 != encoder
->protected_
);
1651 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1653 encoder
->protected_
->max_residual_partition_order
= value
;
1657 FLAC_API FLAC__bool
FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder
*encoder
, unsigned value
)
1659 FLAC__ASSERT(0 != encoder
);
1660 FLAC__ASSERT(0 != encoder
->private_
);
1661 FLAC__ASSERT(0 != encoder
->protected_
);
1662 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1665 /*@@@ deprecated: */
1666 encoder
->protected_
->rice_parameter_search_dist
= value
;
1673 FLAC_API FLAC__bool
FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder
*encoder
, FLAC__uint64 value
)
1675 FLAC__ASSERT(0 != encoder
);
1676 FLAC__ASSERT(0 != encoder
->private_
);
1677 FLAC__ASSERT(0 != encoder
->protected_
);
1678 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1680 encoder
->protected_
->total_samples_estimate
= value
;
1684 FLAC_API FLAC__bool
FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder
*encoder
, FLAC__StreamMetadata
**metadata
, unsigned num_blocks
)
1686 FLAC__ASSERT(0 != encoder
);
1687 FLAC__ASSERT(0 != encoder
->private_
);
1688 FLAC__ASSERT(0 != encoder
->protected_
);
1689 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1695 /* realloc() does not do exactly what we want so... */
1696 if(encoder
->protected_
->metadata
) {
1697 free(encoder
->protected_
->metadata
);
1698 encoder
->protected_
->metadata
= 0;
1699 encoder
->protected_
->num_metadata_blocks
= 0;
1702 FLAC__StreamMetadata
**m
;
1703 if(0 == (m
= safe_malloc_mul_2op_p(sizeof(m
[0]), /*times*/num_blocks
)))
1705 memcpy(m
, metadata
, sizeof(m
[0]) * num_blocks
);
1706 encoder
->protected_
->metadata
= m
;
1707 encoder
->protected_
->num_metadata_blocks
= num_blocks
;
1710 if(!FLAC__ogg_encoder_aspect_set_num_metadata(&encoder
->protected_
->ogg_encoder_aspect
, num_blocks
))
1717 * These three functions are not static, but not publically exposed in
1718 * include/FLAC/ either. They are used by the test suite.
1720 FLAC_API FLAC__bool
FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1722 FLAC__ASSERT(0 != encoder
);
1723 FLAC__ASSERT(0 != encoder
->private_
);
1724 FLAC__ASSERT(0 != encoder
->protected_
);
1725 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1727 encoder
->private_
->disable_constant_subframes
= value
;
1731 FLAC_API FLAC__bool
FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1733 FLAC__ASSERT(0 != encoder
);
1734 FLAC__ASSERT(0 != encoder
->private_
);
1735 FLAC__ASSERT(0 != encoder
->protected_
);
1736 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1738 encoder
->private_
->disable_fixed_subframes
= value
;
1742 FLAC_API FLAC__bool
FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder
*encoder
, FLAC__bool value
)
1744 FLAC__ASSERT(0 != encoder
);
1745 FLAC__ASSERT(0 != encoder
->private_
);
1746 FLAC__ASSERT(0 != encoder
->protected_
);
1747 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_UNINITIALIZED
)
1749 encoder
->private_
->disable_verbatim_subframes
= value
;
1753 FLAC_API FLAC__StreamEncoderState
FLAC__stream_encoder_get_state(const FLAC__StreamEncoder
*encoder
)
1755 FLAC__ASSERT(0 != encoder
);
1756 FLAC__ASSERT(0 != encoder
->private_
);
1757 FLAC__ASSERT(0 != encoder
->protected_
);
1758 return encoder
->protected_
->state
;
1761 FLAC_API FLAC__StreamDecoderState
FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder
*encoder
)
1763 FLAC__ASSERT(0 != encoder
);
1764 FLAC__ASSERT(0 != encoder
->private_
);
1765 FLAC__ASSERT(0 != encoder
->protected_
);
1766 if(encoder
->protected_
->verify
)
1767 return FLAC__stream_decoder_get_state(encoder
->private_
->verify
.decoder
);
1769 return FLAC__STREAM_DECODER_UNINITIALIZED
;
1772 FLAC_API
const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder
*encoder
)
1774 FLAC__ASSERT(0 != encoder
);
1775 FLAC__ASSERT(0 != encoder
->private_
);
1776 FLAC__ASSERT(0 != encoder
->protected_
);
1777 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR
)
1778 return FLAC__StreamEncoderStateString
[encoder
->protected_
->state
];
1780 return FLAC__stream_decoder_get_resolved_state_string(encoder
->private_
->verify
.decoder
);
1783 FLAC_API
void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder
*encoder
, FLAC__uint64
*absolute_sample
, unsigned *frame_number
, unsigned *channel
, unsigned *sample
, FLAC__int32
*expected
, FLAC__int32
*got
)
1785 FLAC__ASSERT(0 != encoder
);
1786 FLAC__ASSERT(0 != encoder
->private_
);
1787 FLAC__ASSERT(0 != encoder
->protected_
);
1788 if(0 != absolute_sample
)
1789 *absolute_sample
= encoder
->private_
->verify
.error_stats
.absolute_sample
;
1790 if(0 != frame_number
)
1791 *frame_number
= encoder
->private_
->verify
.error_stats
.frame_number
;
1793 *channel
= encoder
->private_
->verify
.error_stats
.channel
;
1795 *sample
= encoder
->private_
->verify
.error_stats
.sample
;
1797 *expected
= encoder
->private_
->verify
.error_stats
.expected
;
1799 *got
= encoder
->private_
->verify
.error_stats
.got
;
1802 FLAC_API FLAC__bool
FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder
*encoder
)
1804 FLAC__ASSERT(0 != encoder
);
1805 FLAC__ASSERT(0 != encoder
->private_
);
1806 FLAC__ASSERT(0 != encoder
->protected_
);
1807 return encoder
->protected_
->verify
;
1810 FLAC_API FLAC__bool
FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder
*encoder
)
1812 FLAC__ASSERT(0 != encoder
);
1813 FLAC__ASSERT(0 != encoder
->private_
);
1814 FLAC__ASSERT(0 != encoder
->protected_
);
1815 return encoder
->protected_
->streamable_subset
;
1818 FLAC_API FLAC__bool
FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder
*encoder
)
1820 FLAC__ASSERT(0 != encoder
);
1821 FLAC__ASSERT(0 != encoder
->private_
);
1822 FLAC__ASSERT(0 != encoder
->protected_
);
1823 return encoder
->protected_
->do_md5
;
1826 FLAC_API
unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder
*encoder
)
1828 FLAC__ASSERT(0 != encoder
);
1829 FLAC__ASSERT(0 != encoder
->private_
);
1830 FLAC__ASSERT(0 != encoder
->protected_
);
1831 return encoder
->protected_
->channels
;
1834 FLAC_API
unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder
*encoder
)
1836 FLAC__ASSERT(0 != encoder
);
1837 FLAC__ASSERT(0 != encoder
->private_
);
1838 FLAC__ASSERT(0 != encoder
->protected_
);
1839 return encoder
->protected_
->bits_per_sample
;
1842 FLAC_API
unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder
*encoder
)
1844 FLAC__ASSERT(0 != encoder
);
1845 FLAC__ASSERT(0 != encoder
->private_
);
1846 FLAC__ASSERT(0 != encoder
->protected_
);
1847 return encoder
->protected_
->sample_rate
;
1850 FLAC_API
unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder
*encoder
)
1852 FLAC__ASSERT(0 != encoder
);
1853 FLAC__ASSERT(0 != encoder
->private_
);
1854 FLAC__ASSERT(0 != encoder
->protected_
);
1855 return encoder
->protected_
->blocksize
;
1858 FLAC_API FLAC__bool
FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder
*encoder
)
1860 FLAC__ASSERT(0 != encoder
);
1861 FLAC__ASSERT(0 != encoder
->private_
);
1862 FLAC__ASSERT(0 != encoder
->protected_
);
1863 return encoder
->protected_
->do_mid_side_stereo
;
1866 FLAC_API FLAC__bool
FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder
*encoder
)
1868 FLAC__ASSERT(0 != encoder
);
1869 FLAC__ASSERT(0 != encoder
->private_
);
1870 FLAC__ASSERT(0 != encoder
->protected_
);
1871 return encoder
->protected_
->loose_mid_side_stereo
;
1874 FLAC_API
unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder
*encoder
)
1876 FLAC__ASSERT(0 != encoder
);
1877 FLAC__ASSERT(0 != encoder
->private_
);
1878 FLAC__ASSERT(0 != encoder
->protected_
);
1879 return encoder
->protected_
->max_lpc_order
;
1882 FLAC_API
unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder
*encoder
)
1884 FLAC__ASSERT(0 != encoder
);
1885 FLAC__ASSERT(0 != encoder
->private_
);
1886 FLAC__ASSERT(0 != encoder
->protected_
);
1887 return encoder
->protected_
->qlp_coeff_precision
;
1890 FLAC_API FLAC__bool
FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder
*encoder
)
1892 FLAC__ASSERT(0 != encoder
);
1893 FLAC__ASSERT(0 != encoder
->private_
);
1894 FLAC__ASSERT(0 != encoder
->protected_
);
1895 return encoder
->protected_
->do_qlp_coeff_prec_search
;
1898 FLAC_API FLAC__bool
FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder
*encoder
)
1900 FLAC__ASSERT(0 != encoder
);
1901 FLAC__ASSERT(0 != encoder
->private_
);
1902 FLAC__ASSERT(0 != encoder
->protected_
);
1903 return encoder
->protected_
->do_escape_coding
;
1906 FLAC_API FLAC__bool
FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder
*encoder
)
1908 FLAC__ASSERT(0 != encoder
);
1909 FLAC__ASSERT(0 != encoder
->private_
);
1910 FLAC__ASSERT(0 != encoder
->protected_
);
1911 return encoder
->protected_
->do_exhaustive_model_search
;
1914 FLAC_API
unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder
*encoder
)
1916 FLAC__ASSERT(0 != encoder
);
1917 FLAC__ASSERT(0 != encoder
->private_
);
1918 FLAC__ASSERT(0 != encoder
->protected_
);
1919 return encoder
->protected_
->min_residual_partition_order
;
1922 FLAC_API
unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder
*encoder
)
1924 FLAC__ASSERT(0 != encoder
);
1925 FLAC__ASSERT(0 != encoder
->private_
);
1926 FLAC__ASSERT(0 != encoder
->protected_
);
1927 return encoder
->protected_
->max_residual_partition_order
;
1930 FLAC_API
unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder
*encoder
)
1932 FLAC__ASSERT(0 != encoder
);
1933 FLAC__ASSERT(0 != encoder
->private_
);
1934 FLAC__ASSERT(0 != encoder
->protected_
);
1935 return encoder
->protected_
->rice_parameter_search_dist
;
1938 FLAC_API FLAC__uint64
FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder
*encoder
)
1940 FLAC__ASSERT(0 != encoder
);
1941 FLAC__ASSERT(0 != encoder
->private_
);
1942 FLAC__ASSERT(0 != encoder
->protected_
);
1943 return encoder
->protected_
->total_samples_estimate
;
1946 FLAC_API FLAC__bool
FLAC__stream_encoder_process(FLAC__StreamEncoder
*encoder
, const FLAC__int32
* const buffer
[], unsigned samples
)
1948 unsigned i
, j
= 0, channel
;
1949 const unsigned channels
= encoder
->protected_
->channels
, blocksize
= encoder
->protected_
->blocksize
;
1951 FLAC__ASSERT(0 != encoder
);
1952 FLAC__ASSERT(0 != encoder
->private_
);
1953 FLAC__ASSERT(0 != encoder
->protected_
);
1954 FLAC__ASSERT(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_OK
);
1957 const unsigned n
= flac_min(blocksize
+OVERREAD_
-encoder
->private_
->current_sample_number
, samples
-j
);
1959 if(encoder
->protected_
->verify
)
1960 append_to_verify_fifo_(&encoder
->private_
->verify
.input_fifo
, buffer
, j
, channels
, n
);
1962 for(channel
= 0; channel
< channels
; channel
++)
1963 memcpy(&encoder
->private_
->integer_signal
[channel
][encoder
->private_
->current_sample_number
], &buffer
[channel
][j
], sizeof(buffer
[channel
][0]) * n
);
1965 if(encoder
->protected_
->do_mid_side_stereo
) {
1966 FLAC__ASSERT(channels
== 2);
1967 /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
1968 for(i
= encoder
->private_
->current_sample_number
; i
<= blocksize
&& j
< samples
; i
++, j
++) {
1969 encoder
->private_
->integer_signal_mid_side
[1][i
] = buffer
[0][j
] - buffer
[1][j
];
1970 encoder
->private_
->integer_signal_mid_side
[0][i
] = (buffer
[0][j
] + buffer
[1][j
]) >> 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
1976 encoder
->private_
->current_sample_number
+= n
;
1978 /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
1979 if(encoder
->private_
->current_sample_number
> blocksize
) {
1980 FLAC__ASSERT(encoder
->private_
->current_sample_number
== blocksize
+OVERREAD_
);
1981 FLAC__ASSERT(OVERREAD_
== 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
1982 if(!process_frame_(encoder
, /*is_fractional_block=*/false, /*is_last_block=*/false))
1984 /* move unprocessed overread samples to beginnings of arrays */
1985 for(channel
= 0; channel
< channels
; channel
++)
1986 encoder
->private_
->integer_signal
[channel
][0] = encoder
->private_
->integer_signal
[channel
][blocksize
];
1987 if(encoder
->protected_
->do_mid_side_stereo
) {
1988 encoder
->private_
->integer_signal_mid_side
[0][0] = encoder
->private_
->integer_signal_mid_side
[0][blocksize
];
1989 encoder
->private_
->integer_signal_mid_side
[1][0] = encoder
->private_
->integer_signal_mid_side
[1][blocksize
];
1991 encoder
->private_
->current_sample_number
= 1;
1993 } while(j
< samples
);
1998 FLAC_API FLAC__bool
FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder
*encoder
, const FLAC__int32 buffer
[], unsigned samples
)
2000 unsigned i
, j
, k
, channel
;
2001 FLAC__int32 x
, mid
, side
;
2002 const unsigned channels
= encoder
->protected_
->channels
, blocksize
= encoder
->protected_
->blocksize
;
2004 FLAC__ASSERT(0 != encoder
);
2005 FLAC__ASSERT(0 != encoder
->private_
);
2006 FLAC__ASSERT(0 != encoder
->protected_
);
2007 FLAC__ASSERT(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_OK
);
2011 * we have several flavors of the same basic loop, optimized for
2012 * different conditions:
2014 if(encoder
->protected_
->do_mid_side_stereo
&& channels
== 2) {
2016 * stereo coding: unroll channel loop
2019 if(encoder
->protected_
->verify
)
2020 append_to_verify_fifo_interleaved_(&encoder
->private_
->verify
.input_fifo
, buffer
, j
, channels
, flac_min(blocksize
+OVERREAD_
-encoder
->private_
->current_sample_number
, samples
-j
));
2022 /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
2023 for(i
= encoder
->private_
->current_sample_number
; i
<= blocksize
&& j
< samples
; i
++, j
++) {
2024 encoder
->private_
->integer_signal
[0][i
] = mid
= side
= buffer
[k
++];
2026 encoder
->private_
->integer_signal
[1][i
] = x
;
2029 mid
>>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
2030 encoder
->private_
->integer_signal_mid_side
[1][i
] = side
;
2031 encoder
->private_
->integer_signal_mid_side
[0][i
] = mid
;
2033 encoder
->private_
->current_sample_number
= i
;
2034 /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
2036 if(!process_frame_(encoder
, /*is_fractional_block=*/false, /*is_last_block=*/false))
2038 /* move unprocessed overread samples to beginnings of arrays */
2039 FLAC__ASSERT(i
== blocksize
+OVERREAD_
);
2040 FLAC__ASSERT(OVERREAD_
== 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
2041 encoder
->private_
->integer_signal
[0][0] = encoder
->private_
->integer_signal
[0][blocksize
];
2042 encoder
->private_
->integer_signal
[1][0] = encoder
->private_
->integer_signal
[1][blocksize
];
2043 encoder
->private_
->integer_signal_mid_side
[0][0] = encoder
->private_
->integer_signal_mid_side
[0][blocksize
];
2044 encoder
->private_
->integer_signal_mid_side
[1][0] = encoder
->private_
->integer_signal_mid_side
[1][blocksize
];
2045 encoder
->private_
->current_sample_number
= 1;
2047 } while(j
< samples
);
2051 * independent channel coding: buffer each channel in inner loop
2054 if(encoder
->protected_
->verify
)
2055 append_to_verify_fifo_interleaved_(&encoder
->private_
->verify
.input_fifo
, buffer
, j
, channels
, flac_min(blocksize
+OVERREAD_
-encoder
->private_
->current_sample_number
, samples
-j
));
2057 /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */
2058 for(i
= encoder
->private_
->current_sample_number
; i
<= blocksize
&& j
< samples
; i
++, j
++) {
2059 for(channel
= 0; channel
< channels
; channel
++)
2060 encoder
->private_
->integer_signal
[channel
][i
] = buffer
[k
++];
2062 encoder
->private_
->current_sample_number
= i
;
2063 /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */
2065 if(!process_frame_(encoder
, /*is_fractional_block=*/false, /*is_last_block=*/false))
2067 /* move unprocessed overread samples to beginnings of arrays */
2068 FLAC__ASSERT(i
== blocksize
+OVERREAD_
);
2069 FLAC__ASSERT(OVERREAD_
== 1); /* assert we only overread 1 sample which simplifies the rest of the code below */
2070 for(channel
= 0; channel
< channels
; channel
++)
2071 encoder
->private_
->integer_signal
[channel
][0] = encoder
->private_
->integer_signal
[channel
][blocksize
];
2072 encoder
->private_
->current_sample_number
= 1;
2074 } while(j
< samples
);
2080 /***********************************************************************
2082 * Private class methods
2084 ***********************************************************************/
2086 void set_defaults_(FLAC__StreamEncoder
*encoder
)
2088 FLAC__ASSERT(0 != encoder
);
2090 #ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING
2091 encoder
->protected_
->verify
= true;
2093 encoder
->protected_
->verify
= false;
2095 encoder
->protected_
->streamable_subset
= true;
2096 encoder
->protected_
->do_md5
= true;
2097 encoder
->protected_
->do_mid_side_stereo
= false;
2098 encoder
->protected_
->loose_mid_side_stereo
= false;
2099 encoder
->protected_
->channels
= 2;
2100 encoder
->protected_
->bits_per_sample
= 16;
2101 encoder
->protected_
->sample_rate
= 44100;
2102 encoder
->protected_
->blocksize
= 0;
2103 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2104 encoder
->protected_
->num_apodizations
= 1;
2105 encoder
->protected_
->apodizations
[0].type
= FLAC__APODIZATION_TUKEY
;
2106 encoder
->protected_
->apodizations
[0].parameters
.tukey
.p
= 0.5;
2108 encoder
->protected_
->max_lpc_order
= 0;
2109 encoder
->protected_
->qlp_coeff_precision
= 0;
2110 encoder
->protected_
->do_qlp_coeff_prec_search
= false;
2111 encoder
->protected_
->do_exhaustive_model_search
= false;
2112 encoder
->protected_
->do_escape_coding
= false;
2113 encoder
->protected_
->min_residual_partition_order
= 0;
2114 encoder
->protected_
->max_residual_partition_order
= 0;
2115 encoder
->protected_
->rice_parameter_search_dist
= 0;
2116 encoder
->protected_
->total_samples_estimate
= 0;
2117 encoder
->protected_
->metadata
= 0;
2118 encoder
->protected_
->num_metadata_blocks
= 0;
2120 encoder
->private_
->seek_table
= 0;
2121 encoder
->private_
->disable_constant_subframes
= false;
2122 encoder
->private_
->disable_fixed_subframes
= false;
2123 encoder
->private_
->disable_verbatim_subframes
= false;
2125 encoder
->private_
->is_ogg
= false;
2127 encoder
->private_
->read_callback
= 0;
2128 encoder
->private_
->write_callback
= 0;
2129 encoder
->private_
->seek_callback
= 0;
2130 encoder
->private_
->tell_callback
= 0;
2131 encoder
->private_
->metadata_callback
= 0;
2132 encoder
->private_
->progress_callback
= 0;
2133 encoder
->private_
->client_data
= 0;
2136 FLAC__ogg_encoder_aspect_set_defaults(&encoder
->protected_
->ogg_encoder_aspect
);
2139 FLAC__stream_encoder_set_compression_level(encoder
, 5);
2142 void free_(FLAC__StreamEncoder
*encoder
)
2144 unsigned i
, channel
;
2146 FLAC__ASSERT(0 != encoder
);
2147 if(encoder
->protected_
->metadata
) {
2148 free(encoder
->protected_
->metadata
);
2149 encoder
->protected_
->metadata
= 0;
2150 encoder
->protected_
->num_metadata_blocks
= 0;
2152 for(i
= 0; i
< encoder
->protected_
->channels
; i
++) {
2153 if(0 != encoder
->private_
->integer_signal_unaligned
[i
]) {
2154 free(encoder
->private_
->integer_signal_unaligned
[i
]);
2155 encoder
->private_
->integer_signal_unaligned
[i
] = 0;
2157 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2158 if(0 != encoder
->private_
->real_signal_unaligned
[i
]) {
2159 free(encoder
->private_
->real_signal_unaligned
[i
]);
2160 encoder
->private_
->real_signal_unaligned
[i
] = 0;
2164 for(i
= 0; i
< 2; i
++) {
2165 if(0 != encoder
->private_
->integer_signal_mid_side_unaligned
[i
]) {
2166 free(encoder
->private_
->integer_signal_mid_side_unaligned
[i
]);
2167 encoder
->private_
->integer_signal_mid_side_unaligned
[i
] = 0;
2169 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2170 if(0 != encoder
->private_
->real_signal_mid_side_unaligned
[i
]) {
2171 free(encoder
->private_
->real_signal_mid_side_unaligned
[i
]);
2172 encoder
->private_
->real_signal_mid_side_unaligned
[i
] = 0;
2176 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2177 for(i
= 0; i
< encoder
->protected_
->num_apodizations
; i
++) {
2178 if(0 != encoder
->private_
->window_unaligned
[i
]) {
2179 free(encoder
->private_
->window_unaligned
[i
]);
2180 encoder
->private_
->window_unaligned
[i
] = 0;
2183 if(0 != encoder
->private_
->windowed_signal_unaligned
) {
2184 free(encoder
->private_
->windowed_signal_unaligned
);
2185 encoder
->private_
->windowed_signal_unaligned
= 0;
2188 for(channel
= 0; channel
< encoder
->protected_
->channels
; channel
++) {
2189 for(i
= 0; i
< 2; i
++) {
2190 if(0 != encoder
->private_
->residual_workspace_unaligned
[channel
][i
]) {
2191 free(encoder
->private_
->residual_workspace_unaligned
[channel
][i
]);
2192 encoder
->private_
->residual_workspace_unaligned
[channel
][i
] = 0;
2196 for(channel
= 0; channel
< 2; channel
++) {
2197 for(i
= 0; i
< 2; i
++) {
2198 if(0 != encoder
->private_
->residual_workspace_mid_side_unaligned
[channel
][i
]) {
2199 free(encoder
->private_
->residual_workspace_mid_side_unaligned
[channel
][i
]);
2200 encoder
->private_
->residual_workspace_mid_side_unaligned
[channel
][i
] = 0;
2204 if(0 != encoder
->private_
->abs_residual_partition_sums_unaligned
) {
2205 free(encoder
->private_
->abs_residual_partition_sums_unaligned
);
2206 encoder
->private_
->abs_residual_partition_sums_unaligned
= 0;
2208 if(0 != encoder
->private_
->raw_bits_per_partition_unaligned
) {
2209 free(encoder
->private_
->raw_bits_per_partition_unaligned
);
2210 encoder
->private_
->raw_bits_per_partition_unaligned
= 0;
2212 if(encoder
->protected_
->verify
) {
2213 for(i
= 0; i
< encoder
->protected_
->channels
; i
++) {
2214 if(0 != encoder
->private_
->verify
.input_fifo
.data
[i
]) {
2215 free(encoder
->private_
->verify
.input_fifo
.data
[i
]);
2216 encoder
->private_
->verify
.input_fifo
.data
[i
] = 0;
2220 FLAC__bitwriter_free(encoder
->private_
->frame
);
2223 FLAC__bool
resize_buffers_(FLAC__StreamEncoder
*encoder
, unsigned new_blocksize
)
2226 unsigned i
, channel
;
2228 FLAC__ASSERT(new_blocksize
> 0);
2229 FLAC__ASSERT(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_OK
);
2230 FLAC__ASSERT(encoder
->private_
->current_sample_number
== 0);
2232 /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */
2233 if(new_blocksize
<= encoder
->private_
->input_capacity
)
2238 /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx()
2239 * requires that the input arrays (in our case the integer signals)
2240 * have a buffer of up to 3 zeroes in front (at negative indices) for
2241 * alignment purposes; we use 4 in front to keep the data well-aligned.
2244 for(i
= 0; ok
&& i
< encoder
->protected_
->channels
; i
++) {
2245 ok
= ok
&& FLAC__memory_alloc_aligned_int32_array(new_blocksize
+4+OVERREAD_
, &encoder
->private_
->integer_signal_unaligned
[i
], &encoder
->private_
->integer_signal
[i
]);
2246 memset(encoder
->private_
->integer_signal
[i
], 0, sizeof(FLAC__int32
)*4);
2247 encoder
->private_
->integer_signal
[i
] += 4;
2248 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2249 #if 0 /* @@@ currently unused */
2250 if(encoder
->protected_
->max_lpc_order
> 0)
2251 ok
= ok
&& FLAC__memory_alloc_aligned_real_array(new_blocksize
+OVERREAD_
, &encoder
->private_
->real_signal_unaligned
[i
], &encoder
->private_
->real_signal
[i
]);
2255 for(i
= 0; ok
&& i
< 2; i
++) {
2256 ok
= ok
&& FLAC__memory_alloc_aligned_int32_array(new_blocksize
+4+OVERREAD_
, &encoder
->private_
->integer_signal_mid_side_unaligned
[i
], &encoder
->private_
->integer_signal_mid_side
[i
]);
2257 memset(encoder
->private_
->integer_signal_mid_side
[i
], 0, sizeof(FLAC__int32
)*4);
2258 encoder
->private_
->integer_signal_mid_side
[i
] += 4;
2259 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2260 #if 0 /* @@@ currently unused */
2261 if(encoder
->protected_
->max_lpc_order
> 0)
2262 ok
= ok
&& FLAC__memory_alloc_aligned_real_array(new_blocksize
+OVERREAD_
, &encoder
->private_
->real_signal_mid_side_unaligned
[i
], &encoder
->private_
->real_signal_mid_side
[i
]);
2266 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2267 if(ok
&& encoder
->protected_
->max_lpc_order
> 0) {
2268 for(i
= 0; ok
&& i
< encoder
->protected_
->num_apodizations
; i
++)
2269 ok
= ok
&& FLAC__memory_alloc_aligned_real_array(new_blocksize
, &encoder
->private_
->window_unaligned
[i
], &encoder
->private_
->window
[i
]);
2270 ok
= ok
&& FLAC__memory_alloc_aligned_real_array(new_blocksize
, &encoder
->private_
->windowed_signal_unaligned
, &encoder
->private_
->windowed_signal
);
2273 for(channel
= 0; ok
&& channel
< encoder
->protected_
->channels
; channel
++) {
2274 for(i
= 0; ok
&& i
< 2; i
++) {
2275 ok
= ok
&& FLAC__memory_alloc_aligned_int32_array(new_blocksize
, &encoder
->private_
->residual_workspace_unaligned
[channel
][i
], &encoder
->private_
->residual_workspace
[channel
][i
]);
2278 for(channel
= 0; ok
&& channel
< 2; channel
++) {
2279 for(i
= 0; ok
&& i
< 2; i
++) {
2280 ok
= ok
&& FLAC__memory_alloc_aligned_int32_array(new_blocksize
, &encoder
->private_
->residual_workspace_mid_side_unaligned
[channel
][i
], &encoder
->private_
->residual_workspace_mid_side
[channel
][i
]);
2283 /* the *2 is an approximation to the series 1 + 1/2 + 1/4 + ... that sums tree occupies in a flat array */
2284 /*@@@ new_blocksize*2 is too pessimistic, but to fix, we need smarter logic because a smaller new_blocksize can actually increase the # of partitions; would require moving this out into a separate function, then checking its capacity against the need of the current blocksize&min/max_partition_order (and maybe predictor order) */
2285 ok
= ok
&& FLAC__memory_alloc_aligned_uint64_array(new_blocksize
* 2, &encoder
->private_
->abs_residual_partition_sums_unaligned
, &encoder
->private_
->abs_residual_partition_sums
);
2286 if(encoder
->protected_
->do_escape_coding
)
2287 ok
= ok
&& FLAC__memory_alloc_aligned_unsigned_array(new_blocksize
* 2, &encoder
->private_
->raw_bits_per_partition_unaligned
, &encoder
->private_
->raw_bits_per_partition
);
2289 /* now adjust the windows if the blocksize has changed */
2290 #ifndef FLAC__INTEGER_ONLY_LIBRARY
2291 if(ok
&& new_blocksize
!= encoder
->private_
->input_capacity
&& encoder
->protected_
->max_lpc_order
> 0) {
2292 for(i
= 0; ok
&& i
< encoder
->protected_
->num_apodizations
; i
++) {
2293 switch(encoder
->protected_
->apodizations
[i
].type
) {
2294 case FLAC__APODIZATION_BARTLETT
:
2295 FLAC__window_bartlett(encoder
->private_
->window
[i
], new_blocksize
);
2297 case FLAC__APODIZATION_BARTLETT_HANN
:
2298 FLAC__window_bartlett_hann(encoder
->private_
->window
[i
], new_blocksize
);
2300 case FLAC__APODIZATION_BLACKMAN
:
2301 FLAC__window_blackman(encoder
->private_
->window
[i
], new_blocksize
);
2303 case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE
:
2304 FLAC__window_blackman_harris_4term_92db_sidelobe(encoder
->private_
->window
[i
], new_blocksize
);
2306 case FLAC__APODIZATION_CONNES
:
2307 FLAC__window_connes(encoder
->private_
->window
[i
], new_blocksize
);
2309 case FLAC__APODIZATION_FLATTOP
:
2310 FLAC__window_flattop(encoder
->private_
->window
[i
], new_blocksize
);
2312 case FLAC__APODIZATION_GAUSS
:
2313 FLAC__window_gauss(encoder
->private_
->window
[i
], new_blocksize
, encoder
->protected_
->apodizations
[i
].parameters
.gauss
.stddev
);
2315 case FLAC__APODIZATION_HAMMING
:
2316 FLAC__window_hamming(encoder
->private_
->window
[i
], new_blocksize
);
2318 case FLAC__APODIZATION_HANN
:
2319 FLAC__window_hann(encoder
->private_
->window
[i
], new_blocksize
);
2321 case FLAC__APODIZATION_KAISER_BESSEL
:
2322 FLAC__window_kaiser_bessel(encoder
->private_
->window
[i
], new_blocksize
);
2324 case FLAC__APODIZATION_NUTTALL
:
2325 FLAC__window_nuttall(encoder
->private_
->window
[i
], new_blocksize
);
2327 case FLAC__APODIZATION_RECTANGLE
:
2328 FLAC__window_rectangle(encoder
->private_
->window
[i
], new_blocksize
);
2330 case FLAC__APODIZATION_TRIANGLE
:
2331 FLAC__window_triangle(encoder
->private_
->window
[i
], new_blocksize
);
2333 case FLAC__APODIZATION_TUKEY
:
2334 FLAC__window_tukey(encoder
->private_
->window
[i
], new_blocksize
, encoder
->protected_
->apodizations
[i
].parameters
.tukey
.p
);
2336 case FLAC__APODIZATION_WELCH
:
2337 FLAC__window_welch(encoder
->private_
->window
[i
], new_blocksize
);
2341 /* double protection */
2342 FLAC__window_hann(encoder
->private_
->window
[i
], new_blocksize
);
2350 encoder
->private_
->input_capacity
= new_blocksize
;
2352 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
2357 FLAC__bool
write_bitbuffer_(FLAC__StreamEncoder
*encoder
, unsigned samples
, FLAC__bool is_last_block
)
2359 const FLAC__byte
*buffer
;
2362 FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder
->private_
->frame
));
2364 if(!FLAC__bitwriter_get_buffer(encoder
->private_
->frame
, &buffer
, &bytes
)) {
2365 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
2369 if(encoder
->protected_
->verify
) {
2370 encoder
->private_
->verify
.output
.data
= buffer
;
2371 encoder
->private_
->verify
.output
.bytes
= bytes
;
2372 if(encoder
->private_
->verify
.state_hint
== ENCODER_IN_MAGIC
) {
2373 encoder
->private_
->verify
.needs_magic_hack
= true;
2376 if(!FLAC__stream_decoder_process_single(encoder
->private_
->verify
.decoder
)) {
2377 FLAC__bitwriter_release_buffer(encoder
->private_
->frame
);
2378 FLAC__bitwriter_clear(encoder
->private_
->frame
);
2379 if(encoder
->protected_
->state
!= FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
)
2380 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR
;
2386 if(write_frame_(encoder
, buffer
, bytes
, samples
, is_last_block
) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK
) {
2387 FLAC__bitwriter_release_buffer(encoder
->private_
->frame
);
2388 FLAC__bitwriter_clear(encoder
->private_
->frame
);
2389 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2393 FLAC__bitwriter_release_buffer(encoder
->private_
->frame
);
2394 FLAC__bitwriter_clear(encoder
->private_
->frame
);
2397 encoder
->private_
->streaminfo
.data
.stream_info
.min_framesize
= flac_min(bytes
, encoder
->private_
->streaminfo
.data
.stream_info
.min_framesize
);
2398 encoder
->private_
->streaminfo
.data
.stream_info
.max_framesize
= flac_max(bytes
, encoder
->private_
->streaminfo
.data
.stream_info
.max_framesize
);
2404 FLAC__StreamEncoderWriteStatus
write_frame_(FLAC__StreamEncoder
*encoder
, const FLAC__byte buffer
[], size_t bytes
, unsigned samples
, FLAC__bool is_last_block
)
2406 FLAC__StreamEncoderWriteStatus status
;
2407 FLAC__uint64 output_position
= 0;
2409 /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
2410 if(encoder
->private_
->tell_callback
&& encoder
->private_
->tell_callback(encoder
, &output_position
, encoder
->private_
->client_data
) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR
) {
2411 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2412 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR
;
2416 * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets.
2419 FLAC__MetadataType type
= (buffer
[0] & 0x7f);
2420 if(type
== FLAC__METADATA_TYPE_STREAMINFO
)
2421 encoder
->protected_
->streaminfo_offset
= output_position
;
2422 else if(type
== FLAC__METADATA_TYPE_SEEKTABLE
&& encoder
->protected_
->seektable_offset
== 0)
2423 encoder
->protected_
->seektable_offset
= output_position
;
2427 * Mark the current seek point if hit (if audio_offset == 0 that
2428 * means we're still writing metadata and haven't hit the first
2431 if(0 != encoder
->private_
->seek_table
&& encoder
->protected_
->audio_offset
> 0 && encoder
->private_
->seek_table
->num_points
> 0) {
2432 const unsigned blocksize
= FLAC__stream_encoder_get_blocksize(encoder
);
2433 const FLAC__uint64 frame_first_sample
= encoder
->private_
->samples_written
;
2434 const FLAC__uint64 frame_last_sample
= frame_first_sample
+ (FLAC__uint64
)blocksize
- 1;
2435 FLAC__uint64 test_sample
;
2437 for(i
= encoder
->private_
->first_seekpoint_to_check
; i
< encoder
->private_
->seek_table
->num_points
; i
++) {
2438 test_sample
= encoder
->private_
->seek_table
->points
[i
].sample_number
;
2439 if(test_sample
> frame_last_sample
) {
2442 else if(test_sample
>= frame_first_sample
) {
2443 encoder
->private_
->seek_table
->points
[i
].sample_number
= frame_first_sample
;
2444 encoder
->private_
->seek_table
->points
[i
].stream_offset
= output_position
- encoder
->protected_
->audio_offset
;
2445 encoder
->private_
->seek_table
->points
[i
].frame_samples
= blocksize
;
2446 encoder
->private_
->first_seekpoint_to_check
++;
2447 /* DO NOT: "break;" and here's why:
2448 * The seektable template may contain more than one target
2449 * sample for any given frame; we will keep looping, generating
2450 * duplicate seekpoints for them, and we'll clean it up later,
2451 * just before writing the seektable back to the metadata.
2455 encoder
->private_
->first_seekpoint_to_check
++;
2461 if(encoder
->private_
->is_ogg
) {
2462 status
= FLAC__ogg_encoder_aspect_write_callback_wrapper(
2463 &encoder
->protected_
->ogg_encoder_aspect
,
2467 encoder
->private_
->current_frame_number
,
2469 (FLAC__OggEncoderAspectWriteCallbackProxy
)encoder
->private_
->write_callback
,
2471 encoder
->private_
->client_data
2476 status
= encoder
->private_
->write_callback(encoder
, buffer
, bytes
, samples
, encoder
->private_
->current_frame_number
, encoder
->private_
->client_data
);
2478 if(status
== FLAC__STREAM_ENCODER_WRITE_STATUS_OK
) {
2479 encoder
->private_
->bytes_written
+= bytes
;
2480 encoder
->private_
->samples_written
+= samples
;
2481 /* we keep a high watermark on the number of frames written because
2482 * when the encoder goes back to write metadata, 'current_frame'
2483 * will drop back to 0.
2485 encoder
->private_
->frames_written
= flac_max(encoder
->private_
->frames_written
, encoder
->private_
->current_frame_number
+1);
2488 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2493 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks. */
2494 void update_metadata_(const FLAC__StreamEncoder
*encoder
)
2496 FLAC__byte b
[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH
)];
2497 const FLAC__StreamMetadata
*metadata
= &encoder
->private_
->streaminfo
;
2498 const FLAC__uint64 samples
= metadata
->data
.stream_info
.total_samples
;
2499 const unsigned min_framesize
= metadata
->data
.stream_info
.min_framesize
;
2500 const unsigned max_framesize
= metadata
->data
.stream_info
.max_framesize
;
2501 const unsigned bps
= metadata
->data
.stream_info
.bits_per_sample
;
2502 FLAC__StreamEncoderSeekStatus seek_status
;
2504 FLAC__ASSERT(metadata
->type
== FLAC__METADATA_TYPE_STREAMINFO
);
2506 /* All this is based on intimate knowledge of the stream header
2507 * layout, but a change to the header format that would break this
2508 * would also break all streams encoded in the previous format.
2512 * Write MD5 signature
2515 const unsigned md5_offset
=
2516 FLAC__STREAM_METADATA_HEADER_LENGTH
+
2518 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN
+
2519 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
+
2520 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN
+
2521 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN
+
2522 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN
+
2523 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN
+
2524 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
+
2525 FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
2528 if((seek_status
= encoder
->private_
->seek_callback(encoder
, encoder
->protected_
->streaminfo_offset
+ md5_offset
, encoder
->private_
->client_data
)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK
) {
2529 if(seek_status
== FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
)
2530 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2533 if(encoder
->private_
->write_callback(encoder
, metadata
->data
.stream_info
.md5sum
, 16, 0, 0, encoder
->private_
->client_data
) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK
) {
2534 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2540 * Write total samples
2543 const unsigned total_samples_byte_offset
=
2544 FLAC__STREAM_METADATA_HEADER_LENGTH
+
2546 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN
+
2547 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
+
2548 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN
+
2549 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN
+
2550 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN
+
2551 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN
+
2552 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
2556 b
[0] = ((FLAC__byte
)(bps
-1) << 4) | (FLAC__byte
)((samples
>> 32) & 0x0F);
2557 b
[1] = (FLAC__byte
)((samples
>> 24) & 0xFF);
2558 b
[2] = (FLAC__byte
)((samples
>> 16) & 0xFF);
2559 b
[3] = (FLAC__byte
)((samples
>> 8) & 0xFF);
2560 b
[4] = (FLAC__byte
)(samples
& 0xFF);
2561 if((seek_status
= encoder
->private_
->seek_callback(encoder
, encoder
->protected_
->streaminfo_offset
+ total_samples_byte_offset
, encoder
->private_
->client_data
)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK
) {
2562 if(seek_status
== FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
)
2563 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2566 if(encoder
->private_
->write_callback(encoder
, b
, 5, 0, 0, encoder
->private_
->client_data
) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK
) {
2567 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2573 * Write min/max framesize
2576 const unsigned min_framesize_offset
=
2577 FLAC__STREAM_METADATA_HEADER_LENGTH
+
2579 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN
+
2580 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
2583 b
[0] = (FLAC__byte
)((min_framesize
>> 16) & 0xFF);
2584 b
[1] = (FLAC__byte
)((min_framesize
>> 8) & 0xFF);
2585 b
[2] = (FLAC__byte
)(min_framesize
& 0xFF);
2586 b
[3] = (FLAC__byte
)((max_framesize
>> 16) & 0xFF);
2587 b
[4] = (FLAC__byte
)((max_framesize
>> 8) & 0xFF);
2588 b
[5] = (FLAC__byte
)(max_framesize
& 0xFF);
2589 if((seek_status
= encoder
->private_
->seek_callback(encoder
, encoder
->protected_
->streaminfo_offset
+ min_framesize_offset
, encoder
->private_
->client_data
)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK
) {
2590 if(seek_status
== FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
)
2591 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2594 if(encoder
->private_
->write_callback(encoder
, b
, 6, 0, 0, encoder
->private_
->client_data
) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK
) {
2595 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2603 if(0 != encoder
->private_
->seek_table
&& encoder
->private_
->seek_table
->num_points
> 0 && encoder
->protected_
->seektable_offset
> 0) {
2606 FLAC__format_seektable_sort(encoder
->private_
->seek_table
);
2608 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder
->private_
->seek_table
));
2610 if((seek_status
= encoder
->private_
->seek_callback(encoder
, encoder
->protected_
->seektable_offset
+ FLAC__STREAM_METADATA_HEADER_LENGTH
, encoder
->private_
->client_data
)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK
) {
2611 if(seek_status
== FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
)
2612 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2616 for(i
= 0; i
< encoder
->private_
->seek_table
->num_points
; i
++) {
2619 xx
= encoder
->private_
->seek_table
->points
[i
].sample_number
;
2620 b
[7] = (FLAC__byte
)xx
; xx
>>= 8;
2621 b
[6] = (FLAC__byte
)xx
; xx
>>= 8;
2622 b
[5] = (FLAC__byte
)xx
; xx
>>= 8;
2623 b
[4] = (FLAC__byte
)xx
; xx
>>= 8;
2624 b
[3] = (FLAC__byte
)xx
; xx
>>= 8;
2625 b
[2] = (FLAC__byte
)xx
; xx
>>= 8;
2626 b
[1] = (FLAC__byte
)xx
; xx
>>= 8;
2627 b
[0] = (FLAC__byte
)xx
; xx
>>= 8;
2628 xx
= encoder
->private_
->seek_table
->points
[i
].stream_offset
;
2629 b
[15] = (FLAC__byte
)xx
; xx
>>= 8;
2630 b
[14] = (FLAC__byte
)xx
; xx
>>= 8;
2631 b
[13] = (FLAC__byte
)xx
; xx
>>= 8;
2632 b
[12] = (FLAC__byte
)xx
; xx
>>= 8;
2633 b
[11] = (FLAC__byte
)xx
; xx
>>= 8;
2634 b
[10] = (FLAC__byte
)xx
; xx
>>= 8;
2635 b
[9] = (FLAC__byte
)xx
; xx
>>= 8;
2636 b
[8] = (FLAC__byte
)xx
; xx
>>= 8;
2637 x
= encoder
->private_
->seek_table
->points
[i
].frame_samples
;
2638 b
[17] = (FLAC__byte
)x
; x
>>= 8;
2639 b
[16] = (FLAC__byte
)x
; x
>>= 8;
2640 if(encoder
->private_
->write_callback(encoder
, b
, 18, 0, 0, encoder
->private_
->client_data
) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK
) {
2641 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_CLIENT_ERROR
;
2649 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks. */
2650 void update_ogg_metadata_(FLAC__StreamEncoder
*encoder
)
2652 /* the # of bytes in the 1st packet that precede the STREAMINFO */
2653 static const unsigned FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH
=
2654 FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH
+
2655 FLAC__OGG_MAPPING_MAGIC_LENGTH
+
2656 FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH
+
2657 FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH
+
2658 FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH
+
2659 FLAC__STREAM_SYNC_LENGTH
2661 FLAC__byte b
[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH
)];
2662 const FLAC__StreamMetadata
*metadata
= &encoder
->private_
->streaminfo
;
2663 const FLAC__uint64 samples
= metadata
->data
.stream_info
.total_samples
;
2664 const unsigned min_framesize
= metadata
->data
.stream_info
.min_framesize
;
2665 const unsigned max_framesize
= metadata
->data
.stream_info
.max_framesize
;
2668 FLAC__ASSERT(metadata
->type
== FLAC__METADATA_TYPE_STREAMINFO
);
2669 FLAC__ASSERT(0 != encoder
->private_
->seek_callback
);
2671 /* Pre-check that client supports seeking, since we don't want the
2672 * ogg_helper code to ever have to deal with this condition.
2674 if(encoder
->private_
->seek_callback(encoder
, 0, encoder
->private_
->client_data
) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED
)
2677 /* All this is based on intimate knowledge of the stream header
2678 * layout, but a change to the header format that would break this
2679 * would also break all streams encoded in the previous format.
2683 ** Write STREAMINFO stats
2685 simple_ogg_page__init(&page
);
2686 if(!simple_ogg_page__get_at(encoder
, encoder
->protected_
->streaminfo_offset
, &page
, encoder
->private_
->seek_callback
, encoder
->private_
->read_callback
, encoder
->private_
->client_data
)) {
2687 simple_ogg_page__clear(&page
);
2688 return; /* state already set */
2692 * Write MD5 signature
2695 const unsigned md5_offset
=
2696 FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH
+
2697 FLAC__STREAM_METADATA_HEADER_LENGTH
+
2699 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN
+
2700 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
+
2701 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN
+
2702 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN
+
2703 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN
+
2704 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN
+
2705 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
+
2706 FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN
2709 if(md5_offset
+ 16 > (unsigned)page
.body_len
) {
2710 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_OGG_ERROR
;
2711 simple_ogg_page__clear(&page
);
2714 memcpy(page
.body
+ md5_offset
, metadata
->data
.stream_info
.md5sum
, 16);
2718 * Write total samples
2721 const unsigned total_samples_byte_offset
=
2722 FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH
+
2723 FLAC__STREAM_METADATA_HEADER_LENGTH
+
2725 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN
+
2726 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
+
2727 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN
+
2728 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN
+
2729 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN
+
2730 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN
+
2731 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN
2735 if(total_samples_byte_offset
+ 5 > (unsigned)page
.body_len
) {
2736 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_OGG_ERROR
;
2737 simple_ogg_page__clear(&page
);
2740 b
[0] = (FLAC__byte
)page
.body
[total_samples_byte_offset
] & 0xF0;
2741 b
[0] |= (FLAC__byte
)((samples
>> 32) & 0x0F);
2742 b
[1] = (FLAC__byte
)((samples
>> 24) & 0xFF);
2743 b
[2] = (FLAC__byte
)((samples
>> 16) & 0xFF);
2744 b
[3] = (FLAC__byte
)((samples
>> 8) & 0xFF);
2745 b
[4] = (FLAC__byte
)(samples
& 0xFF);
2746 memcpy(page
.body
+ total_samples_byte_offset
, b
, 5);
2750 * Write min/max framesize
2753 const unsigned min_framesize_offset
=
2754 FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH
+
2755 FLAC__STREAM_METADATA_HEADER_LENGTH
+
2757 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN
+
2758 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN
2761 if(min_framesize_offset
+ 6 > (unsigned)page
.body_len
) {
2762 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_OGG_ERROR
;
2763 simple_ogg_page__clear(&page
);
2766 b
[0] = (FLAC__byte
)((min_framesize
>> 16) & 0xFF);
2767 b
[1] = (FLAC__byte
)((min_framesize
>> 8) & 0xFF);
2768 b
[2] = (FLAC__byte
)(min_framesize
& 0xFF);
2769 b
[3] = (FLAC__byte
)((max_framesize
>> 16) & 0xFF);
2770 b
[4] = (FLAC__byte
)((max_framesize
>> 8) & 0xFF);
2771 b
[5] = (FLAC__byte
)(max_framesize
& 0xFF);
2772 memcpy(page
.body
+ min_framesize_offset
, b
, 6);
2774 if(!simple_ogg_page__set_at(encoder
, encoder
->protected_
->streaminfo_offset
, &page
, encoder
->private_
->seek_callback
, encoder
->private_
->write_callback
, encoder
->private_
->client_data
)) {
2775 simple_ogg_page__clear(&page
);
2776 return; /* state already set */
2778 simple_ogg_page__clear(&page
);
2783 if(0 != encoder
->private_
->seek_table
&& encoder
->private_
->seek_table
->num_points
> 0 && encoder
->protected_
->seektable_offset
> 0) {
2787 FLAC__format_seektable_sort(encoder
->private_
->seek_table
);
2789 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder
->private_
->seek_table
));
2791 simple_ogg_page__init(&page
);
2792 if(!simple_ogg_page__get_at(encoder
, encoder
->protected_
->seektable_offset
, &page
, encoder
->private_
->seek_callback
, encoder
->private_
->read_callback
, encoder
->private_
->client_data
)) {
2793 simple_ogg_page__clear(&page
);
2794 return; /* state already set */
2797 if((FLAC__STREAM_METADATA_HEADER_LENGTH
+ 18*encoder
->private_
->seek_table
->num_points
) != (unsigned)page
.body_len
) {
2798 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_OGG_ERROR
;
2799 simple_ogg_page__clear(&page
);
2803 for(i
= 0, p
= page
.body
+ FLAC__STREAM_METADATA_HEADER_LENGTH
; i
< encoder
->private_
->seek_table
->num_points
; i
++, p
+= 18) {
2806 xx
= encoder
->private_
->seek_table
->points
[i
].sample_number
;
2807 b
[7] = (FLAC__byte
)xx
; xx
>>= 8;
2808 b
[6] = (FLAC__byte
)xx
; xx
>>= 8;
2809 b
[5] = (FLAC__byte
)xx
; xx
>>= 8;
2810 b
[4] = (FLAC__byte
)xx
; xx
>>= 8;
2811 b
[3] = (FLAC__byte
)xx
; xx
>>= 8;
2812 b
[2] = (FLAC__byte
)xx
; xx
>>= 8;
2813 b
[1] = (FLAC__byte
)xx
; xx
>>= 8;
2814 b
[0] = (FLAC__byte
)xx
; xx
>>= 8;
2815 xx
= encoder
->private_
->seek_table
->points
[i
].stream_offset
;
2816 b
[15] = (FLAC__byte
)xx
; xx
>>= 8;
2817 b
[14] = (FLAC__byte
)xx
; xx
>>= 8;
2818 b
[13] = (FLAC__byte
)xx
; xx
>>= 8;
2819 b
[12] = (FLAC__byte
)xx
; xx
>>= 8;
2820 b
[11] = (FLAC__byte
)xx
; xx
>>= 8;
2821 b
[10] = (FLAC__byte
)xx
; xx
>>= 8;
2822 b
[9] = (FLAC__byte
)xx
; xx
>>= 8;
2823 b
[8] = (FLAC__byte
)xx
; xx
>>= 8;
2824 x
= encoder
->private_
->seek_table
->points
[i
].frame_samples
;
2825 b
[17] = (FLAC__byte
)x
; x
>>= 8;
2826 b
[16] = (FLAC__byte
)x
; x
>>= 8;
2830 if(!simple_ogg_page__set_at(encoder
, encoder
->protected_
->seektable_offset
, &page
, encoder
->private_
->seek_callback
, encoder
->private_
->write_callback
, encoder
->private_
->client_data
)) {
2831 simple_ogg_page__clear(&page
);
2832 return; /* state already set */
2834 simple_ogg_page__clear(&page
);
2839 FLAC__bool
process_frame_(FLAC__StreamEncoder
*encoder
, FLAC__bool is_fractional_block
, FLAC__bool is_last_block
)
2842 FLAC__ASSERT(encoder
->protected_
->state
== FLAC__STREAM_ENCODER_OK
);
2845 * Accumulate raw signal to the MD5 signature
2847 if(encoder
->protected_
->do_md5
&& !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)) {
2848 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
2853 * Process the frame header and subframes into the frame bitbuffer
2855 if(!process_subframes_(encoder
, is_fractional_block
)) {
2856 /* the above function sets the state for us in case of an error */
2861 * Zero-pad the frame to a byte_boundary
2863 if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder
->private_
->frame
)) {
2864 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
2869 * CRC-16 the whole thing
2871 FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder
->private_
->frame
));
2873 !FLAC__bitwriter_get_write_crc16(encoder
->private_
->frame
, &crc
) ||
2874 !FLAC__bitwriter_write_raw_uint32(encoder
->private_
->frame
, crc
, FLAC__FRAME_FOOTER_CRC_LEN
)
2876 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR
;
2883 if(!write_bitbuffer_(encoder
, encoder
->protected_
->blocksize
, is_last_block
)) {
2884 /* the above function sets the state for us in case of an error */
2889 * Get ready for the next frame
2891 encoder
->private_
->current_sample_number
= 0;
2892 encoder
->private_
->current_frame_number
++;
2893 encoder
->private_
->streaminfo
.data
.stream_info
.total_samples
+= (FLAC__uint64
)encoder
->protected_
->blocksize
;
2898 FLAC__bool
process_subframes_(FLAC__StreamEncoder
*encoder
, FLAC__bool is_fractional_block
)
2900 FLAC__FrameHeader frame_header
;
2901 unsigned channel
, min_partition_order
= encoder
->protected_
->min_residual_partition_order
, max_partition_order
;
2902 FLAC__bool do_independent
, do_mid_side
;
2905 * Calculate the min,max Rice partition orders
2907 if(is_fractional_block
) {
2908 max_partition_order
= 0;
2911 max_partition_order
= FLAC__format_get_max_rice_partition_order_from_blocksize(encoder
->protected_
->blocksize
);
2912 max_partition_order
= flac_min(max_partition_order
, encoder
->protected_
->max_residual_partition_order
);
2914 min_partition_order
= flac_min(min_partition_order
, max_partition_order
);
2919 frame_header
.blocksize
= encoder
->protected_
->blocksize
;
2920 frame_header
.sample_rate
= encoder
->protected_
->sample_rate
;
2921 frame_header
.channels
= encoder
->protected_
->channels
;
2922 frame_header
.channel_assignment
= FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
; /* the default unless the encoder determines otherwise */
2923 frame_header
.bits_per_sample
= encoder
->protected_
->bits_per_sample
;
2924 frame_header
.number_type
= FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER
;
2925 frame_header
.number
.frame_number
= encoder
->private_
->current_frame_number
;
2928 * Figure out what channel assignments to try
2930 if(encoder
->protected_
->do_mid_side_stereo
) {
2931 if(encoder
->protected_
->loose_mid_side_stereo
) {
2932 if(encoder
->private_
->loose_mid_side_stereo_frame_count
== 0) {
2933 do_independent
= true;
2937 do_independent
= (encoder
->private_
->last_channel_assignment
== FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
);
2938 do_mid_side
= !do_independent
;
2942 do_independent
= true;
2947 do_independent
= true;
2948 do_mid_side
= false;
2951 FLAC__ASSERT(do_independent
|| do_mid_side
);
2954 * Check for wasted bits; set effective bps for each subframe
2956 if(do_independent
) {
2957 for(channel
= 0; channel
< encoder
->protected_
->channels
; channel
++) {
2958 const unsigned w
= get_wasted_bits_(encoder
->private_
->integer_signal
[channel
], encoder
->protected_
->blocksize
);
2959 encoder
->private_
->subframe_workspace
[channel
][0].wasted_bits
= encoder
->private_
->subframe_workspace
[channel
][1].wasted_bits
= w
;
2960 encoder
->private_
->subframe_bps
[channel
] = encoder
->protected_
->bits_per_sample
- w
;
2964 FLAC__ASSERT(encoder
->protected_
->channels
== 2);
2965 for(channel
= 0; channel
< 2; channel
++) {
2966 const unsigned w
= get_wasted_bits_(encoder
->private_
->integer_signal_mid_side
[channel
], encoder
->protected_
->blocksize
);
2967 encoder
->private_
->subframe_workspace_mid_side
[channel
][0].wasted_bits
= encoder
->private_
->subframe_workspace_mid_side
[channel
][1].wasted_bits
= w
;
2968 encoder
->private_
->subframe_bps_mid_side
[channel
] = encoder
->protected_
->bits_per_sample
- w
+ (channel
==0? 0:1);
2973 * First do a normal encoding pass of each independent channel
2975 if(do_independent
) {
2976 for(channel
= 0; channel
< encoder
->protected_
->channels
; channel
++) {
2980 min_partition_order
,
2981 max_partition_order
,
2983 encoder
->private_
->subframe_bps
[channel
],
2984 encoder
->private_
->integer_signal
[channel
],
2985 encoder
->private_
->subframe_workspace_ptr
[channel
],
2986 encoder
->private_
->partitioned_rice_contents_workspace_ptr
[channel
],
2987 encoder
->private_
->residual_workspace
[channel
],
2988 encoder
->private_
->best_subframe
+channel
,
2989 encoder
->private_
->best_subframe_bits
+channel
2997 * Now do mid and side channels if requested
3000 FLAC__ASSERT(encoder
->protected_
->channels
== 2);
3002 for(channel
= 0; channel
< 2; channel
++) {
3006 min_partition_order
,
3007 max_partition_order
,
3009 encoder
->private_
->subframe_bps_mid_side
[channel
],
3010 encoder
->private_
->integer_signal_mid_side
[channel
],
3011 encoder
->private_
->subframe_workspace_ptr_mid_side
[channel
],
3012 encoder
->private_
->partitioned_rice_contents_workspace_ptr_mid_side
[channel
],
3013 encoder
->private_
->residual_workspace_mid_side
[channel
],
3014 encoder
->private_
->best_subframe_mid_side
+channel
,
3015 encoder
->private_
->best_subframe_bits_mid_side
+channel
3023 * Compose the frame bitbuffer
3026 unsigned left_bps
= 0, right_bps
= 0; /* initialized only to prevent superfluous compiler warning */
3027 FLAC__Subframe
*left_subframe
= 0, *right_subframe
= 0; /* initialized only to prevent superfluous compiler warning */
3028 FLAC__ChannelAssignment channel_assignment
;
3030 FLAC__ASSERT(encoder
->protected_
->channels
== 2);
3032 if(encoder
->protected_
->loose_mid_side_stereo
&& encoder
->private_
->loose_mid_side_stereo_frame_count
> 0) {
3033 channel_assignment
= (encoder
->private_
->last_channel_assignment
== FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
: FLAC__CHANNEL_ASSIGNMENT_MID_SIDE
);
3036 unsigned bits
[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */
3040 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
== 0);
3041 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE
== 1);
3042 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE
== 2);
3043 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_MID_SIDE
== 3);
3044 FLAC__ASSERT(do_independent
&& do_mid_side
);
3046 /* We have to figure out which channel assignent results in the smallest frame */
3047 bits
[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
] = encoder
->private_
->best_subframe_bits
[0] + encoder
->private_
->best_subframe_bits
[1];
3048 bits
[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE
] = encoder
->private_
->best_subframe_bits
[0] + encoder
->private_
->best_subframe_bits_mid_side
[1];
3049 bits
[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE
] = encoder
->private_
->best_subframe_bits
[1] + encoder
->private_
->best_subframe_bits_mid_side
[1];
3050 bits
[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE
] = encoder
->private_
->best_subframe_bits_mid_side
[0] + encoder
->private_
->best_subframe_bits_mid_side
[1];
3052 channel_assignment
= FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
;
3053 min_bits
= bits
[channel_assignment
];
3054 for(ca
= 1; ca
<= 3; ca
++) {
3055 if(bits
[ca
] < min_bits
) {
3056 min_bits
= bits
[ca
];
3057 channel_assignment
= (FLAC__ChannelAssignment
)ca
;
3062 frame_header
.channel_assignment
= channel_assignment
;
3064 if(!FLAC__frame_add_header(&frame_header
, encoder
->private_
->frame
)) {
3065 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
3069 switch(channel_assignment
) {
3070 case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
:
3071 left_subframe
= &encoder
->private_
->subframe_workspace
[0][encoder
->private_
->best_subframe
[0]];
3072 right_subframe
= &encoder
->private_
->subframe_workspace
[1][encoder
->private_
->best_subframe
[1]];
3074 case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE
:
3075 left_subframe
= &encoder
->private_
->subframe_workspace
[0][encoder
->private_
->best_subframe
[0]];
3076 right_subframe
= &encoder
->private_
->subframe_workspace_mid_side
[1][encoder
->private_
->best_subframe_mid_side
[1]];
3078 case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE
:
3079 left_subframe
= &encoder
->private_
->subframe_workspace_mid_side
[1][encoder
->private_
->best_subframe_mid_side
[1]];
3080 right_subframe
= &encoder
->private_
->subframe_workspace
[1][encoder
->private_
->best_subframe
[1]];
3082 case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE
:
3083 left_subframe
= &encoder
->private_
->subframe_workspace_mid_side
[0][encoder
->private_
->best_subframe_mid_side
[0]];
3084 right_subframe
= &encoder
->private_
->subframe_workspace_mid_side
[1][encoder
->private_
->best_subframe_mid_side
[1]];
3090 switch(channel_assignment
) {
3091 case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT
:
3092 left_bps
= encoder
->private_
->subframe_bps
[0];
3093 right_bps
= encoder
->private_
->subframe_bps
[1];
3095 case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE
:
3096 left_bps
= encoder
->private_
->subframe_bps
[0];
3097 right_bps
= encoder
->private_
->subframe_bps_mid_side
[1];
3099 case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE
:
3100 left_bps
= encoder
->private_
->subframe_bps_mid_side
[1];
3101 right_bps
= encoder
->private_
->subframe_bps
[1];
3103 case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE
:
3104 left_bps
= encoder
->private_
->subframe_bps_mid_side
[0];
3105 right_bps
= encoder
->private_
->subframe_bps_mid_side
[1];
3111 /* note that encoder_add_subframe_ sets the state for us in case of an error */
3112 if(!add_subframe_(encoder
, frame_header
.blocksize
, left_bps
, left_subframe
, encoder
->private_
->frame
))
3114 if(!add_subframe_(encoder
, frame_header
.blocksize
, right_bps
, right_subframe
, encoder
->private_
->frame
))
3118 if(!FLAC__frame_add_header(&frame_header
, encoder
->private_
->frame
)) {
3119 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
3123 for(channel
= 0; channel
< encoder
->protected_
->channels
; channel
++) {
3124 if(!add_subframe_(encoder
, frame_header
.blocksize
, encoder
->private_
->subframe_bps
[channel
], &encoder
->private_
->subframe_workspace
[channel
][encoder
->private_
->best_subframe
[channel
]], encoder
->private_
->frame
)) {
3125 /* the above function sets the state for us in case of an error */
3131 if(encoder
->protected_
->loose_mid_side_stereo
) {
3132 encoder
->private_
->loose_mid_side_stereo_frame_count
++;
3133 if(encoder
->private_
->loose_mid_side_stereo_frame_count
>= encoder
->private_
->loose_mid_side_stereo_frames
)
3134 encoder
->private_
->loose_mid_side_stereo_frame_count
= 0;
3137 encoder
->private_
->last_channel_assignment
= frame_header
.channel_assignment
;
3142 FLAC__bool
process_subframe_(
3143 FLAC__StreamEncoder
*encoder
,
3144 unsigned min_partition_order
,
3145 unsigned max_partition_order
,
3146 const FLAC__FrameHeader
*frame_header
,
3147 unsigned subframe_bps
,
3148 const FLAC__int32 integer_signal
[],
3149 FLAC__Subframe
*subframe
[2],
3150 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
[2],
3151 FLAC__int32
*residual
[2],
3152 unsigned *best_subframe
,
3156 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3157 FLAC__float fixed_residual_bits_per_sample
[FLAC__MAX_FIXED_ORDER
+1];
3159 FLAC__fixedpoint fixed_residual_bits_per_sample
[FLAC__MAX_FIXED_ORDER
+1];
3161 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3162 FLAC__double lpc_residual_bits_per_sample
;
3163 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 */
3164 FLAC__double lpc_error
[FLAC__MAX_LPC_ORDER
];
3165 unsigned min_lpc_order
, max_lpc_order
, lpc_order
;
3166 unsigned min_qlp_coeff_precision
, max_qlp_coeff_precision
, qlp_coeff_precision
;
3168 unsigned min_fixed_order
, max_fixed_order
, guess_fixed_order
, fixed_order
;
3169 unsigned rice_parameter
;
3170 unsigned _candidate_bits
, _best_bits
;
3171 unsigned _best_subframe
;
3172 /* only use RICE2 partitions if stream bps > 16 */
3173 const unsigned rice_parameter_limit
= FLAC__stream_encoder_get_bits_per_sample(encoder
) > 16? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER
: FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER
;
3175 FLAC__ASSERT(frame_header
->blocksize
> 0);
3177 /* verbatim subframe is the baseline against which we measure other compressed subframes */
3179 if(encoder
->private_
->disable_verbatim_subframes
&& frame_header
->blocksize
>= FLAC__MAX_FIXED_ORDER
)
3180 _best_bits
= UINT_MAX
;
3182 _best_bits
= evaluate_verbatim_subframe_(encoder
, integer_signal
, frame_header
->blocksize
, subframe_bps
, subframe
[_best_subframe
]);
3184 if(frame_header
->blocksize
>= FLAC__MAX_FIXED_ORDER
) {
3185 unsigned signal_is_constant
= false;
3186 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
);
3187 /* check for constant subframe */
3189 !encoder
->private_
->disable_constant_subframes
&&
3190 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3191 fixed_residual_bits_per_sample
[1] == 0.0
3193 fixed_residual_bits_per_sample
[1] == FLAC__FP_ZERO
3196 /* the above means it's possible all samples are the same value; now double-check it: */
3198 signal_is_constant
= true;
3199 for(i
= 1; i
< frame_header
->blocksize
; i
++) {
3200 if(integer_signal
[0] != integer_signal
[i
]) {
3201 signal_is_constant
= false;
3206 if(signal_is_constant
) {
3207 _candidate_bits
= evaluate_constant_subframe_(encoder
, integer_signal
[0], frame_header
->blocksize
, subframe_bps
, subframe
[!_best_subframe
]);
3208 if(_candidate_bits
< _best_bits
) {
3209 _best_subframe
= !_best_subframe
;
3210 _best_bits
= _candidate_bits
;
3214 if(!encoder
->private_
->disable_fixed_subframes
|| (encoder
->protected_
->max_lpc_order
== 0 && _best_bits
== UINT_MAX
)) {
3216 if(encoder
->protected_
->do_exhaustive_model_search
) {
3217 min_fixed_order
= 0;
3218 max_fixed_order
= FLAC__MAX_FIXED_ORDER
;
3221 min_fixed_order
= max_fixed_order
= guess_fixed_order
;
3223 if(max_fixed_order
>= frame_header
->blocksize
)
3224 max_fixed_order
= frame_header
->blocksize
- 1;
3225 for(fixed_order
= min_fixed_order
; fixed_order
<= max_fixed_order
; fixed_order
++) {
3226 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3227 if(fixed_residual_bits_per_sample
[fixed_order
] >= (FLAC__float
)subframe_bps
)
3228 continue; /* don't even try */
3229 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 */
3231 if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample
[fixed_order
]) >= (int)subframe_bps
)
3232 continue; /* don't even try */
3233 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 */
3235 rice_parameter
++; /* to account for the signed->unsigned conversion during rice coding */
3236 if(rice_parameter
>= rice_parameter_limit
) {
3237 #ifdef DEBUG_VERBOSE
3238 fprintf(stderr
, "clipping rice_parameter (%u -> %u) @0\n", rice_parameter
, rice_parameter_limit
- 1);
3240 rice_parameter
= rice_parameter_limit
- 1;
3243 evaluate_fixed_subframe_(
3246 residual
[!_best_subframe
],
3247 encoder
->private_
->abs_residual_partition_sums
,
3248 encoder
->private_
->raw_bits_per_partition
,
3249 frame_header
->blocksize
,
3253 rice_parameter_limit
,
3254 min_partition_order
,
3255 max_partition_order
,
3256 encoder
->protected_
->do_escape_coding
,
3257 encoder
->protected_
->rice_parameter_search_dist
,
3258 subframe
[!_best_subframe
],
3259 partitioned_rice_contents
[!_best_subframe
]
3261 if(_candidate_bits
< _best_bits
) {
3262 _best_subframe
= !_best_subframe
;
3263 _best_bits
= _candidate_bits
;
3268 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3270 if(encoder
->protected_
->max_lpc_order
> 0) {
3271 if(encoder
->protected_
->max_lpc_order
>= frame_header
->blocksize
)
3272 max_lpc_order
= frame_header
->blocksize
-1;
3274 max_lpc_order
= encoder
->protected_
->max_lpc_order
;
3275 if(max_lpc_order
> 0) {
3277 for (a
= 0; a
< encoder
->protected_
->num_apodizations
; a
++) {
3278 FLAC__lpc_window_data(integer_signal
, encoder
->private_
->window
[a
], encoder
->private_
->windowed_signal
, frame_header
->blocksize
);
3279 encoder
->private_
->local_lpc_compute_autocorrelation(encoder
->private_
->windowed_signal
, frame_header
->blocksize
, max_lpc_order
+1, autoc
);
3280 /* if autoc[0] == 0.0, the signal is constant and we usually won't get here, but it can happen */
3281 if(autoc
[0] != 0.0) {
3282 FLAC__lpc_compute_lp_coefficients(autoc
, &max_lpc_order
, encoder
->private_
->lp_coeff
, lpc_error
);
3283 if(encoder
->protected_
->do_exhaustive_model_search
) {
3287 const unsigned guess_lpc_order
=
3288 FLAC__lpc_compute_best_order(
3291 frame_header
->blocksize
,
3293 encoder
->protected_
->do_qlp_coeff_prec_search
?
3294 FLAC__MIN_QLP_COEFF_PRECISION
: /* have to guess; use the min possible size to avoid accidentally favoring lower orders */
3295 encoder
->protected_
->qlp_coeff_precision
3298 min_lpc_order
= max_lpc_order
= guess_lpc_order
;
3300 if(max_lpc_order
>= frame_header
->blocksize
)
3301 max_lpc_order
= frame_header
->blocksize
- 1;
3302 for(lpc_order
= min_lpc_order
; lpc_order
<= max_lpc_order
; lpc_order
++) {
3303 lpc_residual_bits_per_sample
= FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error
[lpc_order
-1], frame_header
->blocksize
-lpc_order
);
3304 if(lpc_residual_bits_per_sample
>= (FLAC__double
)subframe_bps
)
3305 continue; /* don't even try */
3306 rice_parameter
= (lpc_residual_bits_per_sample
> 0.0)? (unsigned)(lpc_residual_bits_per_sample
+0.5) : 0; /* 0.5 is for rounding */
3307 rice_parameter
++; /* to account for the signed->unsigned conversion during rice coding */
3308 if(rice_parameter
>= rice_parameter_limit
) {
3309 #ifdef DEBUG_VERBOSE
3310 fprintf(stderr
, "clipping rice_parameter (%u -> %u) @1\n", rice_parameter
, rice_parameter_limit
- 1);
3312 rice_parameter
= rice_parameter_limit
- 1;
3314 if(encoder
->protected_
->do_qlp_coeff_prec_search
) {
3315 min_qlp_coeff_precision
= FLAC__MIN_QLP_COEFF_PRECISION
;
3316 /* try to ensure a 32-bit datapath throughout for 16bps(+1bps for side channel) or less */
3317 if(subframe_bps
<= 17) {
3318 max_qlp_coeff_precision
= flac_min(32 - subframe_bps
- lpc_order
, FLAC__MAX_QLP_COEFF_PRECISION
);
3319 max_qlp_coeff_precision
= flac_max(max_qlp_coeff_precision
, min_qlp_coeff_precision
);
3322 max_qlp_coeff_precision
= FLAC__MAX_QLP_COEFF_PRECISION
;
3325 min_qlp_coeff_precision
= max_qlp_coeff_precision
= encoder
->protected_
->qlp_coeff_precision
;
3327 for(qlp_coeff_precision
= min_qlp_coeff_precision
; qlp_coeff_precision
<= max_qlp_coeff_precision
; qlp_coeff_precision
++) {
3329 evaluate_lpc_subframe_(
3332 residual
[!_best_subframe
],
3333 encoder
->private_
->abs_residual_partition_sums
,
3334 encoder
->private_
->raw_bits_per_partition
,
3335 encoder
->private_
->lp_coeff
[lpc_order
-1],
3336 frame_header
->blocksize
,
3339 qlp_coeff_precision
,
3341 rice_parameter_limit
,
3342 min_partition_order
,
3343 max_partition_order
,
3344 encoder
->protected_
->do_escape_coding
,
3345 encoder
->protected_
->rice_parameter_search_dist
,
3346 subframe
[!_best_subframe
],
3347 partitioned_rice_contents
[!_best_subframe
]
3349 if(_candidate_bits
> 0) { /* if == 0, there was a problem quantizing the lpcoeffs */
3350 if(_candidate_bits
< _best_bits
) {
3351 _best_subframe
= !_best_subframe
;
3352 _best_bits
= _candidate_bits
;
3361 #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */
3365 /* under rare circumstances this can happen when all but lpc subframe types are disabled: */
3366 if(_best_bits
== UINT_MAX
) {
3367 FLAC__ASSERT(_best_subframe
== 0);
3368 _best_bits
= evaluate_verbatim_subframe_(encoder
, integer_signal
, frame_header
->blocksize
, subframe_bps
, subframe
[_best_subframe
]);
3371 *best_subframe
= _best_subframe
;
3372 *best_bits
= _best_bits
;
3377 FLAC__bool
add_subframe_(
3378 FLAC__StreamEncoder
*encoder
,
3380 unsigned subframe_bps
,
3381 const FLAC__Subframe
*subframe
,
3382 FLAC__BitWriter
*frame
3385 switch(subframe
->type
) {
3386 case FLAC__SUBFRAME_TYPE_CONSTANT
:
3387 if(!FLAC__subframe_add_constant(&(subframe
->data
.constant
), subframe_bps
, subframe
->wasted_bits
, frame
)) {
3388 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
3392 case FLAC__SUBFRAME_TYPE_FIXED
:
3393 if(!FLAC__subframe_add_fixed(&(subframe
->data
.fixed
), blocksize
- subframe
->data
.fixed
.order
, subframe_bps
, subframe
->wasted_bits
, frame
)) {
3394 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
3398 case FLAC__SUBFRAME_TYPE_LPC
:
3399 if(!FLAC__subframe_add_lpc(&(subframe
->data
.lpc
), blocksize
- subframe
->data
.lpc
.order
, subframe_bps
, subframe
->wasted_bits
, frame
)) {
3400 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
3404 case FLAC__SUBFRAME_TYPE_VERBATIM
:
3405 if(!FLAC__subframe_add_verbatim(&(subframe
->data
.verbatim
), blocksize
, subframe_bps
, subframe
->wasted_bits
, frame
)) {
3406 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_FRAMING_ERROR
;
3417 #define SPOTCHECK_ESTIMATE 0
3418 #if SPOTCHECK_ESTIMATE
3419 static void spotcheck_subframe_estimate_(
3420 FLAC__StreamEncoder
*encoder
,
3422 unsigned subframe_bps
,
3423 const FLAC__Subframe
*subframe
,
3428 FLAC__BitWriter
*frame
= FLAC__bitwriter_new();
3430 fprintf(stderr
, "EST: can't allocate frame\n");
3433 if(!FLAC__bitwriter_init(frame
)) {
3434 fprintf(stderr
, "EST: can't init frame\n");
3437 ret
= add_subframe_(encoder
, blocksize
, subframe_bps
, subframe
, frame
);
3440 const unsigned actual
= FLAC__bitwriter_get_input_bits_unconsumed(frame
);
3441 if(estimate
!= actual
)
3442 fprintf(stderr
, "EST: bad, frame#%u sub#%%d type=%8s est=%u, actual=%u, delta=%d\n", encoder
->private_
->current_frame_number
, FLAC__SubframeTypeString
[subframe
->type
], estimate
, actual
, (int)actual
-(int)estimate
);
3444 FLAC__bitwriter_delete(frame
);
3448 unsigned evaluate_constant_subframe_(
3449 FLAC__StreamEncoder
*encoder
,
3450 const FLAC__int32 signal
,
3452 unsigned subframe_bps
,
3453 FLAC__Subframe
*subframe
3457 subframe
->type
= FLAC__SUBFRAME_TYPE_CONSTANT
;
3458 subframe
->data
.constant
.value
= signal
;
3460 estimate
= FLAC__SUBFRAME_ZERO_PAD_LEN
+ FLAC__SUBFRAME_TYPE_LEN
+ FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN
+ subframe
->wasted_bits
+ subframe_bps
;
3462 #if SPOTCHECK_ESTIMATE
3463 spotcheck_subframe_estimate_(encoder
, blocksize
, subframe_bps
, subframe
, estimate
);
3465 (void)encoder
, (void)blocksize
;
3471 unsigned evaluate_fixed_subframe_(
3472 FLAC__StreamEncoder
*encoder
,
3473 const FLAC__int32 signal
[],
3474 FLAC__int32 residual
[],
3475 FLAC__uint64 abs_residual_partition_sums
[],
3476 unsigned raw_bits_per_partition
[],
3478 unsigned subframe_bps
,
3480 unsigned rice_parameter
,
3481 unsigned rice_parameter_limit
,
3482 unsigned min_partition_order
,
3483 unsigned max_partition_order
,
3484 FLAC__bool do_escape_coding
,
3485 unsigned rice_parameter_search_dist
,
3486 FLAC__Subframe
*subframe
,
3487 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
3490 unsigned i
, residual_bits
, estimate
;
3491 const unsigned residual_samples
= blocksize
- order
;
3493 FLAC__fixed_compute_residual(signal
+order
, residual_samples
, order
, residual
);
3495 subframe
->type
= FLAC__SUBFRAME_TYPE_FIXED
;
3497 subframe
->data
.fixed
.entropy_coding_method
.type
= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE
;
3498 subframe
->data
.fixed
.entropy_coding_method
.data
.partitioned_rice
.contents
= partitioned_rice_contents
;
3499 subframe
->data
.fixed
.residual
= residual
;
3502 find_best_partition_order_(
3505 abs_residual_partition_sums
,
3506 raw_bits_per_partition
,
3510 rice_parameter_limit
,
3511 min_partition_order
,
3512 max_partition_order
,
3515 rice_parameter_search_dist
,
3516 &subframe
->data
.fixed
.entropy_coding_method
3519 subframe
->data
.fixed
.order
= order
;
3520 for(i
= 0; i
< order
; i
++)
3521 subframe
->data
.fixed
.warmup
[i
] = signal
[i
];
3523 estimate
= FLAC__SUBFRAME_ZERO_PAD_LEN
+ FLAC__SUBFRAME_TYPE_LEN
+ FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN
+ subframe
->wasted_bits
+ (order
* subframe_bps
) + residual_bits
;
3525 #if SPOTCHECK_ESTIMATE
3526 spotcheck_subframe_estimate_(encoder
, blocksize
, subframe_bps
, subframe
, estimate
);
3532 #ifndef FLAC__INTEGER_ONLY_LIBRARY
3533 unsigned evaluate_lpc_subframe_(
3534 FLAC__StreamEncoder
*encoder
,
3535 const FLAC__int32 signal
[],
3536 FLAC__int32 residual
[],
3537 FLAC__uint64 abs_residual_partition_sums
[],
3538 unsigned raw_bits_per_partition
[],
3539 const FLAC__real lp_coeff
[],
3541 unsigned subframe_bps
,
3543 unsigned qlp_coeff_precision
,
3544 unsigned rice_parameter
,
3545 unsigned rice_parameter_limit
,
3546 unsigned min_partition_order
,
3547 unsigned max_partition_order
,
3548 FLAC__bool do_escape_coding
,
3549 unsigned rice_parameter_search_dist
,
3550 FLAC__Subframe
*subframe
,
3551 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
3554 FLAC__int32 qlp_coeff
[FLAC__MAX_LPC_ORDER
];
3555 unsigned i
, residual_bits
, estimate
;
3556 int quantization
, ret
;
3557 const unsigned residual_samples
= blocksize
- order
;
3559 /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps streams */
3560 if(subframe_bps
<= 16) {
3561 FLAC__ASSERT(order
> 0);
3562 FLAC__ASSERT(order
<= FLAC__MAX_LPC_ORDER
);
3563 qlp_coeff_precision
= flac_min(qlp_coeff_precision
, 32 - subframe_bps
- FLAC__bitmath_ilog2(order
));
3566 ret
= FLAC__lpc_quantize_coefficients(lp_coeff
, order
, qlp_coeff_precision
, qlp_coeff
, &quantization
);
3568 return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */
3570 if(subframe_bps
+ qlp_coeff_precision
+ FLAC__bitmath_ilog2(order
) <= 32)
3571 if(subframe_bps
<= 16 && qlp_coeff_precision
<= 16)
3572 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal
+order
, residual_samples
, qlp_coeff
, order
, quantization
, residual
);
3574 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients(signal
+order
, residual_samples
, qlp_coeff
, order
, quantization
, residual
);
3576 encoder
->private_
->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal
+order
, residual_samples
, qlp_coeff
, order
, quantization
, residual
);
3578 subframe
->type
= FLAC__SUBFRAME_TYPE_LPC
;
3580 subframe
->data
.lpc
.entropy_coding_method
.type
= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE
;
3581 subframe
->data
.lpc
.entropy_coding_method
.data
.partitioned_rice
.contents
= partitioned_rice_contents
;
3582 subframe
->data
.lpc
.residual
= residual
;
3585 find_best_partition_order_(
3588 abs_residual_partition_sums
,
3589 raw_bits_per_partition
,
3593 rice_parameter_limit
,
3594 min_partition_order
,
3595 max_partition_order
,
3598 rice_parameter_search_dist
,
3599 &subframe
->data
.lpc
.entropy_coding_method
3602 subframe
->data
.lpc
.order
= order
;
3603 subframe
->data
.lpc
.qlp_coeff_precision
= qlp_coeff_precision
;
3604 subframe
->data
.lpc
.quantization_level
= quantization
;
3605 memcpy(subframe
->data
.lpc
.qlp_coeff
, qlp_coeff
, sizeof(FLAC__int32
)*FLAC__MAX_LPC_ORDER
);
3606 for(i
= 0; i
< order
; i
++)
3607 subframe
->data
.lpc
.warmup
[i
] = signal
[i
];
3609 estimate
= FLAC__SUBFRAME_ZERO_PAD_LEN
+ FLAC__SUBFRAME_TYPE_LEN
+ FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN
+ subframe
->wasted_bits
+ FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN
+ FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN
+ (order
* (qlp_coeff_precision
+ subframe_bps
)) + residual_bits
;
3611 #if SPOTCHECK_ESTIMATE
3612 spotcheck_subframe_estimate_(encoder
, blocksize
, subframe_bps
, subframe
, estimate
);
3619 unsigned evaluate_verbatim_subframe_(
3620 FLAC__StreamEncoder
*encoder
,
3621 const FLAC__int32 signal
[],
3623 unsigned subframe_bps
,
3624 FLAC__Subframe
*subframe
3629 subframe
->type
= FLAC__SUBFRAME_TYPE_VERBATIM
;
3631 subframe
->data
.verbatim
.data
= signal
;
3633 estimate
= FLAC__SUBFRAME_ZERO_PAD_LEN
+ FLAC__SUBFRAME_TYPE_LEN
+ FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN
+ subframe
->wasted_bits
+ (blocksize
* subframe_bps
);
3635 #if SPOTCHECK_ESTIMATE
3636 spotcheck_subframe_estimate_(encoder
, blocksize
, subframe_bps
, subframe
, estimate
);
3644 unsigned find_best_partition_order_(
3645 FLAC__StreamEncoderPrivate
*private_
,
3646 const FLAC__int32 residual
[],
3647 FLAC__uint64 abs_residual_partition_sums
[],
3648 unsigned raw_bits_per_partition
[],
3649 unsigned residual_samples
,
3650 unsigned predictor_order
,
3651 unsigned rice_parameter
,
3652 unsigned rice_parameter_limit
,
3653 unsigned min_partition_order
,
3654 unsigned max_partition_order
,
3656 FLAC__bool do_escape_coding
,
3657 unsigned rice_parameter_search_dist
,
3658 FLAC__EntropyCodingMethod
*best_ecm
3661 unsigned residual_bits
, best_residual_bits
= 0;
3662 unsigned best_parameters_index
= 0;
3663 unsigned best_partition_order
= 0;
3664 const unsigned blocksize
= residual_samples
+ predictor_order
;
3666 max_partition_order
= FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order
, blocksize
, predictor_order
);
3667 min_partition_order
= flac_min(min_partition_order
, max_partition_order
);
3669 precompute_partition_info_sums_(residual
, abs_residual_partition_sums
, residual_samples
, predictor_order
, min_partition_order
, max_partition_order
, bps
);
3671 if(do_escape_coding
)
3672 precompute_partition_info_escapes_(residual
, raw_bits_per_partition
, residual_samples
, predictor_order
, min_partition_order
, max_partition_order
);
3675 int partition_order
;
3678 for(partition_order
= (int)max_partition_order
, sum
= 0; partition_order
>= (int)min_partition_order
; partition_order
--) {
3680 set_partitioned_rice_(
3681 #ifdef EXACT_RICE_BITS_CALCULATION
3684 abs_residual_partition_sums
+sum
,
3685 raw_bits_per_partition
+sum
,
3689 rice_parameter_limit
,
3690 rice_parameter_search_dist
,
3691 (unsigned)partition_order
,
3693 &private_
->partitioned_rice_contents_extra
[!best_parameters_index
],
3698 FLAC__ASSERT(best_residual_bits
!= 0);
3701 sum
+= 1u << partition_order
;
3702 if(best_residual_bits
== 0 || residual_bits
< best_residual_bits
) {
3703 best_residual_bits
= residual_bits
;
3704 best_parameters_index
= !best_parameters_index
;
3705 best_partition_order
= partition_order
;
3710 best_ecm
->data
.partitioned_rice
.order
= best_partition_order
;
3714 * We are allowed to de-const the pointer based on our special
3715 * knowledge; it is const to the outside world.
3717 FLAC__EntropyCodingMethod_PartitionedRiceContents
* prc
= (FLAC__EntropyCodingMethod_PartitionedRiceContents
*)best_ecm
->data
.partitioned_rice
.contents
;
3720 /* save best parameters and raw_bits */
3721 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(prc
, flac_max(6u, best_partition_order
));
3722 memcpy(prc
->parameters
, private_
->partitioned_rice_contents_extra
[best_parameters_index
].parameters
, sizeof(unsigned)*(1<<(best_partition_order
)));
3723 if(do_escape_coding
)
3724 memcpy(prc
->raw_bits
, private_
->partitioned_rice_contents_extra
[best_parameters_index
].raw_bits
, sizeof(unsigned)*(1<<(best_partition_order
)));
3726 * Now need to check if the type should be changed to
3727 * FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 based on the
3728 * size of the rice parameters.
3730 for(partition
= 0; partition
< (1u<<best_partition_order
); partition
++) {
3731 if(prc
->parameters
[partition
] >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER
) {
3732 best_ecm
->type
= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2
;
3738 return best_residual_bits
;
3741 #if defined(FLAC__CPU_IA32) && !defined FLAC__NO_ASM && defined FLAC__HAS_NASM
3742 extern void precompute_partition_info_sums_32bit_asm_ia32_(
3743 const FLAC__int32 residual
[],
3744 FLAC__uint64 abs_residual_partition_sums
[],
3746 unsigned predictor_order
,
3747 unsigned min_partition_order
,
3748 unsigned max_partition_order
3752 void precompute_partition_info_sums_(
3753 const FLAC__int32 residual
[],
3754 FLAC__uint64 abs_residual_partition_sums
[],
3755 unsigned residual_samples
,
3756 unsigned predictor_order
,
3757 unsigned min_partition_order
,
3758 unsigned max_partition_order
,
3762 const unsigned default_partition_samples
= (residual_samples
+ predictor_order
) >> max_partition_order
;
3763 unsigned partitions
= 1u << max_partition_order
;
3765 FLAC__ASSERT(default_partition_samples
> predictor_order
);
3767 #if defined(FLAC__CPU_IA32) && !defined FLAC__NO_ASM && defined FLAC__HAS_NASM
3768 /* slightly pessimistic but still catches all common cases */
3769 /* WATCHOUT: "+ bps" is an assumption that the average residual magnitude will not be more than "bps" bits */
3770 if(FLAC__bitmath_ilog2(default_partition_samples
) + bps
< 32) {
3771 precompute_partition_info_sums_32bit_asm_ia32_(residual
, abs_residual_partition_sums
, residual_samples
+ predictor_order
, predictor_order
, min_partition_order
, max_partition_order
);
3776 /* first do max_partition_order */
3778 unsigned partition
, residual_sample
, end
= (unsigned)(-(int)predictor_order
);
3779 /* slightly pessimistic but still catches all common cases */
3780 /* WATCHOUT: "+ bps" is an assumption that the average residual magnitude will not be more than "bps" bits */
3781 if(FLAC__bitmath_ilog2(default_partition_samples
) + bps
< 32) {
3782 FLAC__uint32 abs_residual_partition_sum
;
3784 for(partition
= residual_sample
= 0; partition
< partitions
; partition
++) {
3785 end
+= default_partition_samples
;
3786 abs_residual_partition_sum
= 0;
3787 for( ; residual_sample
< end
; residual_sample
++)
3788 abs_residual_partition_sum
+= abs(residual
[residual_sample
]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */
3789 abs_residual_partition_sums
[partition
] = abs_residual_partition_sum
;
3792 else { /* have to pessimistically use 64 bits for accumulator */
3793 FLAC__uint64 abs_residual_partition_sum
;
3795 for(partition
= residual_sample
= 0; partition
< partitions
; partition
++) {
3796 end
+= default_partition_samples
;
3797 abs_residual_partition_sum
= 0;
3798 for( ; residual_sample
< end
; residual_sample
++)
3799 abs_residual_partition_sum
+= abs(residual
[residual_sample
]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */
3800 abs_residual_partition_sums
[partition
] = abs_residual_partition_sum
;
3805 /* now merge partitions for lower orders */
3807 unsigned from_partition
= 0, to_partition
= partitions
;
3808 int partition_order
;
3809 for(partition_order
= (int)max_partition_order
- 1; partition_order
>= (int)min_partition_order
; partition_order
--) {
3812 for(i
= 0; i
< partitions
; i
++) {
3813 abs_residual_partition_sums
[to_partition
++] =
3814 abs_residual_partition_sums
[from_partition
] +
3815 abs_residual_partition_sums
[from_partition
+1];
3816 from_partition
+= 2;
3822 void precompute_partition_info_escapes_(
3823 const FLAC__int32 residual
[],
3824 unsigned raw_bits_per_partition
[],
3825 unsigned residual_samples
,
3826 unsigned predictor_order
,
3827 unsigned min_partition_order
,
3828 unsigned max_partition_order
3831 int partition_order
;
3832 unsigned from_partition
, to_partition
= 0;
3833 const unsigned blocksize
= residual_samples
+ predictor_order
;
3835 /* first do max_partition_order */
3836 for(partition_order
= (int)max_partition_order
; partition_order
>= 0; partition_order
--) {
3839 unsigned partition
, partition_sample
, partition_samples
, residual_sample
;
3840 const unsigned partitions
= 1u << partition_order
;
3841 const unsigned default_partition_samples
= blocksize
>> partition_order
;
3843 FLAC__ASSERT(default_partition_samples
> predictor_order
);
3845 for(partition
= residual_sample
= 0; partition
< partitions
; partition
++) {
3846 partition_samples
= default_partition_samples
;
3848 partition_samples
-= predictor_order
;
3850 for(partition_sample
= 0; partition_sample
< partition_samples
; partition_sample
++) {
3851 r
= residual
[residual_sample
++];
3852 /* OPT: maybe faster: rmax |= r ^ (r>>31) */
3858 /* now we know all residual values are in the range [-rmax-1,rmax] */
3859 raw_bits_per_partition
[partition
] = rmax
? FLAC__bitmath_ilog2(rmax
) + 2 : 1;
3861 to_partition
= partitions
;
3862 break; /*@@@ yuck, should remove the 'for' loop instead */
3865 /* now merge partitions for lower orders */
3866 for(from_partition
= 0, --partition_order
; partition_order
>= (int)min_partition_order
; partition_order
--) {
3869 const unsigned partitions
= 1u << partition_order
;
3870 for(i
= 0; i
< partitions
; i
++) {
3871 m
= raw_bits_per_partition
[from_partition
];
3873 raw_bits_per_partition
[to_partition
] = flac_max(m
, raw_bits_per_partition
[from_partition
]);
3880 #ifdef EXACT_RICE_BITS_CALCULATION
3881 static inline unsigned count_rice_bits_in_partition_(
3882 const unsigned rice_parameter
,
3883 const unsigned partition_samples
,
3884 const FLAC__int32
*residual
3887 unsigned i
, partition_bits
=
3888 FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN
+ /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */
3889 (1+rice_parameter
) * partition_samples
/* 1 for unary stop bit + rice_parameter for the binary portion */
3891 for(i
= 0; i
< partition_samples
; i
++)
3892 partition_bits
+= ( (FLAC__uint32
)((residual
[i
]<<1)^(residual
[i
]>>31)) >> rice_parameter
);
3893 return partition_bits
;
3896 static inline unsigned count_rice_bits_in_partition_(
3897 const unsigned rice_parameter
,
3898 const unsigned partition_samples
,
3899 const FLAC__uint64 abs_residual_partition_sum
3903 FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN
+ /* actually could end up being FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN but err on side of 16bps */
3904 (1+rice_parameter
) * partition_samples
+ /* 1 for unary stop bit + rice_parameter for the binary portion */
3907 (unsigned)(abs_residual_partition_sum
>> (rice_parameter
-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */
3908 : (unsigned)(abs_residual_partition_sum
<< 1) /* can't shift by negative number, so reverse */
3910 - (partition_samples
>> 1)
3911 /* -(partition_samples>>1) to subtract out extra contributions to the abs_residual_partition_sum.
3912 * The actual number of bits used is closer to the sum(for all i in the partition) of abs(residual[i])>>(rice_parameter-1)
3913 * By using the abs_residual_partition sum, we also add in bits in the LSBs that would normally be shifted out.
3914 * So the subtraction term tries to guess how many extra bits were contributed.
3915 * If the LSBs are randomly distributed, this should average to 0.5 extra bits per sample.
3921 FLAC__bool
set_partitioned_rice_(
3922 #ifdef EXACT_RICE_BITS_CALCULATION
3923 const FLAC__int32 residual
[],
3925 const FLAC__uint64 abs_residual_partition_sums
[],
3926 const unsigned raw_bits_per_partition
[],
3927 const unsigned residual_samples
,
3928 const unsigned predictor_order
,
3929 const unsigned suggested_rice_parameter
,
3930 const unsigned rice_parameter_limit
,
3931 const unsigned rice_parameter_search_dist
,
3932 const unsigned partition_order
,
3933 const FLAC__bool search_for_escapes
,
3934 FLAC__EntropyCodingMethod_PartitionedRiceContents
*partitioned_rice_contents
,
3938 unsigned rice_parameter
, partition_bits
;
3939 unsigned best_partition_bits
, best_rice_parameter
= 0;
3940 unsigned bits_
= FLAC__ENTROPY_CODING_METHOD_TYPE_LEN
+ FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN
;
3941 unsigned *parameters
, *raw_bits
;
3942 #ifdef ENABLE_RICE_PARAMETER_SEARCH
3943 unsigned min_rice_parameter
, max_rice_parameter
;
3945 (void)rice_parameter_search_dist
;
3948 FLAC__ASSERT(suggested_rice_parameter
< FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER
);
3949 FLAC__ASSERT(rice_parameter_limit
<= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER
);
3951 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents
, flac_max(6u, partition_order
));
3952 parameters
= partitioned_rice_contents
->parameters
;
3953 raw_bits
= partitioned_rice_contents
->raw_bits
;
3955 if(partition_order
== 0) {
3956 best_partition_bits
= (unsigned)(-1);
3957 #ifdef ENABLE_RICE_PARAMETER_SEARCH
3958 if(rice_parameter_search_dist
) {
3959 if(suggested_rice_parameter
< rice_parameter_search_dist
)
3960 min_rice_parameter
= 0;
3962 min_rice_parameter
= suggested_rice_parameter
- rice_parameter_search_dist
;
3963 max_rice_parameter
= suggested_rice_parameter
+ rice_parameter_search_dist
;
3964 if(max_rice_parameter
>= rice_parameter_limit
) {
3965 #ifdef DEBUG_VERBOSE
3966 fprintf(stderr
, "clipping rice_parameter (%u -> %u) @5\n", max_rice_parameter
, rice_parameter_limit
- 1);
3968 max_rice_parameter
= rice_parameter_limit
- 1;
3972 min_rice_parameter
= max_rice_parameter
= suggested_rice_parameter
;
3974 for(rice_parameter
= min_rice_parameter
; rice_parameter
<= max_rice_parameter
; rice_parameter
++) {
3976 rice_parameter
= suggested_rice_parameter
;
3978 #ifdef EXACT_RICE_BITS_CALCULATION
3979 partition_bits
= count_rice_bits_in_partition_(rice_parameter
, residual_samples
, residual
);
3981 partition_bits
= count_rice_bits_in_partition_(rice_parameter
, residual_samples
, abs_residual_partition_sums
[0]);
3983 if(partition_bits
< best_partition_bits
) {
3984 best_rice_parameter
= rice_parameter
;
3985 best_partition_bits
= partition_bits
;
3987 #ifdef ENABLE_RICE_PARAMETER_SEARCH
3990 if(search_for_escapes
) {
3991 partition_bits
= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN
+ FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN
+ raw_bits_per_partition
[0] * residual_samples
;
3992 if(partition_bits
<= best_partition_bits
) {
3993 raw_bits
[0] = raw_bits_per_partition
[0];
3994 best_rice_parameter
= 0; /* will be converted to appropriate escape parameter later */
3995 best_partition_bits
= partition_bits
;
4000 parameters
[0] = best_rice_parameter
;
4001 bits_
+= best_partition_bits
;
4004 unsigned partition
, residual_sample
;
4005 unsigned partition_samples
;
4006 FLAC__uint64 mean
, k
;
4007 const unsigned partitions
= 1u << partition_order
;
4008 for(partition
= residual_sample
= 0; partition
< partitions
; partition
++) {
4009 partition_samples
= (residual_samples
+predictor_order
) >> partition_order
;
4010 if(partition
== 0) {
4011 if(partition_samples
<= predictor_order
)
4014 partition_samples
-= predictor_order
;
4016 mean
= abs_residual_partition_sums
[partition
];
4017 /* we are basically calculating the size in bits of the
4018 * average residual magnitude in the partition:
4019 * rice_parameter = floor(log2(mean/partition_samples))
4020 * 'mean' is not a good name for the variable, it is
4021 * actually the sum of magnitudes of all residual values
4022 * in the partition, so the actual mean is
4023 * mean/partition_samples
4025 for(rice_parameter
= 0, k
= partition_samples
; k
< mean
; rice_parameter
++, k
<<= 1)
4027 if(rice_parameter
>= rice_parameter_limit
) {
4028 #ifdef DEBUG_VERBOSE
4029 fprintf(stderr
, "clipping rice_parameter (%u -> %u) @6\n", rice_parameter
, rice_parameter_limit
- 1);
4031 rice_parameter
= rice_parameter_limit
- 1;
4034 best_partition_bits
= (unsigned)(-1);
4035 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4036 if(rice_parameter_search_dist
) {
4037 if(rice_parameter
< rice_parameter_search_dist
)
4038 min_rice_parameter
= 0;
4040 min_rice_parameter
= rice_parameter
- rice_parameter_search_dist
;
4041 max_rice_parameter
= rice_parameter
+ rice_parameter_search_dist
;
4042 if(max_rice_parameter
>= rice_parameter_limit
) {
4043 #ifdef DEBUG_VERBOSE
4044 fprintf(stderr
, "clipping rice_parameter (%u -> %u) @7\n", max_rice_parameter
, rice_parameter_limit
- 1);
4046 max_rice_parameter
= rice_parameter_limit
- 1;
4050 min_rice_parameter
= max_rice_parameter
= rice_parameter
;
4052 for(rice_parameter
= min_rice_parameter
; rice_parameter
<= max_rice_parameter
; rice_parameter
++) {
4054 #ifdef EXACT_RICE_BITS_CALCULATION
4055 partition_bits
= count_rice_bits_in_partition_(rice_parameter
, partition_samples
, residual
+residual_sample
);
4057 partition_bits
= count_rice_bits_in_partition_(rice_parameter
, partition_samples
, abs_residual_partition_sums
[partition
]);
4059 if(partition_bits
< best_partition_bits
) {
4060 best_rice_parameter
= rice_parameter
;
4061 best_partition_bits
= partition_bits
;
4063 #ifdef ENABLE_RICE_PARAMETER_SEARCH
4066 if(search_for_escapes
) {
4067 partition_bits
= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN
+ FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN
+ raw_bits_per_partition
[partition
] * partition_samples
;
4068 if(partition_bits
<= best_partition_bits
) {
4069 raw_bits
[partition
] = raw_bits_per_partition
[partition
];
4070 best_rice_parameter
= 0; /* will be converted to appropriate escape parameter later */
4071 best_partition_bits
= partition_bits
;
4074 raw_bits
[partition
] = 0;
4076 parameters
[partition
] = best_rice_parameter
;
4077 bits_
+= best_partition_bits
;
4078 residual_sample
+= partition_samples
;
4086 unsigned get_wasted_bits_(FLAC__int32 signal
[], unsigned samples
)
4091 for(i
= 0; i
< samples
&& !(x
&1); i
++)
4098 for(shift
= 0; !(x
&1); shift
++)
4103 for(i
= 0; i
< samples
; i
++)
4104 signal
[i
] >>= shift
;
4110 void append_to_verify_fifo_(verify_input_fifo
*fifo
, const FLAC__int32
* const input
[], unsigned input_offset
, unsigned channels
, unsigned wide_samples
)
4114 for(channel
= 0; channel
< channels
; channel
++)
4115 memcpy(&fifo
->data
[channel
][fifo
->tail
], &input
[channel
][input_offset
], sizeof(FLAC__int32
) * wide_samples
);
4117 fifo
->tail
+= wide_samples
;
4119 FLAC__ASSERT(fifo
->tail
<= fifo
->size
);
4122 void append_to_verify_fifo_interleaved_(verify_input_fifo
*fifo
, const FLAC__int32 input
[], unsigned input_offset
, unsigned channels
, unsigned wide_samples
)
4125 unsigned sample
, wide_sample
;
4126 unsigned tail
= fifo
->tail
;
4128 sample
= input_offset
* channels
;
4129 for(wide_sample
= 0; wide_sample
< wide_samples
; wide_sample
++) {
4130 for(channel
= 0; channel
< channels
; channel
++)
4131 fifo
->data
[channel
][tail
] = input
[sample
++];
4136 FLAC__ASSERT(fifo
->tail
<= fifo
->size
);
4139 FLAC__StreamDecoderReadStatus
verify_read_callback_(const FLAC__StreamDecoder
*decoder
, FLAC__byte buffer
[], size_t *bytes
, void *client_data
)
4141 FLAC__StreamEncoder
*encoder
= (FLAC__StreamEncoder
*)client_data
;
4142 const size_t encoded_bytes
= encoder
->private_
->verify
.output
.bytes
;
4145 if(encoder
->private_
->verify
.needs_magic_hack
) {
4146 FLAC__ASSERT(*bytes
>= FLAC__STREAM_SYNC_LENGTH
);
4147 *bytes
= FLAC__STREAM_SYNC_LENGTH
;
4148 memcpy(buffer
, FLAC__STREAM_SYNC_STRING
, *bytes
);
4149 encoder
->private_
->verify
.needs_magic_hack
= false;
4152 if(encoded_bytes
== 0) {
4154 * If we get here, a FIFO underflow has occurred,
4155 * which means there is a bug somewhere.
4158 return FLAC__STREAM_DECODER_READ_STATUS_ABORT
;
4160 else if(encoded_bytes
< *bytes
)
4161 *bytes
= encoded_bytes
;
4162 memcpy(buffer
, encoder
->private_
->verify
.output
.data
, *bytes
);
4163 encoder
->private_
->verify
.output
.data
+= *bytes
;
4164 encoder
->private_
->verify
.output
.bytes
-= *bytes
;
4167 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE
;
4170 FLAC__StreamDecoderWriteStatus
verify_write_callback_(const FLAC__StreamDecoder
*decoder
, const FLAC__Frame
*frame
, const FLAC__int32
* const buffer
[], void *client_data
)
4172 FLAC__StreamEncoder
*encoder
= (FLAC__StreamEncoder
*)client_data
;
4174 const unsigned channels
= frame
->header
.channels
;
4175 const unsigned blocksize
= frame
->header
.blocksize
;
4176 const unsigned bytes_per_block
= sizeof(FLAC__int32
) * blocksize
;
4180 for(channel
= 0; channel
< channels
; channel
++) {
4181 if(0 != memcmp(buffer
[channel
], encoder
->private_
->verify
.input_fifo
.data
[channel
], bytes_per_block
)) {
4182 unsigned i
, sample
= 0;
4183 FLAC__int32 expect
= 0, got
= 0;
4185 for(i
= 0; i
< blocksize
; i
++) {
4186 if(buffer
[channel
][i
] != encoder
->private_
->verify
.input_fifo
.data
[channel
][i
]) {
4188 expect
= (FLAC__int32
)encoder
->private_
->verify
.input_fifo
.data
[channel
][i
];
4189 got
= (FLAC__int32
)buffer
[channel
][i
];
4193 FLAC__ASSERT(i
< blocksize
);
4194 FLAC__ASSERT(frame
->header
.number_type
== FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER
);
4195 encoder
->private_
->verify
.error_stats
.absolute_sample
= frame
->header
.number
.sample_number
+ sample
;
4196 encoder
->private_
->verify
.error_stats
.frame_number
= (unsigned)(frame
->header
.number
.sample_number
/ blocksize
);
4197 encoder
->private_
->verify
.error_stats
.channel
= channel
;
4198 encoder
->private_
->verify
.error_stats
.sample
= sample
;
4199 encoder
->private_
->verify
.error_stats
.expected
= expect
;
4200 encoder
->private_
->verify
.error_stats
.got
= got
;
4201 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA
;
4202 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT
;
4205 /* dequeue the frame from the fifo */
4206 encoder
->private_
->verify
.input_fifo
.tail
-= blocksize
;
4207 FLAC__ASSERT(encoder
->private_
->verify
.input_fifo
.tail
<= OVERREAD_
);
4208 for(channel
= 0; channel
< channels
; channel
++)
4209 memmove(&encoder
->private_
->verify
.input_fifo
.data
[channel
][0], &encoder
->private_
->verify
.input_fifo
.data
[channel
][blocksize
], encoder
->private_
->verify
.input_fifo
.tail
* sizeof(encoder
->private_
->verify
.input_fifo
.data
[0][0]));
4210 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE
;
4213 void verify_metadata_callback_(const FLAC__StreamDecoder
*decoder
, const FLAC__StreamMetadata
*metadata
, void *client_data
)
4215 (void)decoder
, (void)metadata
, (void)client_data
;
4218 void verify_error_callback_(const FLAC__StreamDecoder
*decoder
, FLAC__StreamDecoderErrorStatus status
, void *client_data
)
4220 FLAC__StreamEncoder
*encoder
= (FLAC__StreamEncoder
*)client_data
;
4221 (void)decoder
, (void)status
;
4222 encoder
->protected_
->state
= FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR
;
4225 FLAC__StreamEncoderReadStatus
file_read_callback_(const FLAC__StreamEncoder
*encoder
, FLAC__byte buffer
[], size_t *bytes
, void *client_data
)
4229 *bytes
= fread(buffer
, 1, *bytes
, encoder
->private_
->file
);
4231 if (feof(encoder
->private_
->file
))
4232 return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM
;
4233 else if (ferror(encoder
->private_
->file
))
4234 return FLAC__STREAM_ENCODER_READ_STATUS_ABORT
;
4236 return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE
;
4239 FLAC__StreamEncoderSeekStatus
file_seek_callback_(const FLAC__StreamEncoder
*encoder
, FLAC__uint64 absolute_byte_offset
, void *client_data
)
4243 if(fseeko(encoder
->private_
->file
, (FLAC__off_t
)absolute_byte_offset
, SEEK_SET
) < 0)
4244 return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR
;
4246 return FLAC__STREAM_ENCODER_SEEK_STATUS_OK
;
4249 FLAC__StreamEncoderTellStatus
file_tell_callback_(const FLAC__StreamEncoder
*encoder
, FLAC__uint64
*absolute_byte_offset
, void *client_data
)
4255 offset
= ftello(encoder
->private_
->file
);
4258 return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR
;
4261 *absolute_byte_offset
= (FLAC__uint64
)offset
;
4262 return FLAC__STREAM_ENCODER_TELL_STATUS_OK
;
4266 #ifdef FLAC__VALGRIND_TESTING
4267 static size_t local__fwrite(const void *ptr
, size_t size
, size_t nmemb
, FILE *stream
)
4269 size_t ret
= fwrite(ptr
, size
, nmemb
, stream
);
4275 #define local__fwrite fwrite
4278 FLAC__StreamEncoderWriteStatus
file_write_callback_(const FLAC__StreamEncoder
*encoder
, const FLAC__byte buffer
[], size_t bytes
, unsigned samples
, unsigned current_frame
, void *client_data
)
4280 (void)client_data
, (void)current_frame
;
4282 if(local__fwrite(buffer
, sizeof(FLAC__byte
), bytes
, encoder
->private_
->file
) == bytes
) {
4283 FLAC__bool call_it
= 0 != encoder
->private_
->progress_callback
&& (
4285 /* We would like to be able to use 'samples > 0' in the
4286 * clause here but currently because of the nature of our
4287 * Ogg writing implementation, 'samples' is always 0 (see
4288 * ogg_encoder_aspect.c). The downside is extra progress
4291 encoder
->private_
->is_ogg
? true :
4296 /* NOTE: We have to add +bytes, +samples, and +1 to the stats
4297 * because at this point in the callback chain, the stats
4298 * have not been updated. Only after we return and control
4299 * gets back to write_frame_() are the stats updated
4301 encoder
->private_
->progress_callback(encoder
, encoder
->private_
->bytes_written
+bytes
, encoder
->private_
->samples_written
+samples
, encoder
->private_
->frames_written
+(samples
?1:0), encoder
->private_
->total_frames_estimate
, encoder
->private_
->client_data
);
4303 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK
;
4306 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR
;
4310 * This will forcibly set stdout to binary mode (for OSes that require it)
4312 FILE *get_binary_stdout_(void)
4314 /* if something breaks here it is probably due to the presence or
4315 * absence of an underscore before the identifiers 'setmode',
4316 * 'fileno', and/or 'O_BINARY'; check your system header files.
4318 #if defined _MSC_VER || defined __MINGW32__
4319 _setmode(_fileno(stdout
), _O_BINARY
);
4320 #elif defined __CYGWIN__
4321 /* almost certainly not needed for any modern Cygwin, but let's be safe... */
4322 setmode(_fileno(stdout
), _O_BINARY
);
4323 #elif defined __EMX__
4324 setmode(fileno(stdout
), O_BINARY
);