Linear Predictive Coding

EditDate	2025-2-13

Related Threads: Arts, Anarchist Spellbook, Religion and Philosophy, STEM

This is the heart of both fLaC compression and predicting the next sound, I think

Going to decode here and see how easily it can be introduced into my playAlong code.Web References https://en.wikipedia.org/wiki/Linear prediction

• w:Linear prediction
• w:Linear predictive coding

Linear Predictive Coding

Frame Header 2

Line Number	Code Package	LOC purpose	Operation Description
2987	SDC	read_residual_partitioned_rice	sample += u; Key parameters sample = 4088 for partition 0 4096 thereafter
2883	SDC	read_subframe_lpc	break
2889	SDC	Do Full Decode
2892	SDC	Get Warm-up values	8 previously stored warm-up values based on order=8
Next set of routines are hidden because they are primarily used to determine whether we are 32 bit or 64 bit architecture. We will always be 64 bit.
2898	SDC	FLAC__lpc_restore_signal_wide(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, subframe->qlp_coeff, order, subframe->quantization_level, decoder->private_->output[channel]+order); channel = 0 order = 8 decoder->private_->residual[channel] = 0x555555863340 memory address decoder->private_->frame.header.blocksize-order = 4096 - 8 = 4088 = 0xff8 subframe->qlp_coeff = 0x555555859efc address to start of 32 bit array subframe->quantization_level = 13 0xd decoder->private_->output[channel]+order = 0x5555558599c0 +0x8*8(32 Bits) = 0x5555558599c0 + 0x40 = 0x555555859A00
1238	LPC	void FLAC__lpc_restore_signal_wide(const FLAC__int32 * flac_restrict residual, uint32_t data_len, const FLAC__int32 * flac_restrict qlp_coeff, uint32_t order, int lp_quantization, FLAC__int32 * flac_restrict data) residual = 0xfffffb81 = -1151 data_len = 4088 = 0xff8 qlp_coeff = 0x555555859efc address to start of 32 bit array order = 8 lp_quantization = 13 0xd data = 0x55555585f350 Looks like this is a virgin address need to check (data++) = (FLAC__int32)(*(r++) + (sum >> lp_quantization)); data = 0x55555585f350 -> 0x55555585f394 0x55555585f390 0000 0000 -> c670ffff = ffff70c6 = 30 testBigEndian.raw file. r = 0x555555863340 81FB FFFF 81FD FFFF FE06 0000 D0FC FFFF 09FE FFFF 8AFE FFFF 2504 0000 76F9 FFFF sum = 0xffffffffeea8a9d8 lp_quantization = 0xD = 13
1264	LPC	FLAC__lpc_restore_signal_wide	*(data++) = (FLAC__int32)(*(r++) + (sum >> lp_quantization)); *data -> FFFF70C6 sum = 0xffffffffeea8a9d8 lp_quantization = 13 = 0xd *r = 0xfffffb81 0xffffffffeea8a9d8»0xd = 7FFFFFFFF7545 7FFFFFFFF7545 + 0xfffffb81 = 80000FFFF70C6

Next Edit

First Sample Raw

1256 LPC for(j = 0; j < order; j++) sum += (FLAC__int64)qlp_coeff[j] * (FLAC__int64)(*(--history));

• order = 8
• qlp_coeff const FLAC__int32 * restrict 0x555555859efc

0x555555859efc	E51D0000 282E0000 E0E2FFFF F4CFFFFF 170C0000 17210000 72010000 6EF2FFFF

• history = data = history FLAC__int32 * 0x55555585f350

0x55555585f340 DF91FFFF A28EFFFF 6186FFFF 717BFFFF
0x55555585f350 00000000 00000000 00000000 00000000

1264 LPC *(data++) = (FLAC__int32)(*(r++) + (sum >> lp_quantization)); First result:

• data = FLAC__int32 * restrict 0x55555585f350
  • *data = FLAC__int32 0
• r const FLAC__int32 * 0x555555863340
  • *r const FLAC__int32 -1151 0xfffffb81
• sum = FLAC__int64 -290936360 = 0xffffffffeea8a9d8
• lp_quantization lp_quantization = int 13 = 0xd

Little Endian in Memory C670FFFF
Big Endian as read FFFF70C6
testBigEndian.raw 0030 FF70C6

FLAC Secret Source

/*
 * Linear predictive coding to decompress encoded fLaC file
 * Variable Values
 * *data Address pointing to end of array of samples order deep in starting with warmup values in test case 8 samples
 * *coefficient pointer to start of an array of coefficients
 * *residual  pointer to dataLen long array of 32 bit residual values previously calculated
 * order driving number for coefficients and previous samples available for calculation 8
 * quantization number of bits we have to shift answer to fit to bps in first case 13.  Hope to eliminate as not really needed.
 *
 */
int32_t lpc(uint64_t *data, int32_t *coefficient, uint64_t *residual, uint32_t order,
		uint32_t quantization) {
	/* Calculate predicted sample */
	int32_t sum = 0; // Predicted value being calculated
	/* For each coefficient sample going backwards one at a time add coefficient * sample */
	for (uint32_t j = 0; j < order; j++)
		sum += (int64_t) coefficient[j] * (int64_t) (*(--data));
	/* add residual and ensure fits in bit size */
	sum = (int32_t) (*(residual++) + (sum >> quantization));
	return sum;
}

Notes for code analysis

4 bytes / int 32 Bits.

little endian memory dump of in storage buffer

19 7F D1 4F 19 7F D1 4F 19 7F D1 4F FD 44 01 37  56 26 0A 25 B2 EE F6 7F 9D 10 5D 79 62 33 5B 9F B4 0E 65 24 15 7A 35 13 370144FD4FD17F19 at 2380 in test.flac.

File

3701 44FD 4FD1 4FD1 7F19 7FF6 EEB2 250A 2656 does not line up with contiguous memory location.  Only 64 bit word valid in memory (if reversed) 
loc 2380 in file

word