int netmaskFromIP(const struct sockaddr* in) {
int mask = 0;
if (in->sa_family == AF_INET6) {
auto in6 = (struct sockaddr_in6*)in;
for (size_t i = 0; i < 16; i++) {
mask += addBits(in6->sin6_addr.s6_addr[i]);
}
} else {
auto in4 = (struct sockaddr_in*)in;
auto address = reinterpret_cast<char*>(&in4->sin_addr.s_addr);
for (size_t i = 0; i < 4; i++) {
mask += addBits(address[i]);
}
}
return mask;
}
int L3_huffman_coder_count1( BitHolder **pph, struct huffcodetab *h, int v, int w, int x, int y )
{
HUFFBITS huffbits;
unsigned int signv, signw, signx, signy, p;
int len;
int totalBits = 0;
signv = abs_and_sign( &v );
signw = abs_and_sign( &w );
signx = abs_and_sign( &x );
signy = abs_and_sign( &y );
p = v + (w << 1) + (x << 2) + (y << 3);
huffbits = h->table[p];
len = h->hlen[ p ];
addBits( *pph, huffbits, len );
totalBits += len;
if ( v )
{
addBits( *pph, signv, 1 );
totalBits += 1;
}
if ( w )
{
addBits( *pph, signw, 1 );
totalBits += 1;
}
if ( x )
{
addBits( *pph, signx, 1 );
totalBits += 1;
}
if ( y )
{
addBits( *pph, signy, 1 );
totalBits += 1;
}
return totalBits;
}
static void write_ancillary_data( char *theData, int lengthInBits )
{
/*
*/
int bytesToSend = lengthInBits / 8;
int remainingBits = lengthInBits % 8;
unsigned wrd;
int i;
userFrameDataPH->nrEntries = 0;
for ( i = 0; i < bytesToSend; i++ )
{
wrd = theData[i];
addBits( userFrameDataPH, wrd, 8 );
}
if ( remainingBits )
{
/* right-justify remaining bits */
wrd = theData[bytesToSend] >> (8 - remainingBits);
addBits( userFrameDataPH, wrd, remainingBits );
}
}
/*
Note the discussion of huffmancodebits() on pages 28
and 29 of the IS, as well as the definitions of the side
information on pages 26 and 27.
*/
static void Huffmancodebits( BitHolder **pph, int *ix, gr_info *gi )
{
int L3_huffman_coder_count1( BitHolder **pph, struct huffcodetab *h, int v, int w, int x, int y );
int bigv_bitcount( int ix[576], gr_info *cod_info );
int region1Start;
int region2Start;
int i, bigvalues, count1End;
int v, w, x, y, bits, cbits, xbits, stuffingBits;
unsigned int code, ext;
struct huffcodetab *h;
int bvbits, c1bits, tablezeros, r0, r1, r2, rt, *pr;
int bitsWritten = 0;
tablezeros = 0;
r0 = r1 = r2 = 0;
/* 1: Write the bigvalues */
bigvalues = gi->big_values * 2;
if ( bigvalues )
{
if ( !(gi->mixed_block_flag) && gi->window_switching_flag && (gi->block_type == 2) )
{ /* Three short blocks */
/*
Within each scalefactor band, data is given for successive
time windows, beginning with window 0 and ending with window 2.
Within each window, the quantized values are then arranged in
order of increasing frequency...
*/
int sfb, window, line, start, end;
I192_3 *ix_s;
int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].s[0];
ix_s = (I192_3 *) ix;
region1Start = 12;
region2Start = 576;
for ( sfb = 0; sfb < 13; sfb++ )
{
unsigned tableindex = 100;
start = scalefac[ sfb ];
end = scalefac[ sfb+1 ];
if ( start < region1Start )
tableindex = gi->table_select[ 0 ];
else
tableindex = gi->table_select[ 1 ];
/* assert( tableindex < 32 ); */
for ( window = 0; window < 3; window++ )
for ( line = start; line < end; line += 2 )
{
x = (*ix_s)[line][window];
y = (*ix_s)[line + 1][window];
/* assert( idx < 576 );
assert( idx >= 0 ); */
bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
addBits( *pph, code, cbits );
addBits( *pph, ext, xbits );
bitsWritten += bits;
}
}
}
else if ( gi->mixed_block_flag && gi->block_type == 2 )
{ /* Mixed blocks long, short */
int sfb, window, line, start, end;
unsigned tableindex;
I192_3 *ix_s;
int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].s[0];
ix_s = (I192_3 *) ix;
/* Write the long block region */
tableindex = gi->table_select[0];
if ( tableindex )
for ( i = 0; i < 36; i += 2 )
{
x = ix[i];
y = ix[i + 1];
bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
addBits( *pph, code, cbits );
addBits( *pph, ext, xbits );
bitsWritten += bits;
}
/* Write the short block region */
tableindex = gi->table_select[ 1 ];
/* assert( tableindex < 32 ); */
for ( sfb = 3; sfb < 13; sfb++ )
{
start = scalefac[ sfb ];
end = scalefac[ sfb+1 ];
for ( window = 0; window < 3; window++ )
for ( line = start; line < end; line += 2 )
{
x = (*ix_s)[line][window];
y = (*ix_s)[line + 1][window];
bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
addBits( *pph, code, cbits );
addBits( *pph, ext, xbits );
bitsWritten += bits;
}
}
}
else
{ /* Long blocks */
int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].l[0];
unsigned scalefac_index = 100;
if ( gi->mixed_block_flag )
{
region1Start = 36;
region2Start = 576;
}
else
{
scalefac_index = gi->region0_count + 1;
region1Start = scalefac[ scalefac_index ];
scalefac_index += gi->region1_count + 1;
region2Start = scalefac[ scalefac_index ];
}
for ( i = 0; i < bigvalues; i += 2 )
{
unsigned tableindex = 100;
/* get table pointer */
if ( i < region1Start )
{
tableindex = gi->table_select[0];
pr = &r0;
}
else if ( i < region2Start )
{
tableindex = gi->table_select[1];
pr = &r1;
}
else
{
tableindex = gi->table_select[2];
pr = &r2;
}
/* assert( tableindex < 32 ); */
h = &ht[ tableindex ];
/* get huffman code */
x = ix[i];
y = ix[i + 1];
if ( tableindex )
{
bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
addBits( *pph, code, cbits );
addBits( *pph, ext, xbits );
bitsWritten += rt = bits;
*pr += rt;
}
else
{
tablezeros += 1;
*pr = 0;
}
}
}
}
bvbits = bitsWritten;
/* 2: Write count1 area */
h = &ht[gi->count1table_select + 32];
count1End = bigvalues + (gi->count1 * 4);
for ( i = bigvalues; i < count1End; i += 4 )
{
v = ix[i];
w = ix[i+1];
x = ix[i+2];
y = ix[i+3];
bitsWritten += L3_huffman_coder_count1( pph, h, v, w, x, y );
}
c1bits = bitsWritten - bvbits;
if ( (stuffingBits = gi->part2_3_length - gi->part2_length - bitsWritten) )
{
int stuffingWords = stuffingBits / 32;
int remainingBits = stuffingBits % 32;
/* assert( stuffingBits > 0 ); */
/*
Due to the nature of the Huffman code
tables, we will pad with ones
*/
while ( stuffingWords-- )
addBits( *pph, ~0, 32 );
if ( remainingBits )
addBits( *pph, ~0, remainingBits );
bitsWritten += stuffingBits;
}
}
static int encodeSideInfo( III_side_info_t *si )
{
int gr, ch, scfsi_band, region, window, bits_sent, mode_gr;
layer *info = fr_ps->header;
mode_gr = 2;
headerPH->nrEntries = 0;
addBits( headerPH, 0xfff, 12 );
addBits( headerPH, 1, 1 );
addBits( headerPH, 4 - info->lay, 2 );
addBits( headerPH, !info->error_protection, 1 );
addBits( headerPH, info->bitrate_index, 4 );
addBits( headerPH, info->sampling_frequency, 2 );
addBits( headerPH, info->padding, 1 );
addBits( headerPH, info->extension, 1 );
addBits( headerPH, info->mode, 2 );
addBits( headerPH, info->mode_ext, 2 );
addBits( headerPH, info->copyright, 1 );
addBits( headerPH, info->original, 1 );
addBits( headerPH, info->emphasis, 2 );
bits_sent = 32;
if ( info->error_protection )
{
addBits( headerPH, 0, 16 ); /* Just a dummy add. Real CRC calculated & inserted in writeSideInfo() */
bits_sent += 16;
}
frameSIPH->nrEntries = 0;
for (ch = 0; ch < stereo; ch++ )
channelSIPH[ch]->nrEntries = 0;
for ( gr = 0; gr < 2; gr++ )
for ( ch = 0; ch < stereo; ch++ )
spectrumSIPH[gr][ch]->nrEntries = 0;
addBits( frameSIPH, si->main_data_begin, 9 );
if ( stereo == 2 )
addBits( frameSIPH, si->private_bits, 3 );
else
addBits( frameSIPH, si->private_bits, 5 );
for ( ch = 0; ch < stereo; ch++ )
for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
{
BitHolder **pph = &channelSIPH[ch];
addBits( *pph, si->scfsi[ch][scfsi_band], 1 );
}
for ( gr = 0; gr < 2; gr++ )
for ( ch = 0; ch < stereo; ch++ )
{
BitHolder **pph = &spectrumSIPH[gr][ch];
gr_info *gi = &(si->gr[gr].ch[ch].tt);
addBits( *pph, gi->part2_3_length, 12 );
addBits( *pph, gi->big_values, 9 );
addBits( *pph, gi->global_gain, 8 );
addBits( *pph, gi->scalefac_compress, 4 );
addBits( *pph, gi->window_switching_flag, 1 );
if ( gi->window_switching_flag )
{
addBits( *pph, gi->block_type, 2 );
addBits( *pph, gi->mixed_block_flag, 1 );
for ( region = 0; region < 2; region++ )
addBits( *pph, gi->table_select[region], 5 );
for ( window = 0; window < 3; window++ )
addBits( *pph, gi->subblock_gain[window], 3 );
}
else
{
/* assert( gi->block_type == 0 ); */
for ( region = 0; region < 3; region++ )
addBits( *pph, gi->table_select[region], 5 );
addBits( *pph, gi->region0_count, 4 );
addBits( *pph, gi->region1_count, 3 );
}
addBits( *pph, gi->preflag, 1 );
addBits( *pph, gi->scalefac_scale, 1 );
addBits( *pph, gi->count1table_select, 1 );
}
if ( stereo == 2 )
bits_sent += 256;
else
bits_sent += 136;
return bits_sent;
}
static void encodeMainData( int l3_enc[2][2][576],
III_side_info_t *si,
III_scalefac_t *scalefac )
{
int gr, ch, sfb, window, mode_gr;
mode_gr = 2;
for ( gr = 0; gr < mode_gr; gr++ )
for ( ch = 0; ch < stereo; ch++ )
scaleFactorsPH[gr][ch]->nrEntries = 0;
for ( gr = 0; gr < mode_gr; gr++ )
for ( ch = 0; ch < stereo; ch++ )
codedDataPH[gr][ch]->nrEntries = 0;
for ( gr = 0; gr < 2; gr++ )
{
for ( ch = 0; ch < stereo; ch++ )
{
BitHolder **pph = &scaleFactorsPH[gr][ch];
gr_info *gi = &(si->gr[gr].ch[ch].tt);
unsigned slen1 = slen1_tab[ gi->scalefac_compress ];
unsigned slen2 = slen2_tab[ gi->scalefac_compress ];
int *ix = &l3_enc[gr][ch][0];
if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
{
if ( gi->mixed_block_flag )
{
for ( sfb = 0; sfb < 8; sfb++ )
addBits( *pph, scalefac->l[gr][ch][sfb], slen1 );
for ( sfb = 3; sfb < 6; sfb++ )
for ( window = 0; window < 3; window++ )
addBits( *pph, scalefac->s[gr][ch][sfb][window], slen1 );
for ( sfb = 6; sfb < 12; sfb++ )
for ( window = 0; window < 3; window++ )
addBits( *pph, scalefac->s[gr][ch][sfb][window], slen2 );
}
else
{
for ( sfb = 0; sfb < 6; sfb++ )
for ( window = 0; window < 3; window++ )
addBits( *pph, scalefac->s[gr][ch][sfb][window], slen1 );
for ( sfb = 6; sfb < 12; sfb++ )
for ( window = 0; window < 3; window++ )
addBits( *pph, scalefac->s[gr][ch][sfb][window], slen2 );
}
}
else
{
if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
for ( sfb = 0; sfb < 6; sfb++ )
addBits( *pph, scalefac->l[gr][ch][sfb], slen1 );
if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
for ( sfb = 6; sfb < 11; sfb++ )
addBits( *pph, scalefac->l[gr][ch][sfb], slen1 );
if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
for ( sfb = 11; sfb < 16; sfb++ )
addBits( *pph, scalefac->l[gr][ch][sfb], slen2 );
if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
for ( sfb = 16; sfb < 21; sfb++ )
addBits( *pph, scalefac->l[gr][ch][sfb], slen2 );
}
Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
} /* for ch */
} /* for gr */
} /* main_data */
