encoder-h261.cxx

sloedgy open sip stack source code

			}
		}
	}

	u_int m = mba - mba_; // set macroblock address difference 
	mba_ = mba; // set last absolute macroblock address transmitted
	huffent* he = &hte_mba[m - 1]; // Huffman coded macroblock address
	/* MBA */
	PUT_BITS(he->val, he->nb, nbb_, bb_, bc_);
	if (q != mquant_) {
		/* MTYPE = INTRA + TC + MQUANT */
		PUT_BITS(1, 7, nbb_, bb_, bc_);
		PUT_BITS(q, 5, nbb_, bb_, bc_);
		mquant_ = q;
	} else {
		/* MTYPE = INTRA + TC (no quantizer) */
		PUT_BITS(1, 4, nbb_, bb_, bc_);
	}

	/* luminance */
	const char* lm = llm_[q];
	if (lm == 0) {
		lm = make_level_map(q, 1);
		llm_[q] = lm;
		clm_[q] = make_level_map(q, 2);
	}
	encode_blk(blk + 0, lm);
	encode_blk(blk + 64, lm);
	encode_blk(blk + 128, lm);
	encode_blk(blk + 192, lm);
	/* chominance */
	lm = clm_[q];
	encode_blk(blk + 256, lm);
	encode_blk(blk + 320, lm);
}


/*
 * H261DCTEncoder::encode_mb
 *	encode a macroblock given a set of input DCT coefs
 *	each coef is stored as a short
 */
void
H261DCTEncoder::encode_mb(u_int mba, const u_char* frm,
			  u_int loff, u_int coff, int how)
{
	short *lblk = (short *)frm + loff;
	short *ublk = (short *)frm + coff;
	short *vblk = (short *)frm + coff + 64;

	register u_int q;
	if (how == CR_MOTION)
		q = lq_;
	else if (how == CR_BG)
		q = hq_;
	else
		/* must be at age threshold */
		q = mq_;

	/*
	 * if the default quantizer is too small to handle the coef.
	 * dynamic range, spin through the blocks and see if any
	 * coef. would significantly overflow.
	 */
	if (q < 8) {
		register int cmin = 0, cmax = 0;
		register short* bp = lblk;
		register int i, j;

		// Y U and V blocks
		for (i = 6; --i >= 0; ) {
			++bp;	// ignore dc coef
			for (j = 63; --j >= 0; ) {
				register int v = *bp++;
				if (v < cmin)
					cmin = v;
				else if (v > cmax)
					cmax = v;
			}
		}

		if (cmax < -cmin)
			cmax = -cmin;
		cmax /= (q << 1);
		if (cmax >= 128) {
			/* need to re-quantize */
			register int s;

			for (s = 1; cmax >= (128 << s); ++s) {
			}
			q <<= s;

		}
	}

	u_int m = mba - mba_;
	mba_ = mba;
	huffent* he = &hte_mba[m - 1];
	/* MBA */
	PUT_BITS(he->val, he->nb, nbb_, bb_, bc_);
	if (q != mquant_) {
		/* MTYPE = INTRA + TC + MQUANT */
		PUT_BITS(1, 7, nbb_, bb_, bc_);
		PUT_BITS(q, 5, nbb_, bb_, bc_);
		mquant_ = q;
	} else {
		/* MTYPE = INTRA + TC (no quantizer) */
		PUT_BITS(1, 4, nbb_, bb_, bc_);
	}

	/* luminance */
	const char* lm = llm_[q];
	if (lm == 0) {
		/*
		 * the filter thresh is 0 since we assume the jpeg percept.
		 * quantizer already did the filtering.
		 */
		lm = make_level_map(q, 0);
		llm_[q] = lm;
		clm_[q] = make_level_map(q, 0);
	}
	encode_blk(lblk + 0, lm);
	encode_blk(lblk + 64, lm);
	encode_blk(lblk + 128, lm);
	encode_blk(lblk + 192, lm);
	/* chominance */
	lm = clm_[q];
	encode_blk(ublk, lm);
	encode_blk(vblk, lm);
}

