stream_encoder.c

wince下著名的视频播放器源码

	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->do_mid_side_stereo;
}

FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->loose_mid_side_stereo;
}

FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->channels;
}

FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->bits_per_sample;
}

FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->sample_rate;
}

FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->blocksize;
}

FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->max_lpc_order;
}

FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->qlp_coeff_precision;
}

FLAC_API FLAC__bool FLAC__stream_encoder_get_do_qlp_coeff_prec_search(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->do_qlp_coeff_prec_search;
}

FLAC_API FLAC__bool FLAC__stream_encoder_get_do_escape_coding(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->do_escape_coding;
}

FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->do_exhaustive_model_search;
}

FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->min_residual_partition_order;
}

FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->max_residual_partition_order;
}

FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->rice_parameter_search_dist;
}

FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder)
{
	FLAC__ASSERT(0 != encoder);
	return encoder->protected_->total_samples_estimate;
}

FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples)
{
	unsigned i, j, channel;
	FLAC__int32 x, mid, side;
	const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;

	FLAC__ASSERT(0 != encoder);
	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);

	j = 0;
	/*
	 * we have several flavors of the same basic loop, optimized for
	 * different conditions:
	 */
	if(encoder->protected_->max_lpc_order > 0) {
		if(encoder->protected_->do_mid_side_stereo && channels == 2) {
			/*
			 * stereo coding: unroll channel loop
			 * with LPC: calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					x = mid = side = buffer[0][j];
					encoder->private_->integer_signal[0][i] = x;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
					encoder->private_->real_signal[0][i] = (FLAC__real)x;
#endif
					x = buffer[1][j];
					encoder->private_->integer_signal[1][i] = x;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
					encoder->private_->real_signal[1][i] = (FLAC__real)x;
#endif
					mid += x;
					side -= x;
					mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
					encoder->private_->integer_signal_mid_side[1][i] = side;
					encoder->private_->integer_signal_mid_side[0][i] = mid;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
					encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side;
					encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid;
#endif
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return false;
				}
			} while(j < samples);
		}
		else {
			/*
			 * independent channel coding: buffer each channel in inner loop
			 * with LPC: calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					for(channel = 0; channel < channels; channel++) {
						x = buffer[channel][j];
						encoder->private_->integer_signal[channel][i] = x;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
						encoder->private_->real_signal[channel][i] = (FLAC__real)x;
#endif
					}
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return false;
				}
			} while(j < samples);
		}
	}
	else {
		if(encoder->protected_->do_mid_side_stereo && channels == 2) {
			/*
			 * stereo coding: unroll channel loop
			 * without LPC: no need to calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					encoder->private_->integer_signal[0][i] = mid = side = buffer[0][j];
					x = buffer[1][j];
					encoder->private_->integer_signal[1][i] = x;
					mid += x;
					side -= x;
					mid >>= 1; /* NOTE: not the same as 'mid = (buffer[0][j] + buffer[1][j]) / 2' ! */
					encoder->private_->integer_signal_mid_side[1][i] = side;
					encoder->private_->integer_signal_mid_side[0][i] = mid;
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return false;
				}
			} while(j < samples);
		}
		else {
			/*
			 * independent channel coding: buffer each channel in inner loop
			 * without LPC: no need to calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					for(channel = 0; channel < channels; channel++)
						encoder->private_->integer_signal[channel][i] = buffer[channel][j];
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return false;
				}
			} while(j < samples);
		}
	}

	return true;
}

FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples)
{
	unsigned i, j, k, channel;
	FLAC__int32 x, mid, side;
	const unsigned channels = encoder->protected_->channels, blocksize = encoder->protected_->blocksize;

	FLAC__ASSERT(0 != encoder);
	FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK);

	j = k = 0;
	/*
	 * we have several flavors of the same basic loop, optimized for
	 * different conditions:
	 */
	if(encoder->protected_->max_lpc_order > 0) {
		if(encoder->protected_->do_mid_side_stereo && channels == 2) {
			/*
			 * stereo coding: unroll channel loop
			 * with LPC: calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					x = mid = side = buffer[k++];
					encoder->private_->integer_signal[0][i] = x;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
					encoder->private_->real_signal[0][i] = (FLAC__real)x;
#endif
					x = buffer[k++];
					encoder->private_->integer_signal[1][i] = x;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
					encoder->private_->real_signal[1][i] = (FLAC__real)x;
#endif
					mid += x;
					side -= x;
					mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
					encoder->private_->integer_signal_mid_side[1][i] = side;
					encoder->private_->integer_signal_mid_side[0][i] = mid;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
					encoder->private_->real_signal_mid_side[1][i] = (FLAC__real)side;
					encoder->private_->real_signal_mid_side[0][i] = (FLAC__real)mid;
#endif
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return false;
				}
			} while(j < samples);
		}
		else {
			/*
			 * independent channel coding: buffer each channel in inner loop
			 * with LPC: calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					for(channel = 0; channel < channels; channel++) {
						x = buffer[k++];
						encoder->private_->integer_signal[channel][i] = x;
#ifndef FLAC__INTEGER_ONLY_LIBRARY
						encoder->private_->real_signal[channel][i] = (FLAC__real)x;
#endif
					}
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return false;
				}
			} while(j < samples);
		}
	}
	else {
		if(encoder->protected_->do_mid_side_stereo && channels == 2) {
			/*
			 * stereo coding: unroll channel loop
			 * without LPC: no need to calculate floating point version of signal
			 */
			do {
				if(encoder->protected_->verify)
					append_to_verify_fifo_interleaved_(&encoder->private_->verify.input_fifo, buffer, j, channels, min(blocksize-encoder->private_->current_sample_number, samples-j));

				for(i = encoder->private_->current_sample_number; i < blocksize && j < samples; i++, j++) {
					encoder->private_->integer_signal[0][i] = mid = side = buffer[k++];
					x = buffer[k++];
					encoder->private_->integer_signal[1][i] = x;
					mid += x;
					side -= x;
					mid >>= 1; /* NOTE: not the same as 'mid = (left + right) / 2' ! */
					encoder->private_->integer_signal_mid_side[1][i] = side;
					encoder->private_->integer_signal_mid_side[0][i] = mid;
					encoder->private_->current_sample_number++;
				}
				if(i == blocksize) {
					if(!process_frame_(encoder, false)) /* false => not last frame */
						return fa