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); }