Lines Matching refs:encoder
73 * encoded with) in this encoder is very good, almost always yielding
78 * parameter estimation in this encoder is very good, almost always
134 static void set_defaults_(FLAC__StreamEncoder *encoder);
135 static void free_(FLAC__StreamEncoder *encoder);
136 static FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize);
137 static FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block);
138 static FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block);
139 static void update_metadata_(const FLAC__StreamEncoder *encoder);
141 static void update_ogg_metadata_(FLAC__StreamEncoder *encoder);
143 static FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block);
144 static FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block);
147 FLAC__StreamEncoder *encoder,
161 FLAC__StreamEncoder *encoder,
169 FLAC__StreamEncoder *encoder,
177 FLAC__StreamEncoder *encoder,
197 FLAC__StreamEncoder *encoder,
219 FLAC__StreamEncoder *encoder,
303 static FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
304 static FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data);
305 static FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
306 static FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data);
345 unsigned loose_mid_side_stereo_frames; /* rounded number of frames the encoder will use before trying both independent and mid/side frames again */
349 FLAC__StreamMetadata_SeekTable *seek_table; /* pointer into encoder->protected_->metadata_ where the seek table is */
506 FLAC__StreamEncoder *encoder;
511 encoder = calloc(1, sizeof(FLAC__StreamEncoder));
512 if(encoder == 0) {
516 encoder->protected_ = calloc(1, sizeof(FLAC__StreamEncoderProtected));
517 if(encoder->protected_ == 0) {
518 free(encoder);
522 encoder->private_ = calloc(1, sizeof(FLAC__StreamEncoderPrivate));
523 if(encoder->private_ == 0) {
524 free(encoder->protected_);
525 free(encoder);
529 encoder->private_->frame = FLAC__bitwriter_new();
530 if(encoder->private_->frame == 0) {
531 free(encoder->private_);
532 free(encoder->protected_);
533 free(encoder);
537 encoder->private_->file = 0;
539 set_defaults_(encoder);
541 encoder->private_->is_being_deleted = false;
544 encoder->private_->subframe_workspace_ptr[i][0] = &encoder->private_->subframe_workspace[i][0];
545 encoder->private_->subframe_workspace_ptr[i][1] = &encoder->private_->subframe_workspace[i][1];
548 encoder->private_->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->subframe_workspace_mid_side[i][0];
549 encoder->private_->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->subframe_workspace_mid_side[i][1];
552 encoder->private_->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->partitioned_rice_contents_workspace[i][0];
553 encoder->private_->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->partitioned_rice_contents_workspace[i][1];
556 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][0] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0];
557 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[i][1] = &encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1];
561 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
562 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
565 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
566 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
569 FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->partitioned_rice_contents_extra[i]);
571 encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
573 return encoder;
576 FLAC_API void FLAC__stream_encoder_delete(FLAC__StreamEncoder *encoder)
580 if (encoder == NULL)
583 FLAC__ASSERT(0 != encoder->protected_);
584 FLAC__ASSERT(0 != encoder->private_);
585 FLAC__ASSERT(0 != encoder->private_->frame);
587 encoder->private_->is_being_deleted = true;
589 (void)FLAC__stream_encoder_finish(encoder);
591 if(0 != encoder->private_->verify.decoder)
592 FLAC__stream_decoder_delete(encoder->private_->verify.decoder);
595 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][0]);
596 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace[i][1]);
599 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][0]);
600 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_workspace_mid_side[i][1]);
603 FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->partitioned_rice_contents_extra[i]);
605 FLAC__bitwriter_delete(encoder->private_->frame);
606 free(encoder->private_);
607 free(encoder->protected_);
608 free(encoder);
618 FLAC__StreamEncoder *encoder,
631 FLAC__ASSERT(0 != encoder);
633 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
642 if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS)
645 if(encoder->protected_->channels != 2) {
646 encoder->protected_->do_mid_side_stereo = false;
647 encoder->protected_->loose_mid_side_stereo = false;
649 else if(!encoder->protected_->do_mid_side_stereo)
650 encoder->protected_->loose_mid_side_stereo = false;
652 if(encoder->protected_->bits_per_sample >= 32)
653 encoder->protected_->do_mid_side_stereo = false; /* since we currenty do 32-bit math, the side channel would have 33 bps and overflow */
655 if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE)
658 if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate))
661 if(encoder->protected_->blocksize == 0) {
662 if(encoder->protected_->max_lpc_order == 0)
663 encoder->protected_->blocksize = 1152;
665 encoder->protected_->blocksize = 4096;
668 if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE)
671 if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER)
674 if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order)
677 if(encoder->protected_->qlp_coeff_precision == 0) {
678 if(encoder->protected_->bits_per_sample < 16) {
681 encoder->protected_->qlp_coeff_precision = flac_max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2);
683 else if(encoder->protected_->bits_per_sample == 16) {
684 if(encoder->protected_->blocksize <= 192)
685 encoder->protected_->qlp_coeff_precision = 7;
686 else if(encoder->protected_->blocksize <= 384)
687 encoder->protected_->qlp_coeff_precision = 8;
688 else if(encoder->protected_->blocksize <= 576)
689 encoder->protected_->qlp_coeff_precision = 9;
690 else if(encoder->protected_->blocksize <= 1152)
691 encoder->protected_->qlp_coeff_precision = 10;
692 else if(encoder->protected_->blocksize <= 2304)
693 encoder->protected_->qlp_coeff_precision = 11;
694 else if(encoder->protected_->blocksize <= 4608)
695 encoder->protected_->qlp_coeff_precision = 12;
697 encoder->protected_->qlp_coeff_precision = 13;
700 if(encoder->protected_->blocksize <= 384)
701 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2;
702 else if(encoder->protected_->blocksize <= 1152)
703 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1;
705 encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION;
707 FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION);
709 else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION)
712 if(encoder->protected_->streamable_subset) {
713 if(!FLAC__format_blocksize_is_subset(encoder->protected_->blocksize, encoder->protected_->sample_rate))
715 if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate))
718 encoder->protected_->bits_per_sample != 8 &&
719 encoder->protected_->bits_per_sample != 12 &&
720 encoder->protected_->bits_per_sample != 16 &&
721 encoder->protected_->bits_per_sample != 20 &&
722 encoder->protected_->bits_per_sample != 24
725 if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER)
728 encoder->protected_->sample_rate <= 48000 &&
730 encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ ||
731 encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ
738 if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN))
739 encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1;
740 if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order)
741 encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order;
745 if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) {
747 for(i1 = 1; i1 < encoder->protected_->num_metadata_blocks; i1++) {
748 if(0 != encoder->protected_->metadata[i1] && encoder->protected_->metadata[i1]->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
749 FLAC__StreamMetadata *vc = encoder
751 encoder->protected_->metadata[i1] = encoder->protected_->metadata[i1-1];
752 encoder->protected_->metadata[0] = vc;
759 if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) {
761 for(i2 = 0; i2 < encoder->protected_->num_metadata_blocks; i2++) {
762 if(0 != encoder->protected_->metadata[i2] && encoder->protected_->metadata[i2]->type == FLAC__METADATA_TYPE_SEEKTABLE) {
763 encoder->private_->seek_table = &encoder->protected_->metadata[i2]->data.seek_table;
770 if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0)
776 for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
777 const FLAC__StreamMetadata *m = encoder->protected_->metadata[i];
822 encoder->private_->input_capacity = 0;
823 for(i = 0; i < encoder->protected_->channels; i++) {
824 encoder->private_->integer_signal_unaligned[i] = encoder->private_->integer_signal[i] = 0;
826 encoder->private_->real_signal_unaligned[i] = encoder->private_->real_signal[i] = 0;
830 encoder->private_->integer_signal_mid_side_unaligned[i] = encoder->private_->integer_signal_mid_side[i] = 0;
832 encoder->private_->real_signal_mid_side_unaligned[i] = encoder->private_->real_signal_mid_side[i] = 0;
836 for(i = 0; i < encoder->protected_->num_apodizations; i++)
837 encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0;
838 encoder->private_->windowed_signal_unaligned = encoder->private_->windowed_signal = 0;
840 for(i = 0; i < encoder->protected_->channels; i++) {
841 encoder->private_->residual_workspace_unaligned[i][0] = encoder->private_->residual_workspace[i][0] = 0;
842 encoder->private_->residual_workspace_unaligned[i][1] = encoder->private_->residual_workspace[i][1] = 0;
843 encoder->private_->best_subframe[i] = 0;
846 encoder->private_->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->residual_workspace_mid_side[i][0] = 0;
847 encoder->private_->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->residual_workspace_mid_side[i][1] = 0;
848 encoder->private_->best_subframe_mid_side[i] = 0;
850 encoder->private_->abs_residual_partition_sums_unaligned = encoder->private_->abs_residual_partition_sums = 0;
851 encoder->private_->raw_bits_per_partition_unaligned = encoder->private_->raw_bits_per_partition = 0;
853 encoder->private_->loose_mid_side_stereo_frames = (unsigned)((double)encoder->protected_->sample_rate * 0.4 / (double)encoder->protected_->blocksize + 0.5);
859 FLAC__ASSERT(encoder->protected_->sample_rate <= 655350);
860 FLAC__ASSERT(encoder->protected_->blocksize <= 65535);
861 encoder->private_->loose_mid_side_stereo_frames = (unsigned)FLAC__fixedpoint_trunc((((FLAC__uint64)(encoder->protected_->sample_rate) * (FLAC__uint64)(26214)) << 16) / (encoder->protected_->blocksize<<16) + FLAC__FP_ONE_HALF);
863 if(encoder->private_->loose_mid_side_stereo_frames == 0)
864 encoder->private_->loose_mid_side_stereo_frames = 1;
865 encoder->private_->loose_mid_side_stereo_frame_count = 0;
866 encoder->private_->current_sample_number = 0;
867 encoder->private_->current_frame_number = 0;
872 FLAC__cpu_info(&encoder->private_->cpuinfo);
875 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
877 encoder->private_->local_precompute_partition_info_sums = precompute_partition_info_sums_;
878 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor;
879 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide;
881 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients;
882 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide;
883 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients;
888 if(encoder->private_->cpuinfo.use_asm) {
890 FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_IA32);
892 if(encoder->private_->cpuinfo.ia32.sse) {
893 if(encoder->protected_->max_lpc_order < 4)
894 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4_old;
895 else if(encoder->protected_->max_lpc_order < 8)
896 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8_old;
897 else if(encoder->protected_->max_lpc_order < 12)
898 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12_old;
899 else if(encoder->protected_->max_lpc_order < 16)
900 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_16_old;
902 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
905 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_asm_ia32;
907 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_asm_ia32; /* OPT_IA32: was really necessary for GCC < 4.9 */
908 if(encoder->private_->cpuinfo.ia32.mmx) {
909 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
910 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx;
913 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
914 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32;
917 if(encoder->private_->cpuinfo.ia32.mmx && encoder->private_->cpuinfo.ia32.cmov)
918 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_asm_ia32_mmx_cmov;
922 if(encoder->private_->cpuinfo.ia32.sse) {
923 if(encoder->private_->cpuinfo.ia32.sse42 || !encoder->private_->cpuinfo.ia32.intel) { /* use new autocorrelation functions */
924 if(encoder->protected_->max_lpc_order < 4)
925 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_new;
926 else if(encoder->protected_->max_lpc_order < 8)
927 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_new;
928 else if(encoder->protected_->max_lpc_order < 12)
929 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_new;
930 else if(encoder->protected_->max_lpc_order < 16)
931 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_new;
933 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
936 if(encoder->protected_->max_lpc_order < 4)
937 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_old;
938 else if(encoder->protected_->max_lpc_order < 8)
939 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_old;
940 else if(encoder->protected_->max_lpc_order < 12)
941 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_old;
942 else if(encoder->protected_->max_lpc_order < 16)
943 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_old;
945 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation;
951 if(encoder->private_->cpuinfo.ia32.sse2) {
952 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse2;
953 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2;
957 if(encoder->private_->cpuinfo.ia32.sse41) {
958 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41;
959 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_sse41;
963 if(encoder->private_->cpuinfo.ia32.avx2) {
964 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2;
965 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2;
966 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2;
971 if (encoder->private_->cpuinfo.ia32.sse2) {
972 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2;
973 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_sse2;
977 if (encoder->private_->cpuinfo.ia32.ssse3) {
978 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3;
979 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_ssse3;
984 FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64);
987 if(encoder->private_->cpuinfo.x86.sse42 || !encoder->private_->cpuinfo.x86.intel) { /* use new autocorrelation functions */
988 if(encoder->protected_->max_lpc_order < 4)
989 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_new;
990 else if(encoder->protected_->max_lpc_order < 8)
991 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_new;
992 else if(encoder->protected_->max_lpc_order < 12)
993 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_new;
994 else if(encoder->protected_->max_lpc_order < 16)
995 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_new;
998 if(encoder->protected_->max_lpc_order < 4)
999 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_4_old;
1000 else if(encoder->protected_->max_lpc_order < 8)
1001 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_8_old;
1002 else if(encoder->protected_->max_lpc_order < 12)
1003 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_12_old;
1004 else if(encoder->protected_->max_lpc_order < 16)
1005 encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse_lag_16_old;
1010 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2;
1013 if(encoder->private_->cpuinfo.x86.sse41) {
1014 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41;
1018 if(encoder->private_->cpuinfo.x86.avx2) {
1019 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2;
1020 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2;
1021 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2;
1026 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2;
1027 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_sse2;
1030 if (encoder->private_->cpuinfo.x86.ssse3) {
1031 encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3;
1032 encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_ssse3;
1041 if(encoder->private_->cpuinfo.use_asm) {
1044 if(encoder->private_->cpuinfo.ia32.sse2)
1045 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2;
1048 if(encoder->private_->cpuinfo.ia32.ssse3)
1049 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3;
1052 if(encoder->private_->cpuinfo.ia32.avx2)
1053 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2;
1057 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2;
1060 if(encoder->private_->cpuinfo.x86.ssse3)
1061 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3;
1064 if(encoder->private_->cpuinfo.x86.avx2)
1065 encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2;
1072 encoder->protected_->state = FLAC__STREAM_ENCODER_OK;
1075 encoder->private_->is_ogg = is_ogg;
1076 if(is_ogg && !FLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect)) {
1077 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
1082 encoder->private_->read_callback = read_callback;
1083 encoder->private_->write_callback = write_callback;
1084 encoder->private_->seek_callback = seek_callback;
1085 encoder->private_->tell_callback = tell_callback;
1086 encoder->private_->metadata_callback = metadata_callback;
1087 encoder->private_->client_data = client_data;
1089 if(!resize_buffers_(encoder, encoder->protected_->blocksize)) {
1094 if(!FLAC__bitwriter_init(encoder->private_->frame)) {
1095 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1102 if(encoder->protected_->verify) {
1107 encoder->private_->verify.input_fifo.size = encoder->protected_->blocksize+OVERREAD_;
1108 for(i = 0; i < encoder->protected_->channels; i++) {
1109 if(0 == (encoder->private_->verify.input_fifo.data[i] = safe_malloc_mul_2op_p(sizeof(FLAC__int32), /*times*/encoder->private_->verify.input_fifo.size))) {
1110 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
1114 encoder->private_->verify.input_fifo.tail = 0;
1119 if(0 == encoder->private_->verify.decoder) {
1120 encoder->private_->verify.decoder = FLAC__stream_decoder_new();
1121 if(0 == encoder->private_->verify.decoder) {
1122 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
1127 if(FLAC__stream_decoder_init_stream(encoder->private_->verify.decoder, verify_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, verify_write_callback_, verify_metadata_callback_, verify_error_callback_, /*client_data=*/encoder) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
1128 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
1132 encoder->private_->verify.error_stats.absolute_sample = 0;
1133 encoder->private_->verify.error_stats.frame_number = 0;
1134 encoder->private_->verify.error_stats.channel = 0;
1135 encoder->private_->verify.error_stats.sample = 0;
1136 encoder->private_->verify.error_stats.expected = 0;
1137 encoder->private_->verify.error_stats.got = 0;
1143 encoder->private_->first_seekpoint_to_check = 0;
1144 encoder->private_->samples_written = 0;
1145 encoder->protected_->streaminfo_offset = 0;
1146 encoder->protected_->seektable_offset = 0;
1147 encoder->protected_->audio_offset = 0;
1152 if(encoder->protected_->verify)
1153 encoder->private_->verify.state_hint = ENCODER_IN_MAGIC;
1154 if(!FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, FLAC__STREAM_SYNC, FLAC__STREAM_SYNC_LEN)) {
1155 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1158 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1166 if(encoder->protected_->verify)
1167 encoder->private_->verify.state_hint = ENCODER_IN_METADATA;
1168 encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO;
1169 encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */
1170 encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
1171 encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */
1172 encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize;
1173 encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */
1174 encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */
1175 encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate;
1176 encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels;
1177 encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample;
1178 encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */
1179 memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */
1180 if(encoder->protected_->do_md5)
1181 FLAC__MD5Init(&encoder->private_->md5context);
1182 if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->frame)) {
1183 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1186 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1195 encoder->private_->streaminfo.data.stream_info.min_framesize = (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN) - 1;
1197 encoder->private_->streaminfo.data.stream_info.total_samples = 0;
1212 vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0);
1218 if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->frame)) {
1219 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1222 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1231 for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) {
1232 encoder->protected_->metadata[i]->is_last = (i == encoder->protected_->num_metadata_blocks - 1);
1233 if(!FLAC__add_metadata_block(encoder->protected_->metadata[i], encoder->private_->frame)) {
1234 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
1237 if(!write_bitbuffer_(encoder, 0, /*is_last_block=*/false)) {
1244 if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &encoder->protected_->audio_offset, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) { /* FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED just means we didn't get the offset; no error */
1245 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
1249 if(encoder->protected_->verify)
1250 encoder->private_->verify.state_hint = ENCODER_IN_AUDIO;
1256 FLAC__StreamEncoder *encoder,
1265 encoder,
1277 FLAC__StreamEncoder *encoder,
1287 encoder,
1299 FLAC__StreamEncoder *encoder,
1308 FLAC__ASSERT(0 != encoder);
1311 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1316 encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1336 encoder->private_->file = file;
1338 encoder->private_->progress_callback = progress_callback;
1339 encoder->private_->bytes_written = 0;
1340 encoder->private_->samples_written = 0;
1341 encoder->private_->frames_written = 0;
1344 encoder,
1345 encoder->private_->file == stdout? 0 : is_ogg? file_read_callback_ : 0,
1347 encoder->private_->file == stdout? 0 : file_seek_callback_,
1348 encoder->private_->file == stdout? 0 : file_tell_callback_,
1359 unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
1362 encoder->private_->total_frames_estimate = (unsigned)((FLAC__stream_encoder_get_total_samples_estimate(encoder) + blocksize - 1) / blocksize);
1369 FLAC__StreamEncoder *encoder,
1375 return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/false);
1379 FLAC__StreamEncoder *encoder,
1385 return init_FILE_internal_(encoder, file, progress_callback, client_data, /*is_ogg=*/true);
1389 FLAC__StreamEncoder *encoder,
1398 FLAC__ASSERT(0 != encoder);
1405 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1411 encoder->protected_->state = FLAC__STREAM_ENCODER_IO_ERROR;
1415 return init_FILE_internal_(encoder, file, progress_callback, client_data, is_ogg);
1419 FLAC__StreamEncoder *encoder,
1425 return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/false);
1429 FLAC__StreamEncoder *encoder,
1435 return init_file_internal_(encoder, filename, progress_callback, client_data, /*is_ogg=*/true);
1438 FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder)
1442 FLAC__ASSERT(0 != encoder);
1443 FLAC__ASSERT(0 != encoder->private_);
1444 FLAC__ASSERT(0 != encoder->protected_);
1446 if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED)
1449 if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) {
1450 if(encoder->private_->current_sample_number != 0) {
1451 const FLAC__bool is_fractional_block = encoder->protected_->blocksize != encoder->private_->current_sample_number;
1452 encoder->protected_->blocksize = encoder->private_->current_sample_number;
1453 if(!process_frame_(encoder, is_fractional_block, /*is_last_block=*/true))
1458 if(encoder->protected_->do_md5)
1459 FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context);
1461 if(!encoder->private_->is_being_deleted) {
1462 if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) {
1463 if(encoder
1465 if(encoder->private_->is_ogg)
1466 update_ogg_metadata_(encoder);
1469 update_metadata_(encoder);
1472 if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK)
1475 if(encoder->private_->metadata_callback)
1476 encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data);
1479 if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) {
1481 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
1486 if(0 != encoder->private_->file) {
1487 if(encoder->private_->file != stdout)
1488 fclose(encoder->private_->file);
1489 encoder->private_->file = 0;
1493 if(encoder->private_->is_ogg)
1494 FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect);
1497 free_(encoder);
1498 set_defaults_(encoder);
1501 encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED;
1506 FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncoder *encoder, long value)
1508 FLAC__ASSERT(0 != encoder);
1509 FLAC__ASSERT(0 != encoder->private_);
1510 FLAC__ASSERT(0 != encoder->protected_);
1511 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1514 /* can't check encoder->private_->is_ogg since that's not set until init time */
1515 FLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value);
1523 FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value)
1525 FLAC__ASSERT(0 != encoder);
1526 FLAC__ASSERT(0 != encoder->private_);
1527 FLAC__ASSERT(0 != encoder->protected_);
1528 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1531 encoder->protected_->verify = value;
1536 FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncoder *encoder, FLAC__bool value)
1538 FLAC__ASSERT(0 != encoder);
1539 FLAC__ASSERT(0 != encoder->private_);
1540 FLAC__ASSERT(0 != encoder->protected_);
1541 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1543 encoder->protected_->streamable_subset = value;
1547 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_md5(FLAC__StreamEncoder *encoder, FLAC__bool value)
1549 FLAC__ASSERT(0 != encoder);
1550 FLAC__ASSERT(0 != encoder->private_);
1551 FLAC__ASSERT(0 != encoder->protected_);
1552 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1554 encoder->protected_->do_md5 = value;
1558 FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value)
1560 FLAC__ASSERT(0 != encoder);
1561 FLAC__ASSERT(0 != encoder->private_);
1562 FLAC__ASSERT(0 != encoder->protected_);
1563 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1565 encoder->protected_->channels = value;
1569 FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value)
1571 FLAC__ASSERT(0 != encoder);
1572 FLAC__ASSERT(0 != encoder->private_);
1573 FLAC__ASSERT(0 != encoder->protected_);
1574 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1576 encoder->protected_->bits_per_sample = value;
1580 FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value)
1582 FLAC__ASSERT(0 != encoder);
1583 FLAC__ASSERT(0 != encoder->private_);
1584 FLAC__ASSERT(0 != encoder->protected_);
1585 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1587 encoder->protected_->sample_rate = value;
1591 FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value)
1594 FLAC__ASSERT(0 != encoder);
1595 FLAC__ASSERT(0 != encoder->private_);
1596 FLAC__ASSERT(0 != encoder->protected_);
1597 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1601 ok &= FLAC__stream_encoder_set_do_mid_side_stereo (encoder, compression_levels_[value].do_mid_side_stereo);
1602 ok &= FLAC__stream_encoder_set_loose_mid_side_stereo (encoder, compression_levels_[value].loose_mid_side_stereo);
1605 ok &= FLAC__stream_encoder_set_apodization (encoder, compression_levels_[value].apodization);
1608 encoder->protected_->num_apodizations = 1;
1609 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
1610 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
1613 ok &= FLAC__stream_encoder_set_max_lpc_order (encoder, compression_levels_[value].max_lpc_order);
1614 ok &= FLAC__stream_encoder_set_qlp_coeff_precision (encoder, compression_levels_[value].qlp_coeff_precision);
1615 ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search (encoder, compression_levels_[value].do_qlp_coeff_prec_search);
1616 ok &= FLAC__stream_encoder_set_do_escape_coding (encoder, compression_levels_[value].do_escape_coding);
1617 ok &= FLAC__stream_encoder_set_do_exhaustive_model_search (encoder, compression_levels_[value].do_exhaustive_model_search);
1618 ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order);
1619 ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order);
1620 ok &= FLAC__stream_encoder_set_rice_parameter_search_dist (encoder, compression_levels_[value].rice_parameter_search_dist);
1624 FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value)
1626 FLAC__ASSERT(0 != encoder);
1627 FLAC__ASSERT(0 != encoder->private_);
1628 FLAC__ASSERT(0 != encoder->protected_);
1629 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1631 encoder->protected_->blocksize = value;
1635 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
1637 FLAC__ASSERT(0 != encoder);
1638 FLAC__ASSERT(0 != encoder->private_);
1639 FLAC__ASSERT(0 != encoder->protected_);
1640 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1642 encoder->protected_->do_mid_side_stereo = value;
1646 FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamEncoder *encoder, FLAC__bool value)
1648 FLAC__ASSERT(0 != encoder);
1649 FLAC__ASSERT(0 != encoder->private_);
1650 FLAC__ASSERT(0 != encoder->protected_);
1651 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1653 encoder->protected_->loose_mid_side_stereo = value;
1658 FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *encoder, const char *specification)
1660 FLAC__ASSERT(0 != encoder);
1661 FLAC__ASSERT(0 != encoder->private_);
1662 FLAC__ASSERT(0 != encoder->protected_);
1664 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1669 encoder->protected_->num_apodizations = 0;
1674 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT;
1676 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN;
1678 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN;
1680 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE;
1682 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES;
1684 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP;
1688 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev;
1689 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS;
1693 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING;
1695 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN;
1697 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL;
1699 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL;
1701 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE;
1703 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE;
1707 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p;
1708 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1720 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p;
1721 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1722 }else if (encoder->protected_->num_apodizations + tukey_parts < 32){
1725 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p;
1726 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units);
1727 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units);
1728 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PARTIAL_TUKEY;
1741 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p;
1742 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY;
1743 }else if (encoder->protected_->num_apodizations + tukey_parts < 32){
1746 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p;
1747 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units);
1748 encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units);
1749 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PUNCHOUT_TUKEY;
1754 encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH;
1755 if (encoder->protected_->num_apodizations == 32)
1762 if(encoder->protected_->num_apodizations == 0) {
1763 encoder->protected_->num_apodizations = 1;
1764 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
1765 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
1771 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value)
1773 FLAC__ASSERT(0 != encoder);
1774 FLAC__ASSERT(0 != encoder->private_);
1775 FLAC__ASSERT(0 != encoder->protected_);
1776 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1778 encoder->protected_->max_lpc_order = value;
1782 FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value)
1784 FLAC__ASSERT(0 != encoder);
1785 FLAC__ASSERT(0 != encoder->private_);
1786 FLAC__ASSERT(0 != encoder->protected_);
1787 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1789 encoder->protected_->qlp_coeff_precision = value;
1793 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_qlp_coeff_prec_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1795 FLAC__ASSERT(0 != encoder);
1796 FLAC__ASSERT(0 != encoder->private_);
1797 FLAC__ASSERT(0 != encoder->protected_);
1798 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1800 encoder->protected_->do_qlp_coeff_prec_search = value;
1804 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_escape_coding(FLAC__StreamEncoder *encoder, FLAC__bool value)
1806 FLAC__ASSERT(0 != encoder);
1807 FLAC__ASSERT(0 != encoder->private_);
1808 FLAC__ASSERT(0 != encoder->protected_);
1809 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1813 encoder->protected_->do_escape_coding = value;
1820 FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__StreamEncoder *encoder, FLAC__bool value)
1822 FLAC__ASSERT(0 != encoder);
1823 FLAC__ASSERT(0 != encoder->private_);
1824 FLAC__ASSERT(0 != encoder->protected_);
1825 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1827 encoder->protected_->do_exhaustive_model_search = value;
1831 FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
1833 FLAC__ASSERT(0 != encoder);
1834 FLAC__ASSERT(0 != encoder->private_);
1835 FLAC__ASSERT(0 != encoder->protected_);
1836 if(encoder
1838 encoder->protected_->min_residual_partition_order = value;
1842 FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value)
1844 FLAC__ASSERT(0 != encoder);
1845 FLAC__ASSERT(0 != encoder->private_);
1846 FLAC__ASSERT(0 != encoder->protected_);
1847 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1849 encoder->protected_->max_residual_partition_order = value;
1853 FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value)
1855 FLAC__ASSERT(0 != encoder);
1856 FLAC__ASSERT(0 != encoder->private_);
1857 FLAC__ASSERT(0 != encoder->protected_);
1858 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1862 encoder->protected_->rice_parameter_search_dist = value;
1869 FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__StreamEncoder *encoder, FLAC__uint64 value)
1871 FLAC__ASSERT(0 != encoder);
1872 FLAC__ASSERT(0 != encoder->private_);
1873 FLAC__ASSERT(0 != encoder->protected_);
1874 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1877 encoder->protected_->total_samples_estimate = value;
1881 FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks)
1883 FLAC__ASSERT(0 != encoder);
1884 FLAC__ASSERT(0 != encoder->private_);
1885 FLAC__ASSERT(0 != encoder->protected_);
1886 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1893 if(encoder->protected_->metadata) {
1894 free(encoder->protected_->metadata);
1895 encoder->protected_->metadata = 0;
1896 encoder->protected_->num_metadata_blocks = 0;
1903 encoder->protected_->metadata = m;
1904 encoder->protected_->num_metadata_blocks = num_blocks;
1907 if(!FLAC__ogg_encoder_aspect_set_num_metadata(&encoder->protected_->ogg_encoder_aspect, num_blocks))
1917 FLAC_API FLAC__bool FLAC__stream_encoder_disable_constant_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1919 FLAC__ASSERT(0 != encoder);
1920 FLAC__ASSERT(0 != encoder->private_);
1921 FLAC__ASSERT(0 != encoder->protected_);
1922 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1924 encoder->private_->disable_constant_subframes = value;
1928 FLAC_API FLAC__bool FLAC__stream_encoder_disable_fixed_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1930 FLAC__ASSERT(0 != encoder);
1931 FLAC__ASSERT(0 != encoder->private_);
1932 FLAC__ASSERT(0 != encoder->protected_);
1933 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1935 encoder->private_->disable_fixed_subframes = value;
1939 FLAC_API FLAC__bool FLAC__stream_encoder_disable_verbatim_subframes(FLAC__StreamEncoder *encoder, FLAC__bool value)
1941 FLAC__ASSERT(0 != encoder);
1942 FLAC__ASSERT(0 != encoder->private_);
1943 FLAC__ASSERT(0 != encoder->protected_);
1944 if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED)
1946 encoder->private_->disable_verbatim_subframes = value;
1950 FLAC_API FLAC__StreamEncoderState FLAC__stream_encoder_get_state(const FLAC__StreamEncoder *encoder)
1952 FLAC__ASSERT(0 != encoder);
1953 FLAC__ASSERT(0 != encoder->private_);
1954 FLAC__ASSERT(0 != encoder->protected_);
1955 return encoder->protected_->state;
1958 FLAC_API FLAC__StreamDecoderState FLAC__stream_encoder_get_verify_decoder_state(const FLAC__StreamEncoder *encoder)
1960 FLAC__ASSERT(0 != encoder);
1961 FLAC__ASSERT(0 != encoder->private_);
1962 FLAC__ASSERT(0 != encoder->protected_);
1963 if(encoder->protected_->verify)
1964 return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder);
1969 FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__StreamEncoder *encoder)
1971 FLAC__ASSERT(0 != encoder);
1972 FLAC__ASSERT(0 != encoder->private_);
1973 FLAC__ASSERT(0 != encoder->protected_);
1974 if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR)
1975 return FLAC__StreamEncoderStateString[encoder->protected_->state];
1977 return FLAC__stream_decoder_get_resolved_state_string(encoder->private_->verify.decoder);
1980 FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got)
1982 FLAC__ASSERT(0 != encoder);
1983 FLAC__ASSERT(0 != encoder->private_);
1984 FLAC__ASSERT(0 != encoder->protected_);
1986 *absolute_sample = encoder->private_->verify.error_stats.absolute_sample;
1988 *frame_number = encoder->private_->verify.error_stats.frame_number;
1990 *channel = encoder->private_->verify.error_stats.channel;
1992 *sample = encoder->private_->verify.error_stats.sample;
1994 *expected = encoder->private_->verify.error_stats.expected;
1996 *got = encoder->private_->verify.error_stats.got;
1999 FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder)
2001 FLAC__ASSERT(0 != encoder);
2002 FLAC__ASSERT(0 != encoder->private_);
2003 FLAC__ASSERT(0 != encoder->protected_);
2004 return encoder->protected_->verify;
2007 FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__StreamEncoder *encoder)
2009 FLAC__ASSERT(0 != encoder);
2010 FLAC__ASSERT(0 != encoder->private_);
2011 FLAC__ASSERT(0 != encoder->protected_);
2012 return encoder->protected_->streamable_subset;
2015 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_md5(const FLAC__StreamEncoder *encoder)
2017 FLAC__ASSERT(0 != encoder);
2018 FLAC__ASSERT(0 != encoder->private_);
2019 FLAC__ASSERT(0 != encoder->protected_);
2020 return encoder->protected_->do_md5;
2023 FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
2025 FLAC__ASSERT(0 != encoder);
2026 FLAC__ASSERT(0 != encoder->private_);
2027 FLAC__ASSERT(0 != encoder->protected_);
2028 return encoder->protected_->channels;
2031 FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
2033 FLAC__ASSERT(0 != encoder);
2034 FLAC__ASSERT(0 != encoder->private_);
2035 FLAC__ASSERT(0 != encoder->protected_);
2036 return encoder->protected_->bits_per_sample;
2039 FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
2041 FLAC__ASSERT(0 != encoder);
2042 FLAC__ASSERT(0 != encoder->private_);
2043 FLAC__ASSERT(0 != encoder->protected_);
2044 return encoder->protected_->sample_rate;
2047 FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
2049 FLAC__ASSERT(0 != encoder);
2050 FLAC__ASSERT(0 != encoder->private_);
2051 FLAC__ASSERT(0 != encoder->protected_);
2052 return encoder->protected_->blocksize;
2055 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_mid_side_stereo(const FLAC__StreamEncoder *encoder)
2057 FLAC__ASSERT(0 != encoder);
2058 FLAC__ASSERT(0 != encoder->private_);
2059 FLAC__ASSERT(0 != encoder->protected_);
2060 return encoder->protected_->do_mid_side_stereo;
2063 FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
2065 FLAC__ASSERT(0 != encoder);
2066 FLAC__ASSERT(0 != encoder->private_);
2067 FLAC__ASSERT(0 != encoder->protected_);
2068 return encoder->protected_->loose_mid_side_stereo;
2071 FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
2073 FLAC__ASSERT(0 != encoder);
2074 FLAC__ASSERT(0 != encoder->private_);
2075 FLAC__ASSERT(0 != encoder->protected_);
2076 return encoder->protected_->max_lpc_order;
2079 FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
2081 FLAC__ASSERT(0 != encoder);
2082 FLAC__ASSERT(0 != encoder->private_);
2083 FLAC__ASSERT(0 != encoder->protected_);
2084 return encoder->protected_->qlp_coeff_precision;
2087 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
2089 FLAC__ASSERT(0 != encoder);
2090 FLAC__ASSERT(0 != encoder->private_);
2091 FLAC__ASSERT(0 != encoder->protected_);
2092 return encoder->protected_->do_qlp_coeff_prec_search;
2095 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
2097 FLAC__ASSERT(0 != encoder);
2098 FLAC__ASSERT(0 != encoder->private_);
2099 FLAC__ASSERT(0 != encoder->protected_);
2100 return encoder->protected_->do_escape_coding;
2103 FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
2105 FLAC__ASSERT(0 != encoder);
2106 FLAC__ASSERT(0 != encoder->private_);
2107 FLAC__ASSERT(0 != encoder->protected_);
2108 return encoder->protected_->do_exhaustive_model_search;
2111 FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
2113 FLAC__ASSERT(0 != encoder);
2114 FLAC__ASSERT(0 != encoder->private_);
2115 FLAC__ASSERT(0 != encoder->protected_);
2116 return encoder->protected_->min_residual_partition_order;
2119 FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
2121 FLAC__ASSERT(0 != encoder);
2122 FLAC__ASSERT(0 != encoder->private_);
2123 FLAC__ASSERT(0 != encoder->protected_);
2124 return encoder->protected_->max_residual_partition_order;
2127 FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
2129 FLAC__ASSERT(0 != encoder);
2130 FLAC__ASSERT(0 != encoder->private_);
2131 FLAC__ASSERT(0 != encoder->protected_);
2132 return encoder->protected_->rice_parameter_search_dist;
2135 FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
2137 FLAC__ASSERT(0 != encoder);
2138 FLAC__ASSERT(0 != encoder->private_);
2139 FLAC__ASSERT(0 != encoder->protected_);
2140 return encoder->protected_->total_samples_estimate;
2143 FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
2146 const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
2148 FLAC__ASSERT(0 != encoder);
2149 FLAC__ASSERT(0 != encoder->private_);
2150 FLAC__ASSERT(0 != encoder->protected_);
2151 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2154 const unsigned n = flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j);
2156 if(encoder->protected_->verify)
2157 append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, n);
2163 memcpy(&encoder->private_->integer_signal[channel][encoder->private_->current_sample_number], &buffer[channel][j], sizeof(buffer[channel][0]) * n);
2166 if(encoder->protected_->do_mid_side_stereo) {
2169 for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2170 encoder->private_->integer_signal_mid_side[1][i] = buffer[0][j] - buffer[1][j];
2171 encoder->private_->integer_signal_mid_side[0][i] = (buffer[0][j] + buffer[1][j]) >> 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
2177 encoder->private_->current_sample_number += n;
2180 if(encoder->private_->current_sample_number > blocksize) {
2181 FLAC__ASSERT(encoder->private_->current_sample_number == blocksize+OVERREAD_);
2183 if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2187 encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
2188 if(encoder->protected_->do_mid_side_stereo) {
2189 encoder->private_->integer_signal_mid_side[0][0] = encoder->private_->integer_signal_mid_side[0][blocksize];
2190 encoder->private_->integer_signal_mid_side[1][0] = encoder->private_->integer_signal_mid_side[1][blocksize];
2192 encoder->private_->current_sample_number = 1;
2199 FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
2203 const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;
2205 FLAC__ASSERT(0 != encoder);
2206 FLAC__ASSERT(0 != encoder->private_);
2207 FLAC__ASSERT(0 != encoder->protected_);
2208 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2215 if(encoder->protected_->do_mid_side_stereo && channels == 2) {
2220 if(encoder->protected_->verify)
2221 append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j));
2224 for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2225 encoder->private_->integer_signal[0][i] = mid = side = buffer[k++];
2227 encoder->private_->integer_signal[1][i] = x;
2231 encoder->private_->integer_signal_mid_side[1][i] = side;
2232 encoder->private_->integer_signal_mid_side[0][i] = mid;
2234 encoder->private_->current_sample_number = i;
2237 if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2242 encoder->private_->integer_signal[0][0] = encoder->private_->integer_signal[0][blocksize];
2243 encoder->private_->integer_signal[1][0] = encoder->private_->integer_signal[1][blocksize];
2244 encoder->private_->integer_signal_mid_side[0][0] = encoder->private_->integer_signal_mid_side[0][blocksize];
2245 encoder->private_->integer_signal_mid_side[1][0] = encoder->private_->integer_signal_mid_side[1][blocksize];
2246 encoder->private_->current_sample_number = 1;
2255 if(encoder->protected_->verify)
2256 append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, flac_min(blocksize+OVERREAD_-encoder->private_->current_sample_number, samples-j));
2259 for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) {
2261 encoder->private_->integer_signal[channel][i] = buffer[k++];
2263 encoder->private_->current_sample_number = i;
2266 if(!process_frame_(encoder, /*is_fractional_block=*/false, /*is_last_block=*/false))
2272 encoder->private_->integer_signal[channel][0] = encoder->private_->integer_signal[channel][blocksize];
2273 encoder->private_->current_sample_number = 1;
2287 void set_defaults_(FLAC__StreamEncoder *encoder)
2289 FLAC__ASSERT(0 != encoder);
2292 encoder->protected_->verify = true;
2294 encoder->protected_->verify = false;
2296 encoder->protected_->streamable_subset = true;
2297 encoder->protected_->do_md5 = true;
2298 encoder->protected_->do_mid_side_stereo = false;
2299 encoder->protected_->loose_mid_side_stereo = false;
2300 encoder->protected_->channels = 2;
2301 encoder->protected_->bits_per_sample = 16;
2302 encoder->protected_->sample_rate = 44100;
2303 encoder->protected_->blocksize = 0;
2305 encoder->protected_->num_apodizations = 1;
2306 encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY;
2307 encoder->protected_->apodizations[0].parameters.tukey.p = 0.5;
2309 encoder->protected_->max_lpc_order = 0;
2310 encoder->protected_->qlp_coeff_precision = 0;
2311 encoder->protected_->do_qlp_coeff_prec_search = false;
2312 encoder->protected_->do_exhaustive_model_search = false;
2313 encoder->protected_->do_escape_coding = false;
2314 encoder->protected_->min_residual_partition_order = 0;
2315 encoder->protected_->max_residual_partition_order = 0;
2316 encoder->protected_->rice_parameter_search_dist = 0;
2317 encoder->protected_->total_samples_estimate = 0;
2318 encoder->protected_->metadata = 0;
2319 encoder->protected_->num_metadata_blocks = 0;
2321 encoder->private_->seek_table = 0;
2322 encoder->private_->disable_constant_subframes = false;
2323 encoder->private_->disable_fixed_subframes = false;
2324 encoder->private_->disable_verbatim_subframes = false;
2325 encoder->private_->is_ogg = false;
2326 encoder->private_->read_callback = 0;
2327 encoder->private_->write_callback = 0;
2328 encoder->private_->seek_callback = 0;
2329 encoder->private_->tell_callback = 0;
2330 encoder->private_->metadata_callback = 0;
2331 encoder->private_->progress_callback = 0;
2332 encoder->private_->client_data = 0;
2335 FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect);
2338 FLAC__stream_encoder_set_compression_level(encoder, 5);
2341 void free_(FLAC__StreamEncoder *encoder)
2345 FLAC__ASSERT(0 != encoder);
2346 if(encoder->protected_->metadata) {
2347 free(encoder->protected_->metadata);
2348 encoder->protected_->metadata = 0;
2349 encoder->protected_->num_metadata_blocks = 0;
2351 for(i = 0; i < encoder->protected_->channels; i++) {
2352 if(0 != encoder->private_->integer_signal_unaligned[i]) {
2353 free(encoder->private_->integer_signal_unaligned[i]);
2354 encoder->private_->integer_signal_unaligned[i] = 0;
2357 if(0 != encoder->private_->real_signal_unaligned[i]) {
2358 free(encoder->private_->real_signal_unaligned[i]);
2359 encoder->private_->real_signal_unaligned[i] = 0;
2364 if(0 != encoder->private_->integer_signal_mid_side_unaligned[i]) {
2365 free(encoder->private_->integer_signal_mid_side_unaligned[i]);
2366 encoder->private_->integer_signal_mid_side_unaligned[i] = 0;
2369 if(0 != encoder->private_->real_signal_mid_side_unaligned[i]) {
2370 free(encoder->private_->real_signal_mid_side_unaligned[i]);
2371 encoder->private_->real_signal_mid_side_unaligned[i] = 0;
2376 for(i = 0; i < encoder->protected_->num_apodizations; i++) {
2377 if(0 != encoder->private_->window_unaligned[i]) {
2378 free(encoder->private_->window_unaligned[i]);
2379 encoder->private_->window_unaligned[i] = 0;
2382 if(0 != encoder->private_->windowed_signal_unaligned) {
2383 free(encoder->private_->windowed_signal_unaligned);
2384 encoder->private_->windowed_signal_unaligned = 0;
2387 for(channel = 0; channel < encoder->protected_->channels; channel++) {
2389 if(0 != encoder->private_->residual_workspace_unaligned[channel][i]) {
2390 free(encoder->private_->residual_workspace_unaligned[channel][i]);
2391 encoder->private_->residual_workspace_unaligned[channel][i] = 0;
2397 if(0 != encoder->private_->residual_workspace_mid_side_unaligned[channel][i]) {
2398 free(encoder->private_->residual_workspace_mid_side_unaligned[channel][i]);
2399 encoder->private_->residual_workspace_mid_side_unaligned[channel][i] = 0;
2403 if(0 != encoder->private_->abs_residual_partition_sums_unaligned) {
2404 free(encoder->private_->abs_residual_partition_sums_unaligned);
2405 encoder->private_->abs_residual_partition_sums_unaligned = 0;
2407 if(0 != encoder->private_->raw_bits_per_partition_unaligned) {
2408 free(encoder->private_->raw_bits_per_partition_unaligned);
2409 encoder->private_->raw_bits_per_partition_unaligned = 0;
2411 if(encoder->protected_->verify) {
2412 for(i = 0; i < encoder->protected_->channels; i++) {
2413 if(0 != encoder->private_->verify.input_fifo.data[i]) {
2414 free(encoder->private_->verify.input_fifo.data[i]);
2415 encoder->private_->verify.input_fifo.data[i] = 0;
2419 FLAC__bitwriter_free(encoder->private_->frame);
2422 FLAC__bool resize_buffers_(FLAC__StreamEncoder *encoder, unsigned new_blocksize)
2428 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
2429 FLAC__ASSERT(encoder->private_->current_sample_number == 0);
2432 if(new_blocksize <= encoder->private_->input_capacity)
2443 for(i = 0; ok && i < encoder->protected_->channels; i++) {
2444 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_unaligned[i], &encoder->private_->integer_signal[i]);
2445 memset(encoder->private_->integer_signal[i], 0, sizeof(FLAC__int32)*4);
2446 encoder->private_->integer_signal[i] += 4;
2449 if(encoder->protected_->max_lpc_order > 0)
2450 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize+OVERREAD_, &encoder->private_->real_signal_unaligned[i], &encoder->private_->real_signal[i]);
2455 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize+4+OVERREAD_, &encoder->private_->integer_signal_mid_side_unaligned[i], &encoder->private_->integer_signal_mid_side[i]);
2456 memset(encoder->private_->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4);
2457 encoder->private_->integer_signal_mid_side[i] += 4;
2460 if(encoder->protected_->max_lpc_order > 0)
2461 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize+OVERREAD_, &encoder->private_->real_signal_mid_side_unaligned[i], &encoder->private_->real_signal_mid_side[i]);
2466 if(ok && encoder->protected_->max_lpc_order > 0) {
2467 for(i = 0; ok && i < encoder->protected_->num_apodizations; i++)
2468 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]);
2469 ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->windowed_signal_unaligned, &encoder->private_->windowed_signal);
2472 for(channel = 0; ok && channel < encoder->protected_->channels; channel++) {
2474 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_unaligned[channel][i], &encoder->private_->residual_workspace[channel][i]);
2479 ok = ok && FLAC__memory_alloc_aligned_int32_array(new_blocksize, &encoder->private_->residual_workspace_mid_side_unaligned[channel][i], &encoder->private_->residual_workspace_mid_side[channel][i]);
2484 ok = ok && FLAC__memory_alloc_aligned_uint64_array(new_blocksize * 2, &encoder->private_->abs_residual_partition_sums_unaligned, &encoder->private_->abs_residual_partition_sums);
2485 if(encoder->protected_->do_escape_coding)
2486 ok = ok && FLAC__memory_alloc_aligned_unsigned_array(new_blocksize * 2, &encoder->private_->raw_bits_per_partition_unaligned, &encoder->private_->raw_bits_per_partition);
2490 if(ok && new_blocksize != encoder->private_->input_capacity && encoder->protected_->max_lpc_order > 0) {
2491 for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) {
2492 switch(encoder->protected_->apodizations[i].type) {
2494 FLAC__window_bartlett(encoder->private_->window[i], new_blocksize);
2497 FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize);
2500 FLAC__window_blackman(encoder->private_->window[i], new_blocksize);
2503 FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize);
2506 FLAC__window_connes(encoder->private_->window[i], new_blocksize);
2509 FLAC__window_flattop(encoder->private_->window[i], new_blocksize);
2512 FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev);
2515 FLAC__window_hamming(encoder->private_->window[i], new_blocksize);
2518 FLAC__window_hann(encoder->private_->window[i], new_blocksize);
2521 FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize);
2524 FLAC__window_nuttall(encoder->private_->window[i], new_blocksize);
2527 FLAC__window_rectangle(encoder->private_->window[i], new_blocksize);
2530 FLAC__window_triangle(encoder->private_->window[i], new_blocksize);
2533 FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p);
2536 FLAC__window_partial_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end);
2539 FLAC__window_punchout_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.multiple_tukey.p, encoder->protected_->apodizations[i].parameters.multiple_tukey.start, encoder->protected_->apodizations[i].parameters.multiple_tukey.end);
2542 FLAC__window_welch(encoder->private_->window[i], new_blocksize);
2547 FLAC__window_hann(encoder->private_->window[i], new_blocksize);
2555 encoder->private_->input_capacity = new_blocksize;
2557 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2562 FLAC__bool write_bitbuffer_(FLAC__StreamEncoder *encoder, unsigned samples, FLAC__bool is_last_block)
2567 FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
2569 if(!FLAC__bitwriter_get_buffer(encoder->private_->frame, &buffer, &bytes)) {
2570 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
2574 if(encoder->protected_->verify) {
2575 encoder->private_->verify.output.data = buffer;
2576 encoder->private_->verify.output.bytes = bytes;
2577 if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) {
2578 encoder->private_->verify.needs_magic_hack = true;
2581 if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder)) {
2582 FLAC__bitwriter_release_buffer(encoder->private_->frame);
2583 FLAC__bitwriter_clear(encoder->private_->frame);
2584 if(encoder->protected_->state != FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA)
2585 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
2591 if(write_frame_(encoder, buffer, bytes, samples, is_last_block) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2592 FLAC__bitwriter_release_buffer(encoder->private_->frame);
2593 FLAC__bitwriter_clear(encoder->private_->frame);
2594 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2598 FLAC__bitwriter_release_buffer(encoder->private_->frame);
2599 FLAC__bitwriter_clear(encoder->private_->frame);
2602 encoder->private_->streaminfo.data.stream_info.min_framesize = flac_min(bytes, encoder->private_->streaminfo.data.stream_info.min_framesize);
2603 encoder->private_->streaminfo.data.stream_info.max_framesize = flac_max(bytes, encoder->private_->streaminfo.data.stream_info.max_framesize);
2609 FLAC__StreamEncoderWriteStatus write_frame_(FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, FLAC__bool is_last_block)
2619 if(encoder->private_->tell_callback && encoder->private_->tell_callback(encoder, &output_position, encoder->private_->client_data) == FLAC__STREAM_ENCODER_TELL_STATUS_ERROR) {
2620 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2630 encoder->protected_->streaminfo_offset = output_position;
2631 else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0)
2632 encoder->protected_->seektable_offset = output_position;
2640 if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) {
2641 const unsigned blocksize = FLAC__stream_encoder_get_blocksize(encoder);
2642 const FLAC__uint64 frame_first_sample = encoder
2646 for(i = encoder->private_->first_seekpoint_to_check; i < encoder->private_->seek_table->num_points; i++) {
2647 test_sample = encoder->private_->seek_table->points[i].sample_number;
2652 encoder->private_->seek_table->points[i].sample_number = frame_first_sample;
2653 encoder->private_->seek_table->points[i].stream_offset = output_position - encoder->protected_->audio_offset;
2654 encoder->private_->seek_table->points[i].frame_samples = blocksize;
2655 encoder->private_->first_seekpoint_to_check++;
2664 encoder->private_->first_seekpoint_to_check++;
2670 if(encoder->private_->is_ogg) {
2672 &encoder->protected_->ogg_encoder_aspect,
2676 encoder->private_->current_frame_number,
2678 (FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback,
2679 encoder,
2680 encoder->private_->client_data
2685 status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data);
2688 encoder->private_->bytes_written += bytes;
2689 encoder->private_->samples_written += samples;
2691 * when the encoder goes back to write metadata, 'current_frame'
2694 encoder->private_->frames_written = flac_max(encoder->private_->frames_written, encoder->private_->current_frame_number+1);
2697 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2703 void update_metadata_(const FLAC__StreamEncoder *encoder)
2706 const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
2737 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + md5_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2739 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2742 if(encoder->private_->write_callback(encoder, metadata->data.stream_info.md5sum, 16, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2743 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2770 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + total_samples_byte_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2772 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2775 if(encoder->private_->write_callback(encoder, b, 5, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2776 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2798 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->streaminfo_offset + min_framesize_offset, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2800 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2803 if(encoder->private_->write_callback(encoder, b, 6, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2804 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2812 if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
2815 FLAC__format_seektable_sort(encoder->private_->seek_table);
2817 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
2819 if((seek_status = encoder->private_->seek_callback(encoder, encoder->protected_->seektable_offset + FLAC__STREAM_METADATA_HEADER_LENGTH, encoder->private_->client_data)) != FLAC__STREAM_ENCODER_SEEK_STATUS_OK) {
2821 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2825 for(i = 0; i < encoder->private_->seek_table->num_points; i++) {
2828 xx = encoder->private_->seek_table->points[i].sample_number;
2837 xx = encoder->private_->seek_table->points[i].stream_offset;
2846 x = encoder->private_->seek_table->points[i].frame_samples;
2849 if(encoder->private_->write_callback(encoder, b, 18, 0, 0, encoder->private_->client_data) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) {
2850 encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR;
2859 void update_ogg_metadata_(FLAC__StreamEncoder *encoder)
2871 const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo;
2878 FLAC__ASSERT(0 != encoder->private_->seek_callback);
2883 if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED)
2895 if(!simple_ogg_page__get_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) {
2919 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2945 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2971 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
2983 if(!simple_ogg_page__set_at(encoder, encoder->protected_->streaminfo_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) {
2992 if(0 != encoder->private_->seek_table && encoder->private_->seek_table->num_points > 0 && encoder->protected_->seektable_offset > 0) {
2996 FLAC__format_seektable_sort(encoder->private_->seek_table);
2998 FLAC__ASSERT(FLAC__format_seektable_is_legal(encoder->private_->seek_table));
3001 if(!simple_ogg_page__get_at(encoder, encoder->protected_->seektable_offset, &page, encoder->private_->seek_callback, encoder->private_->read_callback, encoder->private_->client_data)) {
3006 if((FLAC__STREAM_METADATA_HEADER_LENGTH + 18*encoder->private_->seek_table->num_points) != (unsigned)page.body_len) {
3007 encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR;
3012 for(i = 0, p = page.body + FLAC__STREAM_METADATA_HEADER_LENGTH; i < encoder->private_->seek_table->num_points; i++, p += 18) {
3015 xx = encoder->private_->seek_table->points[i].sample_number;
3024 xx = encoder->private_->seek_table->points[i].stream_offset;
3033 x = encoder->private_->seek_table->points[i].frame_samples;
3039 if(!simple_ogg_page__set_at(encoder, encoder->protected_->seektable_offset, &page, encoder->private_->seek_callback, encoder->private_->write_callback, encoder->private_->client_data)) {
3048 FLAC__bool process_frame_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block, FLAC__bool is_last_block)
3051 FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);
3056 if(encoder->protected_->do_md5 && !FLAC__MD5Accumulate(&encoder->private_->md5context, (const FLAC__int32 * const *)encoder->private_->integer_signal, encoder->protected_->channels, encoder->protected_->blocksize, (encoder->protected_->bits_per_sample+7) / 8)) {
3057 encoder
3064 if(!process_subframes_(encoder, is_fractional_block)) {
3072 if(!FLAC__bitwriter_zero_pad_to_byte_boundary(encoder->private_->frame)) {
3073 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
3080 FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(encoder->private_->frame));
3082 !FLAC__bitwriter_get_write_crc16(encoder->private_->frame, &crc) ||
3083 !FLAC__bitwriter_write_raw_uint32(encoder->private_->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN)
3085 encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR;
3092 if(!write_bitbuffer_(encoder, encoder->protected_->blocksize, is_last_block)) {
3100 encoder->private_->current_sample_number = 0;
3101 encoder->private_->current_frame_number++;
3102 encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize;
3107 FLAC__bool process_subframes_(FLAC__StreamEncoder *encoder, FLAC__bool is_fractional_block)
3110 unsigned channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order;
3120 max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize);
3121 max_partition_order = flac_min(max_partition_order, encoder->protected_->max_residual_partition_order);
3128 frame_header.blocksize = encoder->protected_->blocksize;
3129 frame_header.sample_rate = encoder->protected_->sample_rate;
3130 frame_header.channels = encoder->protected_->channels;
3131 frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */
3132 frame_header.bits_per_sample = encoder->protected_->bits_per_sample;
3134 frame_header.number.frame_number = encoder->private_->current_frame_number;
3139 if(encoder->protected_->do_mid_side_stereo) {
3140 if(encoder->protected_->loose_mid_side_stereo) {
3141 if(encoder->private_->loose_mid_side_stereo_frame_count == 0) {
3146 do_independent = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT);
3166 for(channel = 0; channel < encoder->protected_->channels; channel++) {
3167 unsigned w = get_wasted_bits_(encoder->private_->integer_signal[channel], encoder->protected_->blocksize);
3168 if (w > encoder->protected_->bits_per_sample) {
3169 w = encoder->protected_->bits_per_sample;
3171 encoder->private_->subframe_workspace[channel][0].wasted_bits = encoder->private_->subframe_workspace[channel][1].wasted_bits = w;
3172 encoder->private_->subframe_bps[channel] = encoder->protected_->bits_per_sample - w;
3176 FLAC__ASSERT(encoder->protected_->channels == 2);
3178 unsigned w = get_wasted_bits_(encoder->private_->integer_signal_mid_side[channel], encoder->protected_->blocksize);
3179 if (w > encoder->protected_->bits_per_sample) {
3180 w = encoder->protected_->bits_per_sample;
3182 encoder->private_->subframe_workspace_mid_side[channel][0].wasted_bits = encoder->private_->subframe_workspace_mid_side[channel][1].wasted_bits = w;
3183 encoder->private_->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1);
3191 for(channel = 0; channel < encoder->protected_->channels; channel++) {
3194 encoder,
3198 encoder->private_->subframe_bps[channel],
3199 encoder->private_->integer_signal[channel],
3200 encoder->private_->subframe_workspace_ptr[channel],
3201 encoder->private_->partitioned_rice_contents_workspace_ptr[channel],
3202 encoder->private_->residual_workspace[channel],
3203 encoder->private_->best_subframe+channel,
3204 encoder->private_->best_subframe_bits+channel
3215 FLAC__ASSERT(encoder->protected_->channels == 2);
3220 encoder,
3224 encoder->private_->subframe_bps_mid_side[channel],
3225 encoder->private_->integer_signal_mid_side[channel],
3226 encoder->private_->subframe_workspace_ptr_mid_side[channel],
3227 encoder->private_->partitioned_rice_contents_workspace_ptr_mid_side[channel],
3228 encoder->private_->residual_workspace_mid_side[channel],
3229 encoder->private_->best_subframe_mid_side+channel,
3230 encoder->private_->best_subframe_bits_mid_side+channel
3245 FLAC__ASSERT(encoder->protected_->channels == 2);
3247 if(encoder->protected_->loose_mid_side_stereo && encoder->private_->loose_mid_side_stereo_frame_count > 0) {
3248 channel_assignment = (encoder->private_->last_channel_assignment == FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT? FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT : FLAC__CHANNEL_ASSIGNMENT_MID_SIDE);
3262 bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits [1];
3263 bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE ] = encoder->private_->best_subframe_bits [0] + encoder->private_->best_subframe_bits_mid_side[1];
3264 bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = encoder->private_->best_subframe_bits [1] + encoder->private_->best_subframe_bits_mid_side[1];
3265 bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE ] = encoder->private_->best_subframe_bits_mid_side[0] + encoder->private_->best_subframe_bits_mid_side[1];
3279 if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
3280 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3286 left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]];
3287 right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]];
3290 left_subframe = &encoder->private_->subframe_workspace [0][encoder->private_->best_subframe [0]];
3291 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
3294 left_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
3295 right_subframe = &encoder->private_->subframe_workspace [1][encoder->private_->best_subframe [1]];
3298 left_subframe = &encoder->private_->subframe_workspace_mid_side[0][encoder->private_->best_subframe_mid_side[0]];
3299 right_subframe = &encoder->private_->subframe_workspace_mid_side[1][encoder->private_->best_subframe_mid_side[1]];
3307 left_bps = encoder->private_->subframe_bps [0];
3308 right_bps = encoder->private_->subframe_bps [1];
3311 left_bps = encoder->private_->subframe_bps [0];
3312 right_bps = encoder->private_->subframe_bps_mid_side[1];
3315 left_bps = encoder->private_->subframe_bps_mid_side[1];
3316 right_bps = encoder->private_->subframe_bps [1];
3319 left_bps = encoder->private_->subframe_bps_mid_side[0];
3320 right_bps = encoder->private_->subframe_bps_mid_side[1];
3327 if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , encoder->private_->frame))
3329 if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, encoder->private_->frame))
3333 if(!FLAC__frame_add_header(&frame_header, encoder->private_->frame)) {
3334 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3338 for(channel = 0; channel < encoder->protected_->channels; channel++) {
3339 if(!add_subframe_(encoder, frame_header.blocksize, encoder->private_->subframe_bps[channel], &encoder->private_->subframe_workspace[channel][encoder->private_->best_subframe[channel]], encoder->private_->frame)) {
3346 if(encoder->protected_->loose_mid_side_stereo) {
3347 encoder->private_->loose_mid_side_stereo_frame_count++;
3348 if(encoder->private_->loose_mid_side_stereo_frame_count >= encoder->private_->loose_mid_side_stereo_frames)
3349 encoder->private_->loose_mid_side_stereo_frame_count = 0;
3352 encoder->private_->last_channel_assignment = frame_header.channel_assignment;
3358 FLAC__StreamEncoder *encoder,
3378 FLAC__real autoc[FLAC__MAX_LPC_ORDER+1]; /* WATCHOUT: the size is important even though encoder->protected_->max_lpc_order might be less; some asm and x86 intrinsic routines need all the space */
3388 const unsigned rice_parameter_limit = FLAC__stream_encoder_get_bits_per_sample(encoder) > 16? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
3394 if(encoder->private_->disable_verbatim_subframes && frame_header->blocksize >= FLAC__MAX_FIXED_ORDER)
3397 _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
3402 guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor(integer_signal+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
3404 guess_fixed_order = encoder->private_->local_fixed_compute_best_predictor_wide(integer_signal+FLAC__MAX_FIXED_ORDER, frame_header->blocksize-FLAC__MAX_FIXED_ORDER, fixed_residual_bits_per_sample);
3407 !encoder->private_->disable_constant_subframes &&
3425 _candidate_bits = evaluate_constant_subframe_(encoder, integer_signal[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]);
3432 if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) {
3434 if(encoder->protected_->do_exhaustive_model_search) {
3462 encoder,
3465 encoder->private_->abs_residual_partition_sums,
3466 encoder->private_->raw_bits_per_partition,
3474 encoder->protected_->do_escape_coding,
3475 encoder->protected_->rice_parameter_search_dist,
3488 if(encoder->protected_->max_lpc_order > 0) {
3489 if(encoder->protected_->max_lpc_order >= frame_header->blocksize)
3492 max_lpc_order = encoder->protected_->max_lpc_order;
3495 for (a = 0; a < encoder->protected_->num_apodizations; a++) {
3496 FLAC__lpc_window_data(integer_signal, encoder->private_->window[a], encoder->private_->windowed_signal, frame_header->blocksize);
3497 encoder->private_->local_lpc_compute_autocorrelation(encoder->private_->windowed_signal, frame_header->blocksize, max_lpc_order+1, autoc);
3500 FLAC__lpc_compute_lp_coefficients(autoc, &max_lpc_order, encoder->private_->lp_coeff, lpc_error);
3501 if(encoder->protected_->do_exhaustive_model_search) {
3511 encoder->protected_->do_qlp_coeff_prec_search?
3513 encoder->protected_->qlp_coeff_precision
3532 if(encoder->protected_->do_qlp_coeff_prec_search) {
3543 min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision;
3548 encoder,
3551 encoder->private_->abs_residual_partition_sums,
3552 encoder->private_->raw_bits_per_partition,
3553 encoder->private_->lp_coeff[lpc_order-1],
3562 encoder->protected_->do_escape_coding,
3563 encoder->protected_->rice_parameter_search_dist,
3586 _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]);
3596 FLAC__StreamEncoder *encoder,
3606 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3612 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3618 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3624 encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR;
3638 FLAC__StreamEncoder *encoder,
3655 ret = add_subframe_(encoder, blocksize, subframe_bps, subframe, frame);
3660 fprintf(stderr, "EST: bad, frame#%u sub#%%d type=%8s est=%u, actual=%u, delta=%d\n", encoder->private_->current_frame_number, FLAC__SubframeTypeString[subframe->type], estimate, actual, (int)actual-(int)estimate);
3667 FLAC__StreamEncoder *encoder,
3681 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3683 (void)encoder, (void)blocksize;
3690 FLAC__StreamEncoder *encoder,
3721 encoder->private_,
3744 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3752 FLAC__StreamEncoder *encoder,
3790 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3792 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3794 encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(signal+order, residual_samples, qlp_coeff, order, quantization, residual);
3804 encoder->private_,
3830 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3838 FLAC__StreamEncoder *encoder,
3854 spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate);
3856 (void)encoder;
4362 FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
4363 const size_t encoded_bytes = encoder->private_->verify.output.bytes;
4366 if(encoder->private_->verify.needs_magic_hack) {
4370 encoder->private_->verify.needs_magic_hack = false;
4383 memcpy(buffer, encoder->private_->verify.output.data, *bytes);
4384 encoder->private_->verify.output.data += *bytes;
4385 encoder->private_->verify.output.bytes -= *bytes;
4393 FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data;
4402 if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) {
4407 if(buffer[channel][i] != encoder->private_->verify.input_fifo.data[channel][i]) {
4409 expect = (FLAC__int32)encoder->private_->verify.input_fifo.data[channel][i];
4416 encoder->private_->verify.error_stats.absolute_sample = frame->header.number.sample_number + sample;
4417 encoder->private_->verify.error_stats.frame_number = (unsigned)(frame->header.number.sample_number / blocksize);
4418 encoder->private_->verify.error_stats.channel = channel;
4419 encoder->private_->verify.error_stats.sample = sample;
4420 encoder->private_->verify.error_stats.expected = expect;
4421 encoder->private_->verify.error_stats.got = got;
4422 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA;
4427 encoder->private_->verify.input_fifo.tail -= blocksize;
4428 FLAC__ASSERT(encoder->private_->verify.input_fifo.tail <= OVERREAD_);
4430 memmove(&encoder->private_->verify.input_fifo.data[channel][0], &encoder->private_->verify.input_fifo.data[channel][blocksize], encoder->private_->verify.input_fifo.tail * sizeof(encoder->private_->verify.input_fifo.data[0][0]));
4441 FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data;
4443 encoder->protected_->state = FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR;
4446 FLAC__StreamEncoderReadStatus file_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
4450 *bytes = fread(buffer, 1, *bytes, encoder->private_->file);
4452 if (feof(encoder->private_->file))
4454 else if (ferror(encoder->private_->file))
4460 FLAC__StreamEncoderSeekStatus file_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
4464 if(fseeko(encoder->private_->file, (FLAC__off_t)absolute_byte_offset, SEEK_SET) < 0)
4470 FLAC__StreamEncoderTellStatus file_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
4476 offset = ftello(encoder->private_->file);
4499 FLAC__StreamEncoderWriteStatus file_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
4503 if(local__fwrite(buffer, sizeof(FLAC__byte), bytes, encoder->private_->file) == bytes) {
4504 FLAC__bool call_it = 0 != encoder->private_->progress_callback && (
4512 encoder->private_->is_ogg? true :
4522 encoder->private_->progress_callback(encoder, encoder->private_->bytes_written+bytes, encoder->private_->samples_written+samples, encoder->private_->frames_written+(samples?1:0), encoder->private_->total_frames_estimate, encoder->private_->client_data);
