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