/*! ************************************************************************ * \brief * generates code and passes the codeword to the buffer ************************************************************************ */ int writeSyntaxElement_Intra4x4PredictionMode(SyntaxElement *se, DataPartition *this_dataPart) { if (se->value1 == -1) { se->len = 1; se->inf = 1; } else { se->len = 4; se->inf = se->value1; } se->bitpattern = se->inf; writeUVLC2buffer(se, this_dataPart->bitstream); if(se->type != SE_HEADER) this_dataPart->bitstream->write_flag = 1; #if TRACE if(se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * generates code and passes the codeword to the buffer ************************************************************************ */ void writeIntraPredMode_CAVLC(SyntaxElement *se, DataPartition *dp) { if (se->value1 == -1) { se->len = 1; se->inf = 1; } else { se->len = 4; se->inf = se->value1; } se->bitpattern = se->inf; writeUVLC2buffer(se, dp->bitstream); if(se->type != SE_HEADER) dp->bitstream->write_flag = 1; #if TRACE if(dp->bitstream->trace_enabled) trace2out (se); #endif return; }
int writeSyntaxElement_GOLOMB(SyntaxElement *se, Bitstream *bitstream) { unsigned int bits,len,i; unsigned int grad[4],max_lev[4]; if(!( se->golomb_maxlevels&~0xFF )) //only bits 0-7 used? This means normal Golomb word. encode_golomb_word(se->value1,se->golomb_grad,se->golomb_maxlevels,&bits,&len); else { for(i=0UL;i<4UL;i++) { grad[i]=(se->golomb_grad>>(i<<3))&0xFFUL; max_lev[i]=(se->golomb_maxlevels>>(i<<3))&0xFFUL; } encode_multilayer_golomb_word(se->value1,grad,max_lev,&bits,&len); } se->len=len; se->bitpattern=bits; writeUVLC2buffer(se, bitstream); #if TRACE snprintf(se->tracestring, TRACESTRING_SIZE, "Coefficients"); if(se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * generates UVLC code and passes the codeword to the buffer * \author * Tian Dong ************************************************************************ */ int writeSyntaxElement2Buf_Fixed(SyntaxElement *se, Bitstream* this_streamBuffer ) { writeUVLC2buffer(se, this_streamBuffer ); #if TRACE if(se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * passes the fixed codeword to the buffer ************************************************************************ */ int writeSyntaxElement_fixed(SyntaxElement *se, DataPartition *this_dataPart) { writeUVLC2buffer(se, this_dataPart->bitstream); if(se->type != SE_HEADER) this_dataPart->bitstream->write_flag = 1; #if TRACE if(se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * generates UVLC code and passes the codeword to the buffer ************************************************************************ */ void writeSE_SVLC(SyntaxElement *se, DataPartition *dp) { se_linfo (se->value1,se->value2,&(se->len),&(se->inf)); symbol2uvlc(se); writeUVLC2buffer(se, dp->bitstream); if(se->type != SE_HEADER) dp->bitstream->write_flag = 1; #if TRACE if(dp->bitstream->trace_enabled) trace2out (se); #endif }
/*! ************************************************************************ * \brief * generates VLC code and passes the codeword to the buffer ************************************************************************ */ int writeSyntaxElement_VLC(SyntaxElement *se, DataPartition *this_dataPart) { se->inf = se->value1; se->len = se->value2; symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * generates UVLC code and passes the codeword to the buffer * \author * Tian Dong ************************************************************************ */ int writeSyntaxElement2Buf_UVLC(SyntaxElement *se, Bitstream* this_streamBuffer ) { se->mapping(se->value1,se->value2,&(se->len),&(se->inf)); symbol2uvlc(se); writeUVLC2buffer(se, this_streamBuffer ); #if TRACE if(se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * write VLC for Run Before Next Coefficient, VLC0 ************************************************************************ */ int writeSyntaxElement_Run(SyntaxElement *se, DataPartition *this_dataPart) { static const int lentab[TOTRUN_NUM][16] = { {1,1}, {1,2,2}, {2,2,2,2}, {2,2,2,3,3}, {2,2,3,3,3,3}, {2,3,3,3,3,3,3}, {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11}, }; static const int codtab[TOTRUN_NUM][16] = { {1,0}, {1,1,0}, {3,2,1,0}, {3,2,1,1,0}, {3,2,3,2,1,0}, {3,0,1,3,2,5,4}, {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1}, }; int vlcnum; vlcnum = se->len; // se->value1 : run se->len = lentab[vlcnum][se->value1]; se->inf = codtab[vlcnum][se->value1]; if (se->len == 0) { printf("ERROR: (run) not valid: (%d)\n",se->value1); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * generates UVLC code and passes the codeword to the buffer ************************************************************************ */ int writeSyntaxElement_UVLC(SyntaxElement *se, DataPartition *this_dataPart) { se->mapping(se->value1,se->value2,&(se->len),&(se->inf)); symbol2uvlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); if(se->type != SE_HEADER) this_dataPart->bitstream->write_flag = 1; #if TRACE if(se->type <= 1) trace2out (se); #endif return (se->len); }
int u_v (int n, char *tracestring, int value, Bitstream *bitstream) { SyntaxElement symbol, *sym=&symbol; sym->bitpattern = value; sym->len = n; sym->value1 = value; assert (bitstream->streamBuffer != NULL); writeUVLC2buffer(sym, bitstream); #if TRACE strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE); trace2out (sym); #endif return (sym->len); }
/*! ************************************************************************************* * \brief * ue_v, writes an ue(v) syntax element, returns the length in bits * * \param tracestring * the string for the trace file * \param value * the value to be coded * \param bitstream * the target bitstream the value should be coded into * * \return * Number of bits used by the coded syntax element * * \ note * This function writes always the bit buffer for the progressive scan flag, and * should not be used (or should be modified appropriately) for the interlace crap * When used in the context of the Parameter Sets, this is obviously not a * problem. * ************************************************************************************* */ int ue_v (char *tracestring, int value, Bitstream *bitstream) { SyntaxElement symbol, *sym=&symbol; sym->value1 = value; sym->value2 = 0; assert (bitstream->streamBuffer != NULL); ue_linfo(sym->value1,sym->value2,&(sym->len),&(sym->inf)); symbol2uvlc(sym); writeUVLC2buffer (sym, bitstream); #if TRACE strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE); trace2out (sym); #endif return (sym->len); }
/*! ************************************************************************ * \brief * write VLC for Coeff Level ************************************************************************ */ int writeSyntaxElement_Level_VLCN(SyntaxElement *se, int vlc, DataPartition *this_dataPart) { int iCodeword; int iLength; int level = se->value1; int levabs = absm(level); int sign = (level < 0 ? 1 : 0); int shift = vlc-1; int escape = (15<<shift)+1; int numPrefix = (levabs-1)>>shift; int sufmask = ~((0xffffffff)<<shift); int suffix = (levabs-1)&sufmask; if (levabs < escape) { iLength = numPrefix + vlc + 1; iCodeword = (1<<(shift+1))|(suffix<<1)|sign; } else { iLength = 28; iCodeword = (1<<12)|((levabs-escape)<<1)|sign; } se->len = iLength; se->inf = iCodeword; symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * write VLC for NumCoeff and TrailingOnes for Chroma DC ************************************************************************ */ int writeSyntaxElement_NumCoeffTrailingOnesChromaDC(SyntaxElement *se, DataPartition *this_dataPart) { int lentab[4][5] = { { 2, 6, 6, 6, 6,}, { 0, 1, 6, 7, 8,}, { 0, 0, 3, 7, 8,}, { 0, 0, 0, 6, 7,}, }; int codtab[4][5] = { {1,7,4,3,2}, {0,1,6,3,3}, {0,0,1,2,2}, {0,0,0,5,0}, }; // se->value1 : numcoeff // se->value2 : numtrailingones se->len = lentab[se->value2][se->value1]; se->inf = codtab[se->value2][se->value1]; if (se->len == 0) { printf("ERROR: (numcoeff,trailingones) not valid: (%d, %d)\n", se->value1, se->value2); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * generates UVLC code and passes the codeword to the buffer ************************************************************************ */ void writeCBP_VLC (Macroblock* currMB, SyntaxElement *se, DataPartition *dp) { if (currMB->mb_type == I4MB || currMB->mb_type == SI4MB || currMB->mb_type == I8MB) { currMB->cbp_linfo_intra (se->value1, se->value2, &(se->len), &(se->inf)); } else { currMB->cbp_linfo_inter (se->value1,se->value2,&(se->len),&(se->inf)); } symbol2uvlc(se); writeUVLC2buffer(se, dp->bitstream); if(se->type != SE_HEADER) dp->bitstream->write_flag = 1; #if TRACE if(dp->bitstream->trace_enabled) trace2out (se); #endif }
/*! ************************************************************************ * \brief * write VLC for TotalZeros for Chroma DC ************************************************************************ */ int writeSyntaxElement_TotalZerosChromaDC(SyntaxElement *se, DataPartition *this_dataPart) { int lentab[3][4] = { { 1, 2, 3, 3,}, { 1, 2, 2, 0,}, { 1, 1, 0, 0,}, }; int codtab[3][4] = { { 1, 1, 1, 0,}, { 1, 1, 0, 0,}, { 1, 0, 0, 0,}, }; int vlcnum; vlcnum = se->len; // se->value1 : TotalZeros se->len = lentab[vlcnum][se->value1]; se->inf = codtab[vlcnum][se->value1]; if (se->len == 0) { printf("ERROR: (TotalZeros) not valid: (%d)\n",se->value1); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * write VLC for Coeff Level (VLC1) ************************************************************************ */ int writeSyntaxElement_Level_VLC1(SyntaxElement *se, DataPartition *this_dataPart) { int level, levabs, sign; level = se->value1; levabs = absm(level); sign = (level < 0 ? 1 : 0); if (levabs < 8) { se->len = levabs * 2 + sign - 1; se->inf = 1; } else if (levabs < 8+8) { // escape code1 se->len = 14 + 1 + 4; se->inf = (1 << 4) | ((levabs - 8) << 1) | sign; } else { // escape code2 se->len = 14 + 2 + 12; se->inf = (0x1 << 12) | ((levabs - 16)<< 1) | sign; } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * write VLC for TotalZeros for Chroma DC ************************************************************************ */ int writeSyntaxElement_TotalZerosChromaDC(SyntaxElement *se, DataPartition *this_dataPart) { static const int lentab[3][TOTRUN_NUM][16] = { //YUV420 {{ 1,2,3,3}, { 1,2,2}, { 1,1}}, //YUV422 {{ 1,3,3,4,4,4,5,5}, { 3,2,3,3,3,3,3}, { 3,3,2,2,3,3}, { 3,2,2,2,3}, { 2,2,2,2}, { 2,2,1}, { 1,1}}, //YUV444 {{ 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9}, { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6}, { 4,3,3,3,4,4,3,3,4,5,5,6,5,6}, { 5,3,4,4,3,3,3,4,3,4,5,5,5}, { 4,4,4,3,3,3,3,3,4,5,4,5}, { 6,5,3,3,3,3,3,3,4,3,6}, { 6,5,3,3,3,2,3,4,3,6}, { 6,4,5,3,2,2,3,3,6}, { 6,6,4,2,2,3,2,5}, { 5,5,3,2,2,2,4}, { 4,4,3,3,1,3}, { 4,4,2,1,3}, { 3,3,1,2}, { 2,2,1}, { 1,1}} }; static const int codtab[3][TOTRUN_NUM][16] = { //YUV420 {{ 1,1,1,0}, { 1,1,0}, { 1,0}}, //YUV422 {{ 1,2,3,2,3,1,1,0}, { 0,1,1,4,5,6,7}, { 0,1,1,2,6,7}, { 6,0,1,2,7}, { 0,1,2,3}, { 0,1,1}, { 0,1}}, //YUV444 {{1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1}, {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0}, {5,7,6,5,4,3,4,3,2,3,2,1,1,0}, {3,7,5,4,6,5,4,3,3,2,2,1,0}, {5,4,3,7,6,5,4,3,2,1,1,0}, {1,1,7,6,5,4,3,2,1,1,0}, {1,1,5,4,3,3,2,1,1,0}, {1,1,1,3,3,2,2,1,0}, {1,0,1,3,2,1,1,1,}, {1,0,1,3,2,1,1,}, {0,1,1,2,1,3}, {0,1,1,1,1}, {0,1,1,1}, {0,1,1}, {0,1}} }; int vlcnum; int yuv = img->yuv_format - 1; vlcnum = se->len; // se->value1 : TotalZeros se->len = lentab[yuv][vlcnum][se->value1]; se->inf = codtab[yuv][vlcnum][se->value1]; if (se->len == 0) { printf("ERROR: (TotalZeros) not valid: (%d)\n",se->value1); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * write VLC for NumCoeff and TrailingOnes for Chroma DC ************************************************************************ */ int writeSyntaxElement_NumCoeffTrailingOnesChromaDC(SyntaxElement *se, DataPartition *this_dataPart) { static const int lentab[3][4][17] = { //YUV420 {{ 2, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 1, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 3, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //YUV422 {{ 1, 7, 7, 9, 9,10,11,12,13, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 2, 7, 7, 9,10,11,12,12, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 3, 7, 7, 9,10,11,12, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 0, 5, 6, 7, 7,10,11, 0, 0, 0, 0, 0, 0, 0, 0}}, //YUV444 {{ 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16}, { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16}, { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16}, { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}} }; static const int codtab[3][4][17] = { //YUV420 {{ 1, 7, 4, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 1, 6, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //YUV422 {{ 1,15,14, 7, 6, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 1,13,12, 5, 6, 6, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 1,11,10, 4, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 0, 1, 1, 9, 8, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0}}, //YUV444 {{ 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7, 4}, { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10, 6}, { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9, 5}, { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12, 8}} }; int yuv = img->yuv_format - 1; // se->value1 : numcoeff // se->value2 : numtrailingones se->len = lentab[yuv][se->value2][se->value1]; se->inf = codtab[yuv][se->value2][se->value1]; if (se->len == 0) { printf("ERROR: (numcoeff,trailingones) not valid: (%d, %d)\n", se->value1, se->value2); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
int writeSyntaxElement_NumCoeffTrailingOnes(SyntaxElement *se, DataPartition *this_dataPart) { static const int lentab[3][4][17] = { { // 0702 { 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16}, { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16}, { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16}, { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}, }, { { 2, 6, 6, 7, 8, 8, 9,11,11,12,12,12,13,13,13,14,14}, { 0, 2, 5, 6, 6, 7, 8, 9,11,11,12,12,13,13,14,14,14}, { 0, 0, 3, 6, 6, 7, 8, 9,11,11,12,12,13,13,13,14,14}, { 0, 0, 0, 4, 4, 5, 6, 6, 7, 9,11,11,12,13,13,13,14}, }, { { 4, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,10}, { 0, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,10}, { 0, 0, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10}, { 0, 0, 0, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 9,10,10,10}, }, }; static const int codtab[3][4][17] = { { { 1, 5, 7, 7, 7, 7,15,11, 8,15,11,15,11,15,11, 7,4}, { 0, 1, 4, 6, 6, 6, 6,14,10,14,10,14,10, 1,14,10,6}, { 0, 0, 1, 5, 5, 5, 5, 5,13, 9,13, 9,13, 9,13, 9,5}, { 0, 0, 0, 3, 3, 4, 4, 4, 4, 4,12,12, 8,12, 8,12,8}, }, { { 3,11, 7, 7, 7, 4, 7,15,11,15,11, 8,15,11, 7, 9,7}, { 0, 2, 7,10, 6, 6, 6, 6,14,10,14,10,14,10,11, 8,6}, { 0, 0, 3, 9, 5, 5, 5, 5,13, 9,13, 9,13, 9, 6,10,5}, { 0, 0, 0, 5, 4, 6, 8, 4, 4, 4,12, 8,12,12, 8, 1,4}, }, { {15,15,11, 8,15,11, 9, 8,15,11,15,11, 8,13, 9, 5,1}, { 0,14,15,12,10, 8,14,10,14,14,10,14,10, 7,12, 8,4}, { 0, 0,13,14,11, 9,13, 9,13,10,13, 9,13, 9,11, 7,3}, { 0, 0, 0,12,11,10, 9, 8,13,12,12,12, 8,12,10, 6,2}, }, }; int vlcnum; vlcnum = se->len; // se->value1 : numcoeff // se->value2 : numtrailingones if (vlcnum == 3) { se->len = 6; // 4 + 2 bit FLC if (se->value1 > 0) { se->inf = ((se->value1-1) << 2) | se->value2; } else { se->inf = 3; } } else { se->len = lentab[vlcnum][se->value2][se->value1]; se->inf = codtab[vlcnum][se->value2][se->value1]; } //se->inf = 0; if (se->len == 0) { printf("ERROR: (numcoeff,trailingones) not valid: vlc=%d (%d, %d)\n", vlcnum, se->value1, se->value2); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }
/*! ************************************************************************ * \brief * write VLC for TotalZeros ************************************************************************ */ int writeSyntaxElement_TotalZeros(SyntaxElement *se, DataPartition *this_dataPart) { int lentab[TOTRUN_NUM][16] = { { 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9}, { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6}, { 4,3,3,3,4,4,3,3,4,5,5,6,5,6}, { 5,3,4,4,3,3,3,4,3,4,5,5,5}, { 4,4,4,3,3,3,3,3,4,5,4,5}, { 6,5,3,3,3,3,3,3,4,3,6}, { 6,5,3,3,3,2,3,4,3,6}, { 6,4,5,3,2,2,3,3,6}, { 6,6,4,2,2,3,2,5}, { 5,5,3,2,2,2,4}, { 4,4,3,3,1,3}, { 4,4,2,1,3}, { 3,3,1,2}, { 2,2,1}, { 1,1}, }; int codtab[TOTRUN_NUM][16] = { {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1}, {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0}, {5,7,6,5,4,3,4,3,2,3,2,1,1,0}, {3,7,5,4,6,5,4,3,3,2,2,1,0}, {5,4,3,7,6,5,4,3,2,1,1,0}, {1,1,7,6,5,4,3,2,1,1,0}, {1,1,5,4,3,3,2,1,1,0}, {1,1,1,3,3,2,2,1,0}, {1,0,1,3,2,1,1,1,}, {1,0,1,3,2,1,1,}, {0,1,1,2,1,3}, {0,1,1,1,1}, {0,1,1,1}, {0,1,1}, {0,1}, }; int vlcnum; vlcnum = se->len; // se->value1 : TotalZeros se->len = lentab[vlcnum][se->value1]; se->inf = codtab[vlcnum][se->value1]; if (se->len == 0) { printf("ERROR: (TotalZeros) not valid: (%d)\n",se->value1); exit(-1); } symbol2vlc(se); writeUVLC2buffer(se, this_dataPart->bitstream); #if TRACE if (se->type <= 1) trace2out (se); #endif return (se->len); }