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