int
H261Encoder::flush(Transmitter::pktbuf* pb, int nbit,
		       Transmitter::pktbuf* npb)
{
	/* flush bit buffer */
	STORE_BITS(bb_, bc_);

	int cc = (nbit + 7) >> 3;
	int ebit = (cc << 3) - nbit;

	/*XXX*/
	if (cc == 0 && npb != 0)
		return 0;

	pb->lenHdr = HDRSIZE;
	pb->lenBuf = cc;
	u_int* rh = (u_int*)pb->hdr;

	*rh = (*rh) | ebit << 26 | sbit_ << 29;

	if (npb != 0) {
		u_char* nbs = (u_char*)npb->buf->data;
		u_int bc = (bc_ - bs_) << 3;
		int tbit = bc + nbb_;
		int extra = ((tbit + 7) >> 3) - (nbit >> 3);
		if (extra > 0)
			memcpy(nbs, bs_ + (nbit >> 3), extra);
		bs_ = nbs;
		sbit_ = nbit & 7;
		tbit -= nbit &~ 7;
		bc = tbit &~ (NBIT - 1);
		nbb_ = tbit - bc;
		bc_ = bs_ + (bc >> 3);
		/*
		 * Prime the bit buffer.  Be careful to set bits that
		 * are not yet in use to 0, since output bits are later
		 * or'd into the buffer.
		 */
		if (nbb_ > 0) {
			u_int n = NBIT - nbb_;
			bb_ = (LOAD_BITS(bc_) >> n) << n;
		} else
			bb_ = 0;
	}
	tx_->StoreOnePacket(pb);
	return (cc + HDRSIZE);
}

int H261DCTEncoder::consume(const VideoFrame *vf)
{
	if (!SameSize(vf))
		SetSize(vf->width, vf->height);
	return(encode(vf, vf->crvec));
}

int H261PixelEncoder::consume(const VideoFrame *vf)
{
	if (!SameSize(vf))
		SetSize(vf->width, vf->height);
	return(encode(vf, vf->crvec));
}

//////NOTE: HDRSIZE is the size of the H261 hdr in the rtp packet.== 4
int H261Encoder::encode(const VideoFrame* vf, const BYTE *crvec) {
  Transmitter::pktbuf* pb = tx_->alloc();
	bs_ = (u_char*)pb->buf->data; // pointer to start of buffer
	bc_ = bs_; // pointer to destination in buffer
	u_int ec = (tx_->mtu() - HDRSIZE) << 3; // bits available in H261 packet
	bb_ = 0; // intermediate working space
	nbb_ = 0; // cumulative put bit count
	sbit_ = 0;
	/* RTP/H.261 header */
	u_int* rh = (u_int*)pb->hdr; // H.261 header (32 bits)
	*rh = (1 << 24) | (lq_ << 10); // set motion vector flag V to 1 & set QUANT

	/* PSC Picture Start Code */
	PUT_BITS(0x0001, 16, nbb_, bb_, bc_);
	/* GOB 0 -> picture header Finishes PSC */
	PUT_BITS(0, 4, nbb_, bb_, bc_);
	/* TR Temporal Reference (XXX should do this right) */
	PUT_BITS(0, 5, nbb_, bb_, bc_);

	/* PTYPE = CIF */
	int pt = cif_ ? 7 : 3;
	PUT_BITS(pt, 6, nbb_, bb_, bc_);

	/* PEI Picture Extra Information = none */
	PUT_BITS(0, 1, nbb_, bb_, bc_);

	int step = cif_ ? 1 : 2;
	int cc = 0;

	BYTE* frm = vf->frameptr;
  for (u_int gobIndex = 0; gobIndex < ngob_; gobIndex += step) { // fill in GOB layer
		u_int loff = loff_[gobIndex];
		u_int coff = coff_[gobIndex];
		u_int blkno = blkno_[gobIndex];
		u_int nbit = ((bc_ - bs_) << 3) + nbb_; // # of bits already in buffer

		/* GSC/GN */
		PUT_BITS(0x10 | (gobIndex + 1), 20, nbb_, bb_, bc_);
		/* GQUANT/GEI */
		mquant_ = lq_;
		PUT_BITS(mquant_ << 1, 6, nbb_, bb_, bc_);

		mba_ = 0;
		int line = 11;
		for (u_int mba = 1; mba <= 33; ++mba) {
			/*
			 * If the conditional replenishment algorithm
			 * has decided to send any of the blocks of
			 * this macroblock, code it.
			 */
			u_int s = crvec[blkno];

			if ((s & CR_SEND) != 0) {
				u_int mbpred = mba_;
				encode_mb(mba, frm, loff, coff, CR_STATE(s)); // encode MB
				u_int cbits = ((bc_ - bs_) << 3) + nbb_;
				if (cbits > ec) { // make new packet
					Transmitter::pktbuf* npb;
					npb = tx_->alloc();
					cc += flush(pb, nbit, npb);
					cbits -= nbit;
					pb = npb;
					/* RTP/H.261 header */
					u_int m = mbpred;
					u_int g;
					if (m != 0) {
						g = gobIndex + 1;
						m -= 1;
					} else
						g = 0;

					rh = (u_int*)pb->hdr;
					*rh =	1 << 24 |  //set motion vector flag.
 					      m << 15 |  //macroblock address predictor.
					      g << 20 |  //Group of blocks number.
             mquant_ << 10;//quantizer value.
                                        
				}
				nbit = cbits;
			}

			loff += loffsize_;
			coff += coffsize_;
			blkno += bloffsize_;
			if (--line <= 0) {
				line = 11;
				blkno += bstride_;
				loff += lstride_;
				coff += cstride_;
			}

		}
	}
	cc += flush(pb, ((bc_ - bs_) << 3) + nbb_, 0); 
	return (cc);
}

