static void write_pt_len(int n, int nbit, int i_special)
{
int i, k;
while (n > 0 && pt_len[n - 1] == 0)
{
n--;
}
putbits(nbit, n);
i = 0;
while (i < n)
{
k = pt_len[i++];
if (k <= 6)
{
putbits(3, k);
}
else
{
putbits(k - 3, (1U << (k - 3)) - 2);
}
if (i == i_special)
{
while (i < 6 && pt_len[i] == 0)
{
i++;
}
putbits(2, (i - 3) & 3);
}
}
}
void II_encode_scale(
UINT bit_alloc[2][SBLIMIT],
UINT scfsi[2][SBLIMIT],
UINT scalar[2][3][SBLIMIT],
FRAME* pFrame,
BITSTREAM* pBitstream )
{
int stereo = pFrame->nChannels;
int sblimit = pFrame->sblimit;
int jsbound = pFrame->jsbound;
int i,j,k;
for (i=0;i<sblimit;i++) for (k=0;k<stereo;k++)
if (bit_alloc[k][i]) putbits(pBitstream,scfsi[k][i],2);
for (i=0;i<sblimit;i++) for (k=0;k<stereo;k++)
if (bit_alloc[k][i]) /* above jsbound, bit_alloc[0][i] == ba[1][i] */
switch (scfsi[k][i]) {
case 0: for (j=0;j<3;j++)
putbits(pBitstream,scalar[k][j][i],6);
break;
case 1:
case 3: putbits(pBitstream,scalar[k][0][i],6);
putbits(pBitstream,scalar[k][2][i],6);
break;
case 2: putbits(pBitstream,scalar[k][0][i],6);
}
}
/*
* encodeMainData
* --------------
* Encodes the spectrum and places the coded
* main data in the buffer main.
* Returns the number of bytes stored.
*/
static int encodeMainData(int l3_enc[2][2][samp_per_frame2],
L3_side_info_t *si)
{
int gr, ch;
bits = 0;
by = 0;
bi = 8;
main_[0]=0;
/* huffmancodes plus reservoir stuffing */
for(gr = 0; gr < config.mpeg.granules; gr++)
for (ch = 0; ch < config.mpeg.channels; ch++)
Huffmancodebits( l3_enc[gr][ch], &si->gr[gr].ch[ch].tt ); /* encode the spectrum */
/* ancillary data, used for reservoir stuffing overflow */
if(si->resv_drain)
{
int words = si->resv_drain >> 5;
int remainder = si->resv_drain & 31;
/* pad with zeros */
while(words--)
putbits(main_, 0, 32 );
if(remainder)
putbits(main_, 0, remainder );
}
inline void mppc::putlit(unsigned char *&buf, unsigned int c, unsigned int& l)
{
if (c < 0x80)
putbits(buf, c, 8, l);
else
putbits(buf, c&0x7f|0x100, 9, l);
}
Sfoff_t huffdecode(register Huff_t *hp,Sfio_t *input,Sfio_t *output,int size)
{
register long buffer;
register int left, i, n;
register int lev = 0;
register unsigned char *outp;
register unsigned char *inp;
unsigned char *outend;
unsigned char *outbuff;
Sfoff_t insize = hp->outsize;
/* decode the header if called with different hp */
if(lastid!=hp->id)
{
decode_header(hp);
if(!hp->id)
hp->id = id++;
lastid = hp->id;
}
/* set up output buffers for faster access */
if(!(outp=outbuff=(unsigned char*)sfreserve(output,SF_UNBOUND,SF_LOCKR)))
return(sfvalue(output));
n = sfvalue(output);
if(size>=0)
{
if(n > size)
n = size;
size -= n;
}
outend = outp+n;
/* set up input buffers for faster access */
infile = input;
if(!(inp=inbuff=(unsigned char*)sfreserve(infile,SF_UNBOUND,0)))
return(sfvalue(infile));
inend = inp + sfvalue(infile);
buffer = hp->buffer;
left = hp->left;
/* main decoding loop */
while (1)
{
if(lev==0)
{
fillbuff(buffer,left,hp->maxlev,inp);
i = getbits(buffer,left,CHUNK);
if((n=(numbits[i]-1)) >= 0)
{
putbits(buffer,left,n);
*outp++ = outchar[i];
goto pout;
}
if(hp->excess)
{
putbits(buffer,left,hp->excess);
i >>= hp->excess;
}
lev = CHUNK-hp->excess;
}
static void write_c_len(void)
{
int i, k, n, count;
n = NC;
while (n > 0 && c_len[n - 1] == 0)
{
n--;
}
putbits(CBIT, n);
i = 0;
while (i < n)
{
k = c_len[i++];
if (k == 0)
{
count = 1;
while (i < n && c_len[i] == 0)
{
i++;
count++;
}
if (count <= 2)
{
for (k = 0; k < count; k++)
{
putbits(pt_len[0], pt_code[0]);
}
}
else if (count <= 18)
{
putbits(pt_len[1], pt_code[1]);
putbits(4, count - 3);
}
else if (count == 19)
{
putbits(pt_len[0], pt_code[0]);
putbits(pt_len[1], pt_code[1]);
putbits(4, 15);
}
else
{
putbits(pt_len[2], pt_code[2]);
putbits(CBIT, count - 20);
}
}
else
{
putbits(pt_len[k + 2], pt_code[k + 2]);
}
}
}
/*write N bits byte aligned into the bit stream */
void byte_ali_putbits (Bit_stream_struc * bs, unsigned int val, int N)
{
unsigned long aligning;
if (N > MAX_LENGTH)
fprintf (stderr, "Cannot read or write more than %d bits at a time.\n",
MAX_LENGTH);
aligning = sstell (bs) % 8;
if (aligning)
putbits (bs, (unsigned int) 0, (int) (8 - aligning));
putbits (bs, val, N);
}
/* generate sequence display extension (6.2.2.4, 6.3.6)
*
* content not yet user setable
*/
void putseqdispext()
{
alignbits();
putbits(EXT_START_CODE,32); /* extension_start_code */
putbits(DISP_ID,4); /* extension_start_code_identifier */
putbits(video_format,3); /* video_format */
putbits(1,1); /* colour_description */
putbits(color_primaries,8); /* colour_primaries */
putbits(transfer_characteristics,8); /* transfer_characteristics */
putbits(matrix_coefficients,8); /* matrix_coefficients */
putbits(display_horizontal_size,14); /* display_horizontal_size */
putbits(1,1); /* marker_bit */
putbits(display_vertical_size,14); /* display_vertical_size */
}
static int
packech2(Chain *ch, EiceChain2 *ec2)
{
EiceChain2 lec;
if(!valregaddr(ec2->addr))
return -1;
hleputl(&lec.data, ec2->data);
putbits(ch, &lec.data, DataSz);
putbits(ch, &ec2->addr, AddrSz);
putbits(ch, &ec2->rw, RWSz);
return 0;
}
void flushFrame (void)
{
/* Fill out the last frame with 0xFF */
while (BitsRemaining > 32)
{
putbits (0xFFFFFFFF, 32);
BitsRemaining -= 32;
}
if (BitsRemaining > 0)
putbits (0xFFFFFFFF, BitsRemaining);
BitsRemaining = 0;
}
/*close the device containing the bit stream after a write process*/
void close_bit_stream_w (Bit_stream_struc * bs)
{
putbits (bs, 0, 7);
empty_buffer (bs, bs->buf_byte_idx + 1);
fclose (bs->pt);
desalloc_buffer (bs);
}
void encode_info(FRAME *pFrame,BITSTREAM *pBitstream)
{
PHEADER pHeader = pFrame->pHeader;
/* Total heade is 32 bits in big endian representation */
/* ID POSITION SIZE */
/* frame sync 31-21 12 */
/* MPEG_ID 20-19 2 */
/* LAYER 18-17 2 */
/* CRC disabled 16-16 1 */
/* Bitrate index 15-12 4 */
/* Sampling rate index 11-10 2 */
/* Padding bit 9- 9 1 */
/* Padding bit 9- 9 1 */
/* Private bit 8- 8 1 */
/* Channel mode 7- 6 2 */
/* Join stereo extention 5- 4 2 */
/* Copyright bit 3- 3 1 */
/* Original bit 2- 2 1 */
/* Emphasis 1- 0 2 */
putbits(pBitstream,0xfff,12); // syncword 12 bits
put1bit(pBitstream,pHeader->version); // ID 1 bit
putbits(pBitstream,4-pHeader->lay,2); // HEADER 2 bits
put1bit(pBitstream,!pHeader->bCRC); // bit set => no err prot
putbits(pBitstream,pHeader->bitrate_index,4);
putbits(pBitstream,pHeader->sampling_frequency,2);
put1bit(pBitstream,pHeader->padding);
put1bit(pBitstream,pHeader->bPrivate); // private_bit
putbits(pBitstream,pHeader->mode,2);
putbits(pBitstream,pHeader->mode_ext,2);
put1bit(pBitstream,pHeader->copyright);
put1bit(pBitstream,pHeader->original);
putbits(pBitstream,pHeader->emphasis,2);
}
static int close_blockbuilder(struct blockbuilder *bb) {
int bytesleft;
while(bb->bits_in_shifter) putbits(bb, 0, 1);
bytesleft = bb->revpos - bb->pos + 1;
free(bb);
return bytesleft;
}
/* ------------------------------------------------------------------------ */
void
encode_p_st0(unsigned short j)
{
unsigned short i;
i = j >> 6;
putcode(pt_len[i], pt_code[i]);
putbits(6, j & 0x3f);
}
static void writeBitHolder (BitHolder *part)
{
BitHolderElement *ep;
int i;
ep = part->element;
for (i = 0; i < part->nrEntries; i++, ep++)
putbits (ep->value, ep->length);
}
void II_sample_encoding( UINT sbband[2][3][SCALE_BLOCK][SBLIMIT],
UINT bit_alloc[2][SBLIMIT],
PFRAME pFrame,
PBITSTREAM pBitstream
)
{
UINT j,s,x,y;
int i,k;
int nChannels = pFrame->nChannels;
int sblimit = pFrame->sblimit;
int jsbound = pFrame->jsbound;
ALLOC_16* pAlloc = pFrame->alloc[0];
for (s=0;s<3;s++)
{
for (j=0;j<SCALE_BLOCK;j+=3)
{
for (i=0;i<sblimit;i++)
{
for (k=0;k<((i<jsbound)?nChannels:1);k++)
{
if (bit_alloc[k][i])
{
if (pAlloc[i][bit_alloc[k][i]].group == 3)
{
for (x=0;x<3;x++)
putbits(pBitstream,sbband[k][s][j+x][i],pAlloc[i][bit_alloc[k][i]].bits);
}
else
{
UINT temp;
y =pAlloc[i][bit_alloc[k][i]].steps;
temp = sbband[k][s][j][i] +
sbband[k][s][j+1][i] * y +
sbband[k][s][j+2][i] * y * y;
putbits(pBitstream,temp,pAlloc[i][bit_alloc[k][i]].bits);
}
}
}
}
}
}
}
static int
packech1(Chain *ch, EiceChain1 *ec1)
{
EiceChain1 lec;
uchar unused;
unused = 0;
lec.instr = hmsbputl(&ec1->instr);
hbeputl(&lec.rwdata, ec1->rwdata);
putbits(ch, &lec.rwdata, RWDataSz);
putbits(ch, &unused, 1);
putbits(ch, &lec.wptandbkpt, WpTanDBKptSz);
putbits(ch, &ec1->sysspeed, SysSpeedSz);
putbits(ch, &lec.instr, InstrSz);
return 0;
}
/* generate sequence extension (6.2.2.3, 6.3.5) header (MPEG-2 only) */
void putseqext()
{
alignbits();
putbits(EXT_START_CODE,32); /* extension_start_code */
putbits(SEQ_ID,4); /* extension_start_code_identifier */
putbits((profile<<4)|level,8); /* profile_and_level_indication */
putbits(prog_seq,1); /* progressive sequence */
putbits(chroma_format,2); /* chroma_format */
putbits(horizontal_size>>12,2); /* horizontal_size_extension */
putbits(vertical_size>>12,2); /* vertical_size_extension */
putbits(((int)ceil(bit_rate/400.0))>>18,12); /* bit_rate_extension */
putbits(1,1); /* marker_bit */
putbits(vbv_buffer_size>>10,8); /* vbv_buffer_size_extension */
putbits(0,1); /* low_delay -- currently not implemented */
putbits(0,2); /* frame_rate_extension_n */
putbits(0,5); /* frame_rate_extension_d */
}
int
alignbits ()
{
int ret_value;
if (outcnt!=8) {
ret_value = outcnt; /* outcnt is reset in call to putbits () */
putbits (outcnt, 0);
return ret_value;
}
else
return 0;
}
static int clpf_decision(int k, int l, yuv_frame_t *rec, yuv_frame_t *org, const deblock_data_t *deblock_data, int block_size, void *stream) {
int sum0 = 0, sum1 = 0;
for (int m=0;m<MAX_BLOCK_SIZE/block_size;m++){
for (int n=0;n<MAX_BLOCK_SIZE/block_size;n++){
int xpos = l*MAX_BLOCK_SIZE + n*block_size;
int ypos = k*MAX_BLOCK_SIZE + m*block_size;
int index = (ypos/MIN_PB_SIZE)*(rec->width/MIN_PB_SIZE) + (xpos/MIN_PB_SIZE);
if (deblock_data[index].cbp.y && deblock_data[index].mode != MODE_BIPRED)
(use_simd ? detect_clpf_simd : detect_clpf)(rec->y,org->y,xpos,ypos,rec->width,rec->height,org->stride_y,rec->stride_y,&sum0,&sum1);
}
}
putbits(1, sum1 < sum0, (stream_t*)stream);
return sum1 < sum0;
}
static void encode_p(uint p)
{
uint c, q;
c = 0;
q = p;
while (q)
{
q >>= 1;
c++;
}
putbits(pt_len[c], pt_code[c]);
if (c > 1)
{
putbits(c - 1, p & (0xFFFFU >> (17 - c)));
}
void II_encode_bit_alloc(
UINT bit_alloc[2][SBLIMIT],
FRAME *pFrame,
BITSTREAM *pBitstream
)
{
int i,k;
int nChannels = pFrame->nChannels;
int sblimit = pFrame->sblimit;
int jsbound = pFrame->jsbound;
ALLOC_16* pAlloc = pFrame->alloc[0];
for (i=0;i<sblimit;i++)
{
for (k=0;k<((i<jsbound)?nChannels:1);k++)
{
putbits(pBitstream,bit_alloc[k][i],pAlloc[i][0].bits);
}
}
}
int main(int argc, char *argv[])
{
int i;
strcpy(zero, "_");
strcpy(one, "O");
printf("#ifndef __DEF01_H__\n"
"#define __DEF01_H__\n");
putchar('\n');
for(i=0; i<256; i++) {
printf("#define ");
putbits(i, 8, 0);
printf(" 0x%02X", i);
putchar('\n');
}
putchar('\n');
printf("#endif\n");
putchar('\n');
}
lzo2a_999_compress_callback(const lzo_bytep in , lzo_uint in_len,
lzo_bytep out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_callback_p cb,
lzo_uint max_chain)
{
lzo_bytep op;
lzo_bytep bitp = 0;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T* const c = &cc;
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
int r;
lzo_uint32_t b = 0; /* bit buffer */
unsigned k = 0; /* bits in bit buffer */
/* sanity check */
LZO_COMPILE_TIME_ASSERT(LZO2A_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->cb = cb;
c->m1 = c->m2 = c->m3 = c->m4 = 0;
op = out;
r = init_match(c, swd, NULL, 0, 0);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
r = find_match(c, swd, 0, 0);
if (r != 0)
return r;
while (c->look > 0)
{
lzo_uint lazy_match_min_gain = 0;
#if (SWD_N >= 8192)
lzo_uint extra1 = 0;
#endif
lzo_uint extra2 = 0;
lzo_uint ahead = 0;
m_len = c->m_len;
m_off = c->m_off;
#if (SWD_N >= 8192)
if (m_off >= 8192)
{
if (m_len < M3_MIN_LEN)
m_len = 0;
else
lazy_match_min_gain = 1;
}
else
#endif
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
lazy_match_min_gain = 2;
#if (SWD_N >= 8192)
extra1 = 3;
#endif
extra2 = 2;
}
else if (m_len >= 10)
lazy_match_min_gain = 1;
else if (m_len >= 3)
{
lazy_match_min_gain = 1;
#if (SWD_N >= 8192)
extra1 = 1;
#endif
}
else
m_len = 0;
/* try a lazy match */
if (lazy_match_min_gain > 0 && c->look > m_len)
{
unsigned char lit = LZO_BYTE(swd->b_char);
r = find_match(c, swd, 1, 0);
assert(r == 0);
LZO_UNUSED(r);
assert(c->look > 0);
#if (SWD_N >= 8192)
if (m_off < 8192 && c->m_off >= 8192)
lazy_match_min_gain += extra1;
else
#endif
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
if (!(c->m_len >= M1_MIN_LEN &&
c->m_len <= M1_MAX_LEN && c->m_off <= 256))
lazy_match_min_gain += extra2;
}
if (c->m_len >= M1_MIN_LEN &&
c->m_len <= M1_MAX_LEN && c->m_off <= 256)
{
lazy_match_min_gain -= 1;
}
if ((lzo_int) lazy_match_min_gain < 1)
lazy_match_min_gain = 1;
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
#if !defined(NDEBUG)
m_len = c->m_len;
m_off = c->m_off;
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
assert(m_len >= 3 || (m_len >= 2 && m_off <= 256));
#endif
/* code literal */
putbit(0);
putbyte(lit);
c->lit_bytes++;
continue;
}
else
ahead = 1;
assert(m_len > 0);
}
if (m_len == 0)
{
/* a literal */
putbit(0);
putbyte(swd->b_char);
c->lit_bytes++;
r = find_match(c, swd, 1, 0);
assert(r == 0);
LZO_UNUSED(r);
}
else
{
assert(m_len >= M1_MIN_LEN);
assert(m_off > 0);
assert(m_off <= SWD_N);
/* 2 - code match */
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
putbit(1);
putbit(0);
putbits(2, m_len - M1_MIN_LEN);
putbyte(m_off - 1);
c->m1++;
}
#if (SWD_N >= 8192)
else if (m_off >= 8192)
{
unsigned len = m_len;
assert(m_len >= M3_MIN_LEN);
putbit(1);
putbit(1);
putbyte(m_off & 31);
putbyte(m_off >> 5);
putbit(1);
len -= M3_MIN_LEN - 1;
while (len > 255)
{
len -= 255;
putbyte(0);
}
putbyte(len);
c->m4++;
}
#endif
else
{
assert(m_len >= 3);
putbit(1);
putbit(1);
if (m_len <= 9)
{
putbyte(((m_len - 2) << 5) | (m_off & 31));
putbyte(m_off >> 5);
c->m2++;
}
else
{
lzo2a_999_compress_callback ( const lzo_byte *in , lzo_uint in_len,
lzo_byte *out, lzo_uintp out_len,
lzo_voidp wrkmem,
lzo_progress_callback_t cb,
lzo_uint max_chain )
{
lzo_byte *op;
lzo_byte *bitp = 0;
lzo_uint m_len, m_off;
LZO_COMPRESS_T cc;
LZO_COMPRESS_T * const c = &cc;
lzo_swd_t * const swd = (lzo_swd_t *) wrkmem;
int r;
lzo_uint32 b = 0; /* bit buffer */
unsigned k = 0; /* bits in bit buffer */
#if defined(__LZO_QUERY_COMPRESS)
if (__LZO_IS_COMPRESS_QUERY(in,in_len,out,out_len,wrkmem))
return __LZO_QUERY_COMPRESS(in,in_len,out,out_len,wrkmem,1,lzo_sizeof(lzo_swd_t));
#endif
/* sanity check */
if (!lzo_assert(LZO2A_999_MEM_COMPRESS >= lzo_sizeof(lzo_swd_t)))
return LZO_E_ERROR;
c->init = 0;
c->ip = c->in = in;
c->in_end = in + in_len;
c->cb = cb;
c->m1 = c->m2 = c->m3 = c->m4 = 0;
op = out;
r = init_match(c,swd,NULL,0,0);
if (r != 0)
return r;
if (max_chain > 0)
swd->max_chain = max_chain;
r = find_match(c,swd,0,0);
if (r != 0)
return r;
while (c->look > 0)
{
int lazy_match_min_gain = 0;
int extra1 = 0;
int extra2 = 0;
lzo_uint ahead = 0;
LZO_UNUSED(extra1);
m_len = c->m_len;
m_off = c->m_off;
#if (N >= 8192)
if (m_off >= 8192)
{
if (m_len < M3_MIN_LEN)
m_len = 0;
else
lazy_match_min_gain = 1;
}
else
#endif
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
lazy_match_min_gain = 2;
extra1 = 3;
extra2 = 2;
}
else if (m_len >= 10)
lazy_match_min_gain = 1;
else if (m_len >= 3)
{
lazy_match_min_gain = 1;
extra1 = 1;
}
else
m_len = 0;
/* try a lazy match */
if (lazy_match_min_gain > 0 && c->look > m_len)
{
int lit = swd->b_char;
r = find_match(c,swd,1,0);
assert(r == 0);
assert(c->look > 0);
#if (N >= 8192)
if (m_off < 8192 && c->m_off >= 8192)
lazy_match_min_gain += extra1;
else
#endif
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
if (!(c->m_len >= M1_MIN_LEN &&
c->m_len <= M1_MAX_LEN && c->m_off <= 256))
lazy_match_min_gain += extra2;
}
if (c->m_len >= M1_MIN_LEN &&
c->m_len <= M1_MAX_LEN && c->m_off <= 256)
{
lazy_match_min_gain -= 1;
}
if (lazy_match_min_gain < 1)
lazy_match_min_gain = 1;
if (c->m_len >= m_len + lazy_match_min_gain)
{
c->lazy++;
#if !defined(NDEBUG)
m_len = c->m_len;
m_off = c->m_off;
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
m_len) == 0);
assert(m_len >= 3 || (m_len >= 2 && m_off <= 256));
#endif
/* code literal */
putbit(0);
putbyte(lit);
c->lit_bytes++;
continue;
}
else
ahead = 1;
assert(m_len > 0);
}
if (m_len == 0)
{
/* a literal */
putbit(0);
putbyte(swd->b_char);
c->lit_bytes++;
r = find_match(c,swd,1,0);
assert(r == 0);
}
else
{
assert(m_len >= M1_MIN_LEN);
assert(m_off > 0);
assert(m_off <= N);
/* 2 - code match */
if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256)
{
putbit(1);
putbit(0);
putbits(2,m_len - M1_MIN_LEN);
putbyte(m_off - 1);
c->m1++;
}
#if (N >= 8192)
else if (m_off >= 8192)
{
unsigned len = m_len;
assert(m_len >= M3_MIN_LEN);
putbit(1);
putbit(1);
putbyte(m_off & 31);
putbyte(m_off >> 5);
putbit(1);
len -= M3_MIN_LEN - 1;
while (len > 255)
{
len -= 255;
putbyte(0);
}
putbyte(len);
c->m4++;
}
#endif
else
{
assert(m_len >= 3);
putbit(1);
putbit(1);
if (m_len <= 9)
{
putbyte(((m_len - 2) << 5) | (m_off & 31));
putbyte(m_off >> 5);
c->m2++;
}
else
{
void encode_CRC(UINT crc,BITSTREAM* pBitstream)
{
putbits(pBitstream, crc, 16);
}
int
select(
int nd,
fd_set *in,
fd_set *ou,
fd_set *ex,
struct timeval *tv
)
{
fd_mask *ibits[3], *obits[3], *selbits, *sbp;
int error, forever, nselected;
u_int nbufbytes, ncpbytes, nfdbits;
int64_t timo;
if (nd < 0)
return (EINVAL);
/*
* Allocate just enough bits for the non-null fd_sets. Use the
* preallocated auto buffer if possible.
*/
nfdbits = roundup(nd, NFDBITS);
ncpbytes = nfdbits / NBBY;
nbufbytes = 0;
if (in != NULL)
nbufbytes += 2 * ncpbytes;
if (ou != NULL)
nbufbytes += 2 * ncpbytes;
if (ex != NULL)
nbufbytes += 2 * ncpbytes;
selbits = malloc(nbufbytes);
/*
* Assign pointers into the bit buffers and fetch the input bits.
* Put the output buffers together so that they can be bzeroed
* together.
*/
sbp = selbits;
#define getbits(name, x) \
do { \
if (name == NULL) \
ibits[x] = NULL; \
else { \
ibits[x] = sbp + nbufbytes / 2 / sizeof *sbp; \
obits[x] = sbp; \
sbp += ncpbytes / sizeof *sbp; \
bcopy(name, ibits[x], ncpbytes); \
} \
} while (0)
getbits(in, 0);
getbits(ou, 1);
getbits(ex, 2);
#undef getbits
if (nbufbytes != 0)
memset(selbits, 0, nbufbytes / 2);
if (tv) {
timo = tv->tv_usec + (tv->tv_sec * 1000000);
forever = 0;
} else {
timo = 0;
forever = 1;
}
/*
* Poll for I/O events
*/
nselected = 0;
do {
/*
* Scan for pending I/O
*/
error = selscan(ibits, obits, nd, &nselected);
if (error || nselected)
break;
/*
* Adjust timeout is needed
*/
if (timo) {
/*
* Give it a rest
*/
usleep( _SELECT_DELAY_ );
timo -= _SELECT_DELAY_;
}
} while (timo > 0 || forever);
/* select is not restarted after signals... */
if (error == ERESTART)
error = EINTR;
else if (error == EWOULDBLOCK)
error = 0;
#define putbits(name, x) if (name) bcopy(obits[x], name, ncpbytes)
if (error == 0) {
putbits(in, 0);
putbits(ou, 1);
putbits(ex, 2);
#undef putbits
} else {
errno = error;
nselected = -1;
}
free( selbits );
return ( nselected );
}
void encode_frame(encoder_info_t *encoder_info)
{
int k,l;
int width = encoder_info->width;
int height = encoder_info->height;
int num_sb_hor = (width + MAX_BLOCK_SIZE - 1)/MAX_BLOCK_SIZE;
int num_sb_ver = (height + MAX_BLOCK_SIZE - 1)/MAX_BLOCK_SIZE;
stream_t *stream = encoder_info->stream;
memset(encoder_info->deblock_data, 0, ((height/MIN_PB_SIZE) * (width/MIN_PB_SIZE) * sizeof(deblock_data_t)) );
frame_info_t *frame_info = &(encoder_info->frame_info);
double lambda_coeff;
if (frame_info->frame_type == I_FRAME)
lambda_coeff = encoder_info->params->lambda_coeffI;
else if(frame_info->frame_type == P_FRAME)
lambda_coeff = encoder_info->params->lambda_coeffP;
else{
if (frame_info->b_level==0)
lambda_coeff = encoder_info->params->lambda_coeffB0;
else if(frame_info->b_level == 1)
lambda_coeff = encoder_info->params->lambda_coeffB1;
else if (frame_info->b_level == 2)
lambda_coeff = encoder_info->params->lambda_coeffB2;
else if (frame_info->b_level == 3)
lambda_coeff = encoder_info->params->lambda_coeffB3;
else
lambda_coeff = encoder_info->params->lambda_coeffB;
}
frame_info->lambda = lambda_coeff*squared_lambda_QP[frame_info->qp];
putbits(1,encoder_info->frame_info.frame_type!=I_FRAME,stream);
uint8_t qp = encoder_info->frame_info.qp;
putbits(8,(int)qp,stream);
putbits(4,(int)encoder_info->frame_info.num_intra_modes,stream);
// Signal actual number of reference frames
if (frame_info->frame_type!=I_FRAME)
putbits(2,encoder_info->frame_info.num_ref-1,stream);
int r;
for (r=0;r<encoder_info->frame_info.num_ref;r++){
putbits(6,encoder_info->frame_info.ref_array[r]+1,stream);
}
// 16 bit frame number for now
putbits(16,encoder_info->frame_info.frame_num,stream);
for (k=0;k<num_sb_ver;k++){
for (l=0;l<num_sb_hor;l++){
int xposY = l*MAX_BLOCK_SIZE;
int yposY = k*MAX_BLOCK_SIZE;
for (int ref_idx = 0; ref_idx <= frame_info->num_ref - 1; ref_idx++){
frame_info->mvcand_num[ref_idx] = 0;
frame_info->mvcand_mask[ref_idx] = 0;
}
frame_info->best_ref = -1;
int max_delta_qp = encoder_info->params->max_delta_qp;
if (max_delta_qp){
/* RDO-based search for best QP value */
int cost,min_cost,best_qp,qp0,max_delta_qp,min_qp,max_qp;
max_delta_qp = encoder_info->params->max_delta_qp;
min_cost = 1<<30;
stream_pos_t stream_pos_ref;
read_stream_pos(&stream_pos_ref,stream);
best_qp = qp;
min_qp = qp-max_delta_qp;
max_qp = qp+max_delta_qp;
for (qp0=min_qp;qp0<=max_qp;qp0+=encoder_info->params->delta_qp_step){
cost = process_block(encoder_info,MAX_BLOCK_SIZE,yposY,xposY,qp0);
if (cost < min_cost){
min_cost = cost;
best_qp = qp0;
}
}
write_stream_pos(stream,&stream_pos_ref);
process_block(encoder_info,MAX_BLOCK_SIZE,yposY,xposY,best_qp);
}
else{
process_block(encoder_info,MAX_BLOCK_SIZE,yposY,xposY,qp);
}
}
}
if (encoder_info->params->deblocking){
deblock_frame_y(encoder_info->rec, encoder_info->deblock_data, width, height, qp);
int qpc = chroma_qp[qp];
deblock_frame_uv(encoder_info->rec, encoder_info->deblock_data, width, height, qpc);
}
int sb_signal = 1;
if (encoder_info->params->clpf){
putbits(1, 1, stream);
putbits(1, !sb_signal, stream);
clpf_frame(encoder_info->rec, encoder_info->orig, encoder_info->deblock_data, stream,
sb_signal ? clpf_decision : clpf_true);
}
/* Sliding window operation for reference frame buffer by circular buffer */
/* Store pointer to reference frame that is shifted out of reference buffer */
yuv_frame_t *tmp = encoder_info->ref[MAX_REF_FRAMES-1];
/* Update remaining pointers to implement sliding window reference buffer operation */
memmove(encoder_info->ref+1, encoder_info->ref, sizeof(yuv_frame_t*)*(MAX_REF_FRAMES-1));
/* Set ref[0] to the memory slot where the new current reconstructed frame wil replace reference frame being shifted out */
encoder_info->ref[0] = tmp;
/* Pad the reconstructed frame and write into ref[0] */
create_reference_frame(encoder_info->ref[0],encoder_info->rec);
#if 0
/* To test sliding window operation */
int offsetx = 500;
int offsety = 200;
int offset_rec = offsety * encoder_info->rec->stride_y + offsetx;
int offset_ref = offsety * encoder_info->ref[0]->stride_y + offsetx;
printf("rec: %3d ",encoder_info->rec->y[offset_rec]);
printf("ref: ");
for (r=0;r<MAX_REF_FRAMES;r++){
printf("%3d ",encoder_info->ref[r]->y[offset_ref]);
}
#endif
}
int toolame_encode_frame(
short buffer[2][1152],
unsigned char *xpad_data,
unsigned char *output_buffer,
size_t output_buffer_size)
{
extern int minimum;
if (encode_first_call) {
hdr_to_frps(&frame);
encode_first_call = 0;
}
const int nch = frame.nch;
const int error_protection = header.error_protection;
bs.output_buffer = output_buffer;
bs.output_buffer_size = output_buffer_size;
bs.output_buffer_written = 0;
#ifdef REFERENCECODE
short *win_buf[2] = {&buffer[0][0], &buffer[1][0]};
#endif
int adb = available_bits (&header, &glopts);
int lg_frame = adb / 8;
if (header.dab_extension) {
/* You must have one frame in memory if you are in DAB mode */
/* in conformity of the norme ETS 300 401 http://www.etsi.org */
/* see bitstream.c */
if (frameNum == 1)
minimum = lg_frame + MINIMUM;
adb -= header.dab_extension * 8 + (xpad_len ? xpad_len : FPAD_LENGTH) * 8;
}
{
int gr, bl, ch;
/* New polyphase filter
Combines windowing and filtering. Ricardo Feb'03 */
for( gr = 0; gr < 3; gr++ )
for ( bl = 0; bl < 12; bl++ )
for ( ch = 0; ch < nch; ch++ )
WindowFilterSubband( &buffer[ch][gr * 12 * 32 + 32 * bl], ch,
&(*sb_sample)[ch][gr][bl][0] );
}
#ifdef REFERENCECODE
{
/* Old code. left here for reference */
int gr, bl, ch;
for (gr = 0; gr < 3; gr++)
for (bl = 0; bl < SCALE_BLOCK; bl++)
for (ch = 0; ch < nch; ch++) {
window_subband (&win_buf[ch], &(*win_que)[ch][0], ch);
filter_subband (&(*win_que)[ch][0], &(*sb_sample)[ch][gr][bl][0]);
}
}
#endif
#ifdef NEWENCODE
scalefactor_calc_new(*sb_sample, scalar, nch, frame.sblimit);
find_sf_max (scalar, &frame, max_sc);
if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
/* this way we calculate more mono than we need */
/* but it is cheap */
combine_LR_new (*sb_sample, *j_sample, frame.sblimit);
scalefactor_calc_new (j_sample, &j_scale, 1, frame.sblimit);
}
#else
scale_factor_calc (*sb_sample, scalar, nch, frame.sblimit);
pick_scale (scalar, &frame, max_sc);
if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
/* this way we calculate more mono than we need */
/* but it is cheap */
combine_LR (*sb_sample, *j_sample, frame.sblimit);
scale_factor_calc (j_sample, &j_scale, 1, frame.sblimit);
}
#endif
if ((glopts.quickmode == TRUE) && (++psycount % glopts.quickcount != 0)) {
/* We're using quick mode, so we're only calculating the model every
'quickcount' frames. Otherwise, just copy the old ones across */
for (int ch = 0; ch < nch; ch++) {
for (int sb = 0; sb < SBLIMIT; sb++)
smr[ch][sb] = smrdef[ch][sb];
}
}
else {
/* calculate the psymodel */
switch (model) {
case -1:
psycho_n1 (smr, nch);
break;
case 0: /* Psy Model A */
psycho_0 (smr, nch, scalar, (FLOAT) s_freq[header.version][header.sampling_frequency] * 1000);
break;
case 1:
psycho_1 (buffer, max_sc, smr, &frame);
break;
case 2:
for (int ch = 0; ch < nch; ch++) {
psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
}
break;
case 3:
/* Modified psy model 1 */
psycho_3 (buffer, max_sc, smr, &frame, &glopts);
break;
case 4:
/* Modified Psycho Model 2 */
for (int ch = 0; ch < nch; ch++) {
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
}
break;
case 5:
/* Model 5 comparse model 1 and 3 */
psycho_1 (buffer, max_sc, smr, &frame);
fprintf(stdout,"1 ");
smr_dump(smr,nch);
psycho_3 (buffer, max_sc, smr, &frame, &glopts);
fprintf(stdout,"3 ");
smr_dump(smr,nch);
break;
case 6:
/* Model 6 compares model 2 and 4 */
for (int ch = 0; ch < nch; ch++)
psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"2 ");
smr_dump(smr,nch);
for (int ch = 0; ch < nch; ch++)
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"4 ");
smr_dump(smr,nch);
break;
case 7:
fprintf(stdout,"Frame: %i\n",frameNum);
/* Dump the SMRs for all models */
psycho_1 (buffer, max_sc, smr, &frame);
fprintf(stdout,"1");
smr_dump(smr, nch);
psycho_3 (buffer, max_sc, smr, &frame, &glopts);
fprintf(stdout,"3");
smr_dump(smr,nch);
for (int ch = 0; ch < nch; ch++)
psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"2");
smr_dump(smr,nch);
for (int ch = 0; ch < nch; ch++)
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"4");
smr_dump(smr,nch);
break;
case 8:
/* Compare 0 and 4 */
psycho_n1 (smr, nch);
fprintf(stdout,"0");
smr_dump(smr,nch);
for (int ch = 0; ch < nch; ch++)
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"4");
smr_dump(smr,nch);
break;
default:
fprintf (stderr, "Invalid psy model specification: %i\n", model);
exit (0);
}
if (glopts.quickmode == TRUE) {
/* copy the smr values and reuse them later */
for (int ch = 0; ch < nch; ch++) {
for (int sb = 0; sb < SBLIMIT; sb++)
smrdef[ch][sb] = smr[ch][sb];
}
}
if (glopts.verbosity > 4) {
smr_dump(smr, nch);
}
}
#ifdef NEWENCODE
sf_transmission_pattern (scalar, scfsi, &frame);
main_bit_allocation_new (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
//main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
if (error_protection) {
CRC_calc (&frame, bit_alloc, scfsi, &crc);
}
write_header (&frame, &bs);
//encode_info (&frame, &bs);
if (error_protection) {
putbits (&bs, crc, 16);
}
write_bit_alloc (bit_alloc, &frame, &bs);
//encode_bit_alloc (bit_alloc, &frame, &bs);
write_scalefactors(bit_alloc, scfsi, scalar, &frame, &bs);
//encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
subband_quantization_new (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
*subband, &frame);
//subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
// *subband, &frame);
write_samples_new(*subband, bit_alloc, &frame, &bs);
//sample_encoding (*subband, bit_alloc, &frame, &bs);
#else
transmission_pattern (scalar, scfsi, &frame);
main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
if (error_protection) {
CRC_calc (&frame, bit_alloc, scfsi, &crc);
}
encode_info (&frame, &bs);
if (error_protection) {
encode_CRC (crc, &bs);
}
encode_bit_alloc (bit_alloc, &frame, &bs);
encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
*subband, &frame);
sample_encoding (*subband, bit_alloc, &frame, &bs);
#endif
/* If not all the bits were used, write out a stack of zeros */
for (int i = 0; i < adb; i++) {
put1bit (&bs, 0);
}
if (xpad_len) {
assert(xpad_len > 2);
// insert available X-PAD
for (int i = header.dab_length - xpad_len;
i < header.dab_length - FPAD_LENGTH;
i++) {
putbits (&bs, xpad_data[i], 8);
}
}
for (int i = header.dab_extension - 1; i >= 0; i--) {
CRC_calcDAB (&frame, bit_alloc, scfsi, scalar, &crc, i);
/* this crc is for the previous frame in DAB mode */
if (bs.buf_byte_idx + lg_frame < bs.buf_size)
bs.buf[bs.buf_byte_idx + lg_frame] = crc;
/* reserved 2 bytes for F-PAD in DAB mode */
putbits (&bs, crc, 8);
}
if (xpad_len) {
/* The F-PAD is also given us by mot-encoder */
putbits (&bs, xpad_data[header.dab_length - 2], 8);
putbits (&bs, xpad_data[header.dab_length - 1], 8);
}
else {
putbits (&bs, 0, 16); // FPAD is all-zero
}
return bs.output_buffer_written;
}
int main (int argc, char **argv)
{
typedef double SBS[2][3][SCALE_BLOCK][SBLIMIT];
SBS *sb_sample;
typedef double JSBS[3][SCALE_BLOCK][SBLIMIT];
JSBS *j_sample;
#ifdef REFERENCECODE
typedef double IN[2][HAN_SIZE];
IN *win_que;
#endif
typedef unsigned int SUB[2][3][SCALE_BLOCK][SBLIMIT];
SUB *subband;
frame_info frame;
frame_header header;
char original_file_name[MAX_NAME_SIZE];
char encoded_file_name[MAX_NAME_SIZE];
short **win_buf;
static short buffer[2][1152];
static unsigned int bit_alloc[2][SBLIMIT], scfsi[2][SBLIMIT];
static unsigned int scalar[2][3][SBLIMIT], j_scale[3][SBLIMIT];
static double smr[2][SBLIMIT], lgmin[2][SBLIMIT], max_sc[2][SBLIMIT];
// FLOAT snr32[32];
short sam[2][1344]; /* was [1056]; */
int model, nch, error_protection;
static unsigned int crc;
int sb, ch, adb;
unsigned long frameBits, sentBits = 0;
unsigned long num_samples;
int lg_frame;
int i;
/* Keep track of peaks */
int peak_left = 0;
int peak_right = 0;
char* mot_file = NULL;
char* icy_file = NULL;
/* Used to keep the SNR values for the fast/quick psy models */
static FLOAT smrdef[2][32];
static int psycount = 0;
extern int minimum;
sb_sample = (SBS *) mem_alloc (sizeof (SBS), "sb_sample");
j_sample = (JSBS *) mem_alloc (sizeof (JSBS), "j_sample");
#ifdef REFERENCECODE
win_que = (IN *) mem_alloc (sizeof (IN), "Win_que");
#endif
subband = (SUB *) mem_alloc (sizeof (SUB), "subband");
win_buf = (short **) mem_alloc (sizeof (short *) * 2, "win_buf");
/* clear buffers */
memset ((char *) buffer, 0, sizeof (buffer));
memset ((char *) bit_alloc, 0, sizeof (bit_alloc));
memset ((char *) scalar, 0, sizeof (scalar));
memset ((char *) j_scale, 0, sizeof (j_scale));
memset ((char *) scfsi, 0, sizeof (scfsi));
memset ((char *) smr, 0, sizeof (smr));
memset ((char *) lgmin, 0, sizeof (lgmin));
memset ((char *) max_sc, 0, sizeof (max_sc));
//memset ((char *) snr32, 0, sizeof (snr32));
memset ((char *) sam, 0, sizeof (sam));
global_init ();
header.extension = 0;
frame.header = &header;
frame.tab_num = -1; /* no table loaded */
frame.alloc = NULL;
header.version = MPEG_AUDIO_ID; /* Default: MPEG-1 */
programName = argv[0];
if (argc == 1) /* no command-line args */
short_usage ();
else
parse_args (argc, argv, &frame, &model, &num_samples, original_file_name,
encoded_file_name, &mot_file, &icy_file);
print_config (&frame, &model, original_file_name, encoded_file_name);
uint8_t* xpad_data = NULL;
if (mot_file) {
if (header.dab_length <= 0) {
fprintf(stderr, "Invalid XPAD length specified\n");
return 1;
}
int err = xpad_init(mot_file, header.dab_length + 1);
if (err == -1) {
fprintf(stderr, "XPAD reader initialisation failed\n");
return 1;
}
xpad_data = malloc(header.dab_length + 1);
}
/* this will load the alloc tables and do some other stuff */
hdr_to_frps (&frame);
nch = frame.nch;
error_protection = header.error_protection;
unsigned long samps_read;
while ((samps_read = get_audio(&musicin, buffer, num_samples, nch, &header)) > 0) {
/* Check if we have new PAD data
*/
int xpad_len = 0;
if (mot_file) {
xpad_len = xpad_read_len(xpad_data, header.dab_length + 1);
if (xpad_len == -1) {
fprintf(stderr, "Error reading XPAD data\n");
xpad_len = 0;
}
else if (xpad_len == 0) {
// no PAD available
}
else if (xpad_len == header.dab_length + 1) {
// everything OK
xpad_len = xpad_data[header.dab_length];
}
else {
fprintf(stderr, "xpad length=%d\n", xpad_len);
abort();
}
}
unsigned long j;
for (j = 0; j < samps_read; j++) {
peak_left = MAX(peak_left, buffer[0][j]);
}
for (j = 0; j < samps_read; j++) {
peak_right = MAX(peak_right, buffer[1][j]);
}
// We can always set the zmq peaks, even if the output is not
// used, it just writes some variables
zmqoutput_set_peaks(peak_left, peak_right);
if (glopts.verbosity > 1)
if (++frameNum % 10 == 0) {
fprintf(stderr, "[%4u", frameNum);
if (mot_file) {
fprintf(stderr, " %s",
xpad_len > 0 ? "p" : " ");
}
if (glopts.show_level) {
fprintf(stderr, " (%6d|%-6d) ",
peak_left, peak_right);
fprintf(stderr, "] [%6s|%-6s]\r",
level(0, &peak_left),
level(1, &peak_right) );
}
else {
fprintf(stderr, "]\r");
}
}
fflush(stderr);
win_buf[0] = &buffer[0][0];
win_buf[1] = &buffer[1][0];
adb = available_bits (&header, &glopts);
lg_frame = adb / 8;
if (header.dab_extension) {
/* in 24 kHz we always have 4 bytes */
if (header.sampling_frequency == 1)
header.dab_extension = 4;
/* You must have one frame in memory if you are in DAB mode */
/* in conformity of the norme ETS 300 401 http://www.etsi.org */
/* see bitstream.c */
if (frameNum == 1)
minimum = lg_frame + MINIMUM;
adb -= header.dab_extension * 8 + (xpad_len ? xpad_len : FPAD_LENGTH) * 8;
}
{
int gr, bl, ch;
/* New polyphase filter
Combines windowing and filtering. Ricardo Feb'03 */
for( gr = 0; gr < 3; gr++ )
for ( bl = 0; bl < 12; bl++ )
for ( ch = 0; ch < nch; ch++ )
WindowFilterSubband( &buffer[ch][gr * 12 * 32 + 32 * bl], ch,
&(*sb_sample)[ch][gr][bl][0] );
}
#ifdef REFERENCECODE
{
/* Old code. left here for reference */
int gr, bl, ch;
for (gr = 0; gr < 3; gr++)
for (bl = 0; bl < SCALE_BLOCK; bl++)
for (ch = 0; ch < nch; ch++) {
window_subband (&win_buf[ch], &(*win_que)[ch][0], ch);
filter_subband (&(*win_que)[ch][0], &(*sb_sample)[ch][gr][bl][0]);
}
}
#endif
#ifdef NEWENCODE
scalefactor_calc_new(*sb_sample, scalar, nch, frame.sblimit);
find_sf_max (scalar, &frame, max_sc);
if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
/* this way we calculate more mono than we need */
/* but it is cheap */
combine_LR_new (*sb_sample, *j_sample, frame.sblimit);
scalefactor_calc_new (j_sample, &j_scale, 1, frame.sblimit);
}
#else
scale_factor_calc (*sb_sample, scalar, nch, frame.sblimit);
pick_scale (scalar, &frame, max_sc);
if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
/* this way we calculate more mono than we need */
/* but it is cheap */
combine_LR (*sb_sample, *j_sample, frame.sblimit);
scale_factor_calc (j_sample, &j_scale, 1, frame.sblimit);
}
#endif
if ((glopts.quickmode == TRUE) && (++psycount % glopts.quickcount != 0)) {
/* We're using quick mode, so we're only calculating the model every
'quickcount' frames. Otherwise, just copy the old ones across */
for (ch = 0; ch < nch; ch++) {
for (sb = 0; sb < SBLIMIT; sb++)
smr[ch][sb] = smrdef[ch][sb];
}
} else {
/* calculate the psymodel */
switch (model) {
case -1:
psycho_n1 (smr, nch);
break;
case 0: /* Psy Model A */
psycho_0 (smr, nch, scalar, (FLOAT) s_freq[header.version][header.sampling_frequency] * 1000);
break;
case 1:
psycho_1 (buffer, max_sc, smr, &frame);
break;
case 2:
for (ch = 0; ch < nch; ch++) {
psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
}
break;
case 3:
/* Modified psy model 1 */
psycho_3 (buffer, max_sc, smr, &frame, &glopts);
break;
case 4:
/* Modified Psycho Model 2 */
for (ch = 0; ch < nch; ch++) {
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
}
break;
case 5:
/* Model 5 comparse model 1 and 3 */
psycho_1 (buffer, max_sc, smr, &frame);
fprintf(stdout,"1 ");
smr_dump(smr,nch);
psycho_3 (buffer, max_sc, smr, &frame, &glopts);
fprintf(stdout,"3 ");
smr_dump(smr,nch);
break;
case 6:
/* Model 6 compares model 2 and 4 */
for (ch = 0; ch < nch; ch++)
psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"2 ");
smr_dump(smr,nch);
for (ch = 0; ch < nch; ch++)
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"4 ");
smr_dump(smr,nch);
break;
case 7:
fprintf(stdout,"Frame: %i\n",frameNum);
/* Dump the SMRs for all models */
psycho_1 (buffer, max_sc, smr, &frame);
fprintf(stdout,"1");
smr_dump(smr, nch);
psycho_3 (buffer, max_sc, smr, &frame, &glopts);
fprintf(stdout,"3");
smr_dump(smr,nch);
for (ch = 0; ch < nch; ch++)
psycho_2 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"2");
smr_dump(smr,nch);
for (ch = 0; ch < nch; ch++)
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"4");
smr_dump(smr,nch);
break;
case 8:
/* Compare 0 and 4 */
psycho_n1 (smr, nch);
fprintf(stdout,"0");
smr_dump(smr,nch);
for (ch = 0; ch < nch; ch++)
psycho_4 (&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT) s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout,"4");
smr_dump(smr,nch);
break;
default:
fprintf (stderr, "Invalid psy model specification: %i\n", model);
exit (0);
}
if (glopts.quickmode == TRUE)
/* copy the smr values and reuse them later */
for (ch = 0; ch < nch; ch++) {
for (sb = 0; sb < SBLIMIT; sb++)
smrdef[ch][sb] = smr[ch][sb];
}
if (glopts.verbosity > 4)
smr_dump(smr, nch);
}
#ifdef NEWENCODE
sf_transmission_pattern (scalar, scfsi, &frame);
main_bit_allocation_new (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
//main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
if (error_protection)
CRC_calc (&frame, bit_alloc, scfsi, &crc);
write_header (&frame, &bs);
//encode_info (&frame, &bs);
if (error_protection)
putbits (&bs, crc, 16);
write_bit_alloc (bit_alloc, &frame, &bs);
//encode_bit_alloc (bit_alloc, &frame, &bs);
write_scalefactors(bit_alloc, scfsi, scalar, &frame, &bs);
//encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
subband_quantization_new (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
*subband, &frame);
//subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
// *subband, &frame);
write_samples_new(*subband, bit_alloc, &frame, &bs);
//sample_encoding (*subband, bit_alloc, &frame, &bs);
#else
transmission_pattern (scalar, scfsi, &frame);
main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
if (error_protection)
CRC_calc (&frame, bit_alloc, scfsi, &crc);
encode_info (&frame, &bs);
if (error_protection)
encode_CRC (crc, &bs);
encode_bit_alloc (bit_alloc, &frame, &bs);
encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
*subband, &frame);
sample_encoding (*subband, bit_alloc, &frame, &bs);
#endif
/* If not all the bits were used, write out a stack of zeros */
for (i = 0; i < adb; i++)
put1bit (&bs, 0);
if (xpad_len) {
assert(xpad_len > 2);
// insert available X-PAD
for (i = header.dab_length - xpad_len; i < header.dab_length - FPAD_LENGTH; i++)
putbits (&bs, xpad_data[i], 8);
}
for (i = header.dab_extension - 1; i >= 0; i--) {
CRC_calcDAB (&frame, bit_alloc, scfsi, scalar, &crc, i);
/* this crc is for the previous frame in DAB mode */
if (bs.buf_byte_idx + lg_frame < bs.buf_size)
bs.buf[bs.buf_byte_idx + lg_frame] = crc;
/* reserved 2 bytes for F-PAD in DAB mode */
putbits (&bs, crc, 8);
}
if (xpad_len) {
/* The F-PAD is also given us by mot-encoder */
putbits (&bs, xpad_data[header.dab_length - 2], 8);
putbits (&bs, xpad_data[header.dab_length - 1], 8);
}
else {
putbits (&bs, 0, 16); // FPAD is all-zero
}
#if defined(VLC_INPUT)
if (glopts.input_select == INPUT_SELECT_VLC) {
vlc_in_write_icy();
}
#endif
frameBits = sstell (&bs) - sentBits;
if (frameBits % 8) { /* a program failure */
fprintf (stderr, "Sent %ld bits = %ld slots plus %ld\n", frameBits,
frameBits / 8, frameBits % 8);
fprintf (stderr, "If you are reading this, the program is broken\n");
fprintf (stderr, "Please report a bug.\n");
exit(1);
}
sentBits += frameBits;
// Reset peak measurement
peak_left = 0;
peak_right = 0;
}
fprintf(stdout, "Main loop has quit with samps_read = %zu\n", samps_read);
close_bit_stream_w (&bs);
if ((glopts.verbosity > 1) && (glopts.vbr == TRUE)) {
int i;
#ifdef NEWENCODE
extern int vbrstats_new[15];
#else
extern int vbrstats[15];
#endif
fprintf (stdout, "VBR stats:\n");
for (i = 1; i < 15; i++)
fprintf (stdout, "%4i ", bitrate[header.version][i]);
fprintf (stdout, "\n");
for (i = 1; i < 15; i++)
#ifdef NEWENCODE
fprintf (stdout,"%4i ",vbrstats_new[i]);
#else
fprintf (stdout, "%4i ", vbrstats[i]);
#endif
fprintf (stdout, "\n");
}
fprintf (stderr,
"Avg slots/frame = %.3f; b/smp = %.2f; bitrate = %.3f kbps\n",
(FLOAT) sentBits / (frameNum * 8),
(FLOAT) sentBits / (frameNum * 1152),
(FLOAT) sentBits / (frameNum * 1152) *
s_freq[header.version][header.sampling_frequency]);
if (glopts.input_select == INPUT_SELECT_WAV) {
if ( fclose (musicin.wav_input) != 0) {
fprintf (stderr, "Could not close \"%s\".\n", original_file_name);
exit (2);
}
}
fprintf (stderr, "\nDone\n");
exit (0);
}
