91  * encoded with) in this encoder is very good, almost always yielding
96  * parameter estimation in this encoder is very good, almost always
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);
157 static void update_ogg_metadata_(FLAC__StreamEncoder *encoder);
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);
163 	FLAC__StreamEncoder *encoder,
177 	FLAC__StreamEncoder *encoder,
185 	FLAC__StreamEncoder *encoder,
193 	FLAC__StreamEncoder *encoder,
213 	FLAC__StreamEncoder *encoder,
235 	FLAC__StreamEncoder *encoder, 
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);
361 	unsigned loose_mid_side_stereo_frames;            /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
365 	FLAC__StreamMetadata_SeekTable *seek_table;       /* pointer into encoder->protected_->metadata_ where the seek table is */
524 	FLAC__StreamEncoder *encoder;
529 	encoder = (FLAC__StreamEncoder*)calloc(1, sizeof(FLAC__StreamEncoder));
530 	if(encoder == 0) {
534 	encoder->protected_ = (FLAC__StreamEncoderProtected*)calloc(1, sizeof(FLAC__StreamEncoderProtected));
535 	if(encoder->protected_ == 0) {
536 		free(encoder);
540 	encoder->private_ = (FLAC__StreamEncoderPrivate*)calloc(1, sizeof(FLAC__StreamEncoderPrivate));
541 	if(encoder->private_ == 0) {
542 		free(encoder->protected_);
543 		free(encoder);
547 	encoder->private_->frame = FLAC__bitwriter_new();
548 	if(encoder->private_->frame == 0) {
549 		free(encoder->private_);
550 		free(encoder->protected_);
551 		free(encoder);
555 	encoder->private_->file = 0;
557 	set_defaults_(encoder);
559 	encoder->private_->is_being_deleted = false;
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];
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];
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];
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];
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]);
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]);
587 		FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]);
589 	encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
591 	return encoder;
594 FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
598 	FLAC__ASSERT(0 != encoder);
599 	FLAC__ASSERT(0 != encoder->protected_);
600 	FLAC__ASSERT(0 != encoder->private_);
601 	FLAC__ASSERT(0 != encoder->private_->frame);
603 	encoder->private_->is_being_deleted = true;
605 	(void)FLAC__stream_encoder_finish(encoder);
607 	if(0 != encoder->private_->verify.decoder)
608 		FLAC__stream_decoder_delete(encoder->private_->verify.decoder);
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]);
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]);
619 		FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]);
621 	FLAC__bitwriter_delete(encoder->private_->frame);
622 	free(encoder->private_);
623 	free(encoder->protected_);
624 	free(encoder);
634 	FLAC__StreamEncoder *encoder,
647 	FLAC__ASSERT(0 != encoder);
649 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
660 	if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
663 	if(encoder->protected_->channels != 2) {
664 		encoder->protected_->do_mid_side_stereo = false;
665 		encoder->protected_->loose_mid_side_stereo = false;
667 	else if(!encoder->protected_->do_mid_side_stereo)
668 		encoder->protected_->loose_mid_side_stereo = false;
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 */
673 	if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE)
676 	if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
679 	if(encoder->protected_->blocksize == 0) {
680 		if(encoder->protected_->max_lpc_order == 0)
681 			encoder->protected_->blocksize = 1152;
683 			encoder->protected_->blocksize = 4096;
686 	if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
689 	if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER)
692 	if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order)
695 	if(encoder->protected_->qlp_coeff_precision == 0) {
696 		if(encoder->protected_->bits_per_sample < 16) {
699 			encoder->protected_->qlp_coeff_precision = max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2);
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;
715 				encoder->protected_->qlp_coeff_precision = 13;
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;
723 				encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
725 		FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION);
727 	else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION)
730 	if(encoder->protected_->streamable_subset) {
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
746 		if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate))
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
756 		if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER)
759 			encoder->protected_->sample_rate <= 48000 &&
761 				encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ ||
762 				encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ
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;
776 	if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) {
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];
782 					encoder->protected_->metadata[i] = encoder->protected_->metadata[i-1];
783 				encoder->protected_->metadata[0] = vc;
790 	if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) {
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;
801 	if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0)
807 	for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
808 		const FLAC__StreamMetadata *m = encoder->protected_->metadata[i];
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;
857 		encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0;
861 		encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0;
863 		encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0;
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;
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;
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;
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;
884 	encoder->private_->loose_mid_side_stereo_frames = (unsigned)((FLAC__double)encoder->protected_->sample_rate * 0.4 / (FLAC__double)encoder->protected_->blocksize + 0.5);
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);
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;
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 */
907 	FLAC__cpu_info(&encoder->private_->cpuinfo);
910 	encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
912 	encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor;
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;
921 	if(encoder->private_->cpuinfo.use_asm) {
923 		FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32);
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;
933 				encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
935 		else if(encoder->private_->cpuinfo.data.ia32._3dnow)
936 			encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_3dnow;
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;
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;
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;
955 	if(encoder->private_->use_wide_by_block) {
956 		encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_wide;
960 	encoder->protected_->state = FLAC__STREAM_ENCODER_OK;
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;
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;
977 	if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
982 	if(!FLAC__bitwriter_init(encoder->private_->frame)) {
983 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
990 	if(encoder->protected_->verify) {
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;
1002 		encoder->private_->verify.input_fifo.tail = 0;
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;
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;
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;
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;
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;
1044 	if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
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;
1072 	if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1081 	encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1;
1083 	encoder->private_->streaminfo.data.stream_info.total_samples = 0;
1098 		vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0);
1104 		if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame)) {
1105 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1108 		if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
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;
1123 		if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
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;
1135 	if(encoder->protected_->verify)
1136 		encoder->private_->verify.state_hint = ENCODER_IN_AUDIO;
1142 	FLAC__StreamEncoder *encoder,
1151 		encoder,
1163 	FLAC__StreamEncoder *encoder,
1173 		encoder,
1185 	FLAC__StreamEncoder *encoder,
1194 	FLAC__ASSERT(0 != encoder);
1197 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1202 		encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1214 	encoder->private_->file = file;
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;
1222 		encoder,
1223 		encoder->private_->file == stdout? 0 : is_ogg? file_read_callback_ : 0,
1225 		encoder->private_->file == stdout? 0 : file_seek_callback_,
1226 		encoder->private_->file == stdout? 0 : file_tell_callback_,
1237 		unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
1240 		encoder->private_->total_frames_estimate = (unsigned)((FLAC__stream_encoder_get_total_samples_estimate(encoder) + blocksize - 1) / blocksize);
1247 	FLAC__StreamEncoder *encoder,
1253 	return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/false);
1257 	FLAC__StreamEncoder *encoder,
1263 	return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/true);
1267 	FLAC__StreamEncoder *encoder,
1276 	FLAC__ASSERT(0 != encoder);
1283 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1289 		encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1293 	return init_FILE_internal_(encoder, file, progress_callback, client_data, is_ogg);
1297 	FLAC__StreamEncoder *encoder,
1303 	return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/false);
1307 	FLAC__StreamEncoder *encoder,
1313 	return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/true);
1316 FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
1320 	FLAC__ASSERT(0 != encoder);
1321 	FLAC__ASSERT(0 != encoder->private_);
1322 	FLAC__ASSERT(0 != encoder->protected_);
1324 	if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED)
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))
1336 	if(encoder->protected_->do_md5)
1337 		FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context);
1339 	if(!encoder->private_->is_being_deleted) {
1340 		if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) {
1341 			if(encoder->private_->seek_callback) {
1343 				if(encoder->private_->is_ogg)
1344 					update_ogg_metadata_(encoder);
1347 				update_metadata_(encoder);
1350 				if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK)
1353 			if(encoder->private_->metadata_callback)
1354 				encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data);
1357 		if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) {
1359 				encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
1364 	if(0 != encoder->private_->file) {
1365 		if(encoder->private_->file != stdout)
1366 			fclose(encoder->private_->file);
1367 		encoder->private_->file = 0;
1371 	if(encoder->private_->is_ogg)
1372 		FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect);
1375 	free_(encoder);
1376 	set_defaults_(encoder);
1379 		encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
1384 FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long value)
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)
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);
1401 FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1409 	encoder->protected_->verify = value;
1414 FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value)
1416 	FLAC__ASSERT(0 != encoder);
1417 	FLAC__ASSERT(0 != encoder->private_);
1418 	FLAC__ASSERT(0 != encoder->protected_);
1419 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1421 	encoder->protected_->streamable_subset = value;
1425 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value)
1427 	FLAC__ASSERT(0 != encoder);
1428 	FLAC__ASSERT(0 != encoder->private_);
1429 	FLAC__ASSERT(0 != encoder->protected_);
1430 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1432 	encoder->protected_->do_md5 = value;
1436 FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
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)
1443 	encoder->protected_->channels = value;
1447 FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
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)
1454 	encoder->protected_->bits_per_sample = value;
1458 FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
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)
1465 	encoder->protected_->sample_rate = value;
1469 FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value)
1472 	FLAC__ASSERT(0 != encoder);
1473 	FLAC__ASSERT(0 != encoder->private_);
1474 	FLAC__ASSERT(0 != encoder->protected_);
1475 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
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);
1484 	ok &= FLAC__stream_encoder_set_apodization                 (encoder, compression_levels_[value].apodization);
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;
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);
1503 FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
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)
1510 	encoder->protected_->blocksize = value;
1514 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1521 	encoder->protected_->do_mid_side_stereo = value;
1525 FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1532 	encoder->protected_->loose_mid_side_stereo = value;
1537 FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *encoder, const char *specification)
1539 	FLAC__ASSERT(0 != encoder);
1540 	FLAC__ASSERT(0 != encoder->private_);
1541 	FLAC__ASSERT(0 != encoder->protected_);
1543 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1548 	encoder->protected_->num_apodizations = 0;
1553 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT;
1555 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN;
1557 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN;
1559 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE;
1561 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES;
1563 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP;
1567 				encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev;
1568 				encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS;
1572 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING;
1574 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN;
1576 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL;
1578 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL;
1580 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE;
1582 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE;
1586 				encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p;
1587 				encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1591 			encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH;
1592 		if (encoder->protected_->num_apodizations == 32)
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;
1608 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value)
1610 	FLAC__ASSERT(0 != encoder);
1611 	FLAC__ASSERT(0 != encoder->private_);
1612 	FLAC__ASSERT(0 != encoder->protected_);
1613 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1615 	encoder->protected_->max_lpc_order = value;
1619 FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value)
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)
1626 	encoder->protected_->qlp_coeff_precision = value;
1630 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1637 	encoder->protected_->do_qlp_coeff_prec_search = value;
1641 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1650 	encoder->protected_->do_escape_coding = value;
1657 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1659 	FLAC__ASSERT(0 != encoder);
1660 	FLAC__ASSERT(0 != encoder->private_);
1661 	FLAC__ASSERT(0 != encoder->protected_);
1662 	if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1664 	encoder->protected_->do_exhaustive_model_search = value;
1668 FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
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)
1675 	encoder->protected_->min_residual_partition_order = value;
1679 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
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)
1686 	encoder->protected_->max_residual_partition_order = value;
1690 FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value)
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)
1699 	encoder->protected_->rice_parameter_search_dist = value;
1706 FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value)
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)
1713 	encoder->protected_->total_samples_estimate = value;
1717 FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
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)
1729 	if(encoder->protected_->metadata) {
1730 		free(encoder->protected_->metadata);
1731 		encoder->protected_->metadata = 0;
1732 		encoder->protected_->num_metadata_blocks = 0;
1739 		encoder->protected_->metadata = m;
1740 		encoder->protected_->num_metadata_blocks = num_blocks;
1743 	if(!FLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks))
1753 FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1760 	encoder->private_->disable_constant_subframes = value;
1764 FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1771 	encoder->private_->disable_fixed_subframes = value;
1775 FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
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)
1782 	encoder->private_->disable_verbatim_subframes = value;
1786 FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
1788 	FLAC__ASSERT(0 != encoder);
1789 	FLAC__ASSERT(0 != encoder->private_);
1790 	FLAC__ASSERT(0 != encoder->protected_);
1791 	return encoder->protected_->state;
1794 FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder)
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);
1805 FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder)
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];
1813 		return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder);
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)
1818 	FLAC__ASSERT(0 != encoder);
1819 	FLAC__ASSERT(0 != encoder->private_);
1820 	FLAC__ASSERT(0 != encoder->protected_);
1822 		*absolute_sample = encoder->private_->verify.error_stats.absolute_sample;
1824 		*frame_number = encoder->private_->verify.error_stats.frame_number;
1826 		*channel = encoder->private_->verify.error_stats.channel;
1828 		*sample = encoder->private_->verify.error_stats.sample;
1830 		*expected = encoder->private_->verify.error_stats.expected;
1832 		*got = encoder->private_->verify.error_stats.got;
1835 FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder)
1837 	FLAC__ASSERT(0 != encoder);
1838 	FLAC__ASSERT(0 != encoder->private_);
1839 	FLAC__ASSERT(0 != encoder->protected_);
1840 	return encoder->protected_->verify;
1843 FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
1845 	FLAC__ASSERT(0 != encoder);
1846 	FLAC__ASSERT(0 != encoder->private_);
1847 	FLAC__ASSERT(0 != encoder->protected_);
1848 	return encoder->protected_->streamable_subset;
1851 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder *encoder)
1853 	FLAC__ASSERT(0 != encoder);
1854 	FLAC__ASSERT(0 != encoder->private_);
1855 	FLAC__ASSERT(0 != encoder->protected_);
1856 	return encoder->protected_->do_md5;
1859 FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
1861 	FLAC__ASSERT(0 != encoder);
1862 	FLAC__ASSERT(0 != encoder->private_);
1863 	FLAC__ASSERT(0 != encoder->protected_);
1864 	return encoder->protected_->channels;
1867 FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
1869 	FLAC__ASSERT(0 != encoder);
1870 	FLAC__ASSERT(0 != encoder->private_);
1871 	FLAC__ASSERT(0 != encoder->protected_);
1872 	return encoder->protected_->bits_per_sample;
1875 FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
1877 	FLAC__ASSERT(0 != encoder);
1878 	FLAC__ASSERT(0 != encoder->private_);
1879 	FLAC__ASSERT(0 != encoder->protected_);
1880 	return encoder->protected_->sample_rate;
1883 FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
1885 	FLAC__ASSERT(0 != encoder);
1886 	FLAC__ASSERT(0 != encoder->private_);
1887 	FLAC__ASSERT(0 != encoder->protected_);
1888 	return encoder->protected_->blocksize;
1891 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
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;
1899 FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
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;
1907 FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
1909 	FLAC__ASSERT(0 != encoder);
1910 	FLAC__ASSERT(0 != encoder->private_);
1911 	FLAC__ASSERT(0 != encoder->protected_);
1912 	return encoder->protected_->max_lpc_order;
1915 FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
1917 	FLAC__ASSERT(0 != encoder);
1918 	FLAC__ASSERT(0 != encoder->private_);
1919 	FLAC__ASSERT(0 != encoder->protected_);
1920 	return encoder->protected_->qlp_coeff_precision;
1923 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
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;
1931 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
1933 	FLAC__ASSERT(0 != encoder);
1934 	FLAC__ASSERT(0 != encoder->private_);
1935 	FLAC__ASSERT(0 != encoder->protected_);
1936 	return encoder->protected_->do_escape_coding;
1939 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
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;
1947 FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
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;
1955 FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
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;
1963 FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
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;
1971 FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
1973 	FLAC__ASSERT(0 != encoder);
1974 	FLAC__ASSERT(0 != encoder->private_);
1975 	FLAC__ASSERT(0 != encoder->protected_);
1976 	return encoder->protected_->total_samples_estimate;
1979 FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
1982 	const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
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);
1990 		const unsigned n = min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j);
1992 		if(encoder->protected_->verify)
1993 			append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, n);
1996 			memcpy(&encoder->private_->integer_signal[channel][encoder->private_->current_sample_number], &buffer[channel][j], sizeof(buffer[channel][0]) * n);
1998 		if(encoder->protected_->do_mid_side_stereo) {
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' ! */
2009 		encoder->private_->current_sample_number += n;
2012 		if(encoder->private_->current_sample_number > blocksize) {
2013 			FLAC__ASSERT(encoder->private_->current_sample_number == blocksize+OVERREAD_);
2015 			if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
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];
2024 			encoder->private_->current_sample_number = 1;
2031 FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
2035 	const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
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);
2047 	if(encoder->protected_->do_mid_side_stereo && channels == 2) {
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));
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++];
2059 				encoder->private_->integer_signal[1][i] = x;
2063 				encoder->private_->integer_signal_mid_side[1][i] = side;
2064 				encoder->private_->integer_signal_mid_side[0][i] = mid;
2066 			encoder->private_->current_sample_number = i;
2069 				if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
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;
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));
2091 			for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2093 					encoder->private_->integer_signal[channel][i] = buffer[k++];
2095 			encoder->private_->current_sample_number = i;
2098 				if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2104 					encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
2105 				encoder->private_->current_sample_number = 1;
2119 void set_defaults_(FLAC__StreamEncoder *encoder)
2121 	FLAC__ASSERT(0 != encoder);
2124 	encoder->protected_->verify = true;
2126 	encoder->protected_->verify = false;
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;
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;
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;
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;
2158 	encoder->private_->is_ogg = false;
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;
2169 	FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect);
2173 void free_(FLAC__StreamEncoder *encoder)
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;
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;
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;
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;
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;
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;
2214 	if(0 != encoder->private_->windowed_signal_unaligned) {
2215 		free(encoder->private_->windowed_signal_unaligned);
2216 		encoder->private_->windowed_signal_unaligned = 0;
2219 	for(channel = 0; channel < encoder->protected_->channels; channel++) {
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;
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;
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;
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;
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;
2251 	FLAC__bitwriter_free(encoder->private_->frame);
2254 FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize)
2260 	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2261 	FLAC__ASSERT(encoder->private_->current_sample_number == 0);
2264 	if(new_blocksize <= encoder->private_->input_capacity)
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;
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]);
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;
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]);
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);
2304 	for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
2306 			ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][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]);
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);
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) {
2326 					FLAC__window_bartlett(encoder->private_->window[i], new_blocksize);
2329 					FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize);
2332 					FLAC__window_blackman(encoder->private_->window[i], new_blocksize);
2335 					FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize);
2338 					FLAC__window_connes(encoder->private_->window[i], new_blocksize);
2341 					FLAC__window_flattop(encoder->private_->window[i], new_blocksize);
2344 					FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev);
2347 					FLAC__window_hamming(encoder->private_->window[i], new_blocksize);
2350 					FLAC__window_hann(encoder->private_->window[i], new_blocksize);
2353 					FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize);
2356 					FLAC__window_nuttall(encoder->private_->window[i], new_blocksize);
2359 					FLAC__window_rectangle(encoder->private_->window[i], new_blocksize);
2362 					FLAC__window_triangle(encoder->private_->window[i], new_blocksize);
2365 					FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p);
2368 					FLAC__window_welch(encoder->private_->window[i], new_blocksize);
2373 					FLAC__window_hann(encoder->private_->window[i], new_blocksize);
2381 		encoder->private_->input_capacity = new_blocksize;
2383 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2388 FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block)
2393 	FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
2395 	if(!FLAC__bitwriter_get_buffer(encoder->private_->frame, &buffer, &bytes)) {
2396 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
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;
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;
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;
2424 	FLAC__bitwriter_release_buffer(encoder->private_->frame);
2425 	FLAC__bitwriter_clear(encoder->private_->frame);
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);
2435 FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block)
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;
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;
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;
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;
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++;
2486 				encoder->private_->first_seekpoint_to_check++;
2492 	if(encoder->private_->is_ogg) {
2494 			&encoder->protected_->ogg_encoder_aspect,
2498 			encoder->private_->current_frame_number,
2500 			(FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback,
2501 			encoder,
2502 			encoder->private_->client_data
2507 	status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data);
2510 		encoder->private_->bytes_written += bytes;
2511 		encoder->private_->samples_written += samples;
2513 		 * when the encoder goes back to write metadata, 'current_frame'
2516 		encoder->private_->frames_written = max(encoder->private_->frames_written, encoder->private_->current_frame_number+1);
2519 		encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2525 void update_metadata_(const FLAC__StreamEncoder *encoder)
2528 	const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
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) {
2561 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
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;
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) {
2594 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
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;
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) {
2622 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
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;
2634 	if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
2637 		FLAC__format_seektable_sort(encoder->private_->seek_table);
2639 		FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
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) {
2643 				encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2647 		for(i = 0; i < encoder->private_->seek_table->num_points; i++) {
2650 			xx = encoder->private_->seek_table->points[i].sample_number;
2659 			xx = encoder->private_->seek_table->points[i].stream_offset;
2668 			x = encoder->private_->seek_table->points[i].frame_samples;
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;
2681 void update_ogg_metadata_(FLAC__StreamEncoder *encoder)
2693 	const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
2700 	FLAC__ASSERT(0 != encoder->private_->seek_callback);
2705 	if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED)
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)) {
2741 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2767 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2793 			encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
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)) {
2814 	if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
2818 		FLAC__format_seektable_sort(encoder->private_->seek_table);
2820 		FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
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)) {
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;
2834 		for(i = 0, p = page.body + FLAC__STREAM_METADATA_HEADER_LENGTH; i < encoder->private_->seek_table->num_points; i++, p += 18) {
2837 			xx = encoder->private_->seek_table->points[i].sample_number;
2846 			xx = encoder->private_->seek_table->points[i].stream_offset;
2855 			x = encoder->private_->seek_table->points[i].frame_samples;
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)) {
2870 FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block)
2873 	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
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;
2886 	if(!process_subframes_(encoder, is_fractional_block)) {
2894 	if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder->private_->frame)) {
2895 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2902 	FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
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)
2907 		encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2914 	if(!write_bitbuffer_(encoder, encoder->protected_->blocksize, is_last_block)) {
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;
2929 FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block)
2932 	unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order;
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);
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;
2956 	frame_header.number.frame_number = encoder->private_->current_frame_number;
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) {
2968 				do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_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;
2995 		FLAC__ASSERT(encoder->protected_->channels == 2);
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);
3007 		for(channel = 0; channel < encoder->protected_->channels; channel++) {
3010 					encoder,
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
3031 		FLAC__ASSERT(encoder->protected_->channels == 2);
3036 					encoder,
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
3061 		FLAC__ASSERT(encoder->protected_->channels == 2);
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);
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];
3095 		if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
3096 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
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]];
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]];
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]];
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]];
3123 				left_bps  = encoder->private_->subframe_bps         [0];
3124 				right_bps = encoder->private_->subframe_bps         [1];
3127 				left_bps  = encoder->private_->subframe_bps         [0];
3128 				right_bps = encoder->private_->subframe_bps_mid_side[1];
3131 				left_bps  = encoder->private_->subframe_bps_mid_side[1];
3132 				right_bps = encoder->private_->subframe_bps         [1];
3135 				left_bps  = encoder->private_->subframe_bps_mid_side[0];
3136 				right_bps = encoder->private_->subframe_bps_mid_side[1];
3143 		if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , encoder->private_->frame))
3145 		if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, encoder->private_->frame))
3149 		if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
3150 			encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
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)) {
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;
3168 	encoder->private_->last_channel_assignment = frame_header.channel_assignment;
3174 	FLAC__StreamEncoder *encoder,
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 */
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;
3210 	if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER)
3213 		_best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
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);
3220 			!encoder->private_->disable_constant_subframes &&
3238 			_candidate_bits = evaluate_constant_subframe_(encoder, integer_signal[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]);
3245 			if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) {
3247 				if(encoder->protected_->do_exhaustive_model_search) {
3275 							encoder,
3278 							encoder->private_->abs_residual_partition_sums,
3279 							encoder->private_->raw_bits_per_partition,
3287 							encoder->protected_->do_escape_coding,
3288 							encoder->protected_->rice_parameter_search_dist,
3301 			if(encoder->protected_->max_lpc_order > 0) {
3302 				if(encoder->protected_->max_lpc_order >= frame_header->blocksize)
3305 					max_lpc_order = encoder->protected_->max_lpc_order;
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);
3313 							FLAC__lpc_compute_lp_coefficients(autoc, &max_lpc_order, encoder->private_->lp_coeff, lpc_error);
3314 							if(encoder->protected_->do_exhaustive_model_search) {
3324 											encoder->protected_->do_qlp_coeff_prec_search?
3326 												encoder->protected_->qlp_coeff_precision
3345 								if(encoder->protected_->do_qlp_coeff_prec_search) {
3356 									min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision;
3361 											encoder,
3364 											encoder->private_->abs_residual_partition_sums,
3365 											encoder->private_->raw_bits_per_partition,
3366 											encoder->private_->lp_coeff[lpc_order-1],
3375 											encoder->protected_->do_escape_coding,
3376 											encoder->protected_->rice_parameter_search_dist,
3399 		_best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
3409 	FLAC__StreamEncoder *encoder,
3419 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3425 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3431 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3437 				encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3451 	FLAC__StreamEncoder *encoder,
3468 	ret = add_subframe_(encoder, blocksize, subframe_bps, subframe, frame);
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);
3480 	FLAC__StreamEncoder *encoder,
3494 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3496 	(void)encoder, (void)blocksize;
3503 	FLAC__StreamEncoder *encoder,
3534 			encoder->private_,
3557 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3565 	FLAC__StreamEncoder *encoder,
3603 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3605 			encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3607 		encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3617 			encoder->private_,
3643 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3651 	FLAC__StreamEncoder *encoder,
3667 	spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3669 	(void)encoder;
4172 	FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
4173 	const size_t encoded_bytes = encoder->private_->verify.output.bytes;
4176 	if(encoder->private_->verify.needs_magic_hack) {
4180 		encoder->private_->verify.needs_magic_hack = false;
4193 		memcpy(buffer, encoder->private_->verify.output.data, *bytes);
4194 		encoder->private_->verify.output.data += *bytes;
4195 		encoder->private_->verify.output.bytes -= *bytes;
4203 	FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data;
4212 		if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) {
4217 				if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) {
4219 					expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i];
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;
4237 	encoder->private_->verify.input_fifo.tail -= blocksize;
4238 	FLAC__ASSERT(encoder->private_->verify.input_fifo.tail <= OVERREAD_);
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]));
4251 	FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
4253 	encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
4256 FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
4260 	*bytes = fread(buffer, 1, *bytes, encoder->private_->file);
4262 		if (feof(encoder->private_->file))
4264 		else if (ferror(encoder->private_->file))
4270 FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
4274 	if(fseeko(encoder->private_->file, (off_t)absolute_byte_offset, SEEK_SET) < 0)
4280 FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
4286 	offset = ftello(encoder->private_->file);
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)
4313 	if(local__fwrite(buffer, sizeof(FLAC__byte), bytes, encoder->private_->file) == bytes) {
4314 		FLAC__bool call_it = 0 != encoder->private_->progress_callback && (
4322 			encoder->private_->is_ogg? true :
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);

Indexes created Sun Jun 23 19:15:37 MDT 2024