int H261PixelEncoder::PreIncEncodeSetup(const VideoFrame *vf)
{
  if (!SameSize(vf))
    SetSize(vf->width, vf->height);
  gVf = vf;
  gPicture = TRUE; //if TRUE, send picture layer header
  gNbytes = 0;  //number of bytes in previous packet
  gDbase = 0; //offset from gData where valid data starts
  nbb_ = 0; //# of valid bits in bb_
  bb_ = 0; //intermediate working space
  bc_ = gData; //where to put encoded bits
  gStep = cif_ ? 1 : 2; //Macro Block step size
  gGobMax = cif_ ? 12 : 5; //how many GOB per frame
  sbit_ = 0;
  gSendGOBhdr = TRUE; //must send GOB hdr before sending MB
  gGOBhdrNxt = TRUE; //will start out with GOB header
  //because gGOBhdrNxt == TRUE, no need to initialize the following 2 header variables:
  //gHdrGOBN; // next GOB number for last encoded MB
  //gHdrMBAP; // address of last macroblock encoded in previous packet 1..32
  //mba_= 0; // should not be necessary to initialize this
  gHdrQUANT = lq_; // QUANT in effect for next MB to be encoded
  gNxtMBA = 1; // address of next macroblock to be considered for encoding 1..33
  gNxtGOB = 1; // start encoding at GOB 1
  gDone = FALSE;
  return 1;
} 

void H261PixelEncoder::IncEncodeAndGetPacket(
  u_char * buffer,    // returns buffer of encoded data
  unsigned & length ) // returns actual length of encoded data buffer
{
  u_int previousBitCount = 0, currentBitCount;
  h261hdr_t h261hdr;

  if (gDone) {
    length = 0;
    return;
  }

  // TESTING
  if (!gGOBhdrNxt && ((33 <= gHdrMBAP) || (0 >= gHdrMBAP))) {
    cerr << __FILE__<< "(" << __LINE__ << ") " <<
      "illegal gHdrMBAP value when gGOBhdrNxt is FALSE = " << gHdrMBAP << endl;
    gHdrMBAP = 1;
  }
  //  unsigned t1 = sbit_ << 29;
  //  unsigned t2 = (gGOBhdrNxt?0:gHdrGOBN) << 20;
  //  unsigned t3 = (gGOBhdrNxt||(0==gHdrMBAP)?0:gHdrMBAP-1) << 15;
  //  unsigned t4 = (gGOBhdrNxt?0:gHdrQUANT) << 10;

  // set the H.261 header (32 bits) bits that we know now
  h261hdr =               1 << 24 | // V = 1, I = 0, HMVD = 0, VMVD = 0
                      sbit_ << 29 | // SBIT
    (gGOBhdrNxt?0:gHdrGOBN) << 20 | // GOBN
  (gGOBhdrNxt?0:gHdrMBAP-1) << 15 | // MBAP 
   (gGOBhdrNxt?0:gHdrQUANT) << 10;  // QUANT
                  // gHdrQUANT << 10;  // QUANT set the old & incorrect way

  // if any, move unsent bits encoded during previous packet encode
  unsigned usedBB_INTs;
  u_char* msrc;
  unsigned m1;
  if (sbit_) gNbytes--; // last byte of previous packet has bits needed for this packet
  usedBB_INTs = (gNbytes + gDbase)/sizeof(BB_INT);
  msrc = gData + usedBB_INTs*sizeof(BB_INT);
  gDbase = (gDbase + gNbytes) % sizeof(BB_INT);
  m1 = bc_ - msrc;
  if (m1) memcpy(gData, msrc, m1);
  bc_ = gData + m1; // set starting bc_ address
  
  // encode H.261 stream
  if (gPicture) { // only ever sent at start of 1st packet 
    /* PSC Picture Start Code */
    PUT_BITS(0x0001, 16, nbb_, bb_, bc_);
    /* GOB 0 -> picture header Finishes PSC */
    PUT_BITS(0, 4, nbb_, bb_, bc_);
    /* TR Temporal Reference (XXX should do this right) */
    PUT_BITS(0, 5, nbb_, bb_, bc_);
    /* PTYPE = CIF */
    int pt = cif_ ? 7 : 3;
    PUT_BITS(pt, 6, nbb_, bb_, bc_);
    /* PEI Picture Extra Information = none */
    PUT_BITS(0, 1, nbb_, bb_, bc_);
    gloff = loff_[0];
    gcoff = coff_[0];
    gblkno = blkno_[0];
    gline = 11;
    gPicture = FALSE;
  }
  unsigned bitLimit = 8*(RTP_MTU - sizeof(h261hdr));
  u_char* bbase = gData + gDbase;
  if (!(gNxtGOB > gGobMax)) {
    while ((currentBitCount = nbb_ + 8*(bc_ - bbase)) <= bitLimit) {
      // everything encoded up till now fits within the RTP_MTU buffer
      // test to see if the packet can be broken here
      if (gSendGOBhdr || (0 != mba_)){ // if packet can be broken,
        // record conditions that will be needed to construct the h261 header
        // for the next packet if the packet breaks here
        gHdrGOBN = gNxtGOB; // GOB number in effect for next MB to be encoded
        gHdrMBAP = mba_; // MBA of the last encoded MB & now in the buffer
        gHdrQUANT = mquant_; // QUANT in effect for next MB to be encoded
        gGOBhdrNxt = gSendGOBhdr; // is GOB header next?
        previousBitCount = currentBitCount; // encoded bits now in the buffer
      }
      if (gSendGOBhdr) { // need to send GOB header before can send MB ?
        /* GSC/GN */
        PUT_BITS(0x10 | gNxtGOB, 20, nbb_, bb_, bc_);
        /* GQUANT/GEI */
        mquant_ = lq_;
        PUT_BITS(mquant_ << 1, 6, nbb_, bb_, bc_);
        mba_= 0;
        gSendGOBhdr = FALSE;
      }
      /** If the conditional replenishment algorithm
      * has decided to send any of the blocks of
      * this macroblock, encode it.
      */
      u_int s = gVf->crvec[gblkno];
      if ((s & CR_SEND) != 0) {
        //H261PixelEncoder::encode_mb(u_int mba, // address of macroblock to encode
        //  const u_char* frm, // address of YUV pixels
        //  u_int loff, // Luminance offset from frm
        //  u_int coff, // Chrominance offset from frm
        //  int how)
        encode_mb(gNxtMBA, gVf->frameptr, gloff, gcoff, CR_STATE(s)); // encode MB
        mba_= gNxtMBA;
      }
      gNxtMBA++;
      if (gNxtMBA > 33) {
        gNxtGOB += gStep;
        if (gNxtGOB > gGobMax) {
          gDone = TRUE;
          break; // out of while(), done encoding frame
        }
        gNxtMBA = 1;
        gSendGOBhdr = TRUE; // must send GOB hdr before sending MB
        gloff = loff_[gNxtGOB-1];
        gcoff = coff_[gNxtGOB-1];
        gblkno = blkno_[gNxtGOB-1];
        gline = 11;
      }
      else {
        gloff += loffsize_;
        gcoff += coffsize_;
        gblkno += bloffsize_;
        if (--gline <= 0) {
          gline = 11;
          gblkno += bstride_;
          gloff += lstride_;
          gcoff += cstride_;
        }
      }
    }
  }
  else 
    gDone = TRUE;
  // have full packet now, finish & set up for next packet
  // break packet at end of previous MB unless this is end of frame
  // flush bits from bb_
  STORE_BITS(bb_, bc_); // necessary when gDbase != 0
  if (gDone) {
    unsigned totalBits = nbb_ + 8*(bc_ - bbase);
    if (totalBits <= bitLimit) { // would packet be too big?
      previousBitCount = totalBits;
    }
    else { // need another packet to finish frame
      gDone = FALSE;
    }
  }
  gNbytes = previousBitCount / 8;
  sbit_ = previousBitCount % 8; // SBIT for next packet = good bits for this packet
  if (sbit_) gNbytes++; // include last bits for this frame
  
  // set the H.261 header (32 bits) bits that we know now
  h261hdr |= ((8 - sbit_) & 7) << 26; //EBIT = 8 - SBIT for next packet
  h261hdr = htonl(h261hdr);
  *(h261hdr_t*)buffer = h261hdr;
  memcpy(buffer+sizeof(h261hdr), gData+gDbase, gNbytes);
  length = gNbytes+sizeof(h261hdr);

  if (RTP_MTU < length) { // test for too large packet (I haven't seen one yet)
    cerr << __FILE__<< "(" << __LINE__ << ") " <<
      "packet size of " << length << " > RTP_MTU(" << RTP_MTU << ")" << endl;
  }
}