1 /* libFLAC - Free Lossless Audio Codec library 2 * Copyright (C) 2000-2009 Josh Coalson 3 * Copyright (C) 2011-2016 Xiph.Org Foundation 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * - Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * - Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * - Neither the name of the Xiph.org Foundation nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR 24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 27 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 28 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 29 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #ifdef HAVE_CONFIG_H 34 # include <config.h> 35 #endif 36 37 #include <limits.h> 38 #include <stdio.h> 39 #include <stdlib.h> /* for malloc() */ 40 #include <string.h> /* for memcpy() */ 41 #include <sys/types.h> /* for off_t */ 42 #ifdef _WIN32 43 #include <windows.h> /* for GetFileType() */ 44 #include <io.h> /* for _get_osfhandle() */ 45 #endif 46 #include "share/compat.h" 47 #include "FLAC/assert.h" 48 #include "FLAC/stream_decoder.h" 49 #include "protected/stream_encoder.h" 50 #include "private/bitwriter.h" 51 #include "private/bitmath.h" 52 #include "private/crc.h" 53 #include "private/cpu.h" 54 #include "private/fixed.h" 55 #include "private/format.h" 56 #include "private/lpc.h" 57 #include "private/md5.h" 58 #include "private/memory.h" 59 #include "private/macros.h" 60 #if FLAC__HAS_OGG 61 #include "private/ogg_helper.h" 62 #include "private/ogg_mapping.h" 63 #endif 64 #include "private/stream_encoder.h" 65 #include "private/stream_encoder_framing.h" 66 #include "private/window.h" 67 #include "share/alloc.h" 68 #include "share/private.h" 69 70 71 /* Exact Rice codeword length calculation is off by default. The simple 72 * (and fast) estimation (of how many bits a residual value will be 73 * encoded with) in this encoder is very good, almost always yielding 74 * compression within 0.1% of exact calculation. 75 */ 76 #undef EXACT_RICE_BITS_CALCULATION 77 /* Rice parameter searching is off by default. The simple (and fast) 78 * parameter estimation in this encoder is very good, almost always 79 * yielding compression within 0.1% of the optimal parameters. 80 */ 81 #undef ENABLE_RICE_PARAMETER_SEARCH 82 83 84 typedef struct { 85 FLAC__int32 *data[FLAC__MAX_CHANNELS]; 86 unsigned size; /* of each data[] in samples */ 87 unsigned tail; 88 } verify_input_fifo; 89 90 typedef struct { 91 const FLAC__byte *data; 92 unsigned capacity; 93 unsigned bytes; 94 } verify_output; 95 96 typedef enum { 97 ENCODER_IN_MAGIC = 0, 98 ENCODER_IN_METADATA = 1, 99 ENCODER_IN_AUDIO = 2 100 } EncoderStateHint; 101 102 static struct CompressionLevels { 103 FLAC__bool do_mid_side_stereo; 104 FLAC__bool loose_mid_side_stereo; 105 unsigned max_lpc_order; 106 unsigned qlp_coeff_precision; 107 FLAC__bool do_qlp_coeff_prec_search; 108 FLAC__bool do_escape_coding; 109 FLAC__bool do_exhaustive_model_search; 110 unsigned min_residual_partition_order; 111 unsigned max_residual_partition_order; 112 unsigned rice_parameter_search_dist; 113 const char *apodization; 114 } compression_levels_[] = { 115 { false, false, 0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" }, 116 { true , true , 0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" }, 117 { true , false, 0, 0, false, false, false, 0, 3, 0, "tukey(5e-1)" }, 118 { false, false, 6, 0, false, false, false, 0, 4, 0, "tukey(5e-1)" }, 119 { true , true , 8, 0, false, false, false, 0, 4, 0, "tukey(5e-1)" }, 120 { true , false, 8, 0, false, false, false, 0, 5, 0, "tukey(5e-1)" }, 121 { true , false, 8, 0, false, false, false, 0, 6, 0, "tukey(5e-1);partial_tukey(2)" }, 122 { true , false, 12, 0, false, false, false, 0, 6, 0, "tukey(5e-1);partial_tukey(2)" }, 123 { true , false, 12, 0, false, false, false, 0, 6, 0, "tukey(5e-1);partial_tukey(2);punchout_tukey(3)" } 124 /* here we use locale-independent 5e-1 instead of 0.5 or 0,5 */ 125 }; 126 127 128 /*********************************************************************** 129 * 130 * Private class method prototypes 131 * 132 ***********************************************************************/ 133 134 static void set_defaults_(FLAC__StreamEncoder *encoder); 135 static void free_(FLAC__StreamEncoder *encoder); 136 static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize); 137 static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block); 138 static FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block); 139 static void update_metadata_(const FLAC__StreamEncoder *encoder); 140 #if FLAC__HAS_OGG 141 static void update_ogg_metadata_(FLAC__StreamEncoder *encoder); 142 #endif 143 static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block); 144 static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block); 145 146 static FLAC__bool process_subframe_( 147 FLAC__StreamEncoder *encoder, 148 unsigned min_partition_order, 149 unsigned max_partition_order, 150 const FLAC__FrameHeader *frame_header, 151 unsigned subframe_bps, 152 const FLAC__int32 integer_signal[], 153 FLAC__Subframe *subframe[2], 154 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2], 155 FLAC__int32 *residual[2], 156 unsigned *best_subframe, 157 unsigned *best_bits 158 ); 159 160 static FLAC__bool add_subframe_( 161 FLAC__StreamEncoder *encoder, 162 unsigned blocksize, 163 unsigned subframe_bps, 164 const FLAC__Subframe *subframe, 165 FLAC__BitWriter *frame 166 ); 167 168 static unsigned evaluate_constant_subframe_( 169 FLAC__StreamEncoder *encoder, 170 const FLAC__int32 signal, 171 unsigned blocksize, 172 unsigned subframe_bps, 173 FLAC__Subframe *subframe 174 ); 175 176 static unsigned evaluate_fixed_subframe_( 177 FLAC__StreamEncoder *encoder, 178 const FLAC__int32 signal[], 179 FLAC__int32 residual[], 180 FLAC__uint64 abs_residual_partition_sums[], 181 unsigned raw_bits_per_partition[], 182 unsigned blocksize, 183 unsigned subframe_bps, 184 unsigned order, 185 unsigned rice_parameter, 186 unsigned rice_parameter_limit, 187 unsigned min_partition_order, 188 unsigned max_partition_order, 189 FLAC__bool do_escape_coding, 190 unsigned rice_parameter_search_dist, 191 FLAC__Subframe *subframe, 192 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents 193 ); 194 195 #ifndef FLAC__INTEGER_ONLY_LIBRARY 196 static unsigned evaluate_lpc_subframe_( 197 FLAC__StreamEncoder *encoder, 198 const FLAC__int32 signal[], 199 FLAC__int32 residual[], 200 FLAC__uint64 abs_residual_partition_sums[], 201 unsigned raw_bits_per_partition[], 202 const FLAC__real lp_coeff[], 203 unsigned blocksize, 204 unsigned subframe_bps, 205 unsigned order, 206 unsigned qlp_coeff_precision, 207 unsigned rice_parameter, 208 unsigned rice_parameter_limit, 209 unsigned min_partition_order, 210 unsigned max_partition_order, 211 FLAC__bool do_escape_coding, 212 unsigned rice_parameter_search_dist, 213 FLAC__Subframe *subframe, 214 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents 215 ); 216 #endif 217 218 static unsigned evaluate_verbatim_subframe_( 219 FLAC__StreamEncoder *encoder, 220 const FLAC__int32 signal[], 221 unsigned blocksize, 222 unsigned subframe_bps, 223 FLAC__Subframe *subframe 224 ); 225 226 static unsigned find_best_partition_order_( 227 struct FLAC__StreamEncoderPrivate *private_, 228 const FLAC__int32 residual[], 229 FLAC__uint64 abs_residual_partition_sums[], 230 unsigned raw_bits_per_partition[], 231 unsigned residual_samples, 232 unsigned predictor_order, 233 unsigned rice_parameter, 234 unsigned rice_parameter_limit, 235 unsigned min_partition_order, 236 unsigned max_partition_order, 237 unsigned bps, 238 FLAC__bool do_escape_coding, 239 unsigned rice_parameter_search_dist, 240 FLAC__EntropyCodingMethod *best_ecm 241 ); 242 243 static void precompute_partition_info_sums_( 244 const FLAC__int32 residual[], 245 FLAC__uint64 abs_residual_partition_sums[], 246 unsigned residual_samples, 247 unsigned predictor_order, 248 unsigned min_partition_order, 249 unsigned max_partition_order, 250 unsigned bps 251 ); 252 253 static void precompute_partition_info_escapes_( 254 const FLAC__int32 residual[], 255 unsigned raw_bits_per_partition[], 256 unsigned residual_samples, 257 unsigned predictor_order, 258 unsigned min_partition_order, 259 unsigned max_partition_order 260 ); 261 262 static FLAC__bool set_partitioned_rice_( 263 #ifdef EXACT_RICE_BITS_CALCULATION 264 const FLAC__int32 residual[], 265 #endif 266 const FLAC__uint64 abs_residual_partition_sums[], 267 const unsigned raw_bits_per_partition[], 268 const unsigned residual_samples, 269 const unsigned predictor_order, 270 const unsigned suggested_rice_parameter, 271 const unsigned rice_parameter_limit, 272 const unsigned rice_parameter_search_dist, 273 const unsigned partition_order, 274 const FLAC__bool search_for_escapes, 275 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, 276 unsigned *bits 277 ); 278 279 static unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples); 280 281 /* verify-related routines: */ 282 static void append_to_verify_fifo_( 283 verify_input_fifo *fifo, 284 const FLAC__int32 * const input[], 285 unsigned input_offset, 286 unsigned channels, 287 unsigned wide_samples 288 ); 289 290 static void append_to_verify_fifo_interleaved_( 291 verify_input_fifo *fifo, 292 const FLAC__int32 input[], 293 unsigned input_offset, 294 unsigned channels, 295 unsigned wide_samples 296 ); 297 298 static FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data); 299 static FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data); 300 static void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data); 301 static void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data); 302 303 static FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data); 304 static FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data); 305 static FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data); 306 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); 307 static FILE *get_binary_stdout_(void); 308 309 310 /*********************************************************************** 311 * 312 * Private class data 313 * 314 ***********************************************************************/ 315 316 typedef struct FLAC__StreamEncoderPrivate { 317 unsigned input_capacity; /* current size (in samples) of the signal and residual buffers */ 318 FLAC__int32 *integer_signal[FLAC__MAX_CHANNELS]; /* the integer version of the input signal */ 319 FLAC__int32 *integer_signal_mid_side[2]; /* the integer version of the mid-side input signal (stereo only) */ 320 #ifndef FLAC__INTEGER_ONLY_LIBRARY 321 FLAC__real *real_signal[FLAC__MAX_CHANNELS]; /* (@@@ currently unused) the floating-point version of the input signal */ 322 FLAC__real *real_signal_mid_side[2]; /* (@@@ currently unused) the floating-point version of the mid-side input signal (stereo only) */ 323 FLAC__real *window[FLAC__MAX_APODIZATION_FUNCTIONS]; /* the pre-computed floating-point window for each apodization function */ 324 FLAC__real *windowed_signal; /* the integer_signal[] * current window[] */ 325 #endif 326 unsigned subframe_bps[FLAC__MAX_CHANNELS]; /* the effective bits per sample of the input signal (stream bps - wasted bits) */ 327 unsigned subframe_bps_mid_side[2]; /* the effective bits per sample of the mid-side input signal (stream bps - wasted bits + 0/1) */ 328 FLAC__int32 *residual_workspace[FLAC__MAX_CHANNELS][2]; /* each channel has a candidate and best workspace where the subframe residual signals will be stored */ 329 FLAC__int32 *residual_workspace_mid_side[2][2]; 330 FLAC__Subframe subframe_workspace[FLAC__MAX_CHANNELS][2]; 331 FLAC__Subframe subframe_workspace_mid_side[2][2]; 332 FLAC__Subframe *subframe_workspace_ptr[FLAC__MAX_CHANNELS][2]; 333 FLAC__Subframe *subframe_workspace_ptr_mid_side[2][2]; 334 FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace[FLAC__MAX_CHANNELS][2]; 335 FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_workspace_mid_side[FLAC__MAX_CHANNELS][2]; 336 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr[FLAC__MAX_CHANNELS][2]; 337 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents_workspace_ptr_mid_side[FLAC__MAX_CHANNELS][2]; 338 unsigned best_subframe[FLAC__MAX_CHANNELS]; /* index (0 or 1) into 2nd dimension of the above workspaces */ 339 unsigned best_subframe_mid_side[2]; 340 unsigned best_subframe_bits[FLAC__MAX_CHANNELS]; /* size in bits of the best subframe for each channel */ 341 unsigned best_subframe_bits_mid_side[2]; 342 FLAC__uint64 *abs_residual_partition_sums; /* workspace where the sum of abs(candidate residual) for each partition is stored */ 343 unsigned *raw_bits_per_partition; /* workspace where the sum of silog2(candidate residual) for each partition is stored */ 344 FLAC__BitWriter *frame; /* the current frame being worked on */ 345 unsigned loose_mid_side_stereo_frames; /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */ 346 unsigned loose_mid_side_stereo_frame_count; /* number of frames using the current channel assignment */ 347 FLAC__ChannelAssignment last_channel_assignment; 348 FLAC__StreamMetadata streaminfo; /* scratchpad for STREAMINFO as it is built */ 349 FLAC__StreamMetadata_SeekTable *seek_table; /* pointer into encoder->protected_->metadata_ where the seek table is */ 350 unsigned current_sample_number; 351 unsigned current_frame_number; 352 FLAC__MD5Context md5context; 353 FLAC__CPUInfo cpuinfo; 354 void (*local_precompute_partition_info_sums)(const FLAC__int32 residual[], FLAC__uint64 abs_residual_partition_sums[], unsigned residual_samples, unsigned predictor_order, unsigned min_partition_order, unsigned max_partition_order, unsigned bps); 355 #ifndef FLAC__INTEGER_ONLY_LIBRARY 356 unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]); 357 unsigned (*local_fixed_compute_best_predictor_wide)(const FLAC__int32 data[], unsigned data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]); 358 #else 359 unsigned (*local_fixed_compute_best_predictor)(const FLAC__int32 data[], unsigned data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]); 360 unsigned (*local_fixed_compute_best_predictor_wide)(const FLAC__int32 data[], unsigned data_len, FLAC__fixedpoint residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]); 361 #endif 362 #ifndef FLAC__INTEGER_ONLY_LIBRARY 363 void (*local_lpc_compute_autocorrelation)(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[]); 364 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[]); 365 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[]); 366 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[]); 367 #endif 368 FLAC__bool disable_constant_subframes; 369 FLAC__bool disable_fixed_subframes; 370 FLAC__bool disable_verbatim_subframes; 371 FLAC__bool is_ogg; 372 FLAC__StreamEncoderReadCallback read_callback; /* currently only needed for Ogg FLAC */ 373 FLAC__StreamEncoderSeekCallback seek_callback; 374 FLAC__StreamEncoderTellCallback tell_callback; 375 FLAC__StreamEncoderWriteCallback write_callback; 376 FLAC__StreamEncoderMetadataCallback metadata_callback; 377 FLAC__StreamEncoderProgressCallback progress_callback; 378 void *client_data; 379 unsigned first_seekpoint_to_check; 380 FILE *file; /* only used when encoding to a file */ 381 FLAC__uint64 bytes_written; 382 FLAC__uint64 samples_written; 383 unsigned frames_written; 384 unsigned total_frames_estimate; 385 /* unaligned (original) pointers to allocated data */ 386 FLAC__int32 *integer_signal_unaligned[FLAC__MAX_CHANNELS]; 387 FLAC__int32 *integer_signal_mid_side_unaligned[2]; 388 #ifndef FLAC__INTEGER_ONLY_LIBRARY 389 FLAC__real *real_signal_unaligned[FLAC__MAX_CHANNELS]; /* (@@@ currently unused) */ 390 FLAC__real *real_signal_mid_side_unaligned[2]; /* (@@@ currently unused) */ 391 FLAC__real *window_unaligned[FLAC__MAX_APODIZATION_FUNCTIONS]; 392 FLAC__real *windowed_signal_unaligned; 393 #endif 394 FLAC__int32 *residual_workspace_unaligned[FLAC__MAX_CHANNELS][2]; 395 FLAC__int32 *residual_workspace_mid_side_unaligned[2][2]; 396 FLAC__uint64 *abs_residual_partition_sums_unaligned; 397 unsigned *raw_bits_per_partition_unaligned; 398 /* 399 * These fields have been moved here from private function local 400 * declarations merely to save stack space during encoding. 401 */ 402 #ifndef FLAC__INTEGER_ONLY_LIBRARY 403 FLAC__real lp_coeff[FLAC__MAX_LPC_ORDER][FLAC__MAX_LPC_ORDER]; /* from process_subframe_() */ 404 #endif 405 FLAC__EntropyCodingMethod_PartitionedRiceContents partitioned_rice_contents_extra[2]; /* from find_best_partition_order_() */ 406 /* 407 * The data for the verify section 408 */ 409 struct { 410 FLAC__StreamDecoder *decoder; 411 EncoderStateHint state_hint; 412 FLAC__bool needs_magic_hack; 413 verify_input_fifo input_fifo; 414 verify_output output; 415 struct { 416 FLAC__uint64 absolute_sample; 417 unsigned frame_number; 418 unsigned channel; 419 unsigned sample; 420 FLAC__int32 expected; 421 FLAC__int32 got; 422 } error_stats; 423 } verify; 424 FLAC__bool is_being_deleted; /* if true, call to ..._finish() from ..._delete() will not call the callbacks */ 425 } FLAC__StreamEncoderPrivate; 426 427 /*********************************************************************** 428 * 429 * Public static class data 430 * 431 ***********************************************************************/ 432 433 FLAC_API const char * const FLAC__StreamEncoderStateString[] = { 434 "FLAC__STREAM_ENCODER_OK", 435 "FLAC__STREAM_ENCODER_UNINITIALIZED", 436 "FLAC__STREAM_ENCODER_OGG_ERROR", 437 "FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR", 438 "FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA", 439 "FLAC__STREAM_ENCODER_CLIENT_ERROR", 440 "FLAC__STREAM_ENCODER_IO_ERROR", 441 "FLAC__STREAM_ENCODER_FRAMING_ERROR", 442 "FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR" 443 }; 444 445 FLAC_API const char * const FLAC__StreamEncoderInitStatusString[] = { 446 "FLAC__STREAM_ENCODER_INIT_STATUS_OK", 447 "FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR", 448 "FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER", 449 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS", 450 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS", 451 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE", 452 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE", 453 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE", 454 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER", 455 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION", 456 "FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER", 457 "FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE", 458 "FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA", 459 "FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED" 460 }; 461 462 FLAC_API const char * const FLAC__StreamEncoderReadStatusString[] = { 463 "FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE", 464 "FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM", 465 "FLAC__STREAM_ENCODER_READ_STATUS_ABORT", 466 "FLAC__STREAM_ENCODER_READ_STATUS_UNSUPPORTED" 467 }; 468 469 FLAC_API const char * const FLAC__StreamEncoderWriteStatusString[] = { 470 "FLAC__STREAM_ENCODER_WRITE_STATUS_OK", 471 "FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR" 472 }; 473 474 FLAC_API const char * const FLAC__StreamEncoderSeekStatusString[] = { 475 "FLAC__STREAM_ENCODER_SEEK_STATUS_OK", 476 "FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR", 477 "FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED" 478 }; 479 480 FLAC_API const char * const FLAC__StreamEncoderTellStatusString[] = { 481 "FLAC__STREAM_ENCODER_TELL_STATUS_OK", 482 "FLAC__STREAM_ENCODER_TELL_STATUS_ERROR", 483 "FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED" 484 }; 485 486 /* Number of samples that will be overread to watch for end of stream. By 487 * 'overread', we mean that the FLAC__stream_encoder_process*() calls will 488 * always try to read blocksize+1 samples before encoding a block, so that 489 * even if the stream has a total sample count that is an integral multiple 490 * of the blocksize, we will still notice when we are encoding the last 491 * block. This is needed, for example, to correctly set the end-of-stream 492 * marker in Ogg FLAC. 493 * 494 * WATCHOUT: some parts of the code assert that OVERREAD_ == 1 and there's 495 * not really any reason to change it. 496 */ 497 static const unsigned OVERREAD_ = 1; 498 499 /*********************************************************************** 500 * 501 * Class constructor/destructor 502 * 503 */ 504 FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new(void) 505 { 506 FLAC__StreamEncoder *encoder; 507 unsigned i; 508 509 FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ 510 511 encoder = calloc(1, sizeof(FLAC__StreamEncoder)); 512 if(encoder == 0) { 513 return 0; 514 } 515 516 encoder->protected_ = calloc(1, sizeof(FLAC__StreamEncoderProtected)); 517 if(encoder->protected_ == 0) { 518 free(encoder); 519 return 0; 520 } 521 522 encoder->private_ = calloc(1, sizeof(FLAC__StreamEncoderPrivate)); 523 if(encoder->private_ == 0) { 524 free(encoder->protected_); 525 free(encoder); 526 return 0; 527 } 528 529 encoder->private_->frame = FLAC__bitwriter_new(); 530 if(encoder->private_->frame == 0) { 531 free(encoder->private_); 532 free(encoder->protected_); 533 free(encoder); 534 return 0; 535 } 536 537 encoder->private_->file = 0; 538 539 set_defaults_(encoder); 540 541 encoder->private_->is_being_deleted = false; 542 543 for(i = 0; i < FLAC__MAX_CHANNELS; i++) { 544 encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0]; 545 encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1]; 546 } 547 for(i = 0; i < 2; i++) { 548 encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0]; 549 encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1]; 550 } 551 for(i = 0; i < FLAC__MAX_CHANNELS; i++) { 552 encoder->private_->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_contents_workspace[i][0]; 553 encoder->private_->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_contents_workspace[i][1]; 554 } 555 for(i = 0; i < 2; i++) { 556 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]; 557 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]; 558 } 559 560 for(i = 0; i < FLAC__MAX_CHANNELS; i++) { 561 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][0]); 562 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][1]); 563 } 564 for(i = 0; i < 2; i++) { 565 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]); 566 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]); 567 } 568 for(i = 0; i < 2; i++) 569 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]); 570 571 encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; 572 573 return encoder; 574 } 575 576 FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder) 577 { 578 unsigned i; 579 580 if (encoder == NULL) 581 return ; 582 583 FLAC__ASSERT(0 != encoder->protected_); 584 FLAC__ASSERT(0 != encoder->private_); 585 FLAC__ASSERT(0 != encoder->private_->frame); 586 587 encoder->private_->is_being_deleted = true; 588 589 (void)FLAC__stream_encoder_finish(encoder); 590 591 if(0 != encoder->private_->verify.decoder) 592 FLAC__stream_decoder_delete(encoder->private_->verify.decoder); 593 594 for(i = 0; i < FLAC__MAX_CHANNELS; i++) { 595 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][0]); 596 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][1]); 597 } 598 for(i = 0; i < 2; i++) { 599 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]); 600 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]); 601 } 602 for(i = 0; i < 2; i++) 603 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]); 604 605 FLAC__bitwriter_delete(encoder->private_->frame); 606 free(encoder->private_); 607 free(encoder->protected_); 608 free(encoder); 609 } 610 611 /*********************************************************************** 612 * 613 * Public class methods 614 * 615 ***********************************************************************/ 616 617 static FLAC__StreamEncoderInitStatus init_stream_internal_( 618 FLAC__StreamEncoder *encoder, 619 FLAC__StreamEncoderReadCallback read_callback, 620 FLAC__StreamEncoderWriteCallback write_callback, 621 FLAC__StreamEncoderSeekCallback seek_callback, 622 FLAC__StreamEncoderTellCallback tell_callback, 623 FLAC__StreamEncoderMetadataCallback metadata_callback, 624 void *client_data, 625 FLAC__bool is_ogg 626 ) 627 { 628 unsigned i; 629 FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment, metadata_picture_has_type1, metadata_picture_has_type2; 630 631 FLAC__ASSERT(0 != encoder); 632 633 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 634 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED; 635 636 if(FLAC__HAS_OGG == 0 && is_ogg) 637 return FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER; 638 639 if(0 == write_callback || (seek_callback && 0 == tell_callback)) 640 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS; 641 642 if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS) 643 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS; 644 645 if(encoder->protected_->channels != 2) { 646 encoder->protected_->do_mid_side_stereo = false; 647 encoder->protected_->loose_mid_side_stereo = false; 648 } 649 else if(!encoder->protected_->do_mid_side_stereo) 650 encoder->protected_->loose_mid_side_stereo = false; 651 652 if(encoder->protected_->bits_per_sample >= 32) 653 encoder->protected_->do_mid_side_stereo = false; /* since we currenty do 32-bit math, the side channel would have 33 bps and overflow */ 654 655 if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE) 656 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE; 657 658 if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate)) 659 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE; 660 661 if(encoder->protected_->blocksize == 0) { 662 if(encoder->protected_->max_lpc_order == 0) 663 encoder->protected_->blocksize = 1152; 664 else 665 encoder->protected_->blocksize = 4096; 666 } 667 668 if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE) 669 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE; 670 671 if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER) 672 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER; 673 674 if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order) 675 return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER; 676 677 if(encoder->protected_->qlp_coeff_precision == 0) { 678 if(encoder->protected_->bits_per_sample < 16) { 679 /* @@@ need some data about how to set this here w.r.t. blocksize and sample rate */ 680 /* @@@ until then we'll make a guess */ 681 encoder->protected_->qlp_coeff_precision = flac_max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2); 682 } 683 else if(encoder->protected_->bits_per_sample == 16) { 684 if(encoder->protected_->blocksize <= 192) 685 encoder->protected_->qlp_coeff_precision = 7; 686 else if(encoder->protected_->blocksize <= 384) 687 encoder->protected_->qlp_coeff_precision = 8; 688 else if(encoder->protected_->blocksize <= 576) 689 encoder->protected_->qlp_coeff_precision = 9; 690 else if(encoder->protected_->blocksize <= 1152) 691 encoder->protected_->qlp_coeff_precision = 10; 692 else if(encoder->protected_->blocksize <= 2304) 693 encoder->protected_->qlp_coeff_precision = 11; 694 else if(encoder->protected_->blocksize <= 4608) 695 encoder->protected_->qlp_coeff_precision = 12; 696 else 697 encoder->protected_->qlp_coeff_precision = 13; 698 } 699 else { 700 if(encoder->protected_->blocksize <= 384) 701 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2; 702 else if(encoder->protected_->blocksize <= 1152) 703 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1; 704 else 705 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; 706 } 707 FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION); 708 } 709 else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION) 710 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION; 711 712 if(encoder->protected_->streamable_subset) { 713 if(!FLAC__format_blocksize_is_subset(encoder->protected_->blocksize, encoder->protected_->sample_rate)) 714 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 715 if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate)) 716 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 717 if( 718 encoder->protected_->bits_per_sample != 8 && 719 encoder->protected_->bits_per_sample != 12 && 720 encoder->protected_->bits_per_sample != 16 && 721 encoder->protected_->bits_per_sample != 20 && 722 encoder->protected_->bits_per_sample != 24 723 ) 724 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 725 if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER) 726 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 727 if( 728 encoder->protected_->sample_rate <= 48000 && 729 ( 730 encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ || 731 encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ 732 ) 733 ) { 734 return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 735 } 736 } 737 738 if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) 739 encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1; 740 if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order) 741 encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order; 742 743 #if FLAC__HAS_OGG 744 /* reorder metadata if necessary to ensure that any VORBIS_COMMENT is the first, according to the mapping spec */ 745 if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) { 746 unsigned i1; 747 for(i1 = 1; i1 < encoder->protected_->num_metadata_blocks; i1++) { 748 if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { 749 FLAC__StreamMetadata *vc = encoder->protected_->metadata[i1]; 750 for( ; i1 > 0; i1--) 751 encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1-1]; 752 encoder->protected_->metadata[0] = vc; 753 break; 754 } 755 } 756 } 757 #endif 758 /* keep track of any SEEKTABLE block */ 759 if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) { 760 unsigned i2; 761 for(i2 = 0; i2 < encoder->protected_->num_metadata_blocks; i2++) { 762 if(0 != encoder->protected_->metadata[i2] && encoder->protected_->metadata[i2]->type == FLAC__METADATA_TYPE_SEEKTABLE) { 763 encoder->private_->seek_table = &encoder->protected_->metadata[i2]->data.seek_table; 764 break; /* take only the first one */ 765 } 766 } 767 } 768 769 /* validate metadata */ 770 if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) 771 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 772 metadata_has_seektable = false; 773 metadata_has_vorbis_comment = false; 774 metadata_picture_has_type1 = false; 775 metadata_picture_has_type2 = false; 776 for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { 777 const FLAC__StreamMetadata *m = encoder->protected_->metadata[i]; 778 if(m->type == FLAC__METADATA_TYPE_STREAMINFO) 779 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 780 else if(m->type == FLAC__METADATA_TYPE_SEEKTABLE) { 781 if(metadata_has_seektable) /* only one is allowed */ 782 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 783 metadata_has_seektable = true; 784 if(!FLAC__format_seektable_is_legal(&m->data.seek_table)) 785 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 786 } 787 else if(m->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { 788 if(metadata_has_vorbis_comment) /* only one is allowed */ 789 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 790 metadata_has_vorbis_comment = true; 791 } 792 else if(m->type == FLAC__METADATA_TYPE_CUESHEET) { 793 if(!FLAC__format_cuesheet_is_legal(&m->data.cue_sheet, m->data.cue_sheet.is_cd, /*violation=*/0)) 794 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 795 } 796 else if(m->type == FLAC__METADATA_TYPE_PICTURE) { 797 if(!FLAC__format_picture_is_legal(&m->data.picture, /*violation=*/0)) 798 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 799 if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD) { 800 if(metadata_picture_has_type1) /* there should only be 1 per stream */ 801 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 802 metadata_picture_has_type1 = true; 803 /* standard icon must be 32x32 pixel PNG */ 804 if( 805 m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD && 806 ( 807 (strcmp(m->data.picture.mime_type, "image/png") && strcmp(m->data.picture.mime_type, "-->")) || 808 m->data.picture.width != 32 || 809 m->data.picture.height != 32 810 ) 811 ) 812 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 813 } 814 else if(m->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON) { 815 if(metadata_picture_has_type2) /* there should only be 1 per stream */ 816 return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 817 metadata_picture_has_type2 = true; 818 } 819 } 820 } 821 822 encoder->private_->input_capacity = 0; 823 for(i = 0; i < encoder->protected_->channels; i++) { 824 encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0; 825 #ifndef FLAC__INTEGER_ONLY_LIBRARY 826 encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0; 827 #endif 828 } 829 for(i = 0; i < 2; i++) { 830 encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0; 831 #ifndef FLAC__INTEGER_ONLY_LIBRARY 832 encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0; 833 #endif 834 } 835 #ifndef FLAC__INTEGER_ONLY_LIBRARY 836 for(i = 0; i < encoder->protected_->num_apodizations; i++) 837 encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0; 838 encoder->private_->windowed_signal_unaligned = encoder->private_->windowed_signal = 0; 839 #endif 840 for(i = 0; i < encoder->protected_->channels; i++) { 841 encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0; 842 encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0; 843 encoder->private_->best_subframe[i] = 0; 844 } 845 for(i = 0; i < 2; i++) { 846 encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0; 847 encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0; 848 encoder->private_->best_subframe_mid_side[i] = 0; 849 } 850 encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0; 851 encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0; 852 #ifndef FLAC__INTEGER_ONLY_LIBRARY 853 encoder->private_->loose_mid_side_stereo_frames = (unsigned)((double)encoder->protected_->sample_rate * 0.4 / (double)encoder->protected_->blocksize + 0.5); 854 #else 855 /* 26214 is the approximate fixed-point equivalent to 0.4 (0.4 * 2^16) */ 856 /* sample rate can be up to 655350 Hz, and thus use 20 bits, so we do the multiply÷ by hand */ 857 FLAC__ASSERT(FLAC__MAX_SAMPLE_RATE <= 655350); 858 FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535); 859 FLAC__ASSERT(encoder->protected_->sample_rate <= 655350); 860 FLAC__ASSERT(encoder->protected_->blocksize <= 65535); 861 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); 862 #endif 863 if(encoder->private_->loose_mid_side_stereo_frames == 0) 864 encoder->private_->loose_mid_side_stereo_frames = 1; 865 encoder->private_->loose_mid_side_stereo_frame_count = 0; 866 encoder->private_->current_sample_number = 0; 867 encoder->private_->current_frame_number = 0; 868 869 /* 870 * get the CPU info and set the function pointers 871 */ 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; 876 #endif 877 encoder->private_->local_precompute_partition_info_sums = precompute_partition_info_sums_; 878 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor; 879 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide; 880 #ifndef FLAC__INTEGER_ONLY_LIBRARY 881 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients; 882 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide; 883 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients; 884 #endif 885 /* now override with asm where appropriate */ 886 #ifndef FLAC__INTEGER_ONLY_LIBRARY 887 # ifndef FLAC__NO_ASM 888 if(encoder->private_->cpuinfo.use_asm) { 889 # ifdef FLAC__CPU_IA32 890 FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32); 891 # ifdef FLAC__HAS_NASM 892 if(encoder->private_->cpuinfo.ia32.sse) { 893 if(encoder->protected_->max_lpc_order < 4) 894 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4_old; 895 else if(encoder->protected_->max_lpc_order < 8) 896 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8_old; 897 else if(encoder->protected_->max_lpc_order < 12) 898 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12_old; 899 else if(encoder->protected_->max_lpc_order < 16) 900 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_16_old; 901 else 902 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32; 903 } 904 else 905 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32; 906 907 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_asm_ia32; /* OPT_IA32: was really necessary for GCC < 4.9 */ 908 if(encoder->private_->cpuinfo.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_mmx; 911 } 912 else { 913 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32; 914 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32; 915 } 916 917 if(encoder->private_->cpuinfo.ia32.mmx && encoder->private_->cpuinfo.ia32.cmov) 918 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov; 919 # endif /* FLAC__HAS_NASM */ 920 # if FLAC__HAS_X86INTRIN 921 # if defined FLAC__SSE_SUPPORTED 922 if(encoder->private_->cpuinfo.ia32.sse) { 923 if(encoder->private_->cpuinfo.ia32.sse42 || !encoder->private_->cpuinfo.ia32.intel) { /* use new autocorrelation functions */ 924 if(encoder->protected_->max_lpc_order < 4) 925 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_new; 926 else if(encoder->protected_->max_lpc_order < 8) 927 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_new; 928 else if(encoder->protected_->max_lpc_order < 12) 929 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_new; 930 else if(encoder->protected_->max_lpc_order < 16) 931 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_new; 932 else 933 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 934 } 935 else { /* use old autocorrelation functions */ 936 if(encoder->protected_->max_lpc_order < 4) 937 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_old; 938 else if(encoder->protected_->max_lpc_order < 8) 939 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_old; 940 else if(encoder->protected_->max_lpc_order < 12) 941 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_old; 942 else if(encoder->protected_->max_lpc_order < 16) 943 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_old; 944 else 945 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 946 } 947 } 948 # endif 949 950 # ifdef FLAC__SSE2_SUPPORTED 951 if(encoder->private_->cpuinfo.ia32.sse2) { 952 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse2; 953 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2; 954 } 955 # endif 956 # ifdef FLAC__SSE4_1_SUPPORTED 957 if(encoder->private_->cpuinfo.ia32.sse41) { 958 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41; 959 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_sse41; 960 } 961 # endif 962 # ifdef FLAC__AVX2_SUPPORTED 963 if(encoder->private_->cpuinfo.ia32.avx2) { 964 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2; 965 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2; 966 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2; 967 } 968 # endif 969 970 # ifdef FLAC__SSE2_SUPPORTED 971 if (encoder->private_->cpuinfo.ia32.sse2) { 972 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2; 973 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_sse2; 974 } 975 # endif 976 # ifdef FLAC__SSSE3_SUPPORTED 977 if (encoder->private_->cpuinfo.ia32.ssse3) { 978 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3; 979 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_ssse3; 980 } 981 # endif 982 # endif /* FLAC__HAS_X86INTRIN */ 983 # elif defined FLAC__CPU_X86_64 984 FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64); 985 # if FLAC__HAS_X86INTRIN 986 # ifdef FLAC__SSE_SUPPORTED 987 if(encoder->private_->cpuinfo.x86.sse42 || !encoder->private_->cpuinfo.x86.intel) { /* use new autocorrelation functions */ 988 if(encoder->protected_->max_lpc_order < 4) 989 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_new; 990 else if(encoder->protected_->max_lpc_order < 8) 991 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_new; 992 else if(encoder->protected_->max_lpc_order < 12) 993 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_new; 994 else if(encoder->protected_->max_lpc_order < 16) 995 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_new; 996 } 997 else { 998 if(encoder->protected_->max_lpc_order < 4) 999 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_old; 1000 else if(encoder->protected_->max_lpc_order < 8) 1001 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_old; 1002 else if(encoder->protected_->max_lpc_order < 12) 1003 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_old; 1004 else if(encoder->protected_->max_lpc_order < 16) 1005 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_old; 1006 } 1007 # endif 1008 1009 # ifdef FLAC__SSE2_SUPPORTED 1010 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2; 1011 # endif 1012 # ifdef FLAC__SSE4_1_SUPPORTED 1013 if(encoder->private_->cpuinfo.x86.sse41) { 1014 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41; 1015 } 1016 # endif 1017 # ifdef FLAC__AVX2_SUPPORTED 1018 if(encoder->private_->cpuinfo.x86.avx2) { 1019 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2; 1020 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2; 1021 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2; 1022 } 1023 # endif 1024 1025 # ifdef FLAC__SSE2_SUPPORTED 1026 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2; 1027 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_sse2; 1028 # endif 1029 # ifdef FLAC__SSSE3_SUPPORTED 1030 if (encoder->private_->cpuinfo.x86.ssse3) { 1031 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3; 1032 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_ssse3; 1033 } 1034 # endif 1035 # endif /* FLAC__HAS_X86INTRIN */ 1036 # endif /* FLAC__CPU_... */ 1037 } 1038 # endif /* !FLAC__NO_ASM */ 1039 #endif /* !FLAC__INTEGER_ONLY_LIBRARY */ 1040 #if !defined FLAC__NO_ASM && FLAC__HAS_X86INTRIN 1041 if(encoder->private_->cpuinfo.use_asm) { 1042 # if defined FLAC__CPU_IA32 1043 # ifdef FLAC__SSE2_SUPPORTED 1044 if(encoder->private_->cpuinfo.ia32.sse2) 1045 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2; 1046 # endif 1047 # ifdef FLAC__SSSE3_SUPPORTED 1048 if(encoder->private_->cpuinfo.ia32.ssse3) 1049 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3; 1050 # endif 1051 # ifdef FLAC__AVX2_SUPPORTED 1052 if(encoder->private_->cpuinfo.ia32.avx2) 1053 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2; 1054 # endif 1055 # elif defined FLAC__CPU_X86_64 1056 # ifdef FLAC__SSE2_SUPPORTED 1057 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2; 1058 # endif 1059 # ifdef FLAC__SSSE3_SUPPORTED 1060 if(encoder->private_->cpuinfo.x86.ssse3) 1061 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3; 1062 # endif 1063 # ifdef FLAC__AVX2_SUPPORTED 1064 if(encoder->private_->cpuinfo.x86.avx2) 1065 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2; 1066 # endif 1067 # endif /* FLAC__CPU_... */ 1068 } 1069 #endif /* !FLAC__NO_ASM && FLAC__HAS_X86INTRIN */ 1070 1071 /* set state to OK; from here on, errors are fatal and we'll override the state then */ 1072 encoder->protected_->state = FLAC__STREAM_ENCODER_OK; 1073 1074 #if FLAC__HAS_OGG 1075 encoder->private_->is_ogg = is_ogg; 1076 if(is_ogg && !FLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect)) { 1077 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 1078 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1079 } 1080 #endif 1081 1082 encoder->private_->read_callback = read_callback; 1083 encoder->private_->write_callback = write_callback; 1084 encoder->private_->seek_callback = seek_callback; 1085 encoder->private_->tell_callback = tell_callback; 1086 encoder->private_->metadata_callback = metadata_callback; 1087 encoder->private_->client_data = client_data; 1088 1089 if(!resize_buffers_(encoder, encoder->protected_->blocksize)) { 1090 /* the above function sets the state for us in case of an error */ 1091 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1092 } 1093 1094 if(!FLAC__bitwriter_init(encoder->private_->frame)) { 1095 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1096 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1097 } 1098 1099 /* 1100 * Set up the verify stuff if necessary 1101 */ 1102 if(encoder->protected_->verify) { 1103 /* 1104 * First, set up the fifo which will hold the 1105 * original signal to compare against 1106 */ 1107 encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize+OVERREAD_; 1108 for(i = 0; i < encoder->protected_->channels; i++) { 1109 if(0 == (encoder->private_->verify.input_fifo.data[i] = safe_malloc_mul_2op_p(sizeof(FLAC__int32), /*times*/encoder->private_->verify.input_fifo.size))) { 1110 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1111 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1112 } 1113 } 1114 encoder->private_->verify.input_fifo.tail = 0; 1115 1116 /* 1117 * Now set up a stream decoder for verification 1118 */ 1119 if(0 == encoder->private_->verify.decoder) { 1120 encoder->private_->verify.decoder = FLAC__stream_decoder_new(); 1121 if(0 == encoder->private_->verify.decoder) { 1122 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 1123 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1124 } 1125 } 1126 1127 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) { 1128 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 1129 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1130 } 1131 } 1132 encoder->private_->verify.error_stats.absolute_sample = 0; 1133 encoder->private_->verify.error_stats.frame_number = 0; 1134 encoder->private_->verify.error_stats.channel = 0; 1135 encoder->private_->verify.error_stats.sample = 0; 1136 encoder->private_->verify.error_stats.expected = 0; 1137 encoder->private_->verify.error_stats.got = 0; 1138 1139 /* 1140 * These must be done before we write any metadata, because that 1141 * calls the write_callback, which uses these values. 1142 */ 1143 encoder->private_->first_seekpoint_to_check = 0; 1144 encoder->private_->samples_written = 0; 1145 encoder->protected_->streaminfo_offset = 0; 1146 encoder->protected_->seektable_offset = 0; 1147 encoder->protected_->audio_offset = 0; 1148 1149 /* 1150 * write the stream header 1151 */ 1152 if(encoder->protected_->verify) 1153 encoder->private_->verify.state_hint = ENCODER_IN_MAGIC; 1154 if(!FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) { 1155 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1156 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1157 } 1158 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) { 1159 /* the above function sets the state for us in case of an error */ 1160 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1161 } 1162 1163 /* 1164 * write the STREAMINFO metadata block 1165 */ 1166 if(encoder->protected_->verify) 1167 encoder->private_->verify.state_hint = ENCODER_IN_METADATA; 1168 encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO; 1169 encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */ 1170 encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; 1171 encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */ 1172 encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize; 1173 encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */ 1174 encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */ 1175 encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate; 1176 encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels; 1177 encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample; 1178 encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */ 1179 memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */ 1180 if(encoder->protected_->do_md5) 1181 FLAC__MD5Init(&encoder->private_->md5context); 1182 if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->frame)) { 1183 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1184 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1185 } 1186 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) { 1187 /* the above function sets the state for us in case of an error */ 1188 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1189 } 1190 1191 /* 1192 * Now that the STREAMINFO block is written, we can init this to an 1193 * absurdly-high value... 1194 */ 1195 encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1; 1196 /* ... and clear this to 0 */ 1197 encoder->private_->streaminfo.data.stream_info.total_samples = 0; 1198 1199 /* 1200 * Check to see if the supplied metadata contains a VORBIS_COMMENT; 1201 * if not, we will write an empty one (FLAC__add_metadata_block() 1202 * automatically supplies the vendor string). 1203 * 1204 * WATCHOUT: the Ogg FLAC mapping requires us to write this block after 1205 * the STREAMINFO. (In the case that metadata_has_vorbis_comment is 1206 * true it will have already insured that the metadata list is properly 1207 * ordered.) 1208 */ 1209 if(!metadata_has_vorbis_comment) { 1210 FLAC__StreamMetadata vorbis_comment; 1211 vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT; 1212 vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0); 1213 vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */ 1214 vorbis_comment.data.vorbis_comment.vendor_string.length = 0; 1215 vorbis_comment.data.vorbis_comment.vendor_string.entry = 0; 1216 vorbis_comment.data.vorbis_comment.num_comments = 0; 1217 vorbis_comment.data.vorbis_comment.comments = 0; 1218 if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame)) { 1219 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1220 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1221 } 1222 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) { 1223 /* the above function sets the state for us in case of an error */ 1224 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1225 } 1226 } 1227 1228 /* 1229 * write the user's metadata blocks 1230 */ 1231 for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { 1232 encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1); 1233 if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame)) { 1234 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1235 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1236 } 1237 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) { 1238 /* the above function sets the state for us in case of an error */ 1239 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1240 } 1241 } 1242 1243 /* now that all the metadata is written, we save the stream offset */ 1244 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 */ 1245 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 1246 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1247 } 1248 1249 if(encoder->protected_->verify) 1250 encoder->private_->verify.state_hint = ENCODER_IN_AUDIO; 1251 1252 return FLAC__STREAM_ENCODER_INIT_STATUS_OK; 1253 } 1254 1255 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream( 1256 FLAC__StreamEncoder *encoder, 1257 FLAC__StreamEncoderWriteCallback write_callback, 1258 FLAC__StreamEncoderSeekCallback seek_callback, 1259 FLAC__StreamEncoderTellCallback tell_callback, 1260 FLAC__StreamEncoderMetadataCallback metadata_callback, 1261 void *client_data 1262 ) 1263 { 1264 return init_stream_internal_( 1265 encoder, 1266 /*read_callback=*/0, 1267 write_callback, 1268 seek_callback, 1269 tell_callback, 1270 metadata_callback, 1271 client_data, 1272 /*is_ogg=*/false 1273 ); 1274 } 1275 1276 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_stream( 1277 FLAC__StreamEncoder *encoder, 1278 FLAC__StreamEncoderReadCallback read_callback, 1279 FLAC__StreamEncoderWriteCallback write_callback, 1280 FLAC__StreamEncoderSeekCallback seek_callback, 1281 FLAC__StreamEncoderTellCallback tell_callback, 1282 FLAC__StreamEncoderMetadataCallback metadata_callback, 1283 void *client_data 1284 ) 1285 { 1286 return init_stream_internal_( 1287 encoder, 1288 read_callback, 1289 write_callback, 1290 seek_callback, 1291 tell_callback, 1292 metadata_callback, 1293 client_data, 1294 /*is_ogg=*/true 1295 ); 1296 } 1297 1298 static FLAC__StreamEncoderInitStatus init_FILE_internal_( 1299 FLAC__StreamEncoder *encoder, 1300 FILE *file, 1301 FLAC__StreamEncoderProgressCallback progress_callback, 1302 void *client_data, 1303 FLAC__bool is_ogg 1304 ) 1305 { 1306 FLAC__StreamEncoderInitStatus init_status; 1307 1308 FLAC__ASSERT(0 != encoder); 1309 FLAC__ASSERT(0 != file); 1310 1311 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1312 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED; 1313 1314 /* double protection */ 1315 if(file == 0) { 1316 encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR; 1317 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1318 } 1319 1320 /* 1321 * To make sure that our file does not go unclosed after an error, we 1322 * must assign the FILE pointer before any further error can occur in 1323 * this routine. 1324 */ 1325 if(file == stdout) 1326 file = get_binary_stdout_(); /* just to be safe */ 1327 1328 #ifdef _WIN32 1329 /* 1330 * Windows can suffer quite badly from disk fragmentation. This can be 1331 * reduced significantly by setting the output buffer size to be 10MB. 1332 */ 1333 if(GetFileType((HANDLE)_get_osfhandle(_fileno(file))) == FILE_TYPE_DISK) 1334 setvbuf(file, NULL, _IOFBF, 10*1024*1024); 1335 #endif 1336 encoder->private_->file = file; 1337 1338 encoder->private_->progress_callback = progress_callback; 1339 encoder->private_->bytes_written = 0; 1340 encoder->private_->samples_written = 0; 1341 encoder->private_->frames_written = 0; 1342 1343 init_status = init_stream_internal_( 1344 encoder, 1345 encoder->private_->file == stdout? 0 : is_ogg? file_read_callback_ : 0, 1346 file_write_callback_, 1347 encoder->private_->file == stdout? 0 : file_seek_callback_, 1348 encoder->private_->file == stdout? 0 : file_tell_callback_, 1349 /*metadata_callback=*/0, 1350 client_data, 1351 is_ogg 1352 ); 1353 if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { 1354 /* the above function sets the state for us in case of an error */ 1355 return init_status; 1356 } 1357 1358 { 1359 unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder); 1360 1361 FLAC__ASSERT(blocksize != 0); 1362 encoder->private_->total_frames_estimate = (unsigned)((FLAC__stream_encoder_get_total_samples_estimate(encoder) + blocksize - 1) / blocksize); 1363 } 1364 1365 return init_status; 1366 } 1367 1368 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_FILE( 1369 FLAC__StreamEncoder *encoder, 1370 FILE *file, 1371 FLAC__StreamEncoderProgressCallback progress_callback, 1372 void *client_data 1373 ) 1374 { 1375 return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/false); 1376 } 1377 1378 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE( 1379 FLAC__StreamEncoder *encoder, 1380 FILE *file, 1381 FLAC__StreamEncoderProgressCallback progress_callback, 1382 void *client_data 1383 ) 1384 { 1385 return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/true); 1386 } 1387 1388 static FLAC__StreamEncoderInitStatus init_file_internal_( 1389 FLAC__StreamEncoder *encoder, 1390 const char *filename, 1391 FLAC__StreamEncoderProgressCallback progress_callback, 1392 void *client_data, 1393 FLAC__bool is_ogg 1394 ) 1395 { 1396 FILE *file; 1397 1398 FLAC__ASSERT(0 != encoder); 1399 1400 /* 1401 * To make sure that our file does not go unclosed after an error, we 1402 * have to do the same entrance checks here that are later performed 1403 * in FLAC__stream_encoder_init_FILE() before the FILE* is assigned. 1404 */ 1405 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1406 return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED; 1407 1408 file = filename? flac_fopen(filename, "w+b") : stdout; 1409 1410 if(file == 0) { 1411 encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR; 1412 return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1413 } 1414 1415 return init_FILE_internal_(encoder, file, progress_callback, client_data, is_ogg); 1416 } 1417 1418 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file( 1419 FLAC__StreamEncoder *encoder, 1420 const char *filename, 1421 FLAC__StreamEncoderProgressCallback progress_callback, 1422 void *client_data 1423 ) 1424 { 1425 return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/false); 1426 } 1427 1428 FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_file( 1429 FLAC__StreamEncoder *encoder, 1430 const char *filename, 1431 FLAC__StreamEncoderProgressCallback progress_callback, 1432 void *client_data 1433 ) 1434 { 1435 return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/true); 1436 } 1437 1438 FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder) 1439 { 1440 FLAC__bool error = false; 1441 1442 FLAC__ASSERT(0 != encoder); 1443 FLAC__ASSERT(0 != encoder->private_); 1444 FLAC__ASSERT(0 != encoder->protected_); 1445 1446 if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED) 1447 return true; 1448 1449 if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) { 1450 if(encoder->private_->current_sample_number != 0) { 1451 const FLAC__bool is_fractional_block = encoder->protected_->blocksize != encoder->private_->current_sample_number; 1452 encoder->protected_->blocksize = encoder->private_->current_sample_number; 1453 if(!process_frame_(encoder, is_fractional_block, /*is_last_block=*/true)) 1454 error = true; 1455 } 1456 } 1457 1458 if(encoder->protected_->do_md5) 1459 FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context); 1460 1461 if(!encoder->private_->is_being_deleted) { 1462 if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) { 1463 if(encoder->private_->seek_callback) { 1464 #if FLAC__HAS_OGG 1465 if(encoder->private_->is_ogg) 1466 update_ogg_metadata_(encoder); 1467 else 1468 #endif 1469 update_metadata_(encoder); 1470 1471 /* check if an error occurred while updating metadata */ 1472 if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK) 1473 error = true; 1474 } 1475 if(encoder->private_->metadata_callback) 1476 encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data); 1477 } 1478 1479 if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) { 1480 if(!error) 1481 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA; 1482 error = true; 1483 } 1484 } 1485 1486 if(0 != encoder->private_->file) { 1487 if(encoder->private_->file != stdout) 1488 fclose(encoder->private_->file); 1489 encoder->private_->file = 0; 1490 } 1491 1492 #if FLAC__HAS_OGG 1493 if(encoder->private_->is_ogg) 1494 FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect); 1495 #endif 1496 1497 free_(encoder); 1498 set_defaults_(encoder); 1499 1500 if(!error) 1501 encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; 1502 1503 return !error; 1504 } 1505 1506 FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long value) 1507 { 1508 FLAC__ASSERT(0 != encoder); 1509 FLAC__ASSERT(0 != encoder->private_); 1510 FLAC__ASSERT(0 != encoder->protected_); 1511 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1512 return false; 1513 #if FLAC__HAS_OGG 1514 /* can't check encoder->private_->is_ogg since that's not set until init time */ 1515 FLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value); 1516 return true; 1517 #else 1518 (void)value; 1519 return false; 1520 #endif 1521 } 1522 1523 FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value) 1524 { 1525 FLAC__ASSERT(0 != encoder); 1526 FLAC__ASSERT(0 != encoder->private_); 1527 FLAC__ASSERT(0 != encoder->protected_); 1528 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1529 return false; 1530 #ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING 1531 encoder->protected_->verify = value; 1532 #endif 1533 return true; 1534 } 1535 1536 FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value) 1537 { 1538 FLAC__ASSERT(0 != encoder); 1539 FLAC__ASSERT(0 != encoder->private_); 1540 FLAC__ASSERT(0 != encoder->protected_); 1541 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1542 return false; 1543 encoder->protected_->streamable_subset = value; 1544 return true; 1545 } 1546 1547 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value) 1548 { 1549 FLAC__ASSERT(0 != encoder); 1550 FLAC__ASSERT(0 != encoder->private_); 1551 FLAC__ASSERT(0 != encoder->protected_); 1552 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1553 return false; 1554 encoder->protected_->do_md5 = value; 1555 return true; 1556 } 1557 1558 FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value) 1559 { 1560 FLAC__ASSERT(0 != encoder); 1561 FLAC__ASSERT(0 != encoder->private_); 1562 FLAC__ASSERT(0 != encoder->protected_); 1563 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1564 return false; 1565 encoder->protected_->channels = value; 1566 return true; 1567 } 1568 1569 FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value) 1570 { 1571 FLAC__ASSERT(0 != encoder); 1572 FLAC__ASSERT(0 != encoder->private_); 1573 FLAC__ASSERT(0 != encoder->protected_); 1574 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1575 return false; 1576 encoder->protected_->bits_per_sample = value; 1577 return true; 1578 } 1579 1580 FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value) 1581 { 1582 FLAC__ASSERT(0 != encoder); 1583 FLAC__ASSERT(0 != encoder->private_); 1584 FLAC__ASSERT(0 != encoder->protected_); 1585 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1586 return false; 1587 encoder->protected_->sample_rate = value; 1588 return true; 1589 } 1590 1591 FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value) 1592 { 1593 FLAC__bool ok = true; 1594 FLAC__ASSERT(0 != encoder); 1595 FLAC__ASSERT(0 != encoder->private_); 1596 FLAC__ASSERT(0 != encoder->protected_); 1597 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1598 return false; 1599 if(value >= sizeof(compression_levels_)/sizeof(compression_levels_[0])) 1600 value = sizeof(compression_levels_)/sizeof(compression_levels_[0]) - 1; 1601 ok &= FLAC__stream_encoder_set_do_mid_side_stereo (encoder, compression_levels_[value].do_mid_side_stereo); 1602 ok &= FLAC__stream_encoder_set_loose_mid_side_stereo (encoder, compression_levels_[value].loose_mid_side_stereo); 1603 #ifndef FLAC__INTEGER_ONLY_LIBRARY 1604 #if 1 1605 ok &= FLAC__stream_encoder_set_apodization (encoder, compression_levels_[value].apodization); 1606 #else 1607 /* equivalent to -A tukey(0.5) */ 1608 encoder->protected_->num_apodizations = 1; 1609 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 1610 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 1611 #endif 1612 #endif 1613 ok &= FLAC__stream_encoder_set_max_lpc_order (encoder, compression_levels_[value].max_lpc_order); 1614 ok &= FLAC__stream_encoder_set_qlp_coeff_precision (encoder, compression_levels_[value].qlp_coeff_precision); 1615 ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search (encoder, compression_levels_[value].do_qlp_coeff_prec_search); 1616 ok &= FLAC__stream_encoder_set_do_escape_coding (encoder, compression_levels_[value].do_escape_coding); 1617 ok &= FLAC__stream_encoder_set_do_exhaustive_model_search (encoder, compression_levels_[value].do_exhaustive_model_search); 1618 ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order); 1619 ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order); 1620 ok &= FLAC__stream_encoder_set_rice_parameter_search_dist (encoder, compression_levels_[value].rice_parameter_search_dist); 1621 return ok; 1622 } 1623 1624 FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value) 1625 { 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) 1630 return false; 1631 encoder->protected_->blocksize = value; 1632 return true; 1633 } 1634 1635 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value) 1636 { 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) 1641 return false; 1642 encoder->protected_->do_mid_side_stereo = value; 1643 return true; 1644 } 1645 1646 FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value) 1647 { 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) 1652 return false; 1653 encoder->protected_->loose_mid_side_stereo = value; 1654 return true; 1655 } 1656 1657 /*@@@@add to tests*/ 1658 FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *encoder, const char *specification) 1659 { 1660 FLAC__ASSERT(0 != encoder); 1661 FLAC__ASSERT(0 != encoder->private_); 1662 FLAC__ASSERT(0 != encoder->protected_); 1663 FLAC__ASSERT(0 != specification); 1664 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1665 return false; 1666 #ifdef FLAC__INTEGER_ONLY_LIBRARY 1667 (void)specification; /* silently ignore since we haven't integerized; will always use a rectangular window */ 1668 #else 1669 encoder->protected_->num_apodizations = 0; 1670 while(1) { 1671 const char *s = strchr(specification, ';'); 1672 const size_t n = s? (size_t)(s - specification) : strlen(specification); 1673 if (n==8 && 0 == strncmp("bartlett" , specification, n)) 1674 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT; 1675 else if(n==13 && 0 == strncmp("bartlett_hann", specification, n)) 1676 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN; 1677 else if(n==8 && 0 == strncmp("blackman" , specification, n)) 1678 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN; 1679 else if(n==26 && 0 == strncmp("blackman_harris_4term_92db", specification, n)) 1680 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE; 1681 else if(n==6 && 0 == strncmp("connes" , specification, n)) 1682 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES; 1683 else if(n==7 && 0 == strncmp("flattop" , specification, n)) 1684 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP; 1685 else if(n>7 && 0 == strncmp("gauss(" , specification, 6)) { 1686 FLAC__real stddev = (FLAC__real)strtod(specification+6, 0); 1687 if (stddev > 0.0 && stddev <= 0.5) { 1688 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev; 1689 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS; 1690 } 1691 } 1692 else if(n==7 && 0 == strncmp("hamming" , specification, n)) 1693 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING; 1694 else if(n==4 && 0 == strncmp("hann" , specification, n)) 1695 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN; 1696 else if(n==13 && 0 == strncmp("kaiser_bessel", specification, n)) 1697 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL; 1698 else if(n==7 && 0 == strncmp("nuttall" , specification, n)) 1699 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL; 1700 else if(n==9 && 0 == strncmp("rectangle" , specification, n)) 1701 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE; 1702 else if(n==8 && 0 == strncmp("triangle" , specification, n)) 1703 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE; 1704 else if(n>7 && 0 == strncmp("tukey(" , specification, 6)) { 1705 FLAC__real p = (FLAC__real)strtod(specification+6, 0); 1706 if (p >= 0.0 && p <= 1.0) { 1707 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p; 1708 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 1709 } 1710 } 1711 else if(n>15 && 0 == strncmp("partial_tukey(" , specification, 14)) { 1712 FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+14, 0); 1713 const char *si_1 = strchr(specification, '/'); 1714 FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.1f; 1715 FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f; 1716 const char *si_2 = strchr((si_1?(si_1+1):specification), '/'); 1717 FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f; 1718 1719 if (tukey_parts <= 1) { 1720 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p; 1721 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 1722 }else if (encoder->protected_->num_apodizations + tukey_parts < 32){ 1723 FLAC__int32 m; 1724 for(m = 0; m < tukey_parts; m++){ 1725 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p; 1726 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units); 1727 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units); 1728 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PARTIAL_TUKEY; 1729 } 1730 } 1731 } 1732 else if(n>16 && 0 == strncmp("punchout_tukey(" , specification, 15)) { 1733 FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+15, 0); 1734 const char *si_1 = strchr(specification, '/'); 1735 FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.2f; 1736 FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f; 1737 const char *si_2 = strchr((si_1?(si_1+1):specification), '/'); 1738 FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f; 1739 1740 if (tukey_parts <= 1) { 1741 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p; 1742 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 1743 }else if (encoder->protected_->num_apodizations + tukey_parts < 32){ 1744 FLAC__int32 m; 1745 for(m = 0; m < tukey_parts; m++){ 1746 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p; 1747 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units); 1748 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units); 1749 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PUNCHOUT_TUKEY; 1750 } 1751 } 1752 } 1753 else if(n==5 && 0 == strncmp("welch" , specification, n)) 1754 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH; 1755 if (encoder->protected_->num_apodizations == 32) 1756 break; 1757 if (s) 1758 specification = s+1; 1759 else 1760 break; 1761 } 1762 if(encoder->protected_->num_apodizations == 0) { 1763 encoder->protected_->num_apodizations = 1; 1764 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 1765 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 1766 } 1767 #endif 1768 return true; 1769 } 1770 1771 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value) 1772 { 1773 FLAC__ASSERT(0 != encoder); 1774 FLAC__ASSERT(0 != encoder->private_); 1775 FLAC__ASSERT(0 != encoder->protected_); 1776 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1777 return false; 1778 encoder->protected_->max_lpc_order = value; 1779 return true; 1780 } 1781 1782 FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value) 1783 { 1784 FLAC__ASSERT(0 != encoder); 1785 FLAC__ASSERT(0 != encoder->private_); 1786 FLAC__ASSERT(0 != encoder->protected_); 1787 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1788 return false; 1789 encoder->protected_->qlp_coeff_precision = value; 1790 return true; 1791 } 1792 1793 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value) 1794 { 1795 FLAC__ASSERT(0 != encoder); 1796 FLAC__ASSERT(0 != encoder->private_); 1797 FLAC__ASSERT(0 != encoder->protected_); 1798 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1799 return false; 1800 encoder->protected_->do_qlp_coeff_prec_search = value; 1801 return true; 1802 } 1803 1804 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value) 1805 { 1806 FLAC__ASSERT(0 != encoder); 1807 FLAC__ASSERT(0 != encoder->private_); 1808 FLAC__ASSERT(0 != encoder->protected_); 1809 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1810 return false; 1811 #if 0 1812 /*@@@ deprecated: */ 1813 encoder->protected_->do_escape_coding = value; 1814 #else 1815 (void)value; 1816 #endif 1817 return true; 1818 } 1819 1820 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value) 1821 { 1822 FLAC__ASSERT(0 != encoder); 1823 FLAC__ASSERT(0 != encoder->private_); 1824 FLAC__ASSERT(0 != encoder->protected_); 1825 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1826 return false; 1827 encoder->protected_->do_exhaustive_model_search = value; 1828 return true; 1829 } 1830 1831 FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value) 1832 { 1833 FLAC__ASSERT(0 != encoder); 1834 FLAC__ASSERT(0 != encoder->private_); 1835 FLAC__ASSERT(0 != encoder->protected_); 1836 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1837 return false; 1838 encoder->protected_->min_residual_partition_order = value; 1839 return true; 1840 } 1841 1842 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value) 1843 { 1844 FLAC__ASSERT(0 != encoder); 1845 FLAC__ASSERT(0 != encoder->private_); 1846 FLAC__ASSERT(0 != encoder->protected_); 1847 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1848 return false; 1849 encoder->protected_->max_residual_partition_order = value; 1850 return true; 1851 } 1852 1853 FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value) 1854 { 1855 FLAC__ASSERT(0 != encoder); 1856 FLAC__ASSERT(0 != encoder->private_); 1857 FLAC__ASSERT(0 != encoder->protected_); 1858 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1859 return false; 1860 #if 0 1861 /*@@@ deprecated: */ 1862 encoder->protected_->rice_parameter_search_dist = value; 1863 #else 1864 (void)value; 1865 #endif 1866 return true; 1867 } 1868 1869 FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value) 1870 { 1871 FLAC__ASSERT(0 != encoder); 1872 FLAC__ASSERT(0 != encoder->private_); 1873 FLAC__ASSERT(0 != encoder->protected_); 1874 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1875 return false; 1876 value = flac_min(value, (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN) - 1); 1877 encoder->protected_->total_samples_estimate = value; 1878 return true; 1879 } 1880 1881 FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks) 1882 { 1883 FLAC__ASSERT(0 != encoder); 1884 FLAC__ASSERT(0 != encoder->private_); 1885 FLAC__ASSERT(0 != encoder->protected_); 1886 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1887 return false; 1888 if(0 == metadata) 1889 num_blocks = 0; 1890 if(0 == num_blocks) 1891 metadata = 0; 1892 /* realloc() does not do exactly what we want so... */ 1893 if(encoder->protected_->metadata) { 1894 free(encoder->protected_->metadata); 1895 encoder->protected_->metadata = 0; 1896 encoder->protected_->num_metadata_blocks = 0; 1897 } 1898 if(num_blocks) { 1899 FLAC__StreamMetadata **m; 1900 if(0 == (m = safe_malloc_mul_2op_p(sizeof(m[0]), /*times*/num_blocks))) 1901 return false; 1902 memcpy(m, metadata, sizeof(m[0]) * num_blocks); 1903 encoder->protected_->metadata = m; 1904 encoder->protected_->num_metadata_blocks = num_blocks; 1905 } 1906 #if FLAC__HAS_OGG 1907 if(!FLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks)) 1908 return false; 1909 #endif 1910 return true; 1911 } 1912 1913 /* 1914 * These three functions are not static, but not publically exposed in 1915 * include/FLAC/ either. They are used by the test suite. 1916 */ 1917 FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value) 1918 { 1919 FLAC__ASSERT(0 != encoder); 1920 FLAC__ASSERT(0 != encoder->private_); 1921 FLAC__ASSERT(0 != encoder->protected_); 1922 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1923 return false; 1924 encoder->private_->disable_constant_subframes = value; 1925 return true; 1926 } 1927 1928 FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value) 1929 { 1930 FLAC__ASSERT(0 != encoder); 1931 FLAC__ASSERT(0 != encoder->private_); 1932 FLAC__ASSERT(0 != encoder->protected_); 1933 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1934 return false; 1935 encoder->private_->disable_fixed_subframes = value; 1936 return true; 1937 } 1938 1939 FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value) 1940 { 1941 FLAC__ASSERT(0 != encoder); 1942 FLAC__ASSERT(0 != encoder->private_); 1943 FLAC__ASSERT(0 != encoder->protected_); 1944 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) 1945 return false; 1946 encoder->private_->disable_verbatim_subframes = value; 1947 return true; 1948 } 1949 1950 FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder) 1951 { 1952 FLAC__ASSERT(0 != encoder); 1953 FLAC__ASSERT(0 != encoder->private_); 1954 FLAC__ASSERT(0 != encoder->protected_); 1955 return encoder->protected_->state; 1956 } 1957 1958 FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder) 1959 { 1960 FLAC__ASSERT(0 != encoder); 1961 FLAC__ASSERT(0 != encoder->private_); 1962 FLAC__ASSERT(0 != encoder->protected_); 1963 if(encoder->protected_->verify) 1964 return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder); 1965 else 1966 return FLAC__STREAM_DECODER_UNINITIALIZED; 1967 } 1968 1969 FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder) 1970 { 1971 FLAC__ASSERT(0 != encoder); 1972 FLAC__ASSERT(0 != encoder->private_); 1973 FLAC__ASSERT(0 != encoder->protected_); 1974 if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) 1975 return FLAC__StreamEncoderStateString[encoder->protected_->state]; 1976 else 1977 return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder); 1978 } 1979 1980 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) 1981 { 1982 FLAC__ASSERT(0 != encoder); 1983 FLAC__ASSERT(0 != encoder->private_); 1984 FLAC__ASSERT(0 != encoder->protected_); 1985 if(0 != absolute_sample) 1986 *absolute_sample = encoder->private_->verify.error_stats.absolute_sample; 1987 if(0 != frame_number) 1988 *frame_number = encoder->private_->verify.error_stats.frame_number; 1989 if(0 != channel) 1990 *channel = encoder->private_->verify.error_stats.channel; 1991 if(0 != sample) 1992 *sample = encoder->private_->verify.error_stats.sample; 1993 if(0 != expected) 1994 *expected = encoder->private_->verify.error_stats.expected; 1995 if(0 != got) 1996 *got = encoder->private_->verify.error_stats.got; 1997 } 1998 1999 FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder) 2000 { 2001 FLAC__ASSERT(0 != encoder); 2002 FLAC__ASSERT(0 != encoder->private_); 2003 FLAC__ASSERT(0 != encoder->protected_); 2004 return encoder->protected_->verify; 2005 } 2006 2007 FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder) 2008 { 2009 FLAC__ASSERT(0 != encoder); 2010 FLAC__ASSERT(0 != encoder->private_); 2011 FLAC__ASSERT(0 != encoder->protected_); 2012 return encoder->protected_->streamable_subset; 2013 } 2014 2015 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder *encoder) 2016 { 2017 FLAC__ASSERT(0 != encoder); 2018 FLAC__ASSERT(0 != encoder->private_); 2019 FLAC__ASSERT(0 != encoder->protected_); 2020 return encoder->protected_->do_md5; 2021 } 2022 2023 FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder) 2024 { 2025 FLAC__ASSERT(0 != encoder); 2026 FLAC__ASSERT(0 != encoder->private_); 2027 FLAC__ASSERT(0 != encoder->protected_); 2028 return encoder->protected_->channels; 2029 } 2030 2031 FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder) 2032 { 2033 FLAC__ASSERT(0 != encoder); 2034 FLAC__ASSERT(0 != encoder->private_); 2035 FLAC__ASSERT(0 != encoder->protected_); 2036 return encoder->protected_->bits_per_sample; 2037 } 2038 2039 FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder) 2040 { 2041 FLAC__ASSERT(0 != encoder); 2042 FLAC__ASSERT(0 != encoder->private_); 2043 FLAC__ASSERT(0 != encoder->protected_); 2044 return encoder->protected_->sample_rate; 2045 } 2046 2047 FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder) 2048 { 2049 FLAC__ASSERT(0 != encoder); 2050 FLAC__ASSERT(0 != encoder->private_); 2051 FLAC__ASSERT(0 != encoder->protected_); 2052 return encoder->protected_->blocksize; 2053 } 2054 2055 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder) 2056 { 2057 FLAC__ASSERT(0 != encoder); 2058 FLAC__ASSERT(0 != encoder->private_); 2059 FLAC__ASSERT(0 != encoder->protected_); 2060 return encoder->protected_->do_mid_side_stereo; 2061 } 2062 2063 FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder) 2064 { 2065 FLAC__ASSERT(0 != encoder); 2066 FLAC__ASSERT(0 != encoder->private_); 2067 FLAC__ASSERT(0 != encoder->protected_); 2068 return encoder->protected_->loose_mid_side_stereo; 2069 } 2070 2071 FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder) 2072 { 2073 FLAC__ASSERT(0 != encoder); 2074 FLAC__ASSERT(0 != encoder->private_); 2075 FLAC__ASSERT(0 != encoder->protected_); 2076 return encoder->protected_->max_lpc_order; 2077 } 2078 2079 FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder) 2080 { 2081 FLAC__ASSERT(0 != encoder); 2082 FLAC__ASSERT(0 != encoder->private_); 2083 FLAC__ASSERT(0 != encoder->protected_); 2084 return encoder->protected_->qlp_coeff_precision; 2085 } 2086 2087 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder) 2088 { 2089 FLAC__ASSERT(0 != encoder); 2090 FLAC__ASSERT(0 != encoder->private_); 2091 FLAC__ASSERT(0 != encoder->protected_); 2092 return encoder->protected_->do_qlp_coeff_prec_search; 2093 } 2094 2095 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder) 2096 { 2097 FLAC__ASSERT(0 != encoder); 2098 FLAC__ASSERT(0 != encoder->private_); 2099 FLAC__ASSERT(0 != encoder->protected_); 2100 return encoder->protected_->do_escape_coding; 2101 } 2102 2103 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder) 2104 { 2105 FLAC__ASSERT(0 != encoder); 2106 FLAC__ASSERT(0 != encoder->private_); 2107 FLAC__ASSERT(0 != encoder->protected_); 2108 return encoder->protected_->do_exhaustive_model_search; 2109 } 2110 2111 FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder) 2112 { 2113 FLAC__ASSERT(0 != encoder); 2114 FLAC__ASSERT(0 != encoder->private_); 2115 FLAC__ASSERT(0 != encoder->protected_); 2116 return encoder->protected_->min_residual_partition_order; 2117 } 2118 2119 FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder) 2120 { 2121 FLAC__ASSERT(0 != encoder); 2122 FLAC__ASSERT(0 != encoder->private_); 2123 FLAC__ASSERT(0 != encoder->protected_); 2124 return encoder->protected_->max_residual_partition_order; 2125 } 2126 2127 FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder) 2128 { 2129 FLAC__ASSERT(0 != encoder); 2130 FLAC__ASSERT(0 != encoder->private_); 2131 FLAC__ASSERT(0 != encoder->protected_); 2132 return encoder->protected_->rice_parameter_search_dist; 2133 } 2134 2135 FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder) 2136 { 2137 FLAC__ASSERT(0 != encoder); 2138 FLAC__ASSERT(0 != encoder->private_); 2139 FLAC__ASSERT(0 != encoder->protected_); 2140 return encoder->protected_->total_samples_estimate; 2141 } 2142 2143 FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples) 2144 { 2145 unsigned i, j = 0, channel; 2146 const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize; 2147 2148 FLAC__ASSERT(0 != encoder); 2149 FLAC__ASSERT(0 != encoder->private_); 2150 FLAC__ASSERT(0 != encoder->protected_); 2151 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); 2152 2153 do { 2154 const unsigned n = flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j); 2155 2156 if(encoder->protected_->verify) 2157 append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, n); 2158 2159 for(channel = 0; channel < channels; channel++) { 2160 if (buffer[channel] == NULL) { 2161 return false; 2162 } 2163 memcpy(&encoder->private_->integer_signal[channel][encoder->private_->current_sample_number], &buffer[channel][j], sizeof(buffer[channel][0]) * n); 2164 } 2165 2166 if(encoder->protected_->do_mid_side_stereo) { 2167 FLAC__ASSERT(channels == 2); 2168 /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */ 2169 for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) { 2170 encoder->private_->integer_signal_mid_side[1][i] = buffer[0][j] - buffer[1][j]; 2171 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' ! */ 2172 } 2173 } 2174 else 2175 j += n; 2176 2177 encoder->private_->current_sample_number += n; 2178 2179 /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */ 2180 if(encoder->private_->current_sample_number > blocksize) { 2181 FLAC__ASSERT(encoder->private_->current_sample_number == blocksize+OVERREAD_); 2182 FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */ 2183 if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false)) 2184 return false; 2185 /* move unprocessed overread samples to beginnings of arrays */ 2186 for(channel = 0; channel < channels; channel++) 2187 encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize]; 2188 if(encoder->protected_->do_mid_side_stereo) { 2189 encoder->private_->integer_signal_mid_side[0][0] = encoder->private_->integer_signal_mid_side[0][blocksize]; 2190 encoder->private_->integer_signal_mid_side[1][0] = encoder->private_->integer_signal_mid_side[1][blocksize]; 2191 } 2192 encoder->private_->current_sample_number = 1; 2193 } 2194 } while(j < samples); 2195 2196 return true; 2197 } 2198 2199 FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples) 2200 { 2201 unsigned i, j, k, channel; 2202 FLAC__int32 x, mid, side; 2203 const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize; 2204 2205 FLAC__ASSERT(0 != encoder); 2206 FLAC__ASSERT(0 != encoder->private_); 2207 FLAC__ASSERT(0 != encoder->protected_); 2208 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); 2209 2210 j = k = 0; 2211 /* 2212 * we have several flavors of the same basic loop, optimized for 2213 * different conditions: 2214 */ 2215 if(encoder->protected_->do_mid_side_stereo && channels == 2) { 2216 /* 2217 * stereo coding: unroll channel loop 2218 */ 2219 do { 2220 if(encoder->protected_->verify) 2221 append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j)); 2222 2223 /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */ 2224 for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) { 2225 encoder->private_->integer_signal[0][i] = mid = side = buffer[k++]; 2226 x = buffer[k++]; 2227 encoder->private_->integer_signal[1][i] = x; 2228 mid += x; 2229 side -= x; 2230 mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */ 2231 encoder->private_->integer_signal_mid_side[1][i] = side; 2232 encoder->private_->integer_signal_mid_side[0][i] = mid; 2233 } 2234 encoder->private_->current_sample_number = i; 2235 /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */ 2236 if(i > blocksize) { 2237 if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false)) 2238 return false; 2239 /* move unprocessed overread samples to beginnings of arrays */ 2240 FLAC__ASSERT(i == blocksize+OVERREAD_); 2241 FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */ 2242 encoder->private_->integer_signal[0][0] = encoder->private_->integer_signal[0][blocksize]; 2243 encoder->private_->integer_signal[1][0] = encoder->private_->integer_signal[1][blocksize]; 2244 encoder->private_->integer_signal_mid_side[0][0] = encoder->private_->integer_signal_mid_side[0][blocksize]; 2245 encoder->private_->integer_signal_mid_side[1][0] = encoder->private_->integer_signal_mid_side[1][blocksize]; 2246 encoder->private_->current_sample_number = 1; 2247 } 2248 } while(j < samples); 2249 } 2250 else { 2251 /* 2252 * independent channel coding: buffer each channel in inner loop 2253 */ 2254 do { 2255 if(encoder->protected_->verify) 2256 append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j)); 2257 2258 /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */ 2259 for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) { 2260 for(channel = 0; channel < channels; channel++) 2261 encoder->private_->integer_signal[channel][i] = buffer[k++]; 2262 } 2263 encoder->private_->current_sample_number = i; 2264 /* we only process if we have a full block + 1 extra sample; final block is always handled by FLAC__stream_encoder_finish() */ 2265 if(i > blocksize) { 2266 if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false)) 2267 return false; 2268 /* move unprocessed overread samples to beginnings of arrays */ 2269 FLAC__ASSERT(i == blocksize+OVERREAD_); 2270 FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */ 2271 for(channel = 0; channel < channels; channel++) 2272 encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize]; 2273 encoder->private_->current_sample_number = 1; 2274 } 2275 } while(j < samples); 2276 } 2277 2278 return true; 2279 } 2280 2281 /*********************************************************************** 2282 * 2283 * Private class methods 2284 * 2285 ***********************************************************************/ 2286 2287 void set_defaults_(FLAC__StreamEncoder *encoder) 2288 { 2289 FLAC__ASSERT(0 != encoder); 2290 2291 #ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING 2292 encoder->protected_->verify = true; 2293 #else 2294 encoder->protected_->verify = false; 2295 #endif 2296 encoder->protected_->streamable_subset = true; 2297 encoder->protected_->do_md5 = true; 2298 encoder->protected_->do_mid_side_stereo = false; 2299 encoder->protected_->loose_mid_side_stereo = false; 2300 encoder->protected_->channels = 2; 2301 encoder->protected_->bits_per_sample = 16; 2302 encoder->protected_->sample_rate = 44100; 2303 encoder->protected_->blocksize = 0; 2304 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2305 encoder->protected_->num_apodizations = 1; 2306 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 2307 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 2308 #endif 2309 encoder->protected_->max_lpc_order = 0; 2310 encoder->protected_->qlp_coeff_precision = 0; 2311 encoder->protected_->do_qlp_coeff_prec_search = false; 2312 encoder->protected_->do_exhaustive_model_search = false; 2313 encoder->protected_->do_escape_coding = false; 2314 encoder->protected_->min_residual_partition_order = 0; 2315 encoder->protected_->max_residual_partition_order = 0; 2316 encoder->protected_->rice_parameter_search_dist = 0; 2317 encoder->protected_->total_samples_estimate = 0; 2318 encoder->protected_->metadata = 0; 2319 encoder->protected_->num_metadata_blocks = 0; 2320 2321 encoder->private_->seek_table = 0; 2322 encoder->private_->disable_constant_subframes = false; 2323 encoder->private_->disable_fixed_subframes = false; 2324 encoder->private_->disable_verbatim_subframes = false; 2325 encoder->private_->is_ogg = false; 2326 encoder->private_->read_callback = 0; 2327 encoder->private_->write_callback = 0; 2328 encoder->private_->seek_callback = 0; 2329 encoder->private_->tell_callback = 0; 2330 encoder->private_->metadata_callback = 0; 2331 encoder->private_->progress_callback = 0; 2332 encoder->private_->client_data = 0; 2333 2334 #if FLAC__HAS_OGG 2335 FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect); 2336 #endif 2337 2338 FLAC__stream_encoder_set_compression_level(encoder, 5); 2339 } 2340 2341 void free_(FLAC__StreamEncoder *encoder) 2342 { 2343 unsigned i, channel; 2344 2345 FLAC__ASSERT(0 != encoder); 2346 if(encoder->protected_->metadata) { 2347 free(encoder->protected_->metadata); 2348 encoder->protected_->metadata = 0; 2349 encoder->protected_->num_metadata_blocks = 0; 2350 } 2351 for(i = 0; i < encoder->protected_->channels; i++) { 2352 if(0 != encoder->private_->integer_signal_unaligned[i]) { 2353 free(encoder->private_->integer_signal_unaligned[i]); 2354 encoder->private_->integer_signal_unaligned[i] = 0; 2355 } 2356 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2357 if(0 != encoder->private_->real_signal_unaligned[i]) { 2358 free(encoder->private_->real_signal_unaligned[i]); 2359 encoder->private_->real_signal_unaligned[i] = 0; 2360 } 2361 #endif 2362 } 2363 for(i = 0; i < 2; i++) { 2364 if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) { 2365 free(encoder->private_->integer_signal_mid_side_unaligned[i]); 2366 encoder->private_->integer_signal_mid_side_unaligned[i] = 0; 2367 } 2368 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2369 if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) { 2370 free(encoder->private_->real_signal_mid_side_unaligned[i]); 2371 encoder->private_->real_signal_mid_side_unaligned[i] = 0; 2372 } 2373 #endif 2374 } 2375 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2376 for(i = 0; i < encoder->protected_->num_apodizations; i++) { 2377 if(0 != encoder->private_->window_unaligned[i]) { 2378 free(encoder->private_->window_unaligned[i]); 2379 encoder->private_->window_unaligned[i] = 0; 2380 } 2381 } 2382 if(0 != encoder->private_->windowed_signal_unaligned) { 2383 free(encoder->private_->windowed_signal_unaligned); 2384 encoder->private_->windowed_signal_unaligned = 0; 2385 } 2386 #endif 2387 for(channel = 0; channel < encoder->protected_->channels; channel++) { 2388 for(i = 0; i < 2; i++) { 2389 if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) { 2390 free(encoder->private_->residual_workspace_unaligned[channel][i]); 2391 encoder->private_->residual_workspace_unaligned[channel][i] = 0; 2392 } 2393 } 2394 } 2395 for(channel = 0; channel < 2; channel++) { 2396 for(i = 0; i < 2; i++) { 2397 if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) { 2398 free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]); 2399 encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0; 2400 } 2401 } 2402 } 2403 if(0 != encoder->private_->abs_residual_partition_sums_unaligned) { 2404 free(encoder->private_->abs_residual_partition_sums_unaligned); 2405 encoder->private_->abs_residual_partition_sums_unaligned = 0; 2406 } 2407 if(0 != encoder->private_->raw_bits_per_partition_unaligned) { 2408 free(encoder->private_->raw_bits_per_partition_unaligned); 2409 encoder->private_->raw_bits_per_partition_unaligned = 0; 2410 } 2411 if(encoder->protected_->verify) { 2412 for(i = 0; i < encoder->protected_->channels; i++) { 2413 if(0 != encoder->private_->verify.input_fifo.data[i]) { 2414 free(encoder->private_->verify.input_fifo.data[i]); 2415 encoder->private_->verify.input_fifo.data[i] = 0; 2416 } 2417 } 2418 } 2419 FLAC__bitwriter_free(encoder->private_->frame); 2420 } 2421 2422 FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize) 2423 { 2424 FLAC__bool ok; 2425 unsigned i, channel; 2426 2427 FLAC__ASSERT(new_blocksize > 0); 2428 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); 2429 FLAC__ASSERT(encoder->private_->current_sample_number == 0); 2430 2431 /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */ 2432 if(new_blocksize <= encoder->private_->input_capacity) 2433 return true; 2434 2435 ok = true; 2436 2437 /* WATCHOUT: FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx() and ..._intrin_sse2() 2438 * require that the input arrays (in our case the integer signals) 2439 * have a buffer of up to 3 zeroes in front (at negative indices) for 2440 * alignment purposes; we use 4 in front to keep the data well-aligned. 2441 */ 2442 2443 for(i = 0; ok && i < encoder->protected_->channels; i++) { 2444 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]); 2445 memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4); 2446 encoder->private_->integer_signal[i] += 4; 2447 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2448 #if 0 /* @@@ currently unused */ 2449 if(encoder->protected_->max_lpc_order > 0) 2450 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize+OVERREAD_, &encoder->private_->real_signal_unaligned[i], &encoder->private_->real_signal[i]); 2451 #endif 2452 #endif 2453 } 2454 for(i = 0; ok && i < 2; i++) { 2455 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]); 2456 memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4); 2457 encoder->private_->integer_signal_mid_side[i] += 4; 2458 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2459 #if 0 /* @@@ currently unused */ 2460 if(encoder->protected_->max_lpc_order > 0) 2461 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]); 2462 #endif 2463 #endif 2464 } 2465 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2466 if(ok && encoder->protected_->max_lpc_order > 0) { 2467 for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) 2468 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]); 2469 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->windowed_signal_unaligned, &encoder->private_->windowed_signal); 2470 } 2471 #endif 2472 for(channel = 0; ok && channel < encoder->protected_->channels; channel++) { 2473 for(i = 0; ok && i < 2; i++) { 2474 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]); 2475 } 2476 } 2477 for(channel = 0; ok && channel < 2; channel++) { 2478 for(i = 0; ok && i < 2; i++) { 2479 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]); 2480 } 2481 } 2482 /* the *2 is an approximation to the series 1 + 1/2 + 1/4 + ... that sums tree occupies in a flat array */ 2483 /*@@@ 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) */ 2484 ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_blocksize * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums); 2485 if(encoder->protected_->do_escape_coding) 2486 ok = ok && FLAC__memory_alloc_aligned_unsigned_array(new_blocksize * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition); 2487 2488 /* now adjust the windows if the blocksize has changed */ 2489 #ifndef FLAC__INTEGER_ONLY_LIBRARY 2490 if(ok && new_blocksize != encoder->private_->input_capacity && encoder->protected_->max_lpc_order > 0) { 2491 for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) { 2492 switch(encoder->protected_->apodizations[i].type) { 2493 case FLAC__APODIZATION_BARTLETT: 2494 FLAC__window_bartlett(encoder->private_->window[i], new_blocksize); 2495 break; 2496 case FLAC__APODIZATION_BARTLETT_HANN: 2497 FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize); 2498 break; 2499 case FLAC__APODIZATION_BLACKMAN: 2500 FLAC__window_blackman(encoder->private_->window[i], new_blocksize); 2501 break; 2502 case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE: 2503 FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize); 2504 break; 2505 case FLAC__APODIZATION_CONNES: 2506 FLAC__window_connes(encoder->private_->window[i], new_blocksize); 2507 break; 2508 case FLAC__APODIZATION_FLATTOP: 2509 FLAC__window_flattop(encoder->private_->window[i], new_blocksize); 2510 break; 2511 case FLAC__APODIZATION_GAUSS: 2512 FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev); 2513 break; 2514 case FLAC__APODIZATION_HAMMING: 2515 FLAC__window_hamming(encoder->private_->window[i], new_blocksize); 2516 break; 2517 case FLAC__APODIZATION_HANN: 2518 FLAC__window_hann(encoder->private_->window[i], new_blocksize); 2519 break; 2520 case FLAC__APODIZATION_KAISER_BESSEL: 2521 FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize); 2522 break; 2523 case FLAC__APODIZATION_NUTTALL: 2524 FLAC__window_nuttall(encoder->private_->window[i], new_blocksize); 2525 break; 2526 case FLAC__APODIZATION_RECTANGLE: 2527 FLAC__window_rectangle(encoder->private_->window[i], new_blocksize); 2528 break; 2529 case FLAC__APODIZATION_TRIANGLE: 2530 FLAC__window_triangle(encoder->private_->window[i], new_blocksize); 2531 break; 2532 case FLAC__APODIZATION_TUKEY: 2533 FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p); 2534 break; 2535 case FLAC__APODIZATION_PARTIAL_TUKEY: 2536 FLAC__window_partial_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end); 2537 break; 2538 case FLAC__APODIZATION_PUNCHOUT_TUKEY: 2539 FLAC__window_punchout_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end); 2540 break; 2541 case FLAC__APODIZATION_WELCH: 2542 FLAC__window_welch(encoder->private_->window[i], new_blocksize); 2543 break; 2544 default: 2545 FLAC__ASSERT(0); 2546 /* double protection */ 2547 FLAC__window_hann(encoder->private_->window[i], new_blocksize); 2548 break; 2549 } 2550 } 2551 } 2552 #endif 2553 2554 if(ok) 2555 encoder->private_->input_capacity = new_blocksize; 2556 else 2557 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 2558 2559 return ok; 2560 } 2561 2562 FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block) 2563 { 2564 const FLAC__byte *buffer; 2565 size_t bytes; 2566 2567 FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame)); 2568 2569 if(!FLAC__bitwriter_get_buffer(encoder->private_->frame, &buffer, &bytes)) { 2570 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 2571 return false; 2572 } 2573 2574 if(encoder->protected_->verify) { 2575 encoder->private_->verify.output.data = buffer; 2576 encoder->private_->verify.output.bytes = bytes; 2577 if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) { 2578 encoder->private_->verify.needs_magic_hack = true; 2579 } 2580 else { 2581 if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) { 2582 FLAC__bitwriter_release_buffer(encoder->private_->frame); 2583 FLAC__bitwriter_clear(encoder->private_->frame); 2584 if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) 2585 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 2586 return false; 2587 } 2588 } 2589 } 2590 2591 if(write_frame_(encoder, buffer, bytes, samples, is_last_block) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { 2592 FLAC__bitwriter_release_buffer(encoder->private_->frame); 2593 FLAC__bitwriter_clear(encoder->private_->frame); 2594 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2595 return false; 2596 } 2597 2598 FLAC__bitwriter_release_buffer(encoder->private_->frame); 2599 FLAC__bitwriter_clear(encoder->private_->frame); 2600 2601 if(samples > 0) { 2602 encoder->private_->streaminfo.data.stream_info.min_framesize = flac_min(bytes, encoder->private_->streaminfo.data.stream_info.min_framesize); 2603 encoder->private_->streaminfo.data.stream_info.max_framesize = flac_max(bytes, encoder->private_->streaminfo.data.stream_info.max_framesize); 2604 } 2605 2606 return true; 2607 } 2608 2609 FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block) 2610 { 2611 FLAC__StreamEncoderWriteStatus status; 2612 FLAC__uint64 output_position = 0; 2613 2614 #if FLAC__HAS_OGG == 0 2615 (void)is_last_block; 2616 #endif 2617 2618 /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */ 2619 if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { 2620 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2621 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 2622 } 2623 2624 /* 2625 * Watch for the STREAMINFO block and first SEEKTABLE block to go by and store their offsets. 2626 */ 2627 if(samples == 0) { 2628 FLAC__MetadataType type = (buffer[0] & 0x7f); 2629 if(type == FLAC__METADATA_TYPE_STREAMINFO) 2630 encoder->protected_->streaminfo_offset = output_position; 2631 else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0) 2632 encoder->protected_->seektable_offset = output_position; 2633 } 2634 2635 /* 2636 * Mark the current seek point if hit (if audio_offset == 0 that 2637 * means we're still writing metadata and haven't hit the first 2638 * frame yet) 2639 */ 2640 if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) { 2641 const unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder); 2642 const FLAC__uint64 frame_first_sample = encoder->private_->samples_written; 2643 const FLAC__uint64 frame_last_sample = frame_first_sample + (FLAC__uint64)blocksize - 1; 2644 FLAC__uint64 test_sample; 2645 unsigned i; 2646 for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) { 2647 test_sample = encoder->private_->seek_table->points[i].sample_number; 2648 if(test_sample > frame_last_sample) { 2649 break; 2650 } 2651 else if(test_sample >= frame_first_sample) { 2652 encoder->private_->seek_table->points[i].sample_number = frame_first_sample; 2653 encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset; 2654 encoder->private_->seek_table->points[i].frame_samples = blocksize; 2655 encoder->private_->first_seekpoint_to_check++; 2656 /* DO NOT: "break;" and here's why: 2657 * The seektable template may contain more than one target 2658 * sample for any given frame; we will keep looping, generating 2659 * duplicate seekpoints for them, and we'll clean it up later, 2660 * just before writing the seektable back to the metadata. 2661 */ 2662 } 2663 else { 2664 encoder->private_->first_seekpoint_to_check++; 2665 } 2666 } 2667 } 2668 2669 #if FLAC__HAS_OGG 2670 if(encoder->private_->is_ogg) { 2671 status = FLAC__ogg_encoder_aspect_write_callback_wrapper( 2672 &encoder->protected_->ogg_encoder_aspect, 2673 buffer, 2674 bytes, 2675 samples, 2676 encoder->private_->current_frame_number, 2677 is_last_block, 2678 (FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback, 2679 encoder, 2680 encoder->private_->client_data 2681 ); 2682 } 2683 else 2684 #endif 2685 status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data); 2686 2687 if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { 2688 encoder->private_->bytes_written += bytes; 2689 encoder->private_->samples_written += samples; 2690 /* we keep a high watermark on the number of frames written because 2691 * when the encoder goes back to write metadata, 'current_frame' 2692 * will drop back to 0. 2693 */ 2694 encoder->private_->frames_written = flac_max(encoder->private_->frames_written, encoder->private_->current_frame_number+1); 2695 } 2696 else 2697 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2698 2699 return status; 2700 } 2701 2702 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks. */ 2703 void update_metadata_(const FLAC__StreamEncoder *encoder) 2704 { 2705 FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)]; 2706 const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo; 2707 const FLAC__uint64 samples = metadata->data.stream_info.total_samples; 2708 const unsigned min_framesize = metadata->data.stream_info.min_framesize; 2709 const unsigned max_framesize = metadata->data.stream_info.max_framesize; 2710 const unsigned bps = metadata->data.stream_info.bits_per_sample; 2711 FLAC__StreamEncoderSeekStatus seek_status; 2712 2713 FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); 2714 2715 /* All this is based on intimate knowledge of the stream header 2716 * layout, but a change to the header format that would break this 2717 * would also break all streams encoded in the previous format. 2718 */ 2719 2720 /* 2721 * Write MD5 signature 2722 */ 2723 { 2724 const unsigned md5_offset = 2725 FLAC__STREAM_METADATA_HEADER_LENGTH + 2726 ( 2727 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 2728 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 2729 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 2730 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 2731 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 2732 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 2733 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN + 2734 FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN 2735 ) / 8; 2736 2737 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) { 2738 if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) 2739 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2740 return; 2741 } 2742 if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { 2743 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2744 return; 2745 } 2746 } 2747 2748 /* 2749 * Write total samples 2750 */ 2751 { 2752 const unsigned total_samples_byte_offset = 2753 FLAC__STREAM_METADATA_HEADER_LENGTH + 2754 ( 2755 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 2756 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 2757 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 2758 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 2759 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 2760 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 2761 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN 2762 - 4 2763 ) / 8; 2764 2765 b[0] = ((FLAC__byte)(bps-1) << 4) | (FLAC__byte)((samples >> 32) & 0x0F); 2766 b[1] = (FLAC__byte)((samples >> 24) & 0xFF); 2767 b[2] = (FLAC__byte)((samples >> 16) & 0xFF); 2768 b[3] = (FLAC__byte)((samples >> 8) & 0xFF); 2769 b[4] = (FLAC__byte)(samples & 0xFF); 2770 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) { 2771 if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) 2772 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2773 return; 2774 } 2775 if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { 2776 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2777 return; 2778 } 2779 } 2780 2781 /* 2782 * Write min/max framesize 2783 */ 2784 { 2785 const unsigned min_framesize_offset = 2786 FLAC__STREAM_METADATA_HEADER_LENGTH + 2787 ( 2788 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 2789 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN 2790 ) / 8; 2791 2792 b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF); 2793 b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF); 2794 b[2] = (FLAC__byte)(min_framesize & 0xFF); 2795 b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF); 2796 b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF); 2797 b[5] = (FLAC__byte)(max_framesize & 0xFF); 2798 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) { 2799 if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) 2800 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2801 return; 2802 } 2803 if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { 2804 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2805 return; 2806 } 2807 } 2808 2809 /* 2810 * Write seektable 2811 */ 2812 if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) { 2813 unsigned i; 2814 2815 FLAC__format_seektable_sort(encoder->private_->seek_table); 2816 2817 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table)); 2818 2819 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) { 2820 if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) 2821 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2822 return; 2823 } 2824 2825 for(i = 0; i < encoder->private_->seek_table->num_points; i++) { 2826 FLAC__uint64 xx; 2827 unsigned x; 2828 xx = encoder->private_->seek_table->points[i].sample_number; 2829 b[7] = (FLAC__byte)xx; xx >>= 8; 2830 b[6] = (FLAC__byte)xx; xx >>= 8; 2831 b[5] = (FLAC__byte)xx; xx >>= 8; 2832 b[4] = (FLAC__byte)xx; xx >>= 8; 2833 b[3] = (FLAC__byte)xx; xx >>= 8; 2834 b[2] = (FLAC__byte)xx; xx >>= 8; 2835 b[1] = (FLAC__byte)xx; xx >>= 8; 2836 b[0] = (FLAC__byte)xx; xx >>= 8; 2837 xx = encoder->private_->seek_table->points[i].stream_offset; 2838 b[15] = (FLAC__byte)xx; xx >>= 8; 2839 b[14] = (FLAC__byte)xx; xx >>= 8; 2840 b[13] = (FLAC__byte)xx; xx >>= 8; 2841 b[12] = (FLAC__byte)xx; xx >>= 8; 2842 b[11] = (FLAC__byte)xx; xx >>= 8; 2843 b[10] = (FLAC__byte)xx; xx >>= 8; 2844 b[9] = (FLAC__byte)xx; xx >>= 8; 2845 b[8] = (FLAC__byte)xx; xx >>= 8; 2846 x = encoder->private_->seek_table->points[i].frame_samples; 2847 b[17] = (FLAC__byte)x; x >>= 8; 2848 b[16] = (FLAC__byte)x; x >>= 8; 2849 if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { 2850 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2851 return; 2852 } 2853 } 2854 } 2855 } 2856 2857 #if FLAC__HAS_OGG 2858 /* Gets called when the encoding process has finished so that we can update the STREAMINFO and SEEKTABLE blocks. */ 2859 void update_ogg_metadata_(FLAC__StreamEncoder *encoder) 2860 { 2861 /* the # of bytes in the 1st packet that precede the STREAMINFO */ 2862 static const unsigned FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH = 2863 FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH + 2864 FLAC__OGG_MAPPING_MAGIC_LENGTH + 2865 FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH + 2866 FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH + 2867 FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH + 2868 FLAC__STREAM_SYNC_LENGTH 2869 ; 2870 FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)]; 2871 const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo; 2872 const FLAC__uint64 samples = metadata->data.stream_info.total_samples; 2873 const unsigned min_framesize = metadata->data.stream_info.min_framesize; 2874 const unsigned max_framesize = metadata->data.stream_info.max_framesize; 2875 ogg_page page; 2876 2877 FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); 2878 FLAC__ASSERT(0 != encoder->private_->seek_callback); 2879 2880 /* Pre-check that client supports seeking, since we don't want the 2881 * ogg_helper code to ever have to deal with this condition. 2882 */ 2883 if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED) 2884 return; 2885 2886 /* All this is based on intimate knowledge of the stream header 2887 * layout, but a change to the header format that would break this 2888 * would also break all streams encoded in the previous format. 2889 */ 2890 2891 /** 2892 ** Write STREAMINFO stats 2893 **/ 2894 simple_ogg_page__init(&page); 2895 if(!simple_ogg_page__get_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) { 2896 simple_ogg_page__clear(&page); 2897 return; /* state already set */ 2898 } 2899 2900 /* 2901 * Write MD5 signature 2902 */ 2903 { 2904 const unsigned md5_offset = 2905 FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH + 2906 FLAC__STREAM_METADATA_HEADER_LENGTH + 2907 ( 2908 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 2909 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 2910 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 2911 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 2912 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 2913 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 2914 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN + 2915 FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN 2916 ) / 8; 2917 2918 if(md5_offset + 16 > (unsigned)page.body_len) { 2919 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 2920 simple_ogg_page__clear(&page); 2921 return; 2922 } 2923 memcpy(page.body + md5_offset, metadata->data.stream_info.md5sum, 16); 2924 } 2925 2926 /* 2927 * Write total samples 2928 */ 2929 { 2930 const unsigned total_samples_byte_offset = 2931 FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH + 2932 FLAC__STREAM_METADATA_HEADER_LENGTH + 2933 ( 2934 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 2935 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 2936 FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 2937 FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 2938 FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 2939 FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 2940 FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN 2941 - 4 2942 ) / 8; 2943 2944 if(total_samples_byte_offset + 5 > (unsigned)page.body_len) { 2945 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 2946 simple_ogg_page__clear(&page); 2947 return; 2948 } 2949 b[0] = (FLAC__byte)page.body[total_samples_byte_offset] & 0xF0; 2950 b[0] |= (FLAC__byte)((samples >> 32) & 0x0F); 2951 b[1] = (FLAC__byte)((samples >> 24) & 0xFF); 2952 b[2] = (FLAC__byte)((samples >> 16) & 0xFF); 2953 b[3] = (FLAC__byte)((samples >> 8) & 0xFF); 2954 b[4] = (FLAC__byte)(samples & 0xFF); 2955 memcpy(page.body + total_samples_byte_offset, b, 5); 2956 } 2957 2958 /* 2959 * Write min/max framesize 2960 */ 2961 { 2962 const unsigned min_framesize_offset = 2963 FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH + 2964 FLAC__STREAM_METADATA_HEADER_LENGTH + 2965 ( 2966 FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 2967 FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN 2968 ) / 8; 2969 2970 if(min_framesize_offset + 6 > (unsigned)page.body_len) { 2971 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 2972 simple_ogg_page__clear(&page); 2973 return; 2974 } 2975 b[0] = (FLAC__byte)((min_framesize >> 16) & 0xFF); 2976 b[1] = (FLAC__byte)((min_framesize >> 8) & 0xFF); 2977 b[2] = (FLAC__byte)(min_framesize & 0xFF); 2978 b[3] = (FLAC__byte)((max_framesize >> 16) & 0xFF); 2979 b[4] = (FLAC__byte)((max_framesize >> 8) & 0xFF); 2980 b[5] = (FLAC__byte)(max_framesize & 0xFF); 2981 memcpy(page.body + min_framesize_offset, b, 6); 2982 } 2983 if(!simple_ogg_page__set_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) { 2984 simple_ogg_page__clear(&page); 2985 return; /* state already set */ 2986 } 2987 simple_ogg_page__clear(&page); 2988 2989 /* 2990 * Write seektable 2991 */ 2992 if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) { 2993 unsigned i; 2994 FLAC__byte *p; 2995 2996 FLAC__format_seektable_sort(encoder->private_->seek_table); 2997 2998 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table)); 2999 3000 simple_ogg_page__init(&page); 3001 if(!simple_ogg_page__get_at(encoder, encoder->protected_->seektable_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) { 3002 simple_ogg_page__clear(&page); 3003 return; /* state already set */ 3004 } 3005 3006 if((FLAC__STREAM_METADATA_HEADER_LENGTH + 18*encoder->private_->seek_table->num_points) != (unsigned)page.body_len) { 3007 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 3008 simple_ogg_page__clear(&page); 3009 return; 3010 } 3011 3012 for(i = 0, p = page.body + FLAC__STREAM_METADATA_HEADER_LENGTH; i < encoder->private_->seek_table->num_points; i++, p += 18) { 3013 FLAC__uint64 xx; 3014 unsigned x; 3015 xx = encoder->private_->seek_table->points[i].sample_number; 3016 b[7] = (FLAC__byte)xx; xx >>= 8; 3017 b[6] = (FLAC__byte)xx; xx >>= 8; 3018 b[5] = (FLAC__byte)xx; xx >>= 8; 3019 b[4] = (FLAC__byte)xx; xx >>= 8; 3020 b[3] = (FLAC__byte)xx; xx >>= 8; 3021 b[2] = (FLAC__byte)xx; xx >>= 8; 3022 b[1] = (FLAC__byte)xx; xx >>= 8; 3023 b[0] = (FLAC__byte)xx; xx >>= 8; 3024 xx = encoder->private_->seek_table->points[i].stream_offset; 3025 b[15] = (FLAC__byte)xx; xx >>= 8; 3026 b[14] = (FLAC__byte)xx; xx >>= 8; 3027 b[13] = (FLAC__byte)xx; xx >>= 8; 3028 b[12] = (FLAC__byte)xx; xx >>= 8; 3029 b[11] = (FLAC__byte)xx; xx >>= 8; 3030 b[10] = (FLAC__byte)xx; xx >>= 8; 3031 b[9] = (FLAC__byte)xx; xx >>= 8; 3032 b[8] = (FLAC__byte)xx; xx >>= 8; 3033 x = encoder->private_->seek_table->points[i].frame_samples; 3034 b[17] = (FLAC__byte)x; x >>= 8; 3035 b[16] = (FLAC__byte)x; x >>= 8; 3036 memcpy(p, b, 18); 3037 } 3038 3039 if(!simple_ogg_page__set_at(encoder, encoder->protected_->seektable_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) { 3040 simple_ogg_page__clear(&page); 3041 return; /* state already set */ 3042 } 3043 simple_ogg_page__clear(&page); 3044 } 3045 } 3046 #endif 3047 3048 FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block) 3049 { 3050 FLAC__uint16 crc; 3051 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); 3052 3053 /* 3054 * Accumulate raw signal to the MD5 signature 3055 */ 3056 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)) { 3057 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3058 return false; 3059 } 3060 3061 /* 3062 * Process the frame header and subframes into the frame bitbuffer 3063 */ 3064 if(!process_subframes_(encoder, is_fractional_block)) { 3065 /* the above function sets the state for us in case of an error */ 3066 return false; 3067 } 3068 3069 /* 3070 * Zero-pad the frame to a byte_boundary 3071 */ 3072 if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder->private_->frame)) { 3073 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3074 return false; 3075 } 3076 3077 /* 3078 * CRC-16 the whole thing 3079 */ 3080 FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame)); 3081 if( 3082 !FLAC__bitwriter_get_write_crc16(encoder->private_->frame, &crc) || 3083 !FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN) 3084 ) { 3085 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3086 return false; 3087 } 3088 3089 /* 3090 * Write it 3091 */ 3092 if(!write_bitbuffer_(encoder, encoder->protected_->blocksize, is_last_block)) { 3093 /* the above function sets the state for us in case of an error */ 3094 return false; 3095 } 3096 3097 /* 3098 * Get ready for the next frame 3099 */ 3100 encoder->private_->current_sample_number = 0; 3101 encoder->private_->current_frame_number++; 3102 encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize; 3103 3104 return true; 3105 } 3106 3107 FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block) 3108 { 3109 FLAC__FrameHeader frame_header; 3110 unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order; 3111 FLAC__bool do_independent, do_mid_side; 3112 3113 /* 3114 * Calculate the min,max Rice partition orders 3115 */ 3116 if(is_fractional_block) { 3117 max_partition_order = 0; 3118 } 3119 else { 3120 max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize); 3121 max_partition_order = flac_min(max_partition_order, encoder->protected_->max_residual_partition_order); 3122 } 3123 min_partition_order = flac_min(min_partition_order, max_partition_order); 3124 3125 /* 3126 * Setup the frame 3127 */ 3128 frame_header.blocksize = encoder->protected_->blocksize; 3129 frame_header.sample_rate = encoder->protected_->sample_rate; 3130 frame_header.channels = encoder->protected_->channels; 3131 frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */ 3132 frame_header.bits_per_sample = encoder->protected_->bits_per_sample; 3133 frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; 3134 frame_header.number.frame_number = encoder->private_->current_frame_number; 3135 3136 /* 3137 * Figure out what channel assignments to try 3138 */ 3139 if(encoder->protected_->do_mid_side_stereo) { 3140 if(encoder->protected_->loose_mid_side_stereo) { 3141 if(encoder->private_->loose_mid_side_stereo_frame_count == 0) { 3142 do_independent = true; 3143 do_mid_side = true; 3144 } 3145 else { 3146 do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT); 3147 do_mid_side = !do_independent; 3148 } 3149 } 3150 else { 3151 do_independent = true; 3152 do_mid_side = true; 3153 } 3154 } 3155 else { 3156 do_independent = true; 3157 do_mid_side = false; 3158 } 3159 3160 FLAC__ASSERT(do_independent || do_mid_side); 3161 3162 /* 3163 * Check for wasted bits; set effective bps for each subframe 3164 */ 3165 if(do_independent) { 3166 for(channel = 0; channel < encoder->protected_->channels; channel++) { 3167 unsigned w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize); 3168 if (w > encoder->protected_->bits_per_sample) { 3169 w = encoder->protected_->bits_per_sample; 3170 } 3171 encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w; 3172 encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w; 3173 } 3174 } 3175 if(do_mid_side) { 3176 FLAC__ASSERT(encoder->protected_->channels == 2); 3177 for(channel = 0; channel < 2; channel++) { 3178 unsigned w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize); 3179 if (w > encoder->protected_->bits_per_sample) { 3180 w = encoder->protected_->bits_per_sample; 3181 } 3182 encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w; 3183 encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1); 3184 } 3185 } 3186 3187 /* 3188 * First do a normal encoding pass of each independent channel 3189 */ 3190 if(do_independent) { 3191 for(channel = 0; channel < encoder->protected_->channels; channel++) { 3192 if(! 3193 process_subframe_( 3194 encoder, 3195 min_partition_order, 3196 max_partition_order, 3197 &frame_header, 3198 encoder->private_->subframe_bps[channel], 3199 encoder->private_->integer_signal[channel], 3200 encoder->private_->subframe_workspace_ptr[channel], 3201 encoder->private_->partitioned_rice_contents_workspace_ptr[channel], 3202 encoder->private_->residual_workspace[channel], 3203 encoder->private_->best_subframe+channel, 3204 encoder->private_->best_subframe_bits+channel 3205 ) 3206 ) 3207 return false; 3208 } 3209 } 3210 3211 /* 3212 * Now do mid and side channels if requested 3213 */ 3214 if(do_mid_side) { 3215 FLAC__ASSERT(encoder->protected_->channels == 2); 3216 3217 for(channel = 0; channel < 2; channel++) { 3218 if(! 3219 process_subframe_( 3220 encoder, 3221 min_partition_order, 3222 max_partition_order, 3223 &frame_header, 3224 encoder->private_->subframe_bps_mid_side[channel], 3225 encoder->private_->integer_signal_mid_side[channel], 3226 encoder->private_->subframe_workspace_ptr_mid_side[channel], 3227 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[channel], 3228 encoder->private_->residual_workspace_mid_side[channel], 3229 encoder->private_->best_subframe_mid_side+channel, 3230 encoder->private_->best_subframe_bits_mid_side+channel 3231 ) 3232 ) 3233 return false; 3234 } 3235 } 3236 3237 /* 3238 * Compose the frame bitbuffer 3239 */ 3240 if(do_mid_side) { 3241 unsigned left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */ 3242 FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */ 3243 FLAC__ChannelAssignment channel_assignment; 3244 3245 FLAC__ASSERT(encoder->protected_->channels == 2); 3246 3247 if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) { 3248 channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE); 3249 } 3250 else { 3251 unsigned bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */ 3252 unsigned min_bits; 3253 int ca; 3254 3255 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT == 0); 3256 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE == 1); 3257 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE == 2); 3258 FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_MID_SIDE == 3); 3259 FLAC__ASSERT(do_independent && do_mid_side); 3260 3261 /* We have to figure out which channel assignent results in the smallest frame */ 3262 bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits [1]; 3263 bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE ] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits_mid_side[1]; 3264 bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits [1] + encoder->private_->best_subframe_bits_mid_side[1]; 3265 bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1]; 3266 3267 channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 3268 min_bits = bits[channel_assignment]; 3269 for(ca = 1; ca <= 3; ca++) { 3270 if(bits[ca] < min_bits) { 3271 min_bits = bits[ca]; 3272 channel_assignment = (FLAC__ChannelAssignment)ca; 3273 } 3274 } 3275 } 3276 3277 frame_header.channel_assignment = channel_assignment; 3278 3279 if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) { 3280 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3281 return false; 3282 } 3283 3284 switch(channel_assignment) { 3285 case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: 3286 left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]]; 3287 right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]]; 3288 break; 3289 case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: 3290 left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]]; 3291 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]]; 3292 break; 3293 case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: 3294 left_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]]; 3295 right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]]; 3296 break; 3297 case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: 3298 left_subframe = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]]; 3299 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]]; 3300 break; 3301 default: 3302 FLAC__ASSERT(0); 3303 } 3304 3305 switch(channel_assignment) { 3306 case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: 3307 left_bps = encoder->private_->subframe_bps [0]; 3308 right_bps = encoder->private_->subframe_bps [1]; 3309 break; 3310 case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: 3311 left_bps = encoder->private_->subframe_bps [0]; 3312 right_bps = encoder->private_->subframe_bps_mid_side[1]; 3313 break; 3314 case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: 3315 left_bps = encoder->private_->subframe_bps_mid_side[1]; 3316 right_bps = encoder->private_->subframe_bps [1]; 3317 break; 3318 case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: 3319 left_bps = encoder->private_->subframe_bps_mid_side[0]; 3320 right_bps = encoder->private_->subframe_bps_mid_side[1]; 3321 break; 3322 default: 3323 FLAC__ASSERT(0); 3324 } 3325 3326 /* note that encoder_add_subframe_ sets the state for us in case of an error */ 3327 if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , encoder->private_->frame)) 3328 return false; 3329 if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, encoder->private_->frame)) 3330 return false; 3331 } 3332 else { 3333 if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) { 3334 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3335 return false; 3336 } 3337 3338 for(channel = 0; channel < encoder->protected_->channels; channel++) { 3339 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)) { 3340 /* the above function sets the state for us in case of an error */ 3341 return false; 3342 } 3343 } 3344 } 3345 3346 if(encoder->protected_->loose_mid_side_stereo) { 3347 encoder->private_->loose_mid_side_stereo_frame_count++; 3348 if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames) 3349 encoder->private_->loose_mid_side_stereo_frame_count = 0; 3350 } 3351 3352 encoder->private_->last_channel_assignment = frame_header.channel_assignment; 3353 3354 return true; 3355 } 3356 3357 FLAC__bool process_subframe_( 3358 FLAC__StreamEncoder *encoder, 3359 unsigned min_partition_order, 3360 unsigned max_partition_order, 3361 const FLAC__FrameHeader *frame_header, 3362 unsigned subframe_bps, 3363 const FLAC__int32 integer_signal[], 3364 FLAC__Subframe *subframe[2], 3365 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents[2], 3366 FLAC__int32 *residual[2], 3367 unsigned *best_subframe, 3368 unsigned *best_bits 3369 ) 3370 { 3371 #ifndef FLAC__INTEGER_ONLY_LIBRARY 3372 float fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]; 3373 #else 3374 FLAC__fixedpoint fixed_residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]; 3375 #endif 3376 #ifndef FLAC__INTEGER_ONLY_LIBRARY 3377 double lpc_residual_bits_per_sample; 3378 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 and x86 intrinsic routines need all the space */ 3379 double lpc_error[FLAC__MAX_LPC_ORDER]; 3380 unsigned min_lpc_order, max_lpc_order, lpc_order; 3381 unsigned min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision; 3382 #endif 3383 unsigned min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order; 3384 unsigned rice_parameter; 3385 unsigned _candidate_bits, _best_bits; 3386 unsigned _best_subframe; 3387 /* only use RICE2 partitions if stream bps > 16 */ 3388 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; 3389 3390 FLAC__ASSERT(frame_header->blocksize > 0); 3391 3392 /* verbatim subframe is the baseline against which we measure other compressed subframes */ 3393 _best_subframe = 0; 3394 if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) 3395 _best_bits = UINT_MAX; 3396 else 3397 _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); 3398 3399 if(frame_header->blocksize >= FLAC__MAX_FIXED_ORDER) { 3400 unsigned signal_is_constant = false; 3401 if(subframe_bps + 4 + FLAC__bitmath_ilog2((frame_header->blocksize-FLAC__MAX_FIXED_ORDER)|1) <= 32) 3402 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); 3403 else 3404 guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_wide(integer_signal+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample); 3405 /* check for constant subframe */ 3406 if( 3407 !encoder->private_->disable_constant_subframes && 3408 #ifndef FLAC__INTEGER_ONLY_LIBRARY 3409 fixed_residual_bits_per_sample[1] == 0.0 3410 #else 3411 fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO 3412 #endif 3413 ) { 3414 /* the above means it's possible all samples are the same value; now double-check it: */ 3415 unsigned i; 3416 signal_is_constant = true; 3417 for(i = 1; i < frame_header->blocksize; i++) { 3418 if(integer_signal[0] != integer_signal[i]) { 3419 signal_is_constant = false; 3420 break; 3421 } 3422 } 3423 } 3424 if(signal_is_constant) { 3425 _candidate_bits = evaluate_constant_subframe_(encoder, integer_signal[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]); 3426 if(_candidate_bits < _best_bits) { 3427 _best_subframe = !_best_subframe; 3428 _best_bits = _candidate_bits; 3429 } 3430 } 3431 else { 3432 if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) { 3433 /* encode fixed */ 3434 if(encoder->protected_->do_exhaustive_model_search) { 3435 min_fixed_order = 0; 3436 max_fixed_order = FLAC__MAX_FIXED_ORDER; 3437 } 3438 else { 3439 min_fixed_order = max_fixed_order = guess_fixed_order; 3440 } 3441 if(max_fixed_order >= frame_header->blocksize) 3442 max_fixed_order = frame_header->blocksize - 1; 3443 for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) { 3444 #ifndef FLAC__INTEGER_ONLY_LIBRARY 3445 if(fixed_residual_bits_per_sample[fixed_order] >= (float)subframe_bps) 3446 continue; /* don't even try */ 3447 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 */ 3448 #else 3449 if(FLAC__fixedpoint_trunc(fixed_residual_bits_per_sample[fixed_order]) >= (int)subframe_bps) 3450 continue; /* don't even try */ 3451 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 */ 3452 #endif 3453 rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */ 3454 if(rice_parameter >= rice_parameter_limit) { 3455 #ifdef DEBUG_VERBOSE 3456 fprintf(stderr, "clipping rice_parameter (%u -> %u) @0\n", rice_parameter, rice_parameter_limit - 1); 3457 #endif 3458 rice_parameter = rice_parameter_limit - 1; 3459 } 3460 _candidate_bits = 3461 evaluate_fixed_subframe_( 3462 encoder, 3463 integer_signal, 3464 residual[!_best_subframe], 3465 encoder->private_->abs_residual_partition_sums, 3466 encoder->private_->raw_bits_per_partition, 3467 frame_header->blocksize, 3468 subframe_bps, 3469 fixed_order, 3470 rice_parameter, 3471 rice_parameter_limit, 3472 min_partition_order, 3473 max_partition_order, 3474 encoder->protected_->do_escape_coding, 3475 encoder->protected_->rice_parameter_search_dist, 3476 subframe[!_best_subframe], 3477 partitioned_rice_contents[!_best_subframe] 3478 ); 3479 if(_candidate_bits < _best_bits) { 3480 _best_subframe = !_best_subframe; 3481 _best_bits = _candidate_bits; 3482 } 3483 } 3484 } 3485 3486 #ifndef FLAC__INTEGER_ONLY_LIBRARY 3487 /* encode lpc */ 3488 if(encoder->protected_->max_lpc_order > 0) { 3489 if(encoder->protected_->max_lpc_order >= frame_header->blocksize) 3490 max_lpc_order = frame_header->blocksize-1; 3491 else 3492 max_lpc_order = encoder->protected_->max_lpc_order; 3493 if(max_lpc_order > 0) { 3494 unsigned a; 3495 for (a = 0; a < encoder->protected_->num_apodizations; a++) { 3496 FLAC__lpc_window_data(integer_signal, encoder->private_->window[a], encoder->private_->windowed_signal, frame_header->blocksize); 3497 encoder->private_->local_lpc_compute_autocorrelation(encoder->private_->windowed_signal, frame_header->blocksize, max_lpc_order+1, autoc); 3498 /* if autoc[0] == 0.0, the signal is constant and we usually won't get here, but it can happen */ 3499 if(autoc[0] != 0.0) { 3500 FLAC__lpc_compute_lp_coefficients(autoc, &max_lpc_order, encoder->private_->lp_coeff, lpc_error); 3501 if(encoder->protected_->do_exhaustive_model_search) { 3502 min_lpc_order = 1; 3503 } 3504 else { 3505 const unsigned guess_lpc_order = 3506 FLAC__lpc_compute_best_order( 3507 lpc_error, 3508 max_lpc_order, 3509 frame_header->blocksize, 3510 subframe_bps + ( 3511 encoder->protected_->do_qlp_coeff_prec_search? 3512 FLAC__MIN_QLP_COEFF_PRECISION : /* have to guess; use the min possible size to avoid accidentally favoring lower orders */ 3513 encoder->protected_->qlp_coeff_precision 3514 ) 3515 ); 3516 min_lpc_order = max_lpc_order = guess_lpc_order; 3517 } 3518 if(max_lpc_order >= frame_header->blocksize) 3519 max_lpc_order = frame_header->blocksize - 1; 3520 for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order; lpc_order++) { 3521 lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order); 3522 if(lpc_residual_bits_per_sample >= (double)subframe_bps) 3523 continue; /* don't even try */ 3524 rice_parameter = (lpc_residual_bits_per_sample > 0.0)? (unsigned)(lpc_residual_bits_per_sample+0.5) : 0; /* 0.5 is for rounding */ 3525 rice_parameter++; /* to account for the signed->unsigned conversion during rice coding */ 3526 if(rice_parameter >= rice_parameter_limit) { 3527 #ifdef DEBUG_VERBOSE 3528 fprintf(stderr, "clipping rice_parameter (%u -> %u) @1\n", rice_parameter, rice_parameter_limit - 1); 3529 #endif 3530 rice_parameter = rice_parameter_limit - 1; 3531 } 3532 if(encoder->protected_->do_qlp_coeff_prec_search) { 3533 min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION; 3534 /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps(+1bps for side channel) streams */ 3535 if(subframe_bps <= 17) { 3536 max_qlp_coeff_precision = flac_min(32 - subframe_bps - FLAC__bitmath_ilog2(lpc_order), FLAC__MAX_QLP_COEFF_PRECISION); 3537 max_qlp_coeff_precision = flac_max(max_qlp_coeff_precision, min_qlp_coeff_precision); 3538 } 3539 else 3540 max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; 3541 } 3542 else { 3543 min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision; 3544 } 3545 for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) { 3546 _candidate_bits = 3547 evaluate_lpc_subframe_( 3548 encoder, 3549 integer_signal, 3550 residual[!_best_subframe], 3551 encoder->private_->abs_residual_partition_sums, 3552 encoder->private_->raw_bits_per_partition, 3553 encoder->private_->lp_coeff[lpc_order-1], 3554 frame_header->blocksize, 3555 subframe_bps, 3556 lpc_order, 3557 qlp_coeff_precision, 3558 rice_parameter, 3559 rice_parameter_limit, 3560 min_partition_order, 3561 max_partition_order, 3562 encoder->protected_->do_escape_coding, 3563 encoder->protected_->rice_parameter_search_dist, 3564 subframe[!_best_subframe], 3565 partitioned_rice_contents[!_best_subframe] 3566 ); 3567 if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */ 3568 if(_candidate_bits < _best_bits) { 3569 _best_subframe = !_best_subframe; 3570 _best_bits = _candidate_bits; 3571 } 3572 } 3573 } 3574 } 3575 } 3576 } 3577 } 3578 } 3579 #endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */ 3580 } 3581 } 3582 3583 /* under rare circumstances this can happen when all but lpc subframe types are disabled: */ 3584 if(_best_bits == UINT_MAX) { 3585 FLAC__ASSERT(_best_subframe == 0); 3586 _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); 3587 } 3588 3589 *best_subframe = _best_subframe; 3590 *best_bits = _best_bits; 3591 3592 return true; 3593 } 3594 3595 FLAC__bool add_subframe_( 3596 FLAC__StreamEncoder *encoder, 3597 unsigned blocksize, 3598 unsigned subframe_bps, 3599 const FLAC__Subframe *subframe, 3600 FLAC__BitWriter *frame 3601 ) 3602 { 3603 switch(subframe->type) { 3604 case FLAC__SUBFRAME_TYPE_CONSTANT: 3605 if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) { 3606 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3607 return false; 3608 } 3609 break; 3610 case FLAC__SUBFRAME_TYPE_FIXED: 3611 if(!FLAC__subframe_add_fixed(&(subframe->data.fixed), blocksize - subframe->data.fixed.order, subframe_bps, subframe->wasted_bits, frame)) { 3612 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3613 return false; 3614 } 3615 break; 3616 case FLAC__SUBFRAME_TYPE_LPC: 3617 if(!FLAC__subframe_add_lpc(&(subframe->data.lpc), blocksize - subframe->data.lpc.order, subframe_bps, subframe->wasted_bits, frame)) { 3618 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3619 return false; 3620 } 3621 break; 3622 case FLAC__SUBFRAME_TYPE_VERBATIM: 3623 if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), blocksize, subframe_bps, subframe->wasted_bits, frame)) { 3624 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3625 return false; 3626 } 3627 break; 3628 default: 3629 FLAC__ASSERT(0); 3630 } 3631 3632 return true; 3633 } 3634 3635 #define SPOTCHECK_ESTIMATE 0 3636 #if SPOTCHECK_ESTIMATE 3637 static void spotcheck_subframe_estimate_( 3638 FLAC__StreamEncoder *encoder, 3639 unsigned blocksize, 3640 unsigned subframe_bps, 3641 const FLAC__Subframe *subframe, 3642 unsigned estimate 3643 ) 3644 { 3645 FLAC__bool ret; 3646 FLAC__BitWriter *frame = FLAC__bitwriter_new(); 3647 if(frame == 0) { 3648 fprintf(stderr, "EST: can't allocate frame\n"); 3649 return; 3650 } 3651 if(!FLAC__bitwriter_init(frame)) { 3652 fprintf(stderr, "EST: can't init frame\n"); 3653 return; 3654 } 3655 ret = add_subframe_(encoder, blocksize, subframe_bps, subframe, frame); 3656 FLAC__ASSERT(ret); 3657 { 3658 const unsigned actual = FLAC__bitwriter_get_input_bits_unconsumed(frame); 3659 if(estimate != actual) 3660 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); 3661 } 3662 FLAC__bitwriter_delete(frame); 3663 } 3664 #endif 3665 3666 unsigned evaluate_constant_subframe_( 3667 FLAC__StreamEncoder *encoder, 3668 const FLAC__int32 signal, 3669 unsigned blocksize, 3670 unsigned subframe_bps, 3671 FLAC__Subframe *subframe 3672 ) 3673 { 3674 unsigned estimate; 3675 subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT; 3676 subframe->data.constant.value = signal; 3677 3678 estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + subframe_bps; 3679 3680 #if SPOTCHECK_ESTIMATE 3681 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 3682 #else 3683 (void)encoder, (void)blocksize; 3684 #endif 3685 3686 return estimate; 3687 } 3688 3689 unsigned evaluate_fixed_subframe_( 3690 FLAC__StreamEncoder *encoder, 3691 const FLAC__int32 signal[], 3692 FLAC__int32 residual[], 3693 FLAC__uint64 abs_residual_partition_sums[], 3694 unsigned raw_bits_per_partition[], 3695 unsigned blocksize, 3696 unsigned subframe_bps, 3697 unsigned order, 3698 unsigned rice_parameter, 3699 unsigned rice_parameter_limit, 3700 unsigned min_partition_order, 3701 unsigned max_partition_order, 3702 FLAC__bool do_escape_coding, 3703 unsigned rice_parameter_search_dist, 3704 FLAC__Subframe *subframe, 3705 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents 3706 ) 3707 { 3708 unsigned i, residual_bits, estimate; 3709 const unsigned residual_samples = blocksize - order; 3710 3711 FLAC__fixed_compute_residual(signal+order, residual_samples, order, residual); 3712 3713 subframe->type = FLAC__SUBFRAME_TYPE_FIXED; 3714 3715 subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; 3716 subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; 3717 subframe->data.fixed.residual = residual; 3718 3719 residual_bits = 3720 find_best_partition_order_( 3721 encoder->private_, 3722 residual, 3723 abs_residual_partition_sums, 3724 raw_bits_per_partition, 3725 residual_samples, 3726 order, 3727 rice_parameter, 3728 rice_parameter_limit, 3729 min_partition_order, 3730 max_partition_order, 3731 subframe_bps, 3732 do_escape_coding, 3733 rice_parameter_search_dist, 3734 &subframe->data.fixed.entropy_coding_method 3735 ); 3736 3737 subframe->data.fixed.order = order; 3738 for(i = 0; i < order; i++) 3739 subframe->data.fixed.warmup[i] = signal[i]; 3740 3741 estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (order * subframe_bps) + residual_bits; 3742 3743 #if SPOTCHECK_ESTIMATE 3744 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 3745 #endif 3746 3747 return estimate; 3748 } 3749 3750 #ifndef FLAC__INTEGER_ONLY_LIBRARY 3751 unsigned evaluate_lpc_subframe_( 3752 FLAC__StreamEncoder *encoder, 3753 const FLAC__int32 signal[], 3754 FLAC__int32 residual[], 3755 FLAC__uint64 abs_residual_partition_sums[], 3756 unsigned raw_bits_per_partition[], 3757 const FLAC__real lp_coeff[], 3758 unsigned blocksize, 3759 unsigned subframe_bps, 3760 unsigned order, 3761 unsigned qlp_coeff_precision, 3762 unsigned rice_parameter, 3763 unsigned rice_parameter_limit, 3764 unsigned min_partition_order, 3765 unsigned max_partition_order, 3766 FLAC__bool do_escape_coding, 3767 unsigned rice_parameter_search_dist, 3768 FLAC__Subframe *subframe, 3769 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents 3770 ) 3771 { 3772 FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; /* WATCHOUT: the size is important; some x86 intrinsic routines need more than lpc order elements */ 3773 unsigned i, residual_bits, estimate; 3774 int quantization, ret; 3775 const unsigned residual_samples = blocksize - order; 3776 3777 /* try to keep qlp coeff precision such that only 32-bit math is required for decode of <=16bps(+1bps for side channel) streams */ 3778 if(subframe_bps <= 17) { 3779 FLAC__ASSERT(order > 0); 3780 FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER); 3781 qlp_coeff_precision = flac_min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order)); 3782 } 3783 3784 ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization); 3785 if(ret != 0) 3786 return 0; /* this is a hack to indicate to the caller that we can't do lp at this order on this subframe */ 3787 3788 if(subframe_bps + qlp_coeff_precision + FLAC__bitmath_ilog2(order) <= 32) 3789 if(subframe_bps <= 16 && qlp_coeff_precision <= 16) 3790 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual); 3791 else 3792 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual); 3793 else 3794 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual); 3795 3796 subframe->type = FLAC__SUBFRAME_TYPE_LPC; 3797 3798 subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; 3799 subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; 3800 subframe->data.lpc.residual = residual; 3801 3802 residual_bits = 3803 find_best_partition_order_( 3804 encoder->private_, 3805 residual, 3806 abs_residual_partition_sums, 3807 raw_bits_per_partition, 3808 residual_samples, 3809 order, 3810 rice_parameter, 3811 rice_parameter_limit, 3812 min_partition_order, 3813 max_partition_order, 3814 subframe_bps, 3815 do_escape_coding, 3816 rice_parameter_search_dist, 3817 &subframe->data.lpc.entropy_coding_method 3818 ); 3819 3820 subframe->data.lpc.order = order; 3821 subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision; 3822 subframe->data.lpc.quantization_level = quantization; 3823 memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER); 3824 for(i = 0; i < order; i++) 3825 subframe->data.lpc.warmup[i] = signal[i]; 3826 3827 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; 3828 3829 #if SPOTCHECK_ESTIMATE 3830 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 3831 #endif 3832 3833 return estimate; 3834 } 3835 #endif 3836 3837 unsigned evaluate_verbatim_subframe_( 3838 FLAC__StreamEncoder *encoder, 3839 const FLAC__int32 signal[], 3840 unsigned blocksize, 3841 unsigned subframe_bps, 3842 FLAC__Subframe *subframe 3843 ) 3844 { 3845 unsigned estimate; 3846 3847 subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM; 3848 3849 subframe->data.verbatim.data = signal; 3850 3851 estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (blocksize * subframe_bps); 3852 3853 #if SPOTCHECK_ESTIMATE 3854 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 3855 #else 3856 (void)encoder; 3857 #endif 3858 3859 return estimate; 3860 } 3861 3862 unsigned find_best_partition_order_( 3863 FLAC__StreamEncoderPrivate *private_, 3864 const FLAC__int32 residual[], 3865 FLAC__uint64 abs_residual_partition_sums[], 3866 unsigned raw_bits_per_partition[], 3867 unsigned residual_samples, 3868 unsigned predictor_order, 3869 unsigned rice_parameter, 3870 unsigned rice_parameter_limit, 3871 unsigned min_partition_order, 3872 unsigned max_partition_order, 3873 unsigned bps, 3874 FLAC__bool do_escape_coding, 3875 unsigned rice_parameter_search_dist, 3876 FLAC__EntropyCodingMethod *best_ecm 3877 ) 3878 { 3879 unsigned residual_bits, best_residual_bits = 0; 3880 unsigned best_parameters_index = 0; 3881 unsigned best_partition_order = 0; 3882 const unsigned blocksize = residual_samples + predictor_order; 3883 3884 max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order); 3885 min_partition_order = flac_min(min_partition_order, max_partition_order); 3886 3887 private_->local_precompute_partition_info_sums(residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order, bps); 3888 3889 if(do_escape_coding) 3890 precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order); 3891 3892 { 3893 int partition_order; 3894 unsigned sum; 3895 3896 for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) { 3897 if(! 3898 set_partitioned_rice_( 3899 #ifdef EXACT_RICE_BITS_CALCULATION 3900 residual, 3901 #endif 3902 abs_residual_partition_sums+sum, 3903 raw_bits_per_partition+sum, 3904 residual_samples, 3905 predictor_order, 3906 rice_parameter, 3907 rice_parameter_limit, 3908 rice_parameter_search_dist, 3909 (unsigned)partition_order, 3910 do_escape_coding, 3911 &private_->partitioned_rice_contents_extra[!best_parameters_index], 3912 &residual_bits 3913 ) 3914 ) 3915 { 3916 FLAC__ASSERT(best_residual_bits != 0); 3917 break; 3918 } 3919 sum += 1u << partition_order; 3920 if(best_residual_bits == 0 || residual_bits < best_residual_bits) { 3921 best_residual_bits = residual_bits; 3922 best_parameters_index = !best_parameters_index; 3923 best_partition_order = partition_order; 3924 } 3925 } 3926 } 3927 3928 best_ecm->data.partitioned_rice.order = best_partition_order; 3929 3930 { 3931 /* 3932 * We are allowed to de-const the pointer based on our special 3933 * knowledge; it is const to the outside world. 3934 */ 3935 FLAC__EntropyCodingMethod_PartitionedRiceContents* prc = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_ecm->data.partitioned_rice.contents; 3936 unsigned partition; 3937 3938 /* save best parameters and raw_bits */ 3939 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(prc, flac_max(6u, best_partition_order)); 3940 memcpy(prc->parameters, private_->partitioned_rice_contents_extra[best_parameters_index].parameters, sizeof(unsigned)*(1<<(best_partition_order))); 3941 if(do_escape_coding) 3942 memcpy(prc->raw_bits, private_->partitioned_rice_contents_extra[best_parameters_index].raw_bits, sizeof(unsigned)*(1<<(best_partition_order))); 3943 /* 3944 * Now need to check if the type should be changed to 3945 * FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 based on the 3946 * size of the rice parameters. 3947 */ 3948 for(partition = 0; partition < (1u<<best_partition_order); partition++) { 3949 if(prc->parameters[partition] >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { 3950 best_ecm->type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2; 3951 break; 3952 } 3953 } 3954 } 3955 3956 return best_residual_bits; 3957 } 3958 3959 void precompute_partition_info_sums_( 3960 const FLAC__int32 residual[], 3961 FLAC__uint64 abs_residual_partition_sums[], 3962 unsigned residual_samples, 3963 unsigned predictor_order, 3964 unsigned min_partition_order, 3965 unsigned max_partition_order, 3966 unsigned bps 3967 ) 3968 { 3969 const unsigned default_partition_samples = (residual_samples + predictor_order) >> max_partition_order; 3970 unsigned partitions = 1u << max_partition_order; 3971 3972 FLAC__ASSERT(default_partition_samples > predictor_order); 3973 3974 /* first do max_partition_order */ 3975 { 3976 const unsigned threshold = 32 - FLAC__bitmath_ilog2(default_partition_samples); 3977 unsigned partition, residual_sample, end = (unsigned)(-(int)predictor_order); 3978 /* WATCHOUT: "bps + FLAC__MAX_EXTRA_RESIDUAL_BPS" is the maximum assumed size of the average residual magnitude */ 3979 if(bps + FLAC__MAX_EXTRA_RESIDUAL_BPS < threshold) { 3980 for(partition = residual_sample = 0; partition < partitions; partition++) { 3981 FLAC__uint32 abs_residual_partition_sum = 0; 3982 end += default_partition_samples; 3983 for( ; residual_sample < end; residual_sample++) 3984 abs_residual_partition_sum += abs(residual[residual_sample]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */ 3985 abs_residual_partition_sums[partition] = abs_residual_partition_sum; 3986 } 3987 } 3988 else { /* have to pessimistically use 64 bits for accumulator */ 3989 for(partition = residual_sample = 0; partition < partitions; partition++) { 3990 FLAC__uint64 abs_residual_partition_sum64 = 0; 3991 end += default_partition_samples; 3992 for( ; residual_sample < end; residual_sample++) 3993 abs_residual_partition_sum64 += abs(residual[residual_sample]); /* abs(INT_MIN) is undefined, but if the residual is INT_MIN we have bigger problems */ 3994 abs_residual_partition_sums[partition] = abs_residual_partition_sum64; 3995 } 3996 } 3997 } 3998 3999 /* now merge partitions for lower orders */ 4000 { 4001 unsigned from_partition = 0, to_partition = partitions; 4002 int partition_order; 4003 for(partition_order = (int)max_partition_order - 1; partition_order >= (int)min_partition_order; partition_order--) { 4004 unsigned i; 4005 partitions >>= 1; 4006 for(i = 0; i < partitions; i++) { 4007 abs_residual_partition_sums[to_partition++] = 4008 abs_residual_partition_sums[from_partition ] + 4009 abs_residual_partition_sums[from_partition+1]; 4010 from_partition += 2; 4011 } 4012 } 4013 } 4014 } 4015 4016 void precompute_partition_info_escapes_( 4017 const FLAC__int32 residual[], 4018 unsigned raw_bits_per_partition[], 4019 unsigned residual_samples, 4020 unsigned predictor_order, 4021 unsigned min_partition_order, 4022 unsigned max_partition_order 4023 ) 4024 { 4025 int partition_order; 4026 unsigned from_partition, to_partition = 0; 4027 const unsigned blocksize = residual_samples + predictor_order; 4028 4029 /* first do max_partition_order */ 4030 for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) { 4031 FLAC__int32 r; 4032 FLAC__uint32 rmax; 4033 unsigned partition, partition_sample, partition_samples, residual_sample; 4034 const unsigned partitions = 1u << partition_order; 4035 const unsigned default_partition_samples = blocksize >> partition_order; 4036 4037 FLAC__ASSERT(default_partition_samples > predictor_order); 4038 4039 for(partition = residual_sample = 0; partition < partitions; partition++) { 4040 partition_samples = default_partition_samples; 4041 if(partition == 0) 4042 partition_samples -= predictor_order; 4043 rmax = 0; 4044 for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) { 4045 r = residual[residual_sample++]; 4046 /* OPT: maybe faster: rmax |= r ^ (r>>31) */ 4047 if(r < 0) 4048 rmax |= ~r; 4049 else 4050 rmax |= r; 4051 } 4052 /* now we know all residual values are in the range [-rmax-1,rmax] */ 4053 raw_bits_per_partition[partition] = rmax? FLAC__bitmath_ilog2(rmax) + 2 : 1; 4054 } 4055 to_partition = partitions; 4056 break; /*@@@ yuck, should remove the 'for' loop instead */ 4057 } 4058 4059 /* now merge partitions for lower orders */ 4060 for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) { 4061 unsigned m; 4062 unsigned i; 4063 const unsigned partitions = 1u << partition_order; 4064 for(i = 0; i < partitions; i++) { 4065 m = raw_bits_per_partition[from_partition]; 4066 from_partition++; 4067 raw_bits_per_partition[to_partition] = flac_max(m, raw_bits_per_partition[from_partition]); 4068 from_partition++; 4069 to_partition++; 4070 } 4071 } 4072 } 4073 4074 #ifdef EXACT_RICE_BITS_CALCULATION 4075 static inline unsigned count_rice_bits_in_partition_( 4076 const unsigned rice_parameter, 4077 const unsigned partition_samples, 4078 const FLAC__int32 *residual 4079 ) 4080 { 4081 unsigned i, partition_bits = 4082 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 */ 4083 (1+rice_parameter) * partition_samples /* 1 for unary stop bit + rice_parameter for the binary portion */ 4084 ; 4085 for(i = 0; i < partition_samples; i++) 4086 partition_bits += ( (FLAC__uint32)((residual[i]<<1)^(residual[i]>>31)) >> rice_parameter ); 4087 return partition_bits; 4088 } 4089 #else 4090 static inline unsigned count_rice_bits_in_partition_( 4091 const unsigned rice_parameter, 4092 const unsigned partition_samples, 4093 const FLAC__uint64 abs_residual_partition_sum 4094 ) 4095 { 4096 return 4097 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 */ 4098 (1+rice_parameter) * partition_samples + /* 1 for unary stop bit + rice_parameter for the binary portion */ 4099 ( 4100 rice_parameter? 4101 (unsigned)(abs_residual_partition_sum >> (rice_parameter-1)) /* rice_parameter-1 because the real coder sign-folds instead of using a sign bit */ 4102 : (unsigned)(abs_residual_partition_sum << 1) /* can't shift by negative number, so reverse */ 4103 ) 4104 - (partition_samples >> 1) 4105 /* -(partition_samples>>1) to subtract out extra contributions to the abs_residual_partition_sum. 4106 * The actual number of bits used is closer to the sum(for all i in the partition) of abs(residual[i])>>(rice_parameter-1) 4107 * By using the abs_residual_partition sum, we also add in bits in the LSBs that would normally be shifted out. 4108 * So the subtraction term tries to guess how many extra bits were contributed. 4109 * If the LSBs are randomly distributed, this should average to 0.5 extra bits per sample. 4110 */ 4111 ; 4112 } 4113 #endif 4114 4115 FLAC__bool set_partitioned_rice_( 4116 #ifdef EXACT_RICE_BITS_CALCULATION 4117 const FLAC__int32 residual[], 4118 #endif 4119 const FLAC__uint64 abs_residual_partition_sums[], 4120 const unsigned raw_bits_per_partition[], 4121 const unsigned residual_samples, 4122 const unsigned predictor_order, 4123 const unsigned suggested_rice_parameter, 4124 const unsigned rice_parameter_limit, 4125 const unsigned rice_parameter_search_dist, 4126 const unsigned partition_order, 4127 const FLAC__bool search_for_escapes, 4128 FLAC__EntropyCodingMethod_PartitionedRiceContents *partitioned_rice_contents, 4129 unsigned *bits 4130 ) 4131 { 4132 unsigned rice_parameter, partition_bits; 4133 unsigned best_partition_bits, best_rice_parameter = 0; 4134 unsigned bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; 4135 unsigned *parameters, *raw_bits; 4136 #ifdef ENABLE_RICE_PARAMETER_SEARCH 4137 unsigned min_rice_parameter, max_rice_parameter; 4138 #else 4139 (void)rice_parameter_search_dist; 4140 #endif 4141 4142 FLAC__ASSERT(suggested_rice_parameter < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER); 4143 FLAC__ASSERT(rice_parameter_limit <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER); 4144 4145 FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, flac_max(6u, partition_order)); 4146 parameters = partitioned_rice_contents->parameters; 4147 raw_bits = partitioned_rice_contents->raw_bits; 4148 4149 if(partition_order == 0) { 4150 best_partition_bits = (unsigned)(-1); 4151 #ifdef ENABLE_RICE_PARAMETER_SEARCH 4152 if(rice_parameter_search_dist) { 4153 if(suggested_rice_parameter < rice_parameter_search_dist) 4154 min_rice_parameter = 0; 4155 else 4156 min_rice_parameter = suggested_rice_parameter - rice_parameter_search_dist; 4157 max_rice_parameter = suggested_rice_parameter + rice_parameter_search_dist; 4158 if(max_rice_parameter >= rice_parameter_limit) { 4159 #ifdef DEBUG_VERBOSE 4160 fprintf(stderr, "clipping rice_parameter (%u -> %u) @5\n", max_rice_parameter, rice_parameter_limit - 1); 4161 #endif 4162 max_rice_parameter = rice_parameter_limit - 1; 4163 } 4164 } 4165 else 4166 min_rice_parameter = max_rice_parameter = suggested_rice_parameter; 4167 4168 for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { 4169 #else 4170 rice_parameter = suggested_rice_parameter; 4171 #endif 4172 #ifdef EXACT_RICE_BITS_CALCULATION 4173 partition_bits = count_rice_bits_in_partition_(rice_parameter, residual_samples, residual); 4174 #else 4175 partition_bits = count_rice_bits_in_partition_(rice_parameter, residual_samples, abs_residual_partition_sums[0]); 4176 #endif 4177 if(partition_bits < best_partition_bits) { 4178 best_rice_parameter = rice_parameter; 4179 best_partition_bits = partition_bits; 4180 } 4181 #ifdef ENABLE_RICE_PARAMETER_SEARCH 4182 } 4183 #endif 4184 if(search_for_escapes) { 4185 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; 4186 if(partition_bits <= best_partition_bits) { 4187 raw_bits[0] = raw_bits_per_partition[0]; 4188 best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */ 4189 best_partition_bits = partition_bits; 4190 } 4191 else 4192 raw_bits[0] = 0; 4193 } 4194 parameters[0] = best_rice_parameter; 4195 bits_ += best_partition_bits; 4196 } 4197 else { 4198 unsigned partition, residual_sample; 4199 unsigned partition_samples; 4200 FLAC__uint64 mean, k; 4201 const unsigned partitions = 1u << partition_order; 4202 for(partition = residual_sample = 0; partition < partitions; partition++) { 4203 partition_samples = (residual_samples+predictor_order) >> partition_order; 4204 if(partition == 0) { 4205 if(partition_samples <= predictor_order) 4206 return false; 4207 else 4208 partition_samples -= predictor_order; 4209 } 4210 mean = abs_residual_partition_sums[partition]; 4211 /* we are basically calculating the size in bits of the 4212 * average residual magnitude in the partition: 4213 * rice_parameter = floor(log2(mean/partition_samples)) 4214 * 'mean' is not a good name for the variable, it is 4215 * actually the sum of magnitudes of all residual values 4216 * in the partition, so the actual mean is 4217 * mean/partition_samples 4218 */ 4219 #if 0 /* old simple code */ 4220 for(rice_parameter = 0, k = partition_samples; k < mean; rice_parameter++, k <<= 1) 4221 ; 4222 #else 4223 #if defined FLAC__CPU_X86_64 /* and other 64-bit arch, too */ 4224 if(mean <= 0x80000000/512) { /* 512: more or less optimal for both 16- and 24-bit input */ 4225 #else 4226 if(mean <= 0x80000000/8) { /* 32-bit arch: use 32-bit math if possible */ 4227 #endif 4228 FLAC__uint32 k2, mean2 = (FLAC__uint32) mean; 4229 rice_parameter = 0; k2 = partition_samples; 4230 while(k2*8 < mean2) { /* requires: mean <= (2^31)/8 */ 4231 rice_parameter += 4; k2 <<= 4; /* tuned for 16-bit input */ 4232 } 4233 while(k2 < mean2) { /* requires: mean <= 2^31 */ 4234 rice_parameter++; k2 <<= 1; 4235 } 4236 } 4237 else { 4238 rice_parameter = 0; k = partition_samples; 4239 if(mean <= FLAC__U64L(0x8000000000000000)/128) /* usually mean is _much_ smaller than this value */ 4240 while(k*128 < mean) { /* requires: mean <= (2^63)/128 */ 4241 rice_parameter += 8; k <<= 8; /* tuned for 24-bit input */ 4242 } 4243 while(k < mean) { /* requires: mean <= 2^63 */ 4244 rice_parameter++; k <<= 1; 4245 } 4246 } 4247 #endif 4248 if(rice_parameter >= rice_parameter_limit) { 4249 #ifdef DEBUG_VERBOSE 4250 fprintf(stderr, "clipping rice_parameter (%u -> %u) @6\n", rice_parameter, rice_parameter_limit - 1); 4251 #endif 4252 rice_parameter = rice_parameter_limit - 1; 4253 } 4254 4255 best_partition_bits = (unsigned)(-1); 4256 #ifdef ENABLE_RICE_PARAMETER_SEARCH 4257 if(rice_parameter_search_dist) { 4258 if(rice_parameter < rice_parameter_search_dist) 4259 min_rice_parameter = 0; 4260 else 4261 min_rice_parameter = rice_parameter - rice_parameter_search_dist; 4262 max_rice_parameter = rice_parameter + rice_parameter_search_dist; 4263 if(max_rice_parameter >= rice_parameter_limit) { 4264 #ifdef DEBUG_VERBOSE 4265 fprintf(stderr, "clipping rice_parameter (%u -> %u) @7\n", max_rice_parameter, rice_parameter_limit - 1); 4266 #endif 4267 max_rice_parameter = rice_parameter_limit - 1; 4268 } 4269 } 4270 else 4271 min_rice_parameter = max_rice_parameter = rice_parameter; 4272 4273 for(rice_parameter = min_rice_parameter; rice_parameter <= max_rice_parameter; rice_parameter++) { 4274 #endif 4275 #ifdef EXACT_RICE_BITS_CALCULATION 4276 partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, residual+residual_sample); 4277 #else 4278 partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, abs_residual_partition_sums[partition]); 4279 #endif 4280 if(partition_bits < best_partition_bits) { 4281 best_rice_parameter = rice_parameter; 4282 best_partition_bits = partition_bits; 4283 } 4284 #ifdef ENABLE_RICE_PARAMETER_SEARCH 4285 } 4286 #endif 4287 if(search_for_escapes) { 4288 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; 4289 if(partition_bits <= best_partition_bits) { 4290 raw_bits[partition] = raw_bits_per_partition[partition]; 4291 best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */ 4292 best_partition_bits = partition_bits; 4293 } 4294 else 4295 raw_bits[partition] = 0; 4296 } 4297 parameters[partition] = best_rice_parameter; 4298 bits_ += best_partition_bits; 4299 residual_sample += partition_samples; 4300 } 4301 } 4302 4303 *bits = bits_; 4304 return true; 4305 } 4306 4307 unsigned get_wasted_bits_(FLAC__int32 signal[], unsigned samples) 4308 { 4309 unsigned i, shift; 4310 FLAC__int32 x = 0; 4311 4312 for(i = 0; i < samples && !(x&1); i++) 4313 x |= signal[i]; 4314 4315 if(x == 0) { 4316 shift = 0; 4317 } 4318 else { 4319 for(shift = 0; !(x&1); shift++) 4320 x >>= 1; 4321 } 4322 4323 if(shift > 0) { 4324 for(i = 0; i < samples; i++) 4325 signal[i] >>= shift; 4326 } 4327 4328 return shift; 4329 } 4330 4331 void append_to_verify_fifo_(verify_input_fifo *fifo, const FLAC__int32 * const input[], unsigned input_offset, unsigned channels, unsigned wide_samples) 4332 { 4333 unsigned channel; 4334 4335 for(channel = 0; channel < channels; channel++) 4336 memcpy(&fifo->data[channel][fifo->tail], &input[channel][input_offset], sizeof(FLAC__int32) * wide_samples); 4337 4338 fifo->tail += wide_samples; 4339 4340 FLAC__ASSERT(fifo->tail <= fifo->size); 4341 } 4342 4343 void append_to_verify_fifo_interleaved_(verify_input_fifo *fifo, const FLAC__int32 input[], unsigned input_offset, unsigned channels, unsigned wide_samples) 4344 { 4345 unsigned channel; 4346 unsigned sample, wide_sample; 4347 unsigned tail = fifo->tail; 4348 4349 sample = input_offset * channels; 4350 for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) { 4351 for(channel = 0; channel < channels; channel++) 4352 fifo->data[channel][tail] = input[sample++]; 4353 tail++; 4354 } 4355 fifo->tail = tail; 4356 4357 FLAC__ASSERT(fifo->tail <= fifo->size); 4358 } 4359 4360 FLAC__StreamDecoderReadStatus verify_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data) 4361 { 4362 FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data; 4363 const size_t encoded_bytes = encoder->private_->verify.output.bytes; 4364 (void)decoder; 4365 4366 if(encoder->private_->verify.needs_magic_hack) { 4367 FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH); 4368 *bytes = FLAC__STREAM_SYNC_LENGTH; 4369 memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes); 4370 encoder->private_->verify.needs_magic_hack = false; 4371 } 4372 else { 4373 if(encoded_bytes == 0) { 4374 /* 4375 * If we get here, a FIFO underflow has occurred, 4376 * which means there is a bug somewhere. 4377 */ 4378 FLAC__ASSERT(0); 4379 return FLAC__STREAM_DECODER_READ_STATUS_ABORT; 4380 } 4381 else if(encoded_bytes < *bytes) 4382 *bytes = encoded_bytes; 4383 memcpy(buffer, encoder->private_->verify.output.data, *bytes); 4384 encoder->private_->verify.output.data += *bytes; 4385 encoder->private_->verify.output.bytes -= *bytes; 4386 } 4387 4388 return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; 4389 } 4390 4391 FLAC__StreamDecoderWriteStatus verify_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data) 4392 { 4393 FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data; 4394 unsigned channel; 4395 const unsigned channels = frame->header.channels; 4396 const unsigned blocksize = frame->header.blocksize; 4397 const unsigned bytes_per_block = sizeof(FLAC__int32) * blocksize; 4398 4399 (void)decoder; 4400 4401 for(channel = 0; channel < channels; channel++) { 4402 if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) { 4403 unsigned i, sample = 0; 4404 FLAC__int32 expect = 0, got = 0; 4405 4406 for(i = 0; i < blocksize; i++) { 4407 if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) { 4408 sample = i; 4409 expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i]; 4410 got = (FLAC__int32)buffer[channel][i]; 4411 break; 4412 } 4413 } 4414 FLAC__ASSERT(i < blocksize); 4415 FLAC__ASSERT(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); 4416 encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample; 4417 encoder->private_->verify.error_stats.frame_number = (unsigned)(frame->header.number.sample_number / blocksize); 4418 encoder->private_->verify.error_stats.channel = channel; 4419 encoder->private_->verify.error_stats.sample = sample; 4420 encoder->private_->verify.error_stats.expected = expect; 4421 encoder->private_->verify.error_stats.got = got; 4422 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA; 4423 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 4424 } 4425 } 4426 /* dequeue the frame from the fifo */ 4427 encoder->private_->verify.input_fifo.tail -= blocksize; 4428 FLAC__ASSERT(encoder->private_->verify.input_fifo.tail <= OVERREAD_); 4429 for(channel = 0; channel < channels; channel++) 4430 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])); 4431 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 4432 } 4433 4434 void verify_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) 4435 { 4436 (void)decoder, (void)metadata, (void)client_data; 4437 } 4438 4439 void verify_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) 4440 { 4441 FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data; 4442 (void)decoder, (void)status; 4443 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR; 4444 } 4445 4446 FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data) 4447 { 4448 (void)client_data; 4449 4450 *bytes = fread(buffer, 1, *bytes, encoder->private_->file); 4451 if (*bytes == 0) { 4452 if (feof(encoder->private_->file)) 4453 return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM; 4454 else if (ferror(encoder->private_->file)) 4455 return FLAC__STREAM_ENCODER_READ_STATUS_ABORT; 4456 } 4457 return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE; 4458 } 4459 4460 FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) 4461 { 4462 (void)client_data; 4463 4464 if(fseeko(encoder->private_->file, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0) 4465 return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR; 4466 else 4467 return FLAC__STREAM_ENCODER_SEEK_STATUS_OK; 4468 } 4469 4470 FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) 4471 { 4472 FLAC__off_t offset; 4473 4474 (void)client_data; 4475 4476 offset = ftello(encoder->private_->file); 4477 4478 if(offset < 0) { 4479 return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR; 4480 } 4481 else { 4482 *absolute_byte_offset = (FLAC__uint64)offset; 4483 return FLAC__STREAM_ENCODER_TELL_STATUS_OK; 4484 } 4485 } 4486 4487 #ifdef FLAC__VALGRIND_TESTING 4488 static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) 4489 { 4490 size_t ret = fwrite(ptr, size, nmemb, stream); 4491 if(!ferror(stream)) 4492 fflush(stream); 4493 return ret; 4494 } 4495 #else 4496 #define local__fwrite fwrite 4497 #endif 4498 4499 FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data) 4500 { 4501 (void)client_data, (void)current_frame; 4502 4503 if(local__fwrite(buffer, sizeof(FLAC__byte), bytes, encoder->private_->file) == bytes) { 4504 FLAC__bool call_it = 0 != encoder->private_->progress_callback && ( 4505 #if FLAC__HAS_OGG 4506 /* We would like to be able to use 'samples > 0' in the 4507 * clause here but currently because of the nature of our 4508 * Ogg writing implementation, 'samples' is always 0 (see 4509 * ogg_encoder_aspect.c). The downside is extra progress 4510 * callbacks. 4511 */ 4512 encoder->private_->is_ogg? true : 4513 #endif 4514 samples > 0 4515 ); 4516 if(call_it) { 4517 /* NOTE: We have to add +bytes, +samples, and +1 to the stats 4518 * because at this point in the callback chain, the stats 4519 * have not been updated. Only after we return and control 4520 * gets back to write_frame_() are the stats updated 4521 */ 4522 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); 4523 } 4524 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 4525 } 4526 else 4527 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 4528 } 4529 4530 /* 4531 * This will forcibly set stdout to binary mode (for OSes that require it) 4532 */ 4533 FILE *get_binary_stdout_(void) 4534 { 4535 /* if something breaks here it is probably due to the presence or 4536 * absence of an underscore before the identifiers 'setmode', 4537 * 'fileno', and/or 'O_BINARY'; check your system header files. 4538 */ 4539 #if defined _MSC_VER || defined __MINGW32__ 4540 _setmode(_fileno(stdout), _O_BINARY); 4541 #elif defined __CYGWIN__ 4542 /* almost certainly not needed for any modern Cygwin, but let's be safe... */ 4543 setmode(_fileno(stdout), _O_BINARY); 4544 #elif defined __EMX__ 4545 setmode(fileno(stdout), O_BINARY); 4546 #endif 4547 4548 return stdout; 4549 } 4550
