|
|
/* *************************************************************************
** INTEL Corporation Proprietary Information**** This listing is supplied under the terms of a license** agreement with INTEL Corporation and may not be copied** nor disclosed except in accordance with the terms of** that agreement.**** Copyright (c) 1995-1996 Intel Corporation.** All Rights Reserved.**** **************************************************************************/
/*****************************************************************************
* * e1enc.cpp * * DESCRIPTION: * Specific encoder compression functions. * * Routines: Prototypes in: * H263InitEncoderInstance * H263Compress * H263TermEncoderInstance */
// $Header: S:\h26x\src\enc\e1enc.cpv 1.78 15 Apr 1997 10:24:48 AGUPTA2 $
// $Log: S:\h26x\src\enc\e1enc.cpv $
//
// Rev 1.78 15 Apr 1997 10:24:48 AGUPTA2
// Added checks to ensure 1) bit-stream is less than (8,32)K and 2)
// extended bitstream is less than allocated buffer size.
//
// Rev 1.77 24 Jan 1997 17:12:06 RHAZRA
// We were computing the size of the bitstream to be one more than
// the real size. Now fixed.
//
// Rev 1.76 17 Dec 1996 09:07:16 SCDAY
// changed an ASSERT to handle Memory Layout changes
//
// Rev 1.75 16 Dec 1996 17:36:04 MBODART
// Applied Raj's changes for tweaking ME parameters under RTP.
// Also restructured some code for cleanliness.
//
// Rev 1.74 13 Dec 1996 17:19:02 MBODART
// Bumped the ME SLF parameters for MMX.
//
// Rev 1.73 13 Dec 1996 15:17:02 MBODART
// Adjusted the motion estimation IA spatial loop filter parameters.
// Still need to tune the MMX parameters.
//
// Rev 1.72 05 Dec 1996 10:56:14 MBODART
// Added h261test.ini options for playing with motion estimation parameters.
//
// Rev 1.71 04 Dec 1996 13:23:34 MBODART
// Tweaked some DbgLog messages to aid bit rate tuning.
// Removed some unused code.
//
// Rev 1.70 21 Nov 1996 10:50:32 RHAZRA
// Changed recompression strategy to be more pessimistic with key
// frames since a buffer overflow on a keyframe can cause a host
// of secondary effects.
//
// Rev 1.69 18 Nov 1996 17:11:38 MBODART
// Replaced all debug message invocations with Active Movie's DbgLog.
//
// Rev 1.68 18 Nov 1996 09:02:34 RHAZRA
// Now no DWORD 0 at the end of the bitstream for both the MMX and IA
// codecs.
//
// Rev 1.67 15 Nov 1996 09:47:22 RHAZRA
// #ifdef ed out the addition of a DWORD of zeros at the end of the bitstream.
//
// Rev 1.66 13 Nov 1996 11:37:20 RHAZRA
// Added MMX autosensing
//
// Rev 1.65 21 Oct 1996 10:45:50 RHAZRA
// Changed interface to EDTQ function to keep in sync with exmme.asm which
// now has EMV
//
// Rev 1.64 21 Oct 1996 09:00:18 RHAZRA
// MMX integration
//
// Rev 1.62 16 Sep 1996 13:17:44 RHAZRA
// Added support for SLF to be adaptively turned on and off via
// coding thresholds and differentials.
//
// Rev 1.61 06 Sep 1996 15:04:52 MBODART
// Added performance counters for NT's perfmon.
// New files: cxprf.cpp, cxprf.h, cxprfmac.h.
// New directory: src\perf
// Updated files: e1enc.{h,cpp}, d1dec.{h,cpp}, cdrvdefs.h, h261* makefiles.
//
// Rev 1.60 26 Aug 1996 10:09:02 RHAZRA
// Added checking to ensure that RTP BS Info stream is rewound on
// GOB recompression only if RTP is signalled. This fixes the reported
// failure of build 29 on q1502stl.avi @ 100Kbps.
//
// Rev 1.59 21 Aug 1996 19:01:18 RHAZRA
// Added RTP extended bitstream generation
//
// Rev 1.58 21 Jun 1996 10:06:06 AKASAI
// Changes to e1enc.cpp, e1mbenc.cpp, ex5me.asm to support "improved
// bit rate control", changing MacroBlock Quantization within a
// row of MB's in addition to changing the Quantization change
// between rows of macro blocks.
//
// ex5me.asm had a problem with SLF SWD. Brian updated asm code.
//
//
// Rev 1.57 05 Jun 1996 13:56:52 AKASAI
// Changes to e1enc.cpp: Added new parameter to MOTIONESTIMATION which
// allows for 15 pel radius search otherwise (? maybe 7 pels).
//
// Changes to e1enc.h: New parameter to MOTIONESTIMATION and change to
// offsets in MBAcationStream to match changes in e3mbad.inc, ex5me.asm
// and ex5fdct.asm.
//
// Rev 1.56 29 May 1996 13:53:00 AKASAI
// Tuned the Motion Estimation parameters. Video quality
// seems to remain about the same, bit rate increased a little (200 bits
// per frame), CPU usage decreased a little.
//
// Rev 1.55 14 May 1996 12:33:10 AKASAI
// Got an undefined on wsprintf so moved it to a #ifdef DEBUG_RECOMPRESS
// area.
//
// Rev 1.54 14 May 1996 10:33:46 AKASAI
// Two files changed to hopefully eliminate Quantization clamping
// artifacts and to reduce the max buffer overflow case: e1enc.cpp
// and e1mbenc.cpp.
//
// In e1mbenc.cpp when the MQuant level is < 6 I test to see if
// the 0th coefficient is larger than the values representable
// at that Quant level if it is I increase the Quant level until
// the clamping artifact will not occur. Note: I am test only
// the Oth coefficient, there is the possibility that some other
// coefficient is larger but the performance trade off seems to
// indicate this is good for now and if we still see clamping
// artifacts we can add more testing later.
//
// In e1enc.cpp I modified when the Overflow types of warnings are
// turn on as well as changing the rate the Quantization level
// changes at.
//
// Rev 1.53 24 Apr 1996 12:13:50 AKASAI
// Added re-compression strategy to encoder. Had to change e1enc.cpp,
// e1enc.h and e1mbenc.cpp.
// Basic strategy is if spending too many bits in a GOB quantize the
// next GOB at a higher rate. If after compressing the frame too
// many bits have been used, re-compress the last GOB at a higher
// QUANT level if that still doesn't work send a "Skip" GOB.
// Needed to add extra parameter to GOB+Q_RLE_VLC_WriteBS because
// CalcMBQuant kept decreasing the QUANT when we were in trouble with
// possibly overflowing the buffer.
//
// Rev 1.52 22 Apr 1996 10:54:24 AKASAI
// Two files changed e1enc.cpp and e1mbenc.cpp to try and support
// allowing the Quantization values to go down to 2 instead of
// CLAMP to 6.
// This is part 1 of implementing the re-compression (what to do
// if exceed max compressed buffer size 8KBytes QCIF, 32KBytes FCIF).
// Also changed in e1enc was to limit request uFrameSize to 8KB or
// 32KB. Problem was if user specified too large of a datarate
// request frame size would be larger than the allowed buffer size.
// If you try to compress qnoise10.avi or fnoise5.avi you get an
// ASSERT error until rest of re-compression is implemented.
//
// Rev 1.51 19 Apr 1996 14:26:26 SCDAY
// Added adaptive bit usage profile (Karl's BRC changes)
//
// Rev 1.50 15 Apr 1996 14:10:30 AKASAI
// Updated range to allow for +/- 15 pel search. There was and assert
// if MV outside +/- 15 (in half pel numbers) now assert if [-32,31].
//
// Rev 1.49 11 Apr 1996 16:00:02 AKASAI
// Updated H261 encoder to new interface and macroblock action stream
// data structure in e3mbad.inc for FORWARDDCT. Files updated together
// e1enc.cpp, e1enc.h, ex5fdct.asm, e3mbad.inc.
//
// Added IFNDEF H261 in ex5fdct so that code used only in H263 is
// not assembled for H261.
//
// Rev 1.48 11 Apr 1996 13:02:04 SCDAY
// Fixed zero dirty buffer problem
//
// Rev 1.45 10 Apr 1996 13:06:40 SCDAY
// Changed clearing of bitstream buffer to zero only the "dirty"
// part of the buffer rather than the entire buffer
//
// Rev 1.44 05 Apr 1996 14:36:28 SCDAY
//
// Added ASM version of UV SLF
//
// Rev 1.43 04 Apr 1996 13:45:32 AKASAI
// Added 2 Bytes, 16-bits of zeros at end of bitstream to help 16-bit
// decoder find end of frame. Under testing we saw green blocks at
// end of frame.
//
// Rev 1.42 27 Mar 1996 15:09:52 SCDAY
// Moved declarations/definition of H26X_YUV12toEncYUV12 to excolcnv.cpp
// to incorporate latest H263 changes and SCD 'C' code optimization
//
// Rev 1.41 20 Mar 1996 14:21:04 Sylvia_C_Day
// Added lower level timing stats for SLF_UV
//
// Rev 1.40 26 Feb 1996 10:09:34 AKASAI
// Corrected PicFreeze bit last fix set it to always ON instead of the
// correct usage. ON for Keys OFF for deltas.
// Also fixed 2 other bits that were set incorrectly. HI_RES and SPARE.
// SPARE should always be 1, HI_RES should be OFF (which is 1 for this
// bit).
//
// Rev 1.39 14 Feb 1996 14:53:56 AKASAI
// Added work around for Blazer team to set PicFreeze to ON when
// encoding a KEY FRAME.
//
// Rev 1.38 06 Feb 1996 09:46:00 AKASAI
// Updated Copyright to include 1996.
//
// Rev 1.37 05 Feb 1996 15:24:04 AKASAI
// Changes to support new BRC interface. Tested with RING3 codec.
//
// Rev 1.36 09 Jan 1996 08:52:34 AKASAI
//
// Added U&V plane loop filter. To enable make sure SLF_WORK_AROUND
// is defined in makefile.
//
// Rev 1.35 08 Jan 1996 10:11:58 DBRUCKS
// Disable half pel interpolation of U & V motion vectors in fdct
// Change to use divide and not shift when calculating U & V motion vectors
// in order that we truncate towards zero as the spec requires.
//
// Rev 1.34 29 Dec 1995 18:12:54 DBRUCKS
//
// add clamp_n_to(qp,6,31) to avoid clipping artifacts.
// add code to assign Y2,3,4-PrevPtr based on Y1-PrevPtr for SLF blocks
//
// Rev 1.33 27 Dec 1995 16:51:54 DBRUCKS
// move the increment of InterCodeCnt to e1mbenc.cpp
// cleanup based on H263 v11
// remove unused definitions
//
// Rev 1.32 26 Dec 1995 17:44:52 DBRUCKS
// moved statistics to e1stat
//
// Rev 1.31 20 Dec 1995 16:46:02 DBRUCKS
// get Spox to compile with the timing code
//
// Rev 1.30 20 Dec 1995 15:35:08 DBRUCKS
// get to build without ENC_STATS define
//
// Rev 1.29 20 Dec 1995 14:56:50 DBRUCKS
// add timing stats
//
// Rev 1.28 18 Dec 1995 15:38:02 DBRUCKS
// improve stats
//
// Rev 1.27 13 Dec 1995 13:58:18 DBRUCKS
//
// moved trace and cnvt_fdct_output to exutil.cpp
// removed BitRev as it was not used
// changed to call terminate if init was called with Initialized == True
// implemented TR
//
// Rev 1.26 07 Dec 1995 12:53:38 DBRUCKS
//
// add an ifdef so the ring0 release build succeeds
// change the quality to quant from conversion to use 3 to 31
// fix mb first state initialization for CIF
//
// Rev 1.25 06 Dec 1995 09:43:38 DBRUCKS
//
// initialize blazer COMPINSTINFO variables
// integrate blazer bit rate control into Compress
// remove LINK_ME
//
// Rev 1.24 04 Dec 1995 10:26:28 DBRUCKS
// cleanup the ini file reading function
//
// Rev 1.23 01 Dec 1995 15:37:56 DBRUCKS
//
// Added the bit rate controller
// set the default options (if no INI file) to:
// RING0: MotionEstimation SpatialLoopFilter FixedQuantization of 8
// RING3: MotionEstimation SpatialLoopFilter VfW driven Bit Rate Control
//
// Rev 1.20 28 Nov 1995 13:21:30 DBRUCKS
// add BRC options
// change to read options from an ini file - h261.ini
//
// Rev 1.19 27 Nov 1995 17:53:42 DBRUCKS
// add spatial loop filtering
//
// Rev 1.18 27 Nov 1995 16:41:44 DBRUCKS
// replace B and Future planes with SLF
// remove the scratch space
//
// Rev 1.17 22 Nov 1995 18:21:42 DBRUCKS
// Add an #ifdef around the MOTIONESTIMATION call in order that the IASpox
// environment not be required to call MOTIONESTIMATION when advancing the
// tip. Unless LINK_ME is defined MOTIONESTIMATION will not be called.
//
// Rev 1.16 22 Nov 1995 17:37:36 DBRUCKS
// cleanup me changes
//
// Rev 1.15 22 Nov 1995 15:34:30 DBRUCKS
//
// Motion Estimation works - but needs to be cleaned up
//
// Rev 1.14 20 Nov 1995 12:13:14 DBRUCKS
// Cleanup the encoder terminate function
// Integrate in the picture checksum code (CHECKSUM_PICTURE)
//
// Rev 1.13 17 Nov 1995 14:25:24 BECHOLS
// Made modifications so that this file can be made for ring 0.
//
// Rev 1.12 15 Nov 1995 19:05:22 AKASAI
// Cleaned up some warning messages.
//
// Rev 1.11 15 Nov 1995 14:38:16 AKASAI
//
// Current and Previous frame pointers changed from Addresses to Offsets.
// Change of parameters to call to FOWARDDCT. Some Union thing.
// (Integration point)
//
// Rev 1.10 01 Nov 1995 09:01:12 DBRUCKS
//
// cleanup variable names
// add ZERO_INPUT test option
// make sure all frames end on a byte boundary.
//
// Rev 1.9 27 Oct 1995 17:19:52 DBRUCKS
// initializing PastRef ptrs
//
// Rev 1.8 27 Oct 1995 15:06:26 DBRUCKS
// update cnvt_fdct_output
//
// Rev 1.7 27 Oct 1995 14:31:10 DBRUCKS
// integrate 0-MV delta support based on 263 baseline
//
// Rev 1.6 28 Sep 1995 17:02:34 DBRUCKS
// fix colorIn to not swap left to right
//
// Rev 1.5 28 Sep 1995 15:58:20 DBRUCKS
// remove pragmas
//
// Rev 1.4 28 Sep 1995 14:21:30 DBRUCKS
// fix to match INTRA and INTER enum changes
//
// Rev 1.3 25 Sep 1995 10:22:48 DBRUCKS
// activate call to InitVLC
//
// Rev 1.2 20 Sep 1995 12:38:48 DBRUCKS
// cleanup
//
// Rev 1.0 18 Sep 1995 10:09:30 DBRUCKS
// Initial revision after the archive got corrupted.
//
// Rev 1.4 15 Sep 1995 12:27:32 DBRUCKS
// intra mb header
//
// Rev 1.3 14 Sep 1995 17:16:08 DBRUCKS
// turn on FDCT and some cleanup
//
// Rev 1.2 14 Sep 1995 14:18:52 DBRUCKS
// init mb action stream
//
// Rev 1.1 13 Sep 1995 13:41:50 DBRUCKS
// move the picture header writing into a separate routine.
// implement the gob header writing.
//
// Rev 1.0 12 Sep 1995 15:53:40 DBRUCKS
// initial
//
#define DUMPFILE 0
/* Pick a resiliency strategy.
*/#define REQUESTED_KEY_FRAME 0
#define PERIODIC_KEY_FRAME 1
#define FAST_RECOVERY 2
#define SLOW_RECOVERY 3
#define MAX_STUFFING_BYTES 10
#define RESILIENCY_STRATEGY PERIODIC_KEY_FRAME
#define PERIODIC_KEY_FRAME_PERIODICITY 15 /* Select periodicity (max 32767) */
#define UNRESTRICTED_MOTION_FRAMES 16 /* Number of frames that don't have an Intra slice. 0 for FAST_RECOVERY.
* Modest amount for SLOW_RECOVERY. Unimportant for other strategies. */
#include "precomp.h"
#ifdef ENCODE_STATS
#define ENCODE_STATS_FILENAME "encstats.txt"
#endif
#define PITCHL 384L
#define DEFAULT_DCSTEP 8
#define DEFAULT_QUANTSTEP 36
#define DEFAULT_QUANTSTART 30
#define LEFT 0
#define INNERCOL 1
#define NEARRIGHT 2
#define RIGHT 3
#define TOP 0
#define INNERROW 4
#define NEARBOTTOM 8
#define BOTTOM 12
#define FCIF_NUM_OF_GOBS 12
#define QCIF_NUM_OF_GOBS 3
#if defined(_DEBUG) || defined(DEBUG_RECOMPRESS) || defined(DEBUG_ENC) || defined(DEBUG_BRC)
char string[128];#endif
/* Look up table for quarter pel to half pel conversion of chroma MV's. */const char QtrPelToHalfPel[64] = { -16, -15, -15, -15, -14, -13, -13, -13, -12, -11, -11, -11, -10, -9, -9, -9, -8, -7, -7, -7, -6, -5, -5, -5, -4, -3, -3, -3, -2, -1, -1, -1, 0, 1, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 7, 7, 7, 8, 9, 9, 9, 10, 11, 11, 11, 12, 13, 13, 13, 14, 15, 15, 15 };
/* The GOB number arrays contain the GOB numbers for QCIF and CIF. The lists are zero terminated.
*/static U32 uCIFGOBNumbers[] = {1,2,3,4,5,6,7,8,9,10,11,12,0};static U32 uQCIFGOBNumbers[] = {1,3,5,0};
/* The starting INTER Motion Estimation states are different for QCIF and CIF.
*/#define MAX_ME_STATE_ROW_NUMBER 8
#define BAD_ME_ROW (MAX_ME_STATE_ROW_NUMBER + 1)
static U8 u8FirstInterMEStateRows[MAX_ME_STATE_ROW_NUMBER+1][11] ={ /* 1 2 3 4 5 6 7 8 9 10 11 */ {UpperLeft, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperRight}, {LeftEdge, CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,RightEdge}, {LowerLeft, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerRight}, {UpperLeft, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge}, {UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperEdge, UpperRight},
{LeftEdge, CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock}, {CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,CentralBlock,RightEdge},
{LowerLeft, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge}, {LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerRight},};
//RTP: resiliency tables.
static U8 u8FirstInterMENoVerMVStateRows[MAX_ME_STATE_ROW_NUMBER+1][11] ={ /* 1 2 3 4 5 6 7 8 9 10 11 */ {NoVertLeftEdge, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertRightEdge}, {NoVertLeftEdge, NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertRightEdge}, {NoVertLeftEdge, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertRightEdge}, {NoVertLeftEdge, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock}, {NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertRightEdge},
{NoVertLeftEdge, NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock}, {NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertCentralBlock,NoVertRightEdge},
{NoVertLeftEdge, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock}, {NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertRightEdge},};
static U8 u8FirstInterMENoPosVerMVStateRows[MAX_ME_STATE_ROW_NUMBER+1][11] ={ /* 1 2 3 4 5 6 7 8 9 10 11 */ {NoVertLeftEdge, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertRightEdge}, {LowerLeft, LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerRight}, {LowerLeft, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerRight}, {NoVertLeftEdge, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock}, {NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertCentralBlock, NoVertRightEdge},
{LowerLeft, LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge}, {LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerEdge,LowerRight},
{LowerLeft, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge}, {LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerEdge, LowerRight},}; static U8 u8MEPad[1];static U8 u8QCIFFirstInterMEStateRowNumbers[12] = {0,1,1, 1,1,1, 1,1,2, BAD_ME_ROW,BAD_ME_ROW,BAD_ME_ROW};static U8 u8CIFFirstInterMEStateRowNumbers[40] = {3,5,5, 4,6,6, 5,5,5, 6,6,6, 5,5,5, 6,6,6, 5,5,5, 6,6,6, 5,5,5, 6,6,6, 5,5,7, 6,6,8, BAD_ME_ROW,BAD_ME_ROW,BAD_ME_ROW,BAD_ME_ROW};
/* The starting offsets for each of the GOBs
* - odd GOBs: NumberOfGOBsAbove * PITCH * 3MacroBlocksToAGOB * NumberOfLinesToAMacroBlock * - even GOBs: oddGobValue + 11MacroBlocksToAGOB * NumberOfColumnsToAMacroBlock */static U32 uStartingYOffsets[16] ={ 0, /* not used */ 0*PITCH*3*16, 0*PITCH*3*16+11*16, // 1 and 2
1*PITCH*3*16, 1*PITCH*3*16+11*16, // 3 and 4
2*PITCH*3*16, 2*PITCH*3*16+11*16, // 5 and 6
3*PITCH*3*16, 3*PITCH*3*16+11*16, // 7 and 8
4*PITCH*3*16, 4*PITCH*3*16+11*16, // 9 and 10
5*PITCH*3*16, 5*PITCH*3*16+11*16, // 11 and 12
0, 0, 0 /* not used */};static U32 uStartingUOffsets[16] ={ 0, /* not used */ 0*PITCH*3*8, 0*PITCH*3*8+11*8, // 1 and 2
1*PITCH*3*8, 1*PITCH*3*8+11*8, // 3 and 4
2*PITCH*3*8, 2*PITCH*3*8+11*8, // 5 and 6
3*PITCH*3*8, 3*PITCH*3*8+11*8, // 7 and 8
4*PITCH*3*8, 4*PITCH*3*8+11*8, // 9 and 10
5*PITCH*3*8, 5*PITCH*3*8+11*8, // 11 and 12
0, 0, 0};
/* Table to limit Quant changes between Rows of Marco Blocks */U8 MaxChangeRowMBTbl[32] = { 0, /* Not Used */ 1, /* Not Used when clamp to (2,31) */ 1, /* 2 */ 2, /* 3 */ 2, /* 4 */ 3, /* 5 */ 3, /* 6 */ 3, /* 7 */ 3, /* 8 */ 3, /* 9 */ 3, /* 10 */ 3, /* 11 */ 3, /* 12 */ 3, /* 13 */ 3, /* 14 */ 3, /* 15 */ 3, /* 16 */ 3, /* 17 */ 3, /* 18 */ 3, /* 19 */ 3, /* 20 */ 3, /* 21 */ 3, /* 22 */ 3, /* 23 */ 4, /* 24 */ 4, /* 25 */ 4, /* 26 */ 4, /* 27 */ 4, /* 28 */ 4, /* 29 */ 4, /* 30 */ 4 /* 31 */ };
U8 INTERCODECNT_ADJUST[11]=
// Packet loss (in %)
// 0-9 10-19 20-29 30-39 40-49 50-59 60-69 70-79 80-89 90-99 100
// Refresh limit
{ 132, 100, 80, 75, 60, 45, 20, 10, 5, 3, 1 };
U32 EMPTYTHRESHOLD_ADJUST[5]=
// Packet loss (in %)
// 0-24 25-49 50-74 75-99 100
// Multiplier
{ 1, 2, 3, 4, 10};
/* Static Function declarations
*/static void WriteBeginPictureHeaderToStream(T_H263EncoderCatalog *, U8 ** ,U8 *);
#ifdef CHECKSUM_PICTURE
static void WritePictureChecksum(YVUCheckSum *, U8 ** ,U8 *, U8);#endif
static void WriteEndPictureHeaderToStream(T_H263EncoderCatalog *, U8 ** ,U8 *);
static void WriteGOBHeaderToStream(U32,unsigned int, U8 ** ,U8 *);
static void CalcGOBChromaVecs(T_H263EncoderCatalog *, UN, T_CONFIGURATION *);
static void GetEncoderOptions(T_H263EncoderCatalog *);
static void StartupBRC(T_H263EncoderCatalog *, U32, U32, float);
static void CalculateQP_mean(T_H263EncoderCatalog * EC);
/* Global Data definition
*/#pragma data_seg ("H263EncoderTbl") /* Put in the data segment named "H263EncoderTbl" */
#pragma data_seg ()
/*****************************************************************************
* EXTERNAL FUNCTIONS ****************************************************************************/
/*****************************************************************************
* * H263InitEncoderGlobal * * This function initializes the global tables used by the H261 encoder. Note * that in 16-bit Windows, these tables are copied to the per-instance data * segment, so that they can be used without segment override prefixes. * In 32-bit Windows, the tables are left in their staticly allocated locations. * * Returns an ICERR value */LRESULT H263InitEncoderGlobal(void){ /*
* Initialize fixed length tables for INTRADC */ InitVLC();
return ICERR_OK;} /* end H263InitEncoderGlobal() */
/*****************************************************************************
* * H263InitEncoderInstance * * This function allocates and initializes the per-instance tables used by * the H261 encoder. Note that in 16-bit Windows, the non-instance-specific * global tables are copied to the per-instance data segment, so that they * can be used without segment override prefixes. * * Returns an ICERR value; */LRESULT H263InitEncoderInstance(LPCODINST lpCompInst){
LRESULT lResult = ICERR_ERROR; U32 uGOBNumber; U32 uSize; UN unIndex; UN unStartingMB;
T_H263EncoderInstanceMemory * P32Inst; T_H263EncoderCatalog * EC; U32 * puGOBNumbers; int iMBNumber; UN bEncoderInstLocked = 0; int iNumMBs;
// RTP: declarations
T_CONFIGURATION *pConfiguration; UN uIntraQP; UN uInterQP;
/* If we were already initialized then we need to terminate the instance.
* This happens when two BEGIN's are called without an END. * * Note: We can't just clear the memory because that will throw out the * decoder memory. because it will clear the decoder instance which * contains the decoder catalog pointer. */ if(lpCompInst->Initialized) { lResult = H263TermEncoderInstance(lpCompInst); if (lResult != ICERR_OK) { DBOUT("Warning an error occurred terminating the encoder before reinitializing"); } }
/* Calculate size of encoder instance memory needed. */ //uSize = sizeof(T_H263EncoderInstanceMemory) + 32;
uSize = sizeof(T_H263EncoderInstanceMemory) + sizeof(T_MBlockActionStream);
/*
* Allocate the memory. */ lpCompInst->hEncoderInst = GlobalAlloc(GHND, uSize);
lpCompInst->EncoderInst = (LPVOID) GlobalLock(lpCompInst->hEncoderInst); if (lpCompInst->hEncoderInst == NULL || lpCompInst->EncoderInst == NULL) { lResult = ICERR_MEMORY; goto done; } bEncoderInstLocked = 1;
/* Calculate the 32 bit instance pointer starting at the next
* 32 byte boundary. */ P32Inst = (T_H263EncoderInstanceMemory *) ((((U32) lpCompInst->EncoderInst) + (sizeof(T_MBlockActionStream) - 1)) & ~(sizeof(T_MBlockActionStream) - 1));
/* The encoder catalog is at the start of the per-instance data.
*/ EC = &(P32Inst->EC);
// RTP: initialization
/* Initialize the Configuration information
*/ pConfiguration = &(lpCompInst->Configuration);#if 0
if (LoadConfiguration(pConfiguration) == FALSE) { GetConfigurationDefaults(pConfiguration); }#endif
pConfiguration->bInitialized = TRUE; pConfiguration->bCompressBegin = TRUE;
#ifdef _DEBUG
DBOUT("Encoder Configuration Options:"); wsprintf(string,"bRTPHeader=%d", (int)pConfiguration->bRTPHeader); DBOUT(string); wsprintf(string,"unPacketSize=%d", (int)pConfiguration->unPacketSize); DBOUT(string); wsprintf(string,"bEncoderResiliency=%d", (int)pConfiguration->bEncoderResiliency); DBOUT(string); wsprintf(string,"bDisallowPosVerMVs=%d", (int)pConfiguration->bDisallowPosVerMVs); DBOUT(string); wsprintf(string,"bDisallowAllVerMVs=%d", (int)pConfiguration->bDisallowAllVerMVs); DBOUT(string); wsprintf(string,"unPercentForcedUpdate=%d", (int)pConfiguration->unPercentForcedUpdate); DBOUT(string); wsprintf(string,"unDefaultIntraQuant=%d", (int)pConfiguration->unDefaultIntraQuant); DBOUT(string); wsprintf(string,"unDefaultInterQuant=%d", (int)pConfiguration->unDefaultInterQuant); DBOUT(string); #endif
/* Initialize encoder catalog.
*/ EC->FrameHeight = lpCompInst->yres; EC->FrameWidth = lpCompInst->xres; EC->FrameSz = lpCompInst->FrameSz; EC->NumMBRows = EC->FrameHeight >> 4; EC->NumMBPerRow = EC->FrameWidth >> 4; EC->NumMBs = EC->NumMBRows * EC->NumMBPerRow;
/* Get the Options
*/ GetEncoderOptions(EC);
// RTP: resiliency initialization
if(pConfiguration->bEncoderResiliency && pConfiguration->unPercentForcedUpdate && pConfiguration->unPacketLoss)
{ EC->uNumberForcedIntraMBs = ((EC->NumMBs * pConfiguration->unPercentForcedUpdate) + 50) / 100; EC->uNextIntraMB = 0; }
/* Store pointers to current frame in the catalog.
*/ EC->pU8_CurrFrm = P32Inst->u8CurrentPlane; EC->pU8_CurrFrm_YPlane = EC->pU8_CurrFrm + 16; EC->pU8_CurrFrm_UPlane = EC->pU8_CurrFrm_YPlane + YU_OFFSET; EC->pU8_CurrFrm_VPlane = EC->pU8_CurrFrm_UPlane + UV_OFFSET;
/* Store pointers to the previous frame in the catalog.
*/ EC->pU8_PrevFrm = P32Inst->u8PreviousPlane; EC->pU8_PrevFrm_YPlane = EC->pU8_PrevFrm + 16*PITCH + 16; EC->pU8_PrevFrm_UPlane = EC->pU8_PrevFrm_YPlane + YU_OFFSET; EC->pU8_PrevFrm_VPlane = EC->pU8_PrevFrm_UPlane + UV_OFFSET;
/* Store pointers to the Spatial Loop Filter frame in the catalog.
*/ EC->pU8_SLFFrm = P32Inst->u8SLFPlane; EC->pU8_SLFFrm_YPlane = EC->pU8_SLFFrm + 16; EC->pU8_SLFFrm_UPlane = EC->pU8_SLFFrm_YPlane + YU_OFFSET; EC->pU8_SLFFrm_VPlane = EC->pU8_SLFFrm_UPlane + UV_OFFSET;
/* Store pointers to the Signature frame in the catalog
*/ EC->pU8_Signature = P32Inst->u8Signature; EC->pU8_Signature_YPlane = EC->pU8_Signature + 16*PITCH + 16;
// Store pointer to the RunValSign triplets for Luma and Chroma
EC->pI8_MBRVS_Luma = P32Inst->i8MBRVS_Luma; EC->pI8_MBRVS_Chroma = P32Inst->i8MBRVS_Chroma;
/* Store pointer to the macroblock action stream in the catalog.
*/ EC->pU8_MBlockActionStream = P32Inst->MBActionStream;
/* Store pointer to the GOB DCT coefficient buffer in the catalog.
*/ EC->pU8_DCTCoefBuf = P32Inst->piGOB_DCTCoefs;
/* Store pointer to the bit stream buffer in the catalog.
*/ EC->pU8_BitStream = P32Inst->u8BitStream;
/* Store pointer to private copy of decoder instance info.
*/ EC->pDecInstanceInfo = &(P32Inst->DecInstanceInfo);
/* Fill the picture header structure.
*/ EC->PictureHeader.Split = OFF; EC->PictureHeader.DocCamera = OFF; EC->PictureHeader.PicFreeze = OFF; EC->PictureHeader.StillImage = (EnumOnOff) 1; // For this bit ON=0, OFF=1
EC->PictureHeader.TR = 31; if (EC->FrameWidth == 352) { ASSERT(EC->FrameHeight == 288); EC->PictureHeader.SourceFormat = SF_CIF; EC->u8DefINTRA_QP = 20; EC->u8DefINTER_QP = 13; } else { ASSERT(EC->FrameWidth == 176 && EC->FrameHeight == 144); EC->PictureHeader.SourceFormat = SF_QCIF; EC->u8DefINTRA_QP = 15; EC->u8DefINTER_QP = 10; } EC->PictureHeader.Spare = 1; // Spare bits set to 1
EC->PictureHeader.PEI = 0; EC->PictureHeader.PQUANT = 8; // for now
EC->PictureHeader.PicCodType = INTRAPIC; // for now
#ifndef RING0
/* Save the timing info pointer - only if do this if not Ring0 because
* structure in P32Inst is only declared if not Ring0. */ EC->pEncTimingInfo = P32Inst->EncTimingInfo; #endif
/* Force the first frame to a key frame
*/ EC->bMakeNextFrameKey = TRUE;
/* Initialize table with Bit Usage Profile */// for (iNumMBs = 0; iNumMBs <= 33 ; iNumMBs++)
for (iNumMBs = 0; iNumMBs <= (int)EC->NumMBs ; iNumMBs++) { EC->uBitUsageProfile[iNumMBs] = iNumMBs; // assume linear distribution at first
}
/* Check assumptions about structure sizes and boundary
* alignment. */ ASSERT( sizeof(T_Blk) == sizeof_T_Blk ) ASSERT( sizeof(T_MBlockActionStream) == sizeof_T_MBlockActionStream )
/* Encoder instance memory should start on a 32 byte boundary.
*/ ASSERT( ( (unsigned int)P32Inst & 0x1f) == 0)
/* MB Action Stream should be on a 16 byte boundary.
*/ ASSERT( ( (unsigned int)EC->pU8_MBlockActionStream & 0xf) == 0 )
/* Block structure array should be on a 16 byte boundary.
*/ ASSERT( ( (unsigned int) &(EC->pU8_MBlockActionStream->BlkY1) & 0xf) == 0)
/* Current Frame Buffers should be on a 32 byte boundaries.
*/ ASSERT( ( (unsigned int)EC->pU8_CurrFrm_YPlane & 0x1f) == 0) ASSERT( ( (unsigned int)EC->pU8_CurrFrm_UPlane & 0x1f) == 0) ASSERT( ( (unsigned int)EC->pU8_CurrFrm_VPlane & 0x1f) == 0)
/* Previous Frame Buffers should be on 16 byte boundaries.
*/ ASSERT( ( (unsigned int)EC->pU8_PrevFrm_YPlane & 0x1f) == 0x10) ASSERT( ( (unsigned int)EC->pU8_PrevFrm_UPlane & 0x1f) == 0x10) ASSERT( ( (unsigned int)EC->pU8_PrevFrm_VPlane & 0x1f) == 0x10)
/* Spatial Loop Filter Frame Buffers should be on a 32 byte boundary.
*/ ASSERT( ( (unsigned int)EC->pU8_SLFFrm_YPlane & 0x1f) == 0) ASSERT( ( (unsigned int)EC->pU8_SLFFrm_UPlane & 0x1f) == 0) ASSERT( ( (unsigned int)EC->pU8_SLFFrm_VPlane & 0x1f) == 0)
/* Motion Estimation includes a memory layout. Assert that we satisfy it.
*/ ASSERT( ( (EC->pU8_PrevFrm_YPlane - EC->pU8_CurrFrm_YPlane) % 128) == 80) ASSERT( ( (EC->pU8_SLFFrm_YPlane - EC->pU8_PrevFrm_YPlane) % 4096) == 944)
/* The bitstream should be on a 32 byte boundary
*/ ASSERT( ( (unsigned int)EC->pU8_BitStream & 0x1f) == 0)
/* DCT coefficient array should be on a 32 byte boundary.
*/ ASSERT( ( (unsigned int)EC->pU8_DCTCoefBuf & 0x1f) == 0)
/* Decoder instance structure should be on a DWORD boundary.
*/ ASSERT( ( (unsigned int)EC->pDecInstanceInfo & 0x3 ) == 0 )
/* Initialize MBActionStream
*/ int YBlockOffset, UBlockOffset;
puGOBNumbers = ( EC->PictureHeader.SourceFormat == SF_CIF ) ? uCIFGOBNumbers : uQCIFGOBNumbers;
for (uGOBNumber = *puGOBNumbers++, unStartingMB = 0; uGOBNumber != 0; uGOBNumber = *puGOBNumbers++, unStartingMB += 33) { YBlockOffset = uStartingYOffsets[uGOBNumber]; UBlockOffset = EC->pU8_CurrFrm_UPlane - EC->pU8_CurrFrm_YPlane + uStartingUOffsets[uGOBNumber];
for (unIndex = 0; unIndex < 33; ) { iMBNumber = unStartingMB + unIndex;
/* Clear the counter of the number of consecutive times a macroblock has been inter coded.
*/ (EC->pU8_MBlockActionStream[iMBNumber]).InterCodeCnt = 0;
(EC->pU8_MBlockActionStream[iMBNumber]).BlkY1.BlkOffset = YBlockOffset; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY2.BlkOffset = YBlockOffset+8; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY3.BlkOffset = YBlockOffset+PITCH*8; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY4.BlkOffset = YBlockOffset+PITCH*8+8; (EC->pU8_MBlockActionStream[iMBNumber]).BlkU.BlkOffset = UBlockOffset; (EC->pU8_MBlockActionStream[iMBNumber]).BlkV.BlkOffset = UBlockOffset+UV_OFFSET;
if (! EC->bUseMotionEstimation) { (EC->pU8_MBlockActionStream[iMBNumber]).BlkY1.PHMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY1.PVMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY2.PHMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY2.PVMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY3.PHMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY3.PVMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY4.PHMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY4.PVMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkU.PHMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkU.PVMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkV.PHMV = 0; (EC->pU8_MBlockActionStream[iMBNumber]).BlkV.PVMV = 0; }
YBlockOffset += 16; UBlockOffset += 8;
unIndex++;
if (11 == unIndex || 22 == unIndex) { /* skip to the next row of macro blocks
* - skip forward number of lines in a MB and back 11 macroblocks */ YBlockOffset += PITCH*16 - 11*16; UBlockOffset += PITCH*8 - 11*8; } else if (33 == unIndex) { /* Mark the last MB in this GOB.
*/ (EC->pU8_MBlockActionStream[iMBNumber]).CodedBlocks |= 0x40; } } /* end for unIndex */ } /* end for uGOBNumber */
ASSERT(unStartingMB == EC->NumMBs);
if (! EC->bUseMotionEstimation) { /* Initialize previous frame pointers.
*/ puGOBNumbers = ( EC->PictureHeader.SourceFormat == SF_CIF ) ? uCIFGOBNumbers : uQCIFGOBNumbers;
for (uGOBNumber = *puGOBNumbers++, unStartingMB = 0; uGOBNumber != 0; uGOBNumber = *puGOBNumbers++, unStartingMB += 33) { YBlockOffset = uStartingYOffsets[uGOBNumber]; UBlockOffset = EC->pU8_PrevFrm_UPlane - EC->pU8_PrevFrm_YPlane + uStartingUOffsets[uGOBNumber];
for (unIndex = 0; unIndex < 33; ) { iMBNumber = unStartingMB + unIndex;
(EC->pU8_MBlockActionStream[iMBNumber]).BlkY1.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + YBlockOffset; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY2.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + YBlockOffset+8; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY3.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + YBlockOffset+PITCH*8; (EC->pU8_MBlockActionStream[iMBNumber]).BlkY4.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + YBlockOffset+PITCH*8+8; (EC->pU8_MBlockActionStream[iMBNumber]).BlkU.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + UBlockOffset; (EC->pU8_MBlockActionStream[iMBNumber]).BlkV.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + UBlockOffset+UV_OFFSET;
YBlockOffset += 16; UBlockOffset += 8;
unIndex++;
if (11 == unIndex || 22 == unIndex) { /* skip to the next row of macro blocks
* - skip forward number of lines in a MB and back 11 macroblocks */ YBlockOffset += PITCH*16 - 11*16; UBlockOffset += PITCH*8 - 11*8; } } /* end for unIndex */ } /* end for uGOBNumber */ } /* end ! bUseMotionEstimation */
/* Initialize bit rate controller
*/
// RTP: BRC initialization. Changed call to InitBRC to accomodate
// uIntraQP and uInterQP
if(pConfiguration->bEncoderResiliency && pConfiguration->unPacketLoss) { uIntraQP = pConfiguration->unDefaultIntraQuant; uInterQP = pConfiguration->unDefaultInterQuant; } else { uIntraQP = EC->u8DefINTRA_QP; //def263INTRA_QP;
uInterQP = EC->u8DefINTER_QP; //def263INTER_QP;
}
InitBRC(&(EC->BRCState), /* Address of the state structure */ uIntraQP, //EC->u8DefINTRA_QP, /* default INTRA Quantization value */
uInterQP, //EC->u8DefINTER_QP, /* default INTER Quantization value */
EC->NumMBs); /* number of Macroblocks */
// RTP: initialize BSInfoStream for RTP header generation
if (pConfiguration->bRTPHeader) { H261RTP_InitBsInfoStream(EC, pConfiguration->unPacketSize); } /* Finished initializing the encoder
*/ lpCompInst->Initialized = TRUE; /*
* Create a decoder instance and init it. DecoderInstInfo must be in first 64K. */ EC->pDecInstanceInfo->xres = lpCompInst->xres; EC->pDecInstanceInfo->yres = lpCompInst->yres;
lResult = H263InitDecoderInstance(EC->pDecInstanceInfo, H263_CODEC); if (lResult != ICERR_OK) { DBOUT("Encoder's call to init the decoder failed."); goto done; } lResult = H263InitColorConvertor(EC->pDecInstanceInfo, YUV12ForEnc); if (lResult != ICERR_OK) { DBOUT("Encoder's call to init the color converter failed."); goto done; }
lResult = ICERR_OK;
done: if (bEncoderInstLocked) { GlobalUnlock(lpCompInst->hEncoderInst); } return lResult;
} /* end H263InitEncoderInstance() */
// Define a variety of parameters to be used with motion estimation.
T_MotionEstimationControls MECatalog[] = {
#define ME_DEFAULT_CTRLS 0
{ 300, 128, 20, 150, 100, 100, 50 },
#define ME_MMX_CTRLS 1
// These parameters are used when MMX is enabled.
// NOTE: Of these, only the SLF parameters are currently used.
// For MMX, the other parameters are hard coded in exmme.asm.
{ 300, 128, 20, 150, 100, 200, 100 },
#define ME_CUSTOM_CTRLS 2
// These parameters are used when EC->bUseCustomMotionEstimation is enabled.
// EC-bUseCustomMotionEstimation, and the individual values here, can be
// set via the "ini" file.
{ 300, 128, 20, 150, 100, 100, 50 }};
const U32 MAXCIFSIZE = 32768;const U32 MAXQCIFSIZE = 8192;
/*****************************************************************************
* * H263Compress * * This function drives the compression of one frame * */LRESULT H263Compress( LPCODINST lpCompInst, /* ptr to compressor instance info. */ ICCOMPRESS *lpicComp) /* ptr to ICCOMPRESS structure. */{ FX_ENTRY("H261Compress");
LRESULT lResult = ICERR_ERROR; U32 uGOBNumber; U32 uMB; U8 * pu8CurBitStream; /* pointer to the current location in the bitstream. */ U32 * puGOBNumbers; UN unGQuant; UN unLastEncodedGQuant; UN unSizeBitStream; U32 uMaxSizeBitStream;// UN unSize;
UN unStartingMB; U8 u8BitOffset; /* bit offset in the current byte of the bitstream. */
/* Variables used in recompression */ BOOL bOverFlowWarning = FALSE; BOOL bOverFlowSevereWarning = FALSE; BOOL bOverFlowSevereDanger = FALSE; BOOL bOverFlowed = FALSE; U32 u32AverageSize; U32 u32sizeBitBuffer; U32 u32TooBigSize; UN unGQuantTmp; U8 u8GOBcount;
U32 iSWD; U32 uMAXGOBNumber, uGOBsLeft;
/* save state for if need to recompress last GOB */ U8 * pu8CurBitStreamSave; /* ptr to the curr location in the bitstream. */ U8 u8BitOffsetSave; /* bit offset in the curr byte of the bitstream. */ UN unStartingMBSave; UN unGQuantSave; U8 u8CodedBlockSave[33]; U8 u8blocknum;
U8 * pu8FirstInterMEStateRowNumbers; int inRowNumber; int inMEStateIndex;
U32 uCumFrmSize = 0;
U32 uFrameCount;
U8 *pU8_temp; /* dummy pointer needed for FDCT */ U8 u8_temp; /* dummy variable needed for FDCT */
#ifdef ENCODE_STATS
U32 uStartLow; U32 uStartHigh; U32 uElapsed; U32 uBefore; U32 uEncodeFrameSum = 0; U32 uInputCCSum = 0; U32 uMotionEstimationSum = 0; U32 uFDCTSum = 0; U32 uQRLESum = 0; U32 uDecodeFrameSum = 0; U32 uZeroingBufferSum = 0;// U32 uSLF_UVSum = 0;
int bTimingThisFrame = 0; ENC_TIMING_INFO * pEncTimingInfo = NULL; #endif
U32 uIntraSWDTotal; U32 uIntraSWDBlocks; U32 uInterSWDTotal; U32 uInterSWDBlocks; int MEC_index; T_MotionEstimationControls MEC;
float fFrameRate; U32 uFrameSize; U32 uQuality; T_H263EncoderInstanceMemory * P32Inst; T_H263EncoderCatalog * EC; LPVOID pEncoderInst = NULL;
ENC_BITSTREAM_INFO * pBSInfo;
ICDECOMPRESSEX ICDecExSt;static ICDECOMPRESSEX DefaultICDecExSt = { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0 };
int uPQUANTMin;
// RTP: declaration
T_CONFIGURATION *pConfiguration = &(lpCompInst->Configuration);
#ifdef CHECKSUM_PICTURE
YVUCheckSum YVUCheckSumStruct; U8 * pu8SaveCurBitStream; U8 u8SaveBitOffset; #endif
// check instance pointer
if (!lpCompInst) return ICERR_ERROR;
/********************************************************************
* Lock the instance data private to the encoder. ********************************************************************/ pEncoderInst = (LPVOID)GlobalLock(lpCompInst->hEncoderInst); if (pEncoderInst == NULL) { DBOUT("ERROR :: H263Compress :: ICERR_MEMORY"); lResult = ICERR_MEMORY; goto done; }
/* Generate pointer to the encoder instance memory.
*/ P32Inst = (T_H263EncoderInstanceMemory *) ((((U32) lpCompInst->EncoderInst) + (sizeof(T_MBlockActionStream) - 1)) & ~(sizeof(T_MBlockActionStream) - 1)); /* Get pointer to encoder catalog.
*/ EC = &(P32Inst->EC);
// Check pointer to encoder catalog
if (!EC) return ICERR_ERROR;
pBSInfo = &EC->BSInfo;
/********************************************************************
* Dummy operations. ********************************************************************/ pU8_temp = &u8_temp;
/********************************************************************
* Do per-frame initialization. ********************************************************************/
/* Get the frame number
*/ uFrameCount = pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount; #ifdef ENCODE_STATS
if (uFrameCount < DEC_TIMING_INFO_FRAME_COUNT) { ASSERT(EC->pEncTimingInfo); TIMER_START(bTimingThisFrame,uStartLow,uStartHigh); ASSERT(bTimingThisFrame); EC->uStartLow = uStartLow; EC->uStartHigh = uStartHigh; EC->uStatFrameCount = uFrameCount; } else { ASSERT(!bTimingThisFrame); } EC->bTimingThisFrame = bTimingThisFrame; #endif
if((lpicComp->dwFlags & ICCOMPRESS_KEYFRAME) || (EC->bMakeNextFrameKey == TRUE)) { EC->PictureHeader.PicCodType = INTRAPIC; EC->bMakeNextFrameKey = FALSE; EC->PictureHeader.PicFreeze = ON; } else { EC->PictureHeader.PicCodType = INTERPIC; EC->PictureHeader.PicFreeze = OFF; DBOUT("INTERPIC...") }
if (EC->PictureHeader.PicCodType == INTRAPIC) { /* Initialize macroblocks action stream for INTRA
*/ for (uMB = 0; uMB < EC->NumMBs; uMB++) { (EC->pU8_MBlockActionStream[uMB]).CodedBlocks |= 0x3F; /* Set to all nonempty blocks. */ (EC->pU8_MBlockActionStream[uMB]).CodedBlocksB = 0; (EC->pU8_MBlockActionStream[uMB]).InterCodeCnt = ((U8)uMB)&0xF; /* Seed update pattern */ (EC->pU8_MBlockActionStream[uMB]).FirstMEState = ForceIntra; if (! EC->bUseMotionEstimation) { (EC->pU8_MBlockActionStream[uMB]).BlockType = INTRABLOCK; } } *(lpicComp->lpdwFlags) |= AVIIF_KEYFRAME; lpicComp->dwFlags |= ICCOMPRESS_KEYFRAME; } else // not a key frame, motion vectors present
{ /* Setup to initialize the FirstMEState field. The initial data for
* the FirstMEState is stored compressed in rows of 11 bytes. Different * rows are chosen for CIF and QCIF initialization. */ if ( EC->PictureHeader.SourceFormat == SF_CIF ) { pu8FirstInterMEStateRowNumbers = u8CIFFirstInterMEStateRowNumbers; } else { pu8FirstInterMEStateRowNumbers = u8QCIFFirstInterMEStateRowNumbers; } inRowNumber = *pu8FirstInterMEStateRowNumbers++; ASSERT(inRowNumber <= MAX_ME_STATE_ROW_NUMBER);
/* Initialize macroblocks action stream for INTER
*/ for (inMEStateIndex = 0, uMB = 0; uMB < EC->NumMBs; uMB++, inMEStateIndex++) { /* There are only 11 bytes in a row of data. So reset the Index and go to
* the next row number. */ if (inMEStateIndex == 11) { inMEStateIndex = 0; inRowNumber = *pu8FirstInterMEStateRowNumbers++; ASSERT(inRowNumber <= MAX_ME_STATE_ROW_NUMBER); }
(EC->pU8_MBlockActionStream[uMB]).CodedBlocks |= 0x3F; /* Initialize to all nonempty blocks. */ (EC->pU8_MBlockActionStream[uMB]).CodedBlocksB = 0; if (EC->pU8_MBlockActionStream[uMB].InterCodeCnt >= (pConfiguration->bRTPHeader ? INTERCODECNT_ADJUST[pConfiguration->unPacketLoss/10] : 132)) { (EC->pU8_MBlockActionStream[uMB]).FirstMEState = ForceIntra; /* Force intra blocks. */ (EC->pU8_MBlockActionStream[uMB]).BlockType = INTRABLOCK; } else { // RTP: resiliency stuff
if (pConfiguration->bDisallowAllVerMVs) (EC->pU8_MBlockActionStream[uMB]).FirstMEState = u8FirstInterMENoVerMVStateRows[inRowNumber][inMEStateIndex]; else { if (pConfiguration->bDisallowPosVerMVs) (EC->pU8_MBlockActionStream[uMB]).FirstMEState = u8FirstInterMENoPosVerMVStateRows[inRowNumber][inMEStateIndex]; else (EC->pU8_MBlockActionStream[uMB]).FirstMEState = u8FirstInterMEStateRows[inRowNumber][inMEStateIndex]; } if (! EC->bUseMotionEstimation) { (EC->pU8_MBlockActionStream[uMB]).BlockType = INTERBLOCK; } } } *(lpicComp->lpdwFlags) &= ~AVIIF_KEYFRAME; lpicComp->dwFlags &= ~ICCOMPRESS_KEYFRAME; } // RTP: resiliency stuff
if (pConfiguration->bEncoderResiliency && pConfiguration->unPacketLoss) { UN i; if (EC->uNumberForcedIntraMBs > 0) { for (i=0; i < EC->uNumberForcedIntraMBs; i++) { if (EC->uNextIntraMB == EC->NumMBs) EC->uNextIntraMB=0; (EC->pU8_MBlockActionStream[EC->uNextIntraMB]).FirstMEState = ForceIntra; if (! EC->bUseMotionEstimation) { (EC->pU8_MBlockActionStream[uMB]).BlockType = INTRABLOCK; } } } }
/* Initialize bit stream pointers */ pu8CurBitStream = EC->pU8_BitStream; u8BitOffset = 0;
/******************************************************************
* RGB to YVU 12 Conversion ******************************************************************/ #ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
colorCnvtFrame(EC, lpCompInst, lpicComp, EC->pU8_CurrFrm_YPlane, EC->pU8_CurrFrm_UPlane, EC->pU8_CurrFrm_VPlane);
#ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uInputCCSum) #endif
/********************************************************************
* Setup the bit rate controller ********************************************************************/ // RTP: Configuration setting
// If the Encoder Bit Rate section of the configuration has been
// set ON then, we override quality only or any frame size normally
// sent in and use frame rate and data rate to determine frame
// size.
if (EC->PictureHeader.PicCodType == INTERPIC && lpCompInst->Configuration.bBitRateState == TRUE && lpCompInst->FrameRate != 0.0f && lpicComp->dwFrameSize == 0UL) { DEBUGMSG(ZONE_BITRATE_CONTROL, ("%s: Changing dwFrameSize from %ld to %ld bits\r\n", _fx_, lpicComp->dwFrameSize << 3, (DWORD)((float)lpCompInst->DataRate / lpCompInst->FrameRate) << 3)); lpicComp->dwFrameSize = (U32)((float)lpCompInst->DataRate / lpCompInst->FrameRate); } uFrameSize = lpicComp->dwFrameSize; #ifdef DEBUG_RECOMPRESS
wsprintf(string, "uFrameSize %d", (int) uFrameSize); DBOUT(string); #endif
/* check uFrameSize. Max compressed frame size for QCIF is 8KBytes
* and 32 KBytes for FCIF. */ if ( EC->PictureHeader.SourceFormat == SF_CIF ) { uMaxSizeBitStream = MAXCIFSIZE; if (uFrameSize > MAXCIFSIZE) uFrameSize = MAXCIFSIZE; } else { uMaxSizeBitStream = MAXQCIFSIZE; if (uFrameSize > MAXQCIFSIZE) uFrameSize = MAXQCIFSIZE; } #ifdef DEBUG_RECOMPRESS
wsprintf(string, "uFrameSize %d", (int) uFrameSize); DBOUT(string); #endif
uQuality = lpicComp->dwQuality; fFrameRate = lpCompInst->FrameRate; StartupBRC(EC, uFrameSize, uQuality, fFrameRate);
/* QRLE does not do clamping - it passes 8-bits to VLC. Because of
* that we need to be sure that all values can be represented by 255. * QP-4 represents +-2040 leaving out 2041..2048. * QP-5 represents +-2550 which has no clamping problems. * Because QRLE does not do clamping we should limit our QP to 5. * But I still see some clamping artifacts at 5. See the "Tom" video * encoded with a fixed quantizer at frame 100. For that reason I * am limiting my QP to 6 (which is the same value as the 750 encoder). * * If you had unlimited time you could look at the first four coefficients * and pretty safely decide if you can use lower quantizers. Since we * are supposed to run on a P5/90 we don't have that time. */ //CLAMP_N_TO(EC->PictureHeader.PQUANT,6,31);
/* Change Clamp range to allow quant to get to 2 unless fixed quant
* or quality setting used instead of data rate. This does probably * cause quantization errors at high data rates the question is does * it cause noticable errors at ISDN data rates when the clips are * playing at speed? This will be evaluated witn Beta 02 candidate. * Changes made in e1enc and e1mbenc. */ if (EC->BRCState.uTargetFrmSize == 0) { CLAMP_N_TO(EC->PictureHeader.PQUANT,6,31); } else { uPQUANTMin = clampQP((10000L - (int)lpicComp->dwQuality) * 15L / 10000L); CLAMP_N_TO(EC->PictureHeader.PQUANT, uPQUANTMin, 31); }
// also set previous GQuant
unLastEncodedGQuant = EC->PictureHeader.PQUANT;
if (EC->bBitRateControl) { /* Initialize Cumulative Quantization values
*/ EC->uQP_cumulative = 0; EC->uQP_count = 0; }
/* Increment temporal reference.
*/ #ifdef RING0
Increment_TR_UsingFrameRate(&(EC->PictureHeader.TR), &(EC->fTR_Error), fFrameRate, (pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount) == 0, 0x1F); #else
Increment_TR_UsingTemporalValue(&(EC->PictureHeader.TR), &(EC->u8LastTR), lpicComp->lFrameNum, (pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount) == 0, 0x1F); #endif
// RTP: packet initialization for first GOB
if (pConfiguration->bRTPHeader) { H261RTP_GOBUpdateBsInfo(EC, 1, pu8CurBitStream, 0); }
/********************************************************************
* Write the Picture Header *******************************************************************/ WriteBeginPictureHeaderToStream(EC, &pu8CurBitStream, &u8BitOffset);
#ifdef CHECKSUM_PICTURE
/* Initialize the checksum record to all zeros.
*/ YVUCheckSumStruct.uYCheckSum = 0; YVUCheckSumStruct.uVCheckSum = 0; YVUCheckSumStruct.uUCheckSum = 0; /* save the pointers
*/ pu8SaveCurBitStream = pu8CurBitStream; u8SaveBitOffset = u8BitOffset;
/* write the zero checksum
*/ WritePictureChecksum(&YVUCheckSumStruct, &pu8CurBitStream, &u8BitOffset, 0);
#endif
WriteEndPictureHeaderToStream(EC, &pu8CurBitStream, &u8BitOffset);
/********************************************************************
* Inner Loop: Loop through GOBs and macroblocks. ********************************************************************/ puGOBNumbers = ( EC->PictureHeader.SourceFormat == SF_CIF ) ? uCIFGOBNumbers : uQCIFGOBNumbers; uMAXGOBNumber = ( EC->PictureHeader.SourceFormat == SF_CIF ) ? 12 : 3;
u32sizeBitBuffer = CompressGetSize(lpCompInst, lpicComp->lpbiInput, lpicComp->lpbiOutput);
/* Check to see if we told VfW to create a buffer smaller than the maximum allowable.
*/ ASSERT( u32sizeBitBuffer <= sizeof_bitstreambuf );
if (EC->PictureHeader.PicCodType == INTRAPIC) { u32AverageSize = (EC->PictureHeader.SourceFormat == SF_CIF ) ? (7 * u32sizeBitBuffer/FCIF_NUM_OF_GOBS) >> 3: (7 * u32sizeBitBuffer/QCIF_NUM_OF_GOBS) >> 3; } else { u32AverageSize = (EC->PictureHeader.SourceFormat == SF_CIF ) ? (8 * u32sizeBitBuffer/FCIF_NUM_OF_GOBS) >> 4: (8 * u32sizeBitBuffer/QCIF_NUM_OF_GOBS) >> 4; }
// Select motion estimation parameters.
if (EC->bUseCustomMotionEstimation) MEC_index = ME_CUSTOM_CTRLS; else MEC_index = ME_DEFAULT_CTRLS; // Make a local copy of the controls, so that we can alter the
// controls dynamically, without destroying the original values.
MEC = MECatalog[MEC_index];
if (pConfiguration->bRTPHeader) { MEC.empty_threshold /= EMPTYTHRESHOLD_ADJUST[pConfiguration->unPacketLoss/25]; if (pConfiguration->unPacketLoss > 25) { MEC.zero_vector_threshold = 99999; MEC.nonzero_MV_differential = 99999; if ((MEC.slf_differential <<= 2) > 99999) MEC.slf_differential = 99999; if (pConfiguration->unPacketLoss > 50) { MEC.slf_threshold = 99999; } } }
for (uGOBNumber = *puGOBNumbers++, unStartingMB = 0, u8GOBcount = 1; uGOBNumber != 0; uGOBNumber = *puGOBNumbers++, unStartingMB += 33, u8GOBcount++) { #ifdef DEBUG_ENC
wsprintf(string, "GOB #%d", (int) uGOBNumber); DBOUT(string); trace(string); #endif
uGOBsLeft = uMAXGOBNumber - u8GOBcount;
if (EC->bUseMotionEstimation) { #ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
MOTIONESTIMATION( &(EC->pU8_MBlockActionStream[unStartingMB]), EC->pU8_CurrFrm_YPlane, EC->pU8_PrevFrm_YPlane, EC->pU8_SLFFrm_YPlane, 1, // Do Radius 15 search.
0, // No Half Pel motion estimation
0, // No Block MVs
(int)EC->bUseSpatialLoopFilter, MEC.zero_vector_threshold, // Zero Vector Threshold. If the
// SWD for the zero vector is less than this
// threshold, then don't search for NZ MV's.
// Set to 99999 to not search.
MEC.nonzero_MV_differential, // NonZeroMVDifferential.
// Once the best NZ MV is found, it must be better
// than the 0 MV SWD by at least this amount.
// Set to 99999 to never choose NZ MV.
128, // BlockMVDifferential. The sum of the four block
// SWD must be better than the MB SWD by at least
// this amount to choose block MV's.
// H.261 don't care
MEC.empty_threshold, // Empty Threshold. Set to 0 to not force
// empty blocks.
MEC.intercoding_threshold, // Inter Coding Threshold. If the
// inter SWD is less than this amount then don't
// bother calc. the intra SWD.
MEC.intercoding_differential, // Intra Coding Differential.
// Bias against choosing INTRA blocks.
MEC.slf_threshold, // If the SWD of the chosen MV is less than
// this threshold, then don't bother investigating
// the spatial loop filtered case.
MEC.slf_differential, // If you do look at the SLF case, its
// SWD must be better than the non-SLF SWD by at
// least this much in order to select the SLF type.
&uIntraSWDTotal, &uIntraSWDBlocks, &uInterSWDTotal, &uInterSWDBlocks ); #ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uMotionEstimationSum) #endif
/* If it's an inter frame then, calculate chroma vectors and update the InterCodeCnt.
*/ if (EC->PictureHeader.PicCodType == INTERPIC) {
// RTP: added pConfiguration to CalcGOBChromaVecs()
CalcGOBChromaVecs(EC, unStartingMB, pConfiguration);
} /* end INTERPIC */ } /* end if UseMotionEstimation */
/* Calculate unGQuant based on bits used in previous GOBs, and bits used
* for current GOB of previous frame. */ if (EC->bBitRateControl) { unGQuantTmp = unGQuant; unGQuant = CalcMBQUANT(&(EC->BRCState), EC->uBitUsageProfile[unStartingMB],EC->uBitUsageProfile[EC->NumMBs], uCumFrmSize, EC->PictureHeader.PicCodType); EC->uBitUsageProfile[unStartingMB] = uCumFrmSize;
DEBUGMSG(ZONE_BITRATE_CONTROL_DETAILS, ("%s: Bitrate controller enabled for GOB #%ld (uCumFrmSize = %ld bits and unGQuantTmp = %ld), setting unGQuant = %ld (min and max will truncate from %ld to 31)\r\n", _fx_, uGOBNumber, uCumFrmSize << 3, unGQuantTmp, unGQuant, uPQUANTMin));
/* if bOverFlowSevereDanger True Increase Quant */ if ( bOverFlowSevereDanger ) { DEBUGMSG(ZONE_BITRATE_CONTROL_DETAILS, ("%s: Danger of overflow for GOB #%ld, changing unGQuant from %ld to %ld\r\n", _fx_, uGOBNumber, unGQuant, (unGQuant < unGQuantTmp) ? (unGQuantTmp + ((EC->PictureHeader.PicCodType == INTRAPIC) ? 12 : 6)) : (unGQuant + ((EC->PictureHeader.PicCodType == INTRAPIC) ? 12 : 6))));
if (unGQuant < unGQuantTmp) unGQuant = unGQuantTmp;
if (EC->PictureHeader.PicCodType == INTRAPIC) unGQuant += 12; else unGQuant += 6;
DBOUT("Increasing GQuant increase by +6"); } else if ( bOverFlowSevereWarning ) { DEBUGMSG(ZONE_BITRATE_CONTROL_DETAILS, ("%s: Danger of overflow for GOB #%ld, changing unGQuant from %ld to %ld\r\n", _fx_, uGOBNumber, unGQuant, (unGQuant < unGQuantTmp) ? (unGQuantTmp + ((EC->PictureHeader.PicCodType == INTRAPIC) ? 8 : 4)) : (unGQuant + ((EC->PictureHeader.PicCodType == INTRAPIC) ? 8 : 4))));
/* if bOverFlowSevereWarning True Increase Quant */ if (unGQuant < unGQuantTmp) unGQuant = unGQuantTmp; if (EC->PictureHeader.PicCodType == INTRAPIC) unGQuant += 8; else unGQuant += 4;
DBOUT("Increasing GQuant increase by +4"); } else if ( !bOverFlowWarning ) { DEBUGMSG(ZONE_BITRATE_CONTROL_DETAILS, ("%s: Warning of overflow for GOB #%ld, changing unGQuant from %ld to %ld\r\n", _fx_, uGOBNumber, unGQuant, ((int)unGQuant > ((int)unLastEncodedGQuant + MaxChangeRowMBTbl[unGQuant])) ? (unLastEncodedGQuant + MaxChangeRowMBTbl[unGQuant]) : (((int)unGQuant < ((int)unLastEncodedGQuant - 2)) ? (unLastEncodedGQuant - 2) : unGQuant)));
/* if bOverFlowWarning False limit Quant changes */
/* Limit the quant changes */ if ((int)unGQuant > ((int)unLastEncodedGQuant + MaxChangeRowMBTbl[unGQuant])) { unGQuant = unLastEncodedGQuant + MaxChangeRowMBTbl[unGQuant]; DBOUT("Slowing GQuant increase to +[1-4]"); } else if ((int)unGQuant < ((int)unLastEncodedGQuant - 2)) { unGQuant = unLastEncodedGQuant - 2; DBOUT("Slowing GQuant decrease to -2"); } } else { DBOUT("bOverFlowWarning don't limit Quant change"); }
if (EC->BRCState.uTargetFrmSize == 0) { CLAMP_N_TO(unGQuant,6,31); } else { CLAMP_N_TO(unGQuant, uPQUANTMin , 31); }
unLastEncodedGQuant = unGQuant;
#ifdef DEBUG_BRC
wsprintf(string,"At MB %d GQuant=%d", unStartingMB, unGQuant); DBOUT(string); #endif
} else { unGQuant = EC->PictureHeader.PQUANT; }
if ( bOverFlowWarning ) { /* save state may need to recompress */ pu8CurBitStreamSave = pu8CurBitStream; u8BitOffsetSave = u8BitOffset; unStartingMBSave = unStartingMB; unGQuantSave = unGQuant;
for (u8blocknum = 0; u8blocknum < 33; u8blocknum++) { /* go through last GOBs macroblock action stream
* saving coded block type because quantization * resets the pattern in some blocks quantize to 0. */ u8CodedBlockSave[u8blocknum] = (EC->pU8_MBlockActionStream[unStartingMB+u8blocknum]).CodedBlocks; } }
// RTP: GOB update
if ( (uGOBNumber != 1) && (pConfiguration->bRTPHeader) ) { H261RTP_GOBUpdateBsInfo(EC, uGOBNumber, pu8CurBitStream, (U32) u8BitOffset); }
WriteGOBHeaderToStream(uGOBNumber, unGQuant, &pu8CurBitStream, &u8BitOffset); /* Input is the macroblock action stream with pointers to
* current and previous blocks. Output is a set of 32 DWORDs * containing pairs of coefficients for each block. There are * from 0 to 12 blocks depending on if PB frames are used and * what the CBP field states. */ #ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
FORWARDDCT( &(EC->pU8_MBlockActionStream[unStartingMB]), EC->pU8_CurrFrm_YPlane, EC->pU8_PrevFrm_YPlane, 0, EC->pU8_DCTCoefBuf, 0, // 0 = not a B-frame
0, // 0 = AP not on
0, // 0 = PB?
pU8_temp, // Scratch
EC->NumMBPerRow );
#ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uFDCTSum) #endif
/* Input is the string of coefficient pairs output from the
* DCT routine. */ #ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
GOB_Q_RLE_VLC_WriteBS( EC, EC->pU8_DCTCoefBuf, &pu8CurBitStream, &u8BitOffset, unStartingMB, unGQuant, bOverFlowSevereWarning, (BOOL) pConfiguration->bRTPHeader, // RTP: MBUpdate flag
uGOBNumber, uPQUANTMin);
#ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uQRLESum) #endif
/* Calculate number of bytes used in frame so far.
*/ uCumFrmSize = pu8CurBitStream - EC->pU8_BitStream;
/* Try to make sure we won't overrun the bit stream buffer. Take the stuffing bytes
* at the end into account when you do this. Also make sure that if this GOB is not * recompressed then there is enough space left to send SKIP GOBs for the remaining * GOBs. I am using sizeof (SKIP GOB) = 2 bytes. */
if ( (unsigned)uCumFrmSize >= (u32sizeBitBuffer - (uGOBsLeft*2) - 10) ) { /* Already about to exceed need to recompress */ DBOUT("Need to RECOMPRESS");
if ( bOverFlowWarning ) { #ifdef DEBUG_RECOMPRESS
wsprintf(string,"Bits Used before recompress= %d ", uCumFrmSize*8); DBOUT(string); //trace(string);
#endif
u32TooBigSize = uCumFrmSize; bOverFlowSevereDanger = TRUE;
/* zero out last GOBs worth of bitstream */ U8 u8temp;
u8temp = *pu8CurBitStreamSave; u8temp = (u8temp>>(8-u8BitOffsetSave))<<(8-u8BitOffsetSave); *pu8CurBitStreamSave = u8temp;
memset(pu8CurBitStreamSave+1, 0, pu8CurBitStream - pu8CurBitStreamSave);
/* restore state */ pu8CurBitStream = pu8CurBitStreamSave; u8BitOffset = u8BitOffsetSave; unStartingMB = unStartingMBSave;
if (EC->PictureHeader.PicCodType == INTRAPIC) unGQuant = unGQuantSave + 16; else unGQuant = unGQuantSave + 8; CLAMP_N_TO(unGQuant,6,31);
// RTP: rewind operation
if (pConfiguration->bRTPHeader) H261RTP_RewindBsInfoStream(EC, (U32) uGOBNumber);
for (u8blocknum = 0; u8blocknum < 33; u8blocknum++) { /* go through GOBs macroblock action stream
* restoring coded block type because quantization * resets the patter in some blocks quantize to 0. */ (EC->pU8_MBlockActionStream[unStartingMB+u8blocknum]).CodedBlocks = u8CodedBlockSave[u8blocknum]; } /* rewrite GOB header */ WriteGOBHeaderToStream(uGOBNumber, unGQuant, &pu8CurBitStream, &u8BitOffset); GOB_Q_RLE_VLC_WriteBS( EC, EC->pU8_DCTCoefBuf, &pu8CurBitStream, &u8BitOffset, unStartingMB, unGQuant, bOverFlowSevereDanger, pConfiguration->bRTPHeader, // RTP: switch
uGOBNumber, // RTP: info
uPQUANTMin);
/* test if still too big if so just send skip GOB */ /* For intended KEY frames, this is a problem */
uCumFrmSize = pu8CurBitStream - EC->pU8_BitStream;
if ( (unsigned) uCumFrmSize >= (u32sizeBitBuffer - (uGOBsLeft*2) - 10) ) { bOverFlowed = TRUE;
/* zero out last GOBs worth of bitstream */ u8temp = *pu8CurBitStreamSave; u8temp = (u8temp>>(8-u8BitOffsetSave))<<(8-u8BitOffsetSave); *pu8CurBitStreamSave = u8temp;
memset(pu8CurBitStreamSave+1, 0, pu8CurBitStream - pu8CurBitStreamSave);
/* restore state */ pu8CurBitStream = pu8CurBitStreamSave; u8BitOffset = u8BitOffsetSave; unStartingMB = unStartingMBSave; // unGQuant = unGQuantSave + 8;
// RTP: rewind operation
if (pConfiguration->bRTPHeader) H261RTP_RewindBsInfoStream(EC, (U32) uGOBNumber);
WriteGOBHeaderToStream(uGOBNumber, unGQuant, &pu8CurBitStream, &u8BitOffset); /* write out a stuffing code */ PutBits(FIELDVAL_MBA_STUFFING, FIELDLEN_MBA_STUFFING, &pu8CurBitStream, &u8BitOffset);
DBOUT("Just Sent SKIP GOB"); #ifdef DEBUG_RECOMPRESS
wsprintf(string,"Just Sent SKIP GOB"); //trace(string);
#endif
} } else { DBOUT("Did not save state to recompress"); } }
/* Calculate number of bytes used in frame so far.
*/ uCumFrmSize = pu8CurBitStream - EC->pU8_BitStream; #ifdef DEBUG_RECOMPRESS
wsprintf(string,"Bits Used = %d ", uCumFrmSize*8); DBOUT(string); //trace(string);
#endif
/* Check to make sure we haven't overrun the bit stream buffer.
*/ ASSERT( (unsigned) uCumFrmSize < u32sizeBitBuffer );
/* Setup method to determine if might have a problem with buffer size */ bOverFlowWarning = bOverFlowSevereWarning = bOverFlowSevereDanger = FALSE; if (uCumFrmSize > u8GOBcount*u32AverageSize) { /* allow for more Quant level changes */ bOverFlowWarning = TRUE;
if (uCumFrmSize > u8GOBcount*u32AverageSize + (u32AverageSize>>1)) { /* force Quant level increase */ bOverFlowSevereWarning = TRUE; DBOUT("bOverFlowSevereWarning");
if (uCumFrmSize > u8GOBcount*u32AverageSize+u32AverageSize) { /* force Quant level increase by even more */ bOverFlowSevereDanger = TRUE; DBOUT("bOverFlowSevereDanger"); } } } } /* for uGOBNumber */
/* if recompress failed shove big number in here */ if (bOverFlowed) { /* used max size so quant will go up for next frame */ EC->uBitUsageProfile[unStartingMB] = u32TooBigSize;
} else EC->uBitUsageProfile[unStartingMB] = uCumFrmSize;
/* Make sure we end this frame on a byte boundary - some decoders require this.
*/ while (u8BitOffset != 0) { PutBits(FIELDVAL_MBA_STUFFING, FIELDLEN_MBA_STUFFING, &pu8CurBitStream, &u8BitOffset); }
/* Add extra DWORD of zero's to try and get rid of green blocks akk */ /* 16 bits of zeros seems to work */ /* 8 bits of zeros does not seems to work */#ifdef DWORD_HACK
PutBits(0x0000, 16, &pu8CurBitStream, &u8BitOffset);#endif
if (EC->bBitRateControl) { CalculateQP_mean(EC); }
/********************************************************************
* Calculate the size of the compressed image. ********************************************************************/
unSizeBitStream = pu8CurBitStream - EC->pU8_BitStream; lpCompInst->CompressedSize = unSizeBitStream;
// IP + UDP + RTP + payload mode C header - worst case
#define TRANSPORT_HEADER_SIZE (20 + 8 + 12 + 12)
DWORD dwTransportOverhead;
// Estimate the transport overhead
if (pConfiguration->bRTPHeader) dwTransportOverhead = (lpCompInst->CompressedSize / pConfiguration->unPacketSize + 1) * TRANSPORT_HEADER_SIZE; else dwTransportOverhead = 0UL;
if (EC->PictureHeader.PicCodType == INTRAPIC) {#ifdef _DEBUG
wsprintf(string, "Intra Frame %d size: %d", pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount, unSizeBitStream);#endif
pBSInfo->uKeyFrameCount ++; pBSInfo->uTotalKeyBytes += unSizeBitStream;
if (EC->bBitRateControl) { EC->BRCState.uLastINTRAFrmSz = dwTransportOverhead + unSizeBitStream; } } else {#ifdef _DEBUG
wsprintf(string, "Inter Frame %d size: %d", pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount, unSizeBitStream);#endif
pBSInfo->uDeltaFrameCount ++; pBSInfo->uTotalDeltaBytes += unSizeBitStream;
if (EC->bBitRateControl) { EC->BRCState.uLastINTERFrmSz = dwTransportOverhead + unSizeBitStream; } }#ifdef _DEBUG
DBOUT(string)#endif
DEBUGMSG(ZONE_BITRATE_CONTROL, ("%s: Total cumulated frame size = %ld bits (data: %ld, transport overhead: %ld)\r\n", _fx_, (unSizeBitStream + dwTransportOverhead) << 3, unSizeBitStream << 3, dwTransportOverhead << 3));
/********************************************************************
* Run the decoder on this frame, to get next basis for prediction. ********************************************************************/
ICDecExSt = DefaultICDecExSt; ICDecExSt.lpSrc = EC->pU8_BitStream; ICDecExSt.lpbiSrc = lpicComp->lpbiOutput; ICDecExSt.lpbiSrc->biSizeImage = unSizeBitStream; ICDecExSt.lpDst = P32Inst->u8PreviousPlane; ICDecExSt.lpbiDst = NULL;
if (EC->PictureHeader.PicCodType == INTERPIC) { ICDecExSt.dwFlags = ICDECOMPRESS_NOTKEYFRAME; }
#ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
lResult = H263Decompress (EC->pDecInstanceInfo, (ICDECOMPRESSEX FAR *)&ICDecExSt, FALSE); if (lResult != ICERR_OK) { DBOUT("Encoder's call to decompress failed."); EC->bMakeNextFrameKey = TRUE; goto done; } #ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uDecodeFrameSum) #endif
#ifdef CHECKSUM_PICTURE
lResult = H261PictureCheckSumEntry(EC->pDecInstanceInfo, &YVUCheckSumStruct); if (lResult != ICERR_OK) { DBOUT("Encoder's call to compute the picture checksum failed."); goto done; } /* restore the pointers
*/ pu8CurBitStream = pu8SaveCurBitStream; u8BitOffset = u8SaveBitOffset;
/* update the checksum
*/ WritePictureChecksum(&YVUCheckSumStruct, &pu8CurBitStream, &u8BitOffset, 1); #endif
if (unSizeBitStream > uMaxSizeBitStream) { // Exceeded allowed - 8K for QCIF and 32K for CIF - size
DBOUT("BS exceeds allowed size"); EC->bMakeNextFrameKey = TRUE; goto done; }
// RTP: bstream extension attachment
if (pConfiguration->bRTPHeader) { // Changed this if statement to check for overflow of bitstream buffer
// 4/14/97 AG.
U32 uEBSSize = H261RTP_GetMaxBsInfoStreamSize(EC);
if (uEBSSize + unSizeBitStream <= u32sizeBitBuffer) { unSizeBitStream += (WORD) H261RTP_AttachBsInfoStream(EC, (U8 *)EC->pU8_BitStream, unSizeBitStream); lpCompInst->CompressedSize = unSizeBitStream; } else { DBOUT("BS+EBS exceeds allocated buffer size"); EC->bMakeNextFrameKey = TRUE; goto done; } }
#ifndef RING0
#ifdef DEBUG
{ char buf[60];
wsprintf(buf, "Compressed frame is %d bytes\n", unSizeBitStream); DBOUT(buf); } #endif
#endif
/********************************************************************
* Copy the compressed image to the output area. This is done after * possibly updating the picture checksum. ********************************************************************/ memcpy( lpicComp->lpOutput, EC->pU8_BitStream, unSizeBitStream);
/* zero only the dirty part of the bitstream buffer */ #ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
// unSize = CompressGetSize(lpCompInst, lpicComp->lpbiInput, lpicComp->lpbiOutput);
memset(EC->pU8_BitStream, 0, unSizeBitStream); #ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uZeroingBufferSum) #endif
#ifdef ENCODE_STATS
TIMER_STOP(bTimingThisFrame,uStartLow,uStartHigh,uEncodeFrameSum); if (bTimingThisFrame) { pEncTimingInfo = EC->pEncTimingInfo + uFrameCount; pEncTimingInfo->uEncodeFrame = uEncodeFrameSum; pEncTimingInfo->uInputCC = uInputCCSum; pEncTimingInfo->uMotionEstimation = uMotionEstimationSum; pEncTimingInfo->uFDCT = uFDCTSum; pEncTimingInfo->uQRLE = uQRLESum; pEncTimingInfo->uDecodeFrame = uDecodeFrameSum; pEncTimingInfo->uZeroingBuffer = uZeroingBufferSum;// pEncTimingInfo->uSLF_UV = uSLF_UVSum;
/* Verify that we have time for all the required steps
*/ ASSERT(pEncTimingInfo->uEncodeFrame); ASSERT(pEncTimingInfo->uInputCC); ASSERT(pEncTimingInfo->uMotionEstimation); ASSERT(pEncTimingInfo->uFDCT); ASSERT(pEncTimingInfo->uQRLE); ASSERT(pEncTimingInfo->uDecodeFrame); ASSERT(pEncTimingInfo->uZeroingBuffer);// ASSERT(pEncTimingInfo->uSLF_UV);
} #endif
lResult = ICERR_OK;
done: if (pEncoderInst) { GlobalUnlock(lpCompInst->hEncoderInst); }
return lResult;} /* end H263Compress() */
/*****************************************************************************
* * H263TermEncoderInstance * * This function frees the space allocated for an instance of the H263 encoder. */LRESULT H263TermEncoderInstance(LPCODINST lpCompInst){ LRESULT lResult; LRESULT lLockingResult; LRESULT lDecoderResult; LRESULT lColorOutResult; U8 BIGG * P32Inst; T_H263EncoderCatalog FAR * EC;
// Check instance pointer
if (!lpCompInst) return ICERR_ERROR;
if(lpCompInst->Initialized == FALSE) { DBOUT("Warning: H263TermEncoderInstance(): Uninitialized instance") lResult = ICERR_OK; goto done; } lpCompInst->Initialized = FALSE;
lpCompInst->EncoderInst = (LPVOID)GlobalLock(lpCompInst->hEncoderInst); if (lpCompInst->EncoderInst == NULL) { DBOUT("ERROR :: H263TermEncoderInstance :: ICERR_MEMORY"); lLockingResult = ICERR_MEMORY; lColorOutResult = ICERR_OK; lDecoderResult = ICERR_OK; } else { lLockingResult = ICERR_OK; P32Inst = (U8 *) ((((U32) lpCompInst->EncoderInst) + (sizeof(T_MBlockActionStream) - 1)) & ~(sizeof(T_MBlockActionStream) - 1)); // P32Inst = (U8 *) ((((U32) lpCompInst->EncoderInst) + 31) & ~0x1F);
EC = ((T_H263EncoderCatalog *) P32Inst);
// Check encoder catalog pointer
if (!EC) return ICERR_ERROR;
#ifdef ENCODE_STATS
// OutputEncodeBitStreamStatistics(ENCODE_STATS_FILENAME, &EC->BSInfo, EC->PictureHeader.SourceFormat == SF_CIF);
OutputEncodeTimingStatistics(ENCODE_STATS_FILENAME, EC->pEncTimingInfo); #endif
/* Terminate the color converter
*/ lColorOutResult = H263TermColorConvertor(EC->pDecInstanceInfo); if (lColorOutResult != ICERR_OK) { DBOUT("Terminating the color converter failed."); }
/* Terminate the decoder
*/ lDecoderResult = H263TermDecoderInstance(EC->pDecInstanceInfo); if (lDecoderResult != ICERR_OK) { DBOUT("Terminating the decoder failed."); }
GlobalUnlock(lpCompInst->hEncoderInst); GlobalFree(lpCompInst->hEncoderInst); }
/* set the result
*/ if (lLockingResult != ICERR_OK) { lResult = lLockingResult; } else if (lColorOutResult != ICERR_OK) { lResult = lColorOutResult; } else if (lDecoderResult != ICERR_OK) { lResult = lDecoderResult; } else { lResult = ICERR_OK; }
done:
return lResult;}
/*****************************************************************************
* * WriteBeginPictureHeaderToStream * * Write the beginning of the picture header to the stream updating the * stream pointer and the bit offset. The beginning of the picture header * is everything but the zero PEI bit */static void WriteBeginPictureHeaderToStream( T_H263EncoderCatalog *EC, U8 ** ppu8CurBitStream, U8 * pu8BitOffset){ /* Picture Start Code */ PutBits(FIELDVAL_PSC, FIELDLEN_PSC, ppu8CurBitStream, pu8BitOffset);
/* Temporal Reference */ PutBits( EC->PictureHeader.TR, FIELDLEN_TR, ppu8CurBitStream, pu8BitOffset);
/* PTYPE: Split screen indicator */ PutBits( EC->PictureHeader.Split, FIELDLEN_PTYPE_SPLIT, ppu8CurBitStream, pu8BitOffset);
/* PTYPE: Document camera indicator. */ PutBits( EC->PictureHeader.DocCamera, FIELDLEN_PTYPE_DOC, ppu8CurBitStream, pu8BitOffset);
/* PTYPE: Freeze picture release. */ PutBits( EC->PictureHeader.PicFreeze, FIELDLEN_PTYPE_RELEASE, ppu8CurBitStream, pu8BitOffset);
/* PTYPE: Source image format. */ PutBits( EC->PictureHeader.SourceFormat, FIELDLEN_PTYPE_SRCFORMAT, ppu8CurBitStream, pu8BitOffset);
/* PTYPE: Still image indicator. */ PutBits( EC->PictureHeader.StillImage, FIELDLEN_PTYPE_STILL, ppu8CurBitStream, pu8BitOffset);
/* PTYPE: Still image indicator. */ PutBits( EC->PictureHeader.Spare, FIELDLEN_PTYPE_SPARE, ppu8CurBitStream, pu8BitOffset);
} /* end WriteBeginPictureHeaderToStream() */
/*****************************************************************************
* * WriteEndPictureHeaderToStream * * Write the end of the picture header to the stream updating the * stream pointer and the bit offset. The end of the picture header is the * zero PEI bit. */static void WriteEndPictureHeaderToStream( T_H263EncoderCatalog *EC, U8 ** ppu8CurBitStream, U8 * pu8BitOffset){ /* PEI - Extra insertion information */ PutBits( EC->PictureHeader.PEI, FIELDLEN_PEI, ppu8CurBitStream, pu8BitOffset);
} /* end WriteEndPictureHeaderToStream() */
#ifdef CHECKSUM_PICTURE
/*****************************************************************************
* * WritePictureChecksum * * Write the picture checksum to the file. * * This function should be able to be called twice. The first time it should * be called with 0 values after saving the values of the bitstream poointer * and bitoffset. After completing the picture call it with the actual * checksum values to update. */static void WritePictureChecksum( YVUCheckSum * pYVUCheckSum, U8 ** ppu8CurBitStream, U8 * pu8BitOffset, U8 u8ValidData){ U32 uBytes; UN unData;
/* Tag data
*/ unData = (UN) u8ValidData; PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
/* Y date - high to low bytes.
*/ uBytes = pYVUCheckSum->uYCheckSum;
unData = (UN) ((uBytes >> 24) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) ((uBytes >> 16) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) ((uBytes >> 8) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) (uBytes & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
/* V date - high to low bytes.
*/ uBytes = pYVUCheckSum->uVCheckSum;
unData = (UN) ((uBytes >> 24) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) ((uBytes >> 16) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) ((uBytes >> 8) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) (uBytes & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
/* U date - high to low bytes.
*/ uBytes = pYVUCheckSum->uUCheckSum;
unData = (UN) ((uBytes >> 24) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) ((uBytes >> 16) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) ((uBytes >> 8) & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
unData = (UN) (uBytes & 0xFF); PutBits(1, 1, ppu8CurBitStream, pu8BitOffset); PutBits(unData, 8, ppu8CurBitStream, pu8BitOffset);
} /* WritePictureChecksum() */#endif
/*****************************************************************************
* * WriteGOBHeaderToStream * * Write the GOB header to the stream updating the stream pointer and the * bit offset. */static void WriteGOBHeaderToStream( U32 uGOBNumber, UN unGQuant, U8 ** ppu8CurBitStream, U8 * pu8BitOffset){ /* GOB Start Code */ PutBits(FIELDVAL_GBSC, FIELDLEN_GBSC, ppu8CurBitStream, pu8BitOffset);
/* GOB Number */ PutBits((int)uGOBNumber, FIELDLEN_GN, ppu8CurBitStream, pu8BitOffset);
/* GOB Quant */ PutBits((int)unGQuant, FIELDLEN_GQUANT, ppu8CurBitStream, pu8BitOffset);
/* GEI */ PutBits(0, FIELDLEN_GEI, ppu8CurBitStream, pu8BitOffset);
} /* end WriteGOBHeaderToStream() */
/************************************************************************
* * CalcGOBChromaVecs */static void CalcGOBChromaVecs( T_H263EncoderCatalog * EC, UN unStartingMB, T_CONFIGURATION *pConfiguration){ #ifdef ENCODE_STATS
// #include "ctiming.h"
U32 uStartLow = EC->uStartLow; U32 uStartHigh = EC->uStartHigh; U32 uElapsed; U32 uBefore; U32 uSLF_UVSum = 0; int bTimingThisFrame = EC->bTimingThisFrame; ENC_TIMING_INFO * pEncTimingInfo = NULL; #endif
register T_MBlockActionStream *pCurrMB; T_MBlockActionStream *pLastMBPlus1; char HMV; char VMV; int c;
pCurrMB = &(EC->pU8_MBlockActionStream[unStartingMB]); pLastMBPlus1 = &(EC->pU8_MBlockActionStream[unStartingMB + 33]); for( c = unStartingMB; pCurrMB < pLastMBPlus1 ; pCurrMB++, c++) { if (IsIntraBlock(pCurrMB->BlockType)) continue;
/* Now that are using +/- 15 pel motion search, need to change
valid range of returned MVs. Remember these are in 1/2 pel increments. Valid range is [-32,31] now. */ /*
ASSERT( (pCurrMB->BlkY1.PHMV >= -15) && (pCurrMB->BlkY1.PHMV <= 15) ) ASSERT( (pCurrMB->BlkY1.PVMV >= -15) && (pCurrMB->BlkY1.PVMV <= 15) ) */
ASSERT( (pCurrMB->BlkY1.PHMV >= -32) && (pCurrMB->BlkY1.PHMV <= 31) ) ASSERT( (pCurrMB->BlkY1.PVMV >= -32) && (pCurrMB->BlkY1.PVMV <= 31) )
// RTP: resiliency considerations check
if (pConfiguration->bEncoderResiliency && pConfiguration->unPacketLoss) { if (pConfiguration->bDisallowAllVerMVs) { ASSERT(pCurrMB->BlkY1.PVMV == 0); } else if (pConfiguration->bDisallowPosVerMVs) { ASSERT(pCurrMB->BlkY1.PVMV <= 0); } } HMV = QtrPelToHalfPel[pCurrMB->BlkY1.PHMV+32]; VMV = QtrPelToHalfPel[pCurrMB->BlkY1.PVMV+32];
/* Make sure we don't do half pel interpolation in the fdct
*/ HMV = (HMV / 2) * 2; VMV = (VMV / 2) * 2; /* Assign the motion vectors for use in the dct
*/ pCurrMB->BlkU.PHMV = HMV; pCurrMB->BlkU.PVMV = VMV; pCurrMB->BlkV.PHMV = HMV; pCurrMB->BlkV.PVMV = VMV;
// TBD: get Brian to put this in ex5me.asm
if (IsSLFBlock(pCurrMB->BlockType)) { /*
if (pCurrMB->CodedBlocks & 0x2) ASSERT(pCurrMB->BlkY2.B4_7.PastRef == pCurrMB->BlkY1.B4_7.PastRef + 8); if (pCurrMB->CodedBlocks & 0x4) ASSERT(pCurrMB->BlkY3.B4_7.PastRef == pCurrMB->BlkY1.B4_7.PastRef + 8*PITCH); if (pCurrMB->CodedBlocks & 0x8) ASSERT(pCurrMB->BlkY4.B4_7.PastRef == pCurrMB->BlkY1.B4_7.PastRef + 8*PITCH+8); */ if (pCurrMB->CodedBlocks & 0x2) pCurrMB->BlkY2.B4_7.PastRef = pCurrMB->BlkY1.B4_7.PastRef + 8; if (pCurrMB->CodedBlocks & 0x4) pCurrMB->BlkY3.B4_7.PastRef = pCurrMB->BlkY1.B4_7.PastRef + 8*PITCH; if (pCurrMB->CodedBlocks & 0x8) pCurrMB->BlkY4.B4_7.PastRef = pCurrMB->BlkY1.B4_7.PastRef + 8*PITCH+8; }
/* Motion vectors are in half pels. So we need to divide by 2 to get
* to integer pels. */ ASSERT((VMV / 2) == (VMV >> 1)); /* since we divided by 2 and mult above */ ASSERT((HMV / 2) == (HMV >> 1)); VMV >>= 1; HMV >>= 1;
#ifdef SLF_WORK_AROUND
pCurrMB->BlkU.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + pCurrMB->BlkU.BlkOffset + VMV*PITCH + HMV; pCurrMB->BlkV.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + pCurrMB->BlkV.BlkOffset + VMV*PITCH + HMV;
/* Currently U & V are not SLF.
TBD: assemble version of SLF for U & V, ask Brian */ if (IsSLFBlock(pCurrMB->BlockType)) { if (pCurrMB->CodedBlocks & 0x10) { #ifdef ENCODE_STATS
TIMER_BEFORE(bTimingThisFrame,uStartLow,uStartHigh,uBefore); #endif
EncUVLoopFilter((U8*)pCurrMB->BlkU.B4_7.PastRef, (U8*)EC->pU8_SLFFrm_YPlane+pCurrMB->BlkU.BlkOffset,PITCH); pCurrMB->BlkU.B4_7.PastRef = EC->pU8_SLFFrm_YPlane+pCurrMB->BlkU.BlkOffset; }
if (pCurrMB->CodedBlocks & 0x20) { EncUVLoopFilter((U8*)pCurrMB->BlkV.B4_7.PastRef, (U8*)EC->pU8_SLFFrm_YPlane+pCurrMB->BlkV.BlkOffset,PITCH); pCurrMB->BlkV.B4_7.PastRef = EC->pU8_SLFFrm_YPlane+pCurrMB->BlkV.BlkOffset; #ifdef ENCODE_STATS
TIMER_AFTER_P5(bTimingThisFrame,uStartLow,uStartHigh,uBefore,uElapsed,uSLF_UVSum) #endif
} } #else
pCurrMB->BlkU.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + pCurrMB->BlkU.BlkOffset + VMV*PITCH + HMV; pCurrMB->BlkV.B4_7.PastRef = EC->pU8_PrevFrm_YPlane + pCurrMB->BlkV.BlkOffset + VMV*PITCH + HMV;#endif
} /* for(pCurrMB ... */ #ifdef ENCODE_STATS
if (bTimingThisFrame) { pEncTimingInfo = EC->pEncTimingInfo + EC->uStatFrameCount; pEncTimingInfo->uSLF_UV += uSLF_UVSum; } #endif
} /* end CalcGOBChromaVecs() */
/************************************************************************
* * GetEncoderOptions * * Get the options, saving them in the catalog */static void GetEncoderOptions( T_H263EncoderCatalog * EC){ int bSetOptions = 1; /* Default Options
*/ const int bDefaultUseMotionEstimation = 1; const int bDefaultUseSpatialLoopFilter = 1; const char * szDefaultBRCType = "Normal"; const U32 uDefaultForcedQuant = 8; const U32 uDefaultForcedDataRate = 1024; const float fDefaultForcedFrameRate = (float) 8.0; /* should be the same as szDefaultForcedFrameRate */ #ifndef RING0
const char * szDefaultForcedFrameRate = "8.0"; /* should be the same as fDefaultForcedFrameRate */ #endif
/* INI file variables
*/ #ifndef RING0
UN unResult; DWORD dwResult; char buf120[120]; float fResult; #define SECTION_NAME "Encode"
#define INI_FILE_NAME "h261test.ini"
#endif
/* Read the options from the INI file
*/ #ifndef RING0
{ DBOUT("Getting options from the ini file h261test.ini"); /* Motion Estimation
*/ unResult = GetPrivateProfileInt(SECTION_NAME, "MotionEstimation", bDefaultUseMotionEstimation, INI_FILE_NAME); if (unResult != 0 && unResult != 1) { #ifdef _DEBUG
wsprintf(string,"MotionEstimation ini value error (should be 0 or 1) - using default=%d", (int) bDefaultUseMotionEstimation); DBOUT(string); #endif
unResult = bDefaultUseMotionEstimation; } EC->bUseMotionEstimation = unResult;
/* Set the custom parameters for motion estimation.
*/ unResult = GetPrivateProfileInt(SECTION_NAME, "MEzerothresh", MECatalog[ME_CUSTOM_CTRLS].zero_vector_threshold, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].zero_vector_threshold = unResult; unResult = GetPrivateProfileInt(SECTION_NAME, "MEnonzerodiff", MECatalog[ME_CUSTOM_CTRLS].nonzero_MV_differential, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].nonzero_MV_differential = unResult; unResult = GetPrivateProfileInt(SECTION_NAME, "MEemptythresh", MECatalog[ME_CUSTOM_CTRLS].empty_threshold, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].empty_threshold = unResult; unResult = GetPrivateProfileInt(SECTION_NAME, "MEinterthresh", MECatalog[ME_CUSTOM_CTRLS].intercoding_threshold, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].intercoding_threshold = unResult; unResult = GetPrivateProfileInt(SECTION_NAME, "MEinterdiff", MECatalog[ME_CUSTOM_CTRLS].intercoding_differential, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].intercoding_differential = unResult; unResult = GetPrivateProfileInt(SECTION_NAME, "MEslfthresh", MECatalog[ME_CUSTOM_CTRLS].slf_threshold, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].slf_threshold = unResult; unResult = GetPrivateProfileInt(SECTION_NAME, "MEslfdiff", MECatalog[ME_CUSTOM_CTRLS].slf_differential, INI_FILE_NAME); MECatalog[ME_CUSTOM_CTRLS].slf_differential = unResult;
/* Enable or disable the custom parameters for motion estimation.
*/ unResult = GetPrivateProfileInt(SECTION_NAME, "CustomME", 0, INI_FILE_NAME); EC->bUseCustomMotionEstimation = unResult ? 1 : 0;
/* Spatial Loop Filter
*/ unResult = GetPrivateProfileInt(SECTION_NAME, "SpatialLoopFilter", bDefaultUseSpatialLoopFilter, INI_FILE_NAME); if (unResult != 0 && unResult != 1) { #ifdef _DEBUG
wsprintf(string,"SpatialLoopFilter ini value error (should be 0 or 1) - using default=%d", (int) bDefaultUseSpatialLoopFilter); DBOUT(string); #endif
unResult = bDefaultUseSpatialLoopFilter; } EC->bUseSpatialLoopFilter = unResult;
/* Bit Rate Controller Type
*/ strcpy(buf120,"Error"); dwResult = GetPrivateProfileString(SECTION_NAME, "BRCType", szDefaultBRCType, buf120, 120, INI_FILE_NAME); if ((dwResult == 0) || ((strcmp(buf120,"Normal") != 0) && (strcmp(buf120,"ForcedQuant") != 0) && (strcmp(buf120,"ForcedDataRate") != 0))) { #ifdef _DEBUG
wsprintf(string,"BRCType ini value error (should be Normal, ForcedQuant, or ForcedDataRate) - using default=%s", szDefaultBRCType); DBOUT(string); #endif
strcpy(buf120,szDefaultBRCType); } if (strcmp(buf120,"Normal") == 0) { EC->u8BRCType = BRC_Normal; } else if (strcmp(buf120,"ForcedQuant") == 0) { EC->u8BRCType = BRC_ForcedQuant; } else if (strcmp(buf120,"ForcedDataRate") == 0) { EC->u8BRCType = BRC_ForcedDataRate; } else { ASSERT(0); }
/* ForcedQuant
*/ if (EC->u8BRCType == BRC_ForcedQuant) { unResult = GetPrivateProfileInt(SECTION_NAME, "ForcedQuant", uDefaultForcedQuant, INI_FILE_NAME); if (unResult < 6 || unResult > 31) { #ifdef _DEBUG
wsprintf(string, "ForcedQuant ini value error (should be 6 to 31) - using default=%d", uDefaultForcedQuant); DBOUT(string); #endif
unResult = uDefaultForcedQuant; } EC->uForcedQuant = unResult; }
/* ForcedDataRate
*/ if (EC->u8BRCType == BRC_ForcedDataRate) { unResult = GetPrivateProfileInt(SECTION_NAME, "ForcedDataRate", uDefaultForcedDataRate, INI_FILE_NAME); if (unResult < 1) { #ifdef _DEBUG
wsprintf(string,"ForcedDataRate ini value error (should be > 0) - using default=%d", uDefaultForcedDataRate); DBOUT(string); #endif
unResult = uDefaultForcedDataRate; } EC->uForcedDataRate = unResult;
strcpy(buf120,"0.0"); dwResult = GetPrivateProfileString(SECTION_NAME, "ForcedFrameRate", szDefaultForcedFrameRate, buf120, 120, INI_FILE_NAME); if (dwResult > 0) { fResult = (float) atof(buf120); } else { fResult = (float) 0.0; } if ( fResult <= 0.0 || fResult > 30.0) { #ifdef _DEBUG
wsprintf(string, "ForcedFrameRate ini value error (should be > 0.0 and <= 30.0) - using default=%s", szDefaultForcedFrameRate); DBOUT(string); #endif
fResult = fDefaultForcedFrameRate; } EC->fForcedFrameRate = fResult; }
bSetOptions = 0; } #endif
if (bSetOptions) { EC->bUseMotionEstimation = bDefaultUseMotionEstimation; EC->bUseSpatialLoopFilter = bDefaultUseSpatialLoopFilter; EC->u8BRCType = BRC_Normal; EC->uForcedQuant = uDefaultForcedQuant; /* Used with BRC_ForcedQuant */ EC->uForcedDataRate = uDefaultForcedDataRate; /* Used with BRC_ForcedDataRate */ EC->fForcedFrameRate = fDefaultForcedFrameRate; /* Used with BRC_ForcedDataRate */ }
/* Can only use the SLF if ME is on
*/ if (EC->bUseSpatialLoopFilter && !EC->bUseMotionEstimation) { DBOUT("The Spatial Loop Filter can not be on if Motion Estimation is OFF"); EC->bUseSpatialLoopFilter = 0; }
/* Display the options
*/ if (EC->bUseMotionEstimation) { DBOUT("Encoder option (Motion Estimation) is ON"); } else { DBOUT("Encoder option (Motion Estimation) is OFF"); } if (EC->bUseSpatialLoopFilter) { DBOUT("Encoder option (Spatial Loop Filter) is ON"); } else { DBOUT("Encoder option (Spatial Loop Filter) is OFF"); }
#ifdef _DEBUG
if (EC->bUseCustomMotionEstimation) { wsprintf(string, "Encoder option (Custom Motion Estimation) %5d %5d %5d %5d %5d %5d %5d", MECatalog[ME_CUSTOM_CTRLS].zero_vector_threshold, MECatalog[ME_CUSTOM_CTRLS].nonzero_MV_differential, MECatalog[ME_CUSTOM_CTRLS].empty_threshold, MECatalog[ME_CUSTOM_CTRLS].intercoding_threshold, MECatalog[ME_CUSTOM_CTRLS].intercoding_differential, MECatalog[ME_CUSTOM_CTRLS].slf_threshold, MECatalog[ME_CUSTOM_CTRLS].slf_differential ); DBOUT(string); } #endif
#ifdef _DEBUG
switch (EC->u8BRCType) { case BRC_Normal: DBOUT("Encoder option (BRC Type) is Normal"); break; case BRC_ForcedQuant: wsprintf(string, "Encoder option (BRC Type) is ForcedQuant with value=%d", EC->uForcedQuant); DBOUT(string); break; case BRC_ForcedDataRate: wsprintf(string, "Encoder option (BRC Type) is ForcedDataRate with value=%d", EC->uForcedDataRate); DBOUT(string); break; default: ASSERT(0); /* shouldn't happen */ break; } #endif
DBOUT("Encoder option (UsePerfmonNFMO) is OFF"); DBOUT("Encoder option (MMX) is OFF");} /* end GetEncoderOptions() */
/************************************************************************
* * StartupBRC * * Start up the Bit Rate Controller for this frame * - set EC->bBitRateControl * - set BRCState.TargetFrameRate * - set BRCState.uTargetFrmSize * - set EC->PictureHeader.PQuant */static void StartupBRC( T_H263EncoderCatalog * EC, U32 uVfWDataRate, /* VfW data rate - byte per frame */ U32 uVfWQuality, /* VfW Quality 1..10000 */ float fVfWFrameRate) /* VfW frame rate */{ FX_ENTRY("StartupBRC"); /* Values used to constrain Quant based on Quality.
* * When you change these remember to change GetOptions. */ const int iLowFixedQuant = 6; // the lowest value without clipping artifacts
const int iHighFixedQuant = 31; // the highest value
I32 iRange; I32 iValue; float fValue;
switch (EC->u8BRCType) { case BRC_Normal: if (uVfWDataRate == 0) { EC->bBitRateControl = 0; EC->BRCState.TargetFrameRate = (float) 0.0; /* turn it off */ EC->BRCState.uTargetFrmSize = 0; /* should not be used */ /* Compute the fixed quant from the quality
*/ iRange = iHighFixedQuant - iLowFixedQuant; ASSERT((iRange >= 0) && (iRange <= 30)); iValue = (10000 - (int)uVfWQuality); ASSERT((iValue >= 0) && (iValue <= 10000)); fValue = (float)iValue * (float)iRange / (float)10000.0; iValue = (int) (fValue + (float) 0.5); iValue += iLowFixedQuant; ASSERT((iValue >= iLowFixedQuant) && (iValue <= iHighFixedQuant)); EC->PictureHeader.PQUANT = (U8) iValue;
DEBUGMSG(ZONE_BITRATE_CONTROL, ("\r\n%s: Bitrate controller disabled, setting EC->PictureHeader.PQUANT = %ld\r\n", _fx_, EC->PictureHeader.PQUANT)); } else { EC->bBitRateControl = 1; EC->BRCState.TargetFrameRate = fVfWFrameRate; EC->BRCState.uTargetFrmSize = uVfWDataRate;
DEBUGMSG(ZONE_BITRATE_CONTROL, ("\r\n%s: Bitrate controller enabled with\r\n", _fx_)); DEBUGMSG(ZONE_BITRATE_CONTROL, (" Target frame rate = %ld.%ld fps\r\n Target quality = %ld\r\n Target frame size = %ld bits\r\n Target bitrate = %ld bps\r\n", (DWORD)EC->BRCState.TargetFrameRate, (DWORD)(EC->BRCState.TargetFrameRate - (float)(DWORD)EC->BRCState.TargetFrameRate) * 10UL, uVfWQuality, (DWORD)EC->BRCState.uTargetFrmSize << 3, (DWORD)(EC->BRCState.TargetFrameRate * EC->BRCState.uTargetFrmSize) * 8UL)); DEBUGMSG(ZONE_BITRATE_CONTROL, (" Minimum quantizer = %ld\r\n Maximum quantizer = 31\r\n", clampQP((10000 - uVfWQuality)*15/10000)));
EC->PictureHeader.PQUANT = CalcPQUANT( &(EC->BRCState), EC->PictureHeader.PicCodType); } break; case BRC_ForcedQuant: EC->bBitRateControl = 0; EC->BRCState.TargetFrameRate = (float) 0.0; /* turn it off */ EC->BRCState.uTargetFrmSize = 0; /* should not be used */ EC->PictureHeader.PQUANT = (U8) EC->uForcedQuant; break; case BRC_ForcedDataRate: EC->bBitRateControl = 1; EC->BRCState.TargetFrameRate = EC->fForcedFrameRate; EC->BRCState.uTargetFrmSize = EC->uForcedDataRate;
DEBUGMSG(ZONE_BITRATE_CONTROL, ("\r\n%s: Bitrate controller enabled with\r\n", _fx_)); DEBUGMSG(ZONE_BITRATE_CONTROL, (" Target frame rate = %ld.%ld fps\r\n Target quality = %ld\r\n Target frame size = %ld bits\r\n Target bitrate = %ld bps\r\n", (DWORD)EC->BRCState.TargetFrameRate, (DWORD)(EC->BRCState.TargetFrameRate - (float)(DWORD)EC->BRCState.TargetFrameRate) * 10UL, uVfWQuality, (DWORD)EC->BRCState.uTargetFrmSize << 3, (DWORD)(EC->BRCState.TargetFrameRate * EC->BRCState.uTargetFrmSize) * 8UL)); DEBUGMSG(ZONE_BITRATE_CONTROL, (" Minimum quantizer = %ld\r\n Maximum quantizer = 31\r\n", clampQP((10000 - uVfWQuality)*15/10000)));
EC->PictureHeader.PQUANT = CalcPQUANT( &(EC->BRCState), EC->PictureHeader.PicCodType); break; default: ASSERT(0); /* should never happen */ break; }
#ifdef DEBUG_BRC
wsprintf(string,"PQuant=%d", EC->PictureHeader.PQUANT); DBOUT(string); #endif
} /* end StartupBRC() */
/************************************************************************
* * CalculateQP_mean * * Calculate the new QP_mean value. * * TBD: Consider making this more sophisticated - ie: look at more than * the last frame or look at the second order affect. */static void CalculateQP_mean( T_H263EncoderCatalog * EC){ /* Calculate average quantizer to be used for next frame.
* The current approach changes QP at the beginning of each row. */
/* uQP_count no longer on a row of macroblocks bases, Arlene 6/20/96
if ( EC->PictureHeader.SourceFormat == SF_CIF ) { ASSERT(EC->uQP_count == 2*EC->NumMBRows); } else { ASSERT(EC->uQP_count == EC->NumMBRows); }*/ /* If this is an an INTRA picture use the inter default as QP_mean
* Otherwise compute QP_mean. */ if (EC->PictureHeader.PicCodType == INTRAPIC) { EC->BRCState.QP_mean = EC->u8DefINTER_QP; } else { EC->BRCState.QP_mean = EC->uQP_cumulative / EC->uQP_count;
/* New method, Arlene 6/20/96
EC->BRCState.QP_mean = (EC->uQP_cumulative + (EC->uQP_count >> 1)) / EC->uQP_count;*/ }} /* end CalculateQP_mean() */
|
