e0c0012472433327f48adb6e19bbbd7b648f0906
[theora.git] / lib / encoder_internal.h
1 /********************************************************************
2  *                                                                  *
3  * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
7  *                                                                  *
8  * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2003                *
9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
10  *                                                                  *
11  ********************************************************************
12
13   function:
14   last mod: $Id: encoder_internal.h,v 1.21 2004/03/09 02:02:56 giles Exp $
15
16  ********************************************************************/
17
18 #ifndef ENCODER_INTERNAL_H
19 #define ENCODER_INTERNAL_H
20
21 #ifdef HAVE_CONFIG_H
22 # include "config.h"
23 #endif
24
25 #include <theora/theora.h>
26 #include "huffman.h"
27
28 #ifndef LIBOGG2
29 #define theora_read(x,y,z) ( *z = oggpackB_read(x,y) )
30 #else
31 #define theora_read(x,y,z) ( oggpackB_read(x,y,z) )
32 #endif
33
34 #define CURRENT_ENCODE_VERSION   1
35 #define HUGE_ERROR              (1<<28)  /*  Out of range test value */
36
37 /* Baseline dct height and width. */
38 #define BLOCK_HEIGHT_WIDTH          8
39 #define HFRAGPIXELS                 8
40 #define VFRAGPIXELS                 8
41
42 /* Baseline dct block size */
43 #define BLOCK_SIZE              (BLOCK_HEIGHT_WIDTH * BLOCK_HEIGHT_WIDTH)
44
45 /* Border is for unrestricted mv's */
46 #define UMV_BORDER              16
47 #define STRIDE_EXTRA            (UMV_BORDER * 2)
48 #define Q_TABLE_SIZE            64
49
50 #define BASE_FRAME              0
51 #define NORMAL_FRAME            1
52
53 #define MAX_MODES               8
54 #define MODE_BITS               3
55 #define MODE_METHODS            8
56 #define MODE_METHOD_BITS        3
57
58 /* Different key frame types/methods */
59 #define DCT_KEY_FRAME           0
60
61 #define KEY_FRAME_CONTEXT       5
62
63 /* Preprocessor defines */
64 #define MAX_PREV_FRAMES        16
65
66 /* Number of search sites for a 4-step search (at pixel accuracy) */
67 #define MAX_SEARCH_SITES       33
68
69 #define VERY_BEST_Q            10
70 #define MIN_BPB_FACTOR        0.3
71 #define MAX_BPB_FACTOR        3.0
72
73 #define MAX_MV_EXTENT 31  /* Max search distance in half pixel increments */
74
75 typedef struct CONFIG_TYPE2{
76   double       OutputFrameRate;
77   ogg_uint32_t TargetBandwidth;
78   ogg_uint32_t KeyFrameDataTarget ;  /* Data rate target for key frames */
79
80   ogg_uint32_t FirstFrameQ;
81   ogg_uint32_t BaseQ;
82   ogg_uint32_t MaxQ;            /* Absolute Max Q allowed. */
83   ogg_uint32_t ActiveMaxQ;      /* Currently active Max Q */
84
85 } CONFIG_TYPE2;
86
87 typedef struct coeffNode{
88   int i;
89   struct coeffNode *next;
90 } COEFFNODE;
91
92 typedef struct{
93   unsigned char * Yuv0ptr;
94   unsigned char * Yuv1ptr;
95   unsigned char * SrfWorkSpcPtr;
96   unsigned char * disp_fragments;
97
98   ogg_uint32_t  * RegionIndex; /* Gives pixel index for top left of
99                                  each block */
100   ogg_uint32_t    VideoFrameHeight;
101   ogg_uint32_t    VideoFrameWidth;
102
103 } SCAN_CONFIG_DATA;
104
105 typedef unsigned char YUV_BUFFER_ENTRY;
106
107 typedef struct{
108   ogg_int32_t   x;
109   ogg_int32_t   y;
110 } MOTION_VECTOR;
111
112 typedef MOTION_VECTOR COORDINATE;
113
114 typedef ogg_int16_t     Q_LIST_ENTRY;
115
116 typedef struct PP_INSTANCE {
117   ogg_uint32_t  PrevFrameLimit;
118
119   ogg_uint32_t   *ScanPixelIndexTable;
120   signed char    *ScanDisplayFragments;
121
122   signed char    *PrevFragments[MAX_PREV_FRAMES];
123
124   ogg_uint32_t   *FragScores; /* The individual frame difference ratings. */
125   signed char    *SameGreyDirPixels;
126   signed char    *BarBlockMap;
127
128   /* Number of pixels changed by diff threshold in row of a fragment. */
129   unsigned char  *FragDiffPixels;
130
131   unsigned char  *PixelScores;
132   unsigned char  *PixelChangedMap;
133   unsigned char  *ChLocals;
134   ogg_int16_t    *yuv_differences;
135   ogg_int32_t    *RowChangedPixels;
136   signed char    *TmpCodedMap;
137
138   /* Plane pointers and dimension variables */
139   unsigned char  * YPlanePtr0;
140   unsigned char  * YPlanePtr1;
141   unsigned char  * UPlanePtr0;
142   unsigned char  * UPlanePtr1;
143   unsigned char  * VPlanePtr0;
144   unsigned char  * VPlanePtr1;
145
146   ogg_uint32_t    VideoYPlaneWidth;
147   ogg_uint32_t    VideoYPlaneHeight;
148   ogg_uint32_t    VideoUVPlaneWidth;
149   ogg_uint32_t    VideoUVPlaneHeight;
150
151   ogg_uint32_t    VideoYPlaneStride;
152   ogg_uint32_t    VideoUPlaneStride;
153   ogg_uint32_t    VideoVPlaneStride;
154
155   /* Scan control variables. */
156   unsigned char   HFragPixels;
157   unsigned char   VFragPixels;
158
159   ogg_uint32_t    ScanFrameFragments;
160   ogg_uint32_t    ScanYPlaneFragments;
161   ogg_uint32_t    ScanUVPlaneFragments;
162   ogg_uint32_t    ScanHFragments;
163   ogg_uint32_t    ScanVFragments;
164
165   ogg_uint32_t    YFramePixels;
166   ogg_uint32_t    UVFramePixels;
167
168   ogg_uint32_t    SgcThresh;
169
170   ogg_uint32_t    OutputBlocksUpdated;
171   ogg_uint32_t    KFIndicator;
172
173   /* The pre-processor scan configuration. */
174   SCAN_CONFIG_DATA ScanConfig;
175
176   ogg_int32_t   SRFGreyThresh;
177   ogg_int32_t   SRFColThresh;
178   ogg_int32_t   SgcLevelThresh;
179   ogg_int32_t   SuvcLevelThresh;
180
181   ogg_uint32_t  NoiseSupLevel;
182
183   /* Block Thresholds. */
184   ogg_uint32_t  PrimaryBlockThreshold;
185   unsigned char LineSearchTripTresh;
186
187   int   PAKEnabled;
188
189   int   LevelThresh;
190   int   NegLevelThresh;
191   int   SrfThresh;
192   int   NegSrfThresh;
193   int   HighChange;
194   int   NegHighChange;
195
196   /* Threshold lookup tables */
197   unsigned char SrfPakThreshTable[512];
198   unsigned char SrfThreshTable[512];
199   unsigned char SgcThreshTable[512];
200
201   /* Variables controlling S.A.D. break outs. */
202   ogg_uint32_t GrpLowSadThresh;
203   ogg_uint32_t GrpHighSadThresh;
204   ogg_uint32_t ModifiedGrpLowSadThresh;
205   ogg_uint32_t ModifiedGrpHighSadThresh;
206
207   ogg_int32_t  PlaneHFragments;
208   ogg_int32_t  PlaneVFragments;
209   ogg_int32_t  PlaneHeight;
210   ogg_int32_t  PlaneWidth;
211   ogg_int32_t  PlaneStride;
212
213   ogg_uint32_t BlockThreshold;
214   ogg_uint32_t BlockSgcThresh;
215   double UVBlockThreshCorrection;
216   double UVSgcCorrection;
217
218   double YUVPlaneCorrectionFactor;
219   double AbsDiff_ScoreMultiplierTable[256];
220   unsigned char  NoiseScoreBoostTable[256];
221   unsigned char  MaxLineSearchLen;
222
223   ogg_int32_t YuvDiffsCircularBufferSize;
224   ogg_int32_t ChLocalsCircularBufferSize;
225   ogg_int32_t PixelMapCircularBufferSize;
226
227 } PP_INSTANCE;
228
229
230 typedef enum{
231   CODE_INTER_NO_MV        = 0x0, /* INTER prediction, (0,0) motion
232                                     vector implied.  */
233     CODE_INTRA            = 0x1, /* INTRA i.e. no prediction. */
234     CODE_INTER_PLUS_MV    = 0x2, /* INTER prediction, non zero motion
235                                     vector. */
236     CODE_INTER_LAST_MV    = 0x3, /* Use Last Motion vector */
237     CODE_INTER_PRIOR_LAST = 0x4, /* Prior last motion vector */
238     CODE_USING_GOLDEN     = 0x5, /* 'Golden frame' prediction (no MV). */
239     CODE_GOLDEN_MV        = 0x6, /* 'Golden frame' prediction plus MV. */
240     CODE_INTER_FOURMV     = 0x7  /* Inter prediction 4MV per macro block. */
241 } CODING_MODE;
242
243 typedef struct HUFF_ENTRY {
244   struct HUFF_ENTRY *ZeroChild;
245   struct HUFF_ENTRY *OneChild;
246   struct HUFF_ENTRY *Previous;
247   struct HUFF_ENTRY *Next;
248   ogg_int32_t        Value;
249   ogg_uint32_t       Frequency;
250
251 } HUFF_ENTRY;
252
253 typedef struct codec_setup_info {
254   ogg_uint32_t QThreshTable[Q_TABLE_SIZE];
255   Q_LIST_ENTRY DcScaleFactorTable[Q_TABLE_SIZE];
256   int MaxQMatrixIndex;
257   Q_LIST_ENTRY *qmats;
258   Q_LIST_ENTRY Y_coeffs[64];
259   Q_LIST_ENTRY UV_coeffs[64];
260   Q_LIST_ENTRY Inter_coeffs[64];
261
262   HUFF_ENTRY *HuffRoot[NUM_HUFF_TABLES];
263
264   unsigned char LoopFilterLimitValues[Q_TABLE_SIZE];
265 } codec_setup_info;
266
267 typedef struct PB_INSTANCE {
268   oggpack_buffer *opb;
269   theora_info     info;
270   /* how far do we shift the granulepos to seperate out P frame counts? */
271   int             keyframe_granule_shift;
272
273
274   /***********************************************************************/
275   /* Decoder and Frame Type Information */
276
277   int           DecoderErrorCode;
278   int           FramesHaveBeenSkipped;
279
280   int           PostProcessEnabled;
281   ogg_uint32_t  PostProcessingLevel;    /* Perform post processing */
282
283   /* Frame Info */
284   CODING_MODE   CodingMode;
285   unsigned char FrameType;
286   unsigned char KeyFrameType;
287   ogg_uint32_t  QualitySetting;
288   ogg_uint32_t  FrameQIndex;            /* Quality specified as a
289                                            table index */
290   ogg_uint32_t  ThisFrameQualityValue;  /* Quality value for this frame  */
291   ogg_uint32_t  LastFrameQualityValue;  /* Last Frame's Quality */
292   ogg_int32_t   CodedBlockIndex;        /* Number of Coded Blocks */
293   ogg_uint32_t  CodedBlocksThisFrame;   /* Index into coded blocks */
294   ogg_uint32_t  FrameSize;              /* The number of bytes in the frame. */
295
296   /**********************************************************************/
297   /* Frame Size & Index Information */
298
299   ogg_uint32_t  YPlaneSize;
300   ogg_uint32_t  UVPlaneSize;
301   ogg_uint32_t  YStride;
302   ogg_uint32_t  UVStride;
303   ogg_uint32_t  VFragments;
304   ogg_uint32_t  HFragments;
305   ogg_uint32_t  UnitFragments;
306   ogg_uint32_t  YPlaneFragments;
307   ogg_uint32_t  UVPlaneFragments;
308
309   ogg_uint32_t  ReconYPlaneSize;
310   ogg_uint32_t  ReconUVPlaneSize;
311
312   ogg_uint32_t  YDataOffset;
313   ogg_uint32_t  UDataOffset;
314   ogg_uint32_t  VDataOffset;
315   ogg_uint32_t  ReconYDataOffset;
316   ogg_uint32_t  ReconUDataOffset;
317   ogg_uint32_t  ReconVDataOffset;
318   ogg_uint32_t  YSuperBlocks;   /* Number of SuperBlocks in a Y frame */
319   ogg_uint32_t  UVSuperBlocks;  /* Number of SuperBlocks in a U or V frame */
320   ogg_uint32_t  SuperBlocks;    /* Total number of SuperBlocks in a
321                                    Y,U,V frame */
322
323   ogg_uint32_t  YSBRows;        /* Number of rows of SuperBlocks in a
324                                    Y frame */
325   ogg_uint32_t  YSBCols;        /* Number of cols of SuperBlocks in a
326                                    Y frame */
327   ogg_uint32_t  UVSBRows;       /* Number of rows of SuperBlocks in a
328                                    U or V frame */
329   ogg_uint32_t  UVSBCols;       /* Number of cols of SuperBlocks in a
330                                    U or V frame */
331
332   ogg_uint32_t  YMacroBlocks;   /* Number of Macro-Blocks in Y component */
333   ogg_uint32_t  UVMacroBlocks;  /* Number of Macro-Blocks in U/V component */
334   ogg_uint32_t  MacroBlocks;    /* Total number of Macro-Blocks */
335
336   /**********************************************************************/
337   /* Frames  */
338   YUV_BUFFER_ENTRY *ThisFrameRecon;
339   YUV_BUFFER_ENTRY *GoldenFrame;
340   YUV_BUFFER_ENTRY *LastFrameRecon;
341   YUV_BUFFER_ENTRY *PostProcessBuffer;
342
343   /**********************************************************************/
344   /* Fragment Information */
345   ogg_uint32_t  *pixel_index_table;        /* start address of first
346                                               pixel of fragment in
347                                               source */
348   ogg_uint32_t  *recon_pixel_index_table;  /* start address of first
349                                               pixel in recon buffer */
350
351   unsigned char *display_fragments;        /* Fragment update map */
352   unsigned char *skipped_display_fragments;/* whether fragment YUV
353                                               Conversion and update is to be
354                                               skipped */
355   ogg_int32_t   *CodedBlockList;           /* A list of fragment indices for
356                                               coded blocks. */
357   MOTION_VECTOR *FragMVect;                /* fragment motion vectors */
358
359   ogg_uint32_t  *FragTokenCounts;          /* Number of tokens per fragment */
360   ogg_uint32_t  (*TokenList)[128];         /* Fragment Token Pointers */
361
362   ogg_int32_t   *FragmentVariances;
363   ogg_uint32_t  *FragQIndex;               /* Fragment Quality used in
364                                               PostProcess */
365   Q_LIST_ENTRY (*PPCoefBuffer)[64];        /* PostProcess Buffer for
366                                               coefficients data */
367
368   unsigned char *FragCoeffs;                /* # of coeffs decoded so far for
369                                                fragment */
370   unsigned char *FragCoefEOB;               /* Position of last non 0 coef
371                                                 within QFragData */
372   Q_LIST_ENTRY (*QFragData)[64];            /* Fragment Coefficients
373                                                Array Pointers */
374   CODING_MODE   *FragCodingMethod;          /* coding method for the
375                                                fragment */
376
377   /***********************************************************************/
378   /* pointers to addresses used for allocation and deallocation the
379       others are rounded up to the nearest 32 bytes */
380
381   COEFFNODE     *_Nodes;
382   ogg_uint32_t  *transIndex;                    /* ptr to table of
383                                                    transposed indexes */
384
385   /***********************************************************************/
386   ogg_int32_t    bumpLast;
387
388   /* Macro Block and SuperBlock Information */
389   ogg_int32_t  (*BlockMap)[4][4];               /* super block + sub macro
390                                                    block + sub frag ->
391                                                    FragIndex */
392
393   /* Coded flag arrays and counters for them */
394   unsigned char *SBCodedFlags;
395   unsigned char *SBFullyFlags;
396   unsigned char *MBCodedFlags;
397   unsigned char *MBFullyFlags;
398
399   /**********************************************************************/
400   ogg_uint32_t   EOB_Run;
401
402   COORDINATE    *FragCoordinates;
403   MOTION_VECTOR  MVector;
404   ogg_int32_t    ReconPtr2Offset;       /* Offset for second reconstruction
405                                            in half pixel MC */
406   Q_LIST_ENTRY  *quantized_list;
407   ogg_int16_t   *ReconDataBuffer;
408   Q_LIST_ENTRY   InvLastIntraDC;
409   Q_LIST_ENTRY   InvLastInterDC;
410   Q_LIST_ENTRY   LastIntraDC;
411   Q_LIST_ENTRY   LastInterDC;
412
413   ogg_uint32_t   BlocksToDecode;        /* Blocks to be decoded this frame */
414   ogg_uint32_t   DcHuffChoice;          /* Huffman table selection variables */
415   unsigned char  ACHuffChoice;
416   ogg_uint32_t   QuadMBListIndex;
417
418   ogg_int32_t    ByteCount;
419
420   ogg_uint32_t   bit_pattern;
421   unsigned char  bits_so_far;
422   unsigned char  NextBit;
423   ogg_int32_t    BitsLeft;
424
425   ogg_int16_t   *DequantBuffer;
426
427   ogg_int32_t    fp_quant_InterUV_coeffs[64];
428   ogg_int32_t    fp_quant_InterUV_round[64];
429   ogg_int32_t    fp_ZeroBinSize_InterUV[64];
430
431   ogg_int16_t   *TmpReconBuffer;
432   ogg_int16_t   *TmpDataBuffer;
433
434   /* Loop filter bounding values */
435   unsigned char  LoopFilterLimits[Q_TABLE_SIZE];
436   ogg_int32_t    FiltBoundingValue[512];
437
438   /* Dequantiser and rounding tables */
439   ogg_uint32_t   QThreshTable[Q_TABLE_SIZE];
440   Q_LIST_ENTRY   DcScaleFactorTable[Q_TABLE_SIZE];
441   Q_LIST_ENTRY   Y_coeffs[64];
442   Q_LIST_ENTRY   UV_coeffs[64];
443   Q_LIST_ENTRY   Inter_coeffs[64];
444   Q_LIST_ENTRY  *dequant_InterUV_coeffs;
445   unsigned int   quant_index[64];
446   ogg_int32_t    quant_Y_coeffs[64];
447   ogg_int32_t    quant_UV_coeffs[64];
448   ogg_int32_t    fp_quant_Y_coeffs[64]; /* used in reiniting quantizers */
449
450   HUFF_ENTRY    *HuffRoot_VP3x[NUM_HUFF_TABLES];
451   ogg_uint32_t  *HuffCodeArray_VP3x[NUM_HUFF_TABLES];
452   unsigned char *HuffCodeLengthArray_VP3x[NUM_HUFF_TABLES];
453   const unsigned char *ExtraBitLengths_VP3x;
454
455   /* Quantiser and rounding tables */
456   ogg_int32_t    fp_quant_UV_coeffs[64];
457   ogg_int32_t    fp_quant_Inter_coeffs[64];
458   ogg_int32_t    fp_quant_Y_round[64];
459   ogg_int32_t    fp_quant_UV_round[64];
460   ogg_int32_t    fp_quant_Inter_round[64];
461   ogg_int32_t    fp_ZeroBinSize_Y[64];
462   ogg_int32_t    fp_ZeroBinSize_UV[64];
463   ogg_int32_t    fp_ZeroBinSize_Inter[64];
464   ogg_int32_t   *fquant_coeffs;
465   ogg_int32_t   *fquant_round;
466   ogg_int32_t   *fquant_ZbSize;
467   Q_LIST_ENTRY  *dequant_Y_coeffs;
468   Q_LIST_ENTRY  *dequant_UV_coeffs;
469   Q_LIST_ENTRY  *dequant_Inter_coeffs;
470   Q_LIST_ENTRY  *dequant_coeffs;
471
472   /* Predictor used in choosing entropy table for decoding block patterns. */
473   unsigned char  BlockPatternPredictor;
474
475   short          Modifier[4][512];
476   short         *ModifierPointer[4];
477
478   unsigned char *DataOutputInPtr;
479
480 } PB_INSTANCE;
481
482 typedef struct CP_INSTANCE {
483
484   /* Compressor Configuration */
485   SCAN_CONFIG_DATA ScanConfig;
486   CONFIG_TYPE2     Configuration;
487   int              GoldenFrameEnabled;
488   int              InterPrediction;
489   int              MotionCompensation;
490
491   ogg_uint32_t     LastKeyFrame ;
492   ogg_int32_t      DropCount ;
493   ogg_int32_t      MaxConsDroppedFrames ;
494   ogg_int32_t      DropFrameTriggerBytes;
495   int              DropFrameCandidate;
496
497   /* Compressor Statistics */
498   double           TotErrScore;
499   ogg_int64_t      KeyFrameCount; /* Count of key frames. */
500   ogg_int64_t      TotKeyFrameBytes;
501   ogg_uint32_t     LastKeyFrameSize;
502   ogg_uint32_t     PriorKeyFrameSize[KEY_FRAME_CONTEXT];
503   ogg_uint32_t     PriorKeyFrameDistance[KEY_FRAME_CONTEXT];
504   ogg_int32_t      FrameQuality[6];
505   int              DecoderErrorCode; /* Decoder error flag. */
506   ogg_int32_t      ThreshMapThreshold;
507   ogg_int32_t      TotalMotionScore;
508   ogg_int64_t      TotalByteCount;
509   ogg_int32_t      FixedQ;
510
511   /* Frame Statistics  */
512   signed char      InterCodeCount;
513   ogg_int64_t      CurrentFrame;
514   ogg_int64_t      CarryOver ;
515   ogg_uint32_t     LastFrameSize;
516   ogg_uint32_t     FrameBitCount;
517   int              ThisIsFirstFrame;
518   int              ThisIsKeyFrame;
519
520   ogg_int32_t      MotionScore;
521   ogg_uint32_t     RegulationBlocks;
522   ogg_int32_t      RecoveryMotionScore;
523   int              RecoveryBlocksAdded ;
524   double           ProportionRecBlocks;
525   double           MaxRecFactor ;
526
527   /* Rate Targeting variables. */
528   ogg_uint32_t     ThisFrameTargetBytes;
529   double           BpbCorrectionFactor;
530
531   /* Up regulation variables */
532   ogg_uint32_t     FinalPassLastPos;  /* Used to regulate a final
533                                          unrestricted high quality
534                                          pass. */
535   ogg_uint32_t     LastEndSB;         /* Where we were in the loop
536                                          last time. */
537   ogg_uint32_t     ResidueLastEndSB;  /* Where we were in the residue
538                                          update loop last time. */
539
540   /* Controlling Block Selection */
541   ogg_uint32_t     MVChangeFactor;
542   ogg_uint32_t     FourMvChangeFactor;
543   ogg_uint32_t     MinImprovementForNewMV;
544   ogg_uint32_t     ExhaustiveSearchThresh;
545   ogg_uint32_t     MinImprovementForFourMV;
546   ogg_uint32_t     FourMVThreshold;
547
548   /* Module shared data structures. */
549   ogg_int32_t      frame_target_rate;
550   ogg_int32_t      BaseLineFrameTargetRate;
551   ogg_int32_t      min_blocks_per_frame;
552   ogg_uint32_t     tot_bytes_old;
553
554   /*********************************************************************/
555   /* Frames  Used in the selecetive convolution filtering of the Y plane. */
556   unsigned char    *ConvDestBuffer;
557   YUV_BUFFER_ENTRY *yuv0ptr;
558   YUV_BUFFER_ENTRY *yuv1ptr;
559   /*********************************************************************/
560
561   /*********************************************************************/
562   /* Token Buffers */
563   ogg_uint32_t     *OptimisedTokenListEb; /* Optimised token list extra bits */
564   unsigned char    *OptimisedTokenList;   /* Optimised token list. */
565   unsigned char    *OptimisedTokenListHi; /* Optimised token list huffman
566                                              table index */
567
568   unsigned char    *OptimisedTokenListPl; /* Plane to which the token
569                                              belongs Y = 0 or UV = 1 */
570   ogg_int32_t       OptimisedTokenCount;           /* Count of Optimized tokens */
571   ogg_uint32_t      RunHuffIndex;         /* Huffman table in force at
572                                              the start of a run */
573   ogg_uint32_t      RunPlaneIndex;        /* The plane (Y=0 UV=1) to
574                                              which the first token in
575                                              an EOB run belonged. */
576
577
578   ogg_uint32_t      TotTokenCount;
579   ogg_int32_t       TokensToBeCoded;
580   ogg_int32_t       TokensCoded;
581   /********************************************************************/
582
583   /* SuperBlock, MacroBLock and Fragment Information */
584   /* Coded flag arrays and counters for them */
585   unsigned char    *PartiallyCodedFlags;
586   unsigned char    *PartiallyCodedMbPatterns;
587   unsigned char    *UncodedMbFlags;
588
589   unsigned char    *extra_fragments;   /* extra updates not
590                                           recommended by pre-processor */
591   ogg_int16_t      *OriginalDC;
592
593   ogg_uint32_t     *FragmentLastQ;     /* Array used to keep track of
594                                           quality at which each
595                                           fragment was last
596                                           updated. */
597   unsigned char    *FragTokens;
598   ogg_uint32_t     *FragTokenCounts;   /* Number of tokens per fragment */
599
600   ogg_uint32_t     *RunHuffIndices;
601   ogg_uint32_t     *LastCodedErrorScore;
602   ogg_uint32_t     *ModeList;
603   MOTION_VECTOR    *MVList;
604
605   unsigned char    *BlockCodedFlags;
606
607   ogg_uint32_t      MvListCount;
608   ogg_uint32_t      ModeListCount;
609
610
611   unsigned char    *DataOutputBuffer;
612   /*********************************************************************/
613
614   ogg_uint32_t      RunLength;
615   ogg_uint32_t      MaxBitTarget;     /* Cut off target for rate capping */
616   double            BitRateCapFactor; /* Factor relating normal frame target
617                                          to cut off target. */
618
619   unsigned char     MBCodingMode;     /* Coding mode flags */
620
621   ogg_int32_t       MVPixelOffsetY[MAX_SEARCH_SITES];
622   ogg_uint32_t      InterTripOutThresh;
623   unsigned char     MVEnabled;
624   ogg_uint32_t      MotionVectorSearchCount;
625   ogg_uint32_t      FrameMVSearcOunt;
626   ogg_int32_t       MVSearchSteps;
627   ogg_int32_t       MVOffsetX[MAX_SEARCH_SITES];
628   ogg_int32_t       MVOffsetY[MAX_SEARCH_SITES];
629   ogg_int32_t       HalfPixelRef2Offset[9]; /* Offsets for half pixel
630                                                compensation */
631   signed char       HalfPixelXOffset[9];    /* Half pixel MV offsets for X */
632   signed char       HalfPixelYOffset[9];    /* Half pixel MV offsets for Y */
633
634   ogg_uint32_t      bit_pattern ;
635   unsigned char     bits_so_far ;
636   ogg_uint32_t      lastval ;
637   ogg_uint32_t      lastrun ;
638
639   Q_LIST_ENTRY     *quantized_list;
640
641   MOTION_VECTOR     MVector;
642   ogg_uint32_t      TempBitCount;
643   ogg_int16_t      *DCT_codes; /* Buffer that stores the result of
644                                   Forward DCT */
645   ogg_int16_t      *DCTDataBuffer; /* Input data buffer for Forward DCT */
646
647   /* Motion compensation related variables */
648   ogg_uint32_t      MvMaxExtent;
649
650   double            QTargetModifier[Q_TABLE_SIZE];
651
652   /* instances (used for reconstructing buffers and to hold tokens etc.) */
653   PP_INSTANCE       pp;   /* preprocessor */
654   PB_INSTANCE       pb;   /* playback */
655
656   /* ogg bitpacker for use in packet coding, other API state */
657   oggpack_buffer   *oggbuffer;
658 #ifdef LIBOGG2  /* Remember, this is just until we drop libogg1 */
659   ogg_buffer_state *oggbufferstate;
660 #endif
661   int               readyflag;
662   int               packetflag;
663   int               doneflag;
664
665 } CP_INSTANCE;
666
667 #define clamp255(x) ((unsigned char)((((x)<0)-1) & ((x) | -((x)>255))))
668
669 extern void ConfigurePP( PP_INSTANCE *ppi, int Level ) ;
670 extern ogg_uint32_t YUVAnalyseFrame( PP_INSTANCE *ppi,
671                                      ogg_uint32_t * KFIndicator );
672
673 extern void ClearPPInstance(PP_INSTANCE *ppi);
674 extern void InitPPInstance(PP_INSTANCE *ppi);
675 extern int GetFrameType(PB_INSTANCE *pbi);
676 extern void InitPBInstance(PB_INSTANCE *pbi);
677 extern void ClearPBInstance(PB_INSTANCE *pbi);
678
679
680 extern void IDctSlow(  Q_LIST_ENTRY * InputData,
681                        ogg_int16_t *QuantMatrix,
682                        ogg_int16_t * OutputData ) ;
683
684 extern void IDct10( Q_LIST_ENTRY * InputData,
685                     ogg_int16_t *QuantMatrix,
686                     ogg_int16_t * OutputData );
687
688 extern void IDct1( Q_LIST_ENTRY * InputData,
689                    ogg_int16_t *QuantMatrix,
690                    ogg_int16_t * OutputData );
691
692 extern void ReconIntra( PB_INSTANCE *pbi, unsigned char * ReconPtr,
693                         ogg_int16_t * ChangePtr, ogg_uint32_t LineStep );
694
695 extern void ReconInter( PB_INSTANCE *pbi, unsigned char * ReconPtr,
696                         unsigned char * RefPtr, ogg_int16_t * ChangePtr,
697                         ogg_uint32_t LineStep ) ;
698
699 extern void ReconInterHalfPixel2( PB_INSTANCE *pbi, unsigned char * ReconPtr,
700                                   unsigned char * RefPtr1,
701                                   unsigned char * RefPtr2,
702                                   ogg_int16_t * ChangePtr,
703                                   ogg_uint32_t LineStep ) ;
704
705 extern void SetupLoopFilter(PB_INSTANCE *pbi);
706 extern void CopyBlock(unsigned char *src,
707                       unsigned char *dest,
708                       unsigned int srcstride);
709 extern void LoopFilter(PB_INSTANCE *pbi);
710 extern void ReconRefFrames (PB_INSTANCE *pbi);
711 extern void ExpandToken( Q_LIST_ENTRY * ExpandedBlock,
712                          unsigned char * CoeffIndex, ogg_uint32_t Token,
713                          ogg_int32_t ExtraBits );
714 extern void ClearDownQFragData(PB_INSTANCE *pbi);
715 extern void select_Y_quantiser ( PB_INSTANCE *pbi );
716 extern void select_Inter_quantiser ( PB_INSTANCE *pbi );
717 extern void select_UV_quantiser ( PB_INSTANCE *pbi );
718 extern void select_InterUV_quantiser ( PB_INSTANCE *pbi );
719 extern void quantize( PB_INSTANCE *pbi,
720                       ogg_int16_t * DCT_block,
721                       Q_LIST_ENTRY * quantized_list);
722 extern void UpdateQ( PB_INSTANCE *pbi, ogg_uint32_t NewQ );
723 extern void UpdateQC( CP_INSTANCE *cpi, ogg_uint32_t NewQ );
724 extern void fdct_short ( ogg_int16_t * InputData, ogg_int16_t * OutputData );
725 extern ogg_uint32_t DPCMTokenizeBlock (CP_INSTANCE *cpi,
726                                        ogg_int32_t FragIndex);
727 extern void TransformQuantizeBlock (CP_INSTANCE *cpi, ogg_int32_t FragIndex,
728                                     ogg_uint32_t PixelsPerLine ) ;
729 extern void ClearFragmentInfo(PB_INSTANCE * pbi);
730 extern void InitFragmentInfo(PB_INSTANCE * pbi);
731 extern void ClearFrameInfo(PB_INSTANCE * pbi);
732 extern void InitFrameInfo(PB_INSTANCE * pbi, unsigned int FrameSize);
733 extern void InitializeFragCoordinates(PB_INSTANCE *pbi);
734 extern void InitFrameDetails(PB_INSTANCE *pbi);
735 extern void WriteQTables(PB_INSTANCE *pbi,oggpack_buffer *opb);
736 extern int  ReadQTables(codec_setup_info *ci,oggpack_buffer* opb);
737 extern void CopyQTables(PB_INSTANCE *pbi, codec_setup_info *ci);
738 extern void InitQTables( PB_INSTANCE *pbi );
739 extern void InitHuffmanSet( PB_INSTANCE *pbi );
740 extern void ClearHuffmanSet( PB_INSTANCE *pbi );
741 extern int  ReadHuffmanTrees(codec_setup_info *ci, oggpack_buffer *opb);
742 extern void WriteHuffmanTrees(HUFF_ENTRY *HuffRoot[NUM_HUFF_TABLES],
743                               oggpack_buffer *opb);
744 extern void InitHuffmanTrees(PB_INSTANCE *pbi, const codec_setup_info *ci);
745 extern void ClearHuffmanTrees(HUFF_ENTRY *HuffRoot[NUM_HUFF_TABLES]);
746 extern void WriteFilterTables(PB_INSTANCE *pbi, oggpack_buffer *opb);
747 extern int  ReadFilterTables(codec_setup_info *ci, oggpack_buffer *opb);
748 extern void CopyFilterTables(PB_INSTANCE *pbi, codec_setup_info *ci);
749 extern void InitFilterTables(PB_INSTANCE *pbi);
750 extern void QuadDecodeDisplayFragments ( PB_INSTANCE *pbi );
751 extern void PackAndWriteDFArray( CP_INSTANCE *cpi );
752 extern void UpdateFragQIndex(PB_INSTANCE *pbi);
753 extern void PostProcess(PB_INSTANCE *pbi);
754 extern void InitMotionCompensation ( CP_INSTANCE *cpi );
755 extern ogg_uint32_t GetMBIntraError (CP_INSTANCE *cpi, ogg_uint32_t FragIndex,
756                                      ogg_uint32_t PixelsPerLine ) ;
757 extern ogg_uint32_t GetMBInterError (CP_INSTANCE *cpi,
758                                      unsigned char * SrcPtr,
759                                      unsigned char * RefPtr,
760                                      ogg_uint32_t FragIndex,
761                                      ogg_int32_t LastXMV,
762                                      ogg_int32_t LastYMV,
763                                      ogg_uint32_t PixelsPerLine ) ;
764 extern void WriteFrameHeader( CP_INSTANCE *cpi) ;
765 extern ogg_uint32_t GetMBMVInterError (CP_INSTANCE *cpi,
766                                        unsigned char * RefFramePtr,
767                                        ogg_uint32_t FragIndex,
768                                        ogg_uint32_t PixelsPerLine,
769                                        ogg_int32_t *MVPixelOffset,
770                                        MOTION_VECTOR *MV );
771 extern ogg_uint32_t GetMBMVExhaustiveSearch (CP_INSTANCE *cpi,
772                                              unsigned char * RefFramePtr,
773                                              ogg_uint32_t FragIndex,
774                                              ogg_uint32_t PixelsPerLine,
775                                              MOTION_VECTOR *MV );
776 extern ogg_uint32_t GetFOURMVExhaustiveSearch (CP_INSTANCE *cpi,
777                                                unsigned char * RefFramePtr,
778                                                ogg_uint32_t FragIndex,
779                                                ogg_uint32_t PixelsPerLine,
780                                                MOTION_VECTOR *MV ) ;
781 extern ogg_uint32_t EncodeData(CP_INSTANCE *cpi);
782 extern ogg_uint32_t PickIntra( CP_INSTANCE *cpi,
783                                ogg_uint32_t SBRows,
784                                ogg_uint32_t SBCols);
785 extern ogg_uint32_t PickModes(CP_INSTANCE *cpi,
786                               ogg_uint32_t SBRows,
787                               ogg_uint32_t SBCols,
788                               ogg_uint32_t PixelsPerLine,
789                               ogg_uint32_t *InterError,
790                               ogg_uint32_t *IntraError);
791
792 extern CODING_MODE FrArrayUnpackMode(PB_INSTANCE *pbi);
793 extern void CreateBlockMapping ( ogg_int32_t  (*BlockMap)[4][4],
794                                  ogg_uint32_t YSuperBlocks,
795                                  ogg_uint32_t UVSuperBlocks,
796                                  ogg_uint32_t HFrags, ogg_uint32_t VFrags );
797 extern void UpRegulateDataStream (CP_INSTANCE *cpi, ogg_uint32_t RegulationQ,
798                                   ogg_int32_t RecoveryBlocks ) ;
799 extern void RegulateQ( CP_INSTANCE *cpi, ogg_int32_t UpdateScore );
800 extern void CopyBackExtraFrags(CP_INSTANCE *cpi);
801 extern void UpdateUMVBorder( PB_INSTANCE *pbi,
802                              unsigned char * DestReconPtr );
803 extern void PInitFrameInfo(PP_INSTANCE * ppi);
804 extern int GetFrameType(PB_INSTANCE *pbi);
805 extern void SetFrameType( PB_INSTANCE *pbi,unsigned char FrType );
806 extern double GetEstimatedBpb( CP_INSTANCE *cpi, ogg_uint32_t TargetQ );
807 extern void ClearTmpBuffers(PB_INSTANCE * pbi);
808 extern void InitTmpBuffers(PB_INSTANCE * pbi);
809 extern void ScanYUVInit( PP_INSTANCE *  ppi,
810                          SCAN_CONFIG_DATA * ScanConfigPtr);
811 extern int LoadAndDecode(PB_INSTANCE *pbi);
812 #endif