1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
|
/* ------------------------------------------------------------------
* Copyright (C) 1998-2009 PacketVideo
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied.
* See the License for the specific language governing permissions
* and limitations under the License.
* -------------------------------------------------------------------
*/
#ifndef _MP4LIB_INT_H_
#define _MP4LIB_INT_H_
#include "mp4def.h"
#include "mp4enc_api.h"
#include "rate_control.h"
/* BitstreamEncVideo will be modified */
typedef struct tagBitstream
{
Int(*writeVideoPacket)(UChar *buf, Int nbytes_required); /*write video packet out */
UChar *bitstreamBuffer; /*buffer to hold one video packet*/
Int bufferSize; /*total bitstream buffer size in bytes */
Int byteCount; /*how many bytes already encoded*/
UInt word; /*hold one word temporarily */
Int bitLeft; /*number of bits left in "word" */
UChar* overrunBuffer; /* pointer to overrun buffer */
Int oBSize; /* length of overrun buffer */
struct tagVideoEncData *video;
} BitstreamEncVideo;
typedef struct tagVOP
{
PIXEL *yChan; /* The Y component */
PIXEL *uChan; /* The U component */
PIXEL *vChan; /* The V component */
Int frame; /* frame number */
Int volID; /* Layer number */
//Int timeStamp; /* Vop TimeStamp in msec */
/* Syntax elements copied from VOL (standard) */
Int width; /* Width (multiple of 16) */
Int height; /* Height (multiple of 16) */
Int pitch; /* Pitch (differs from width for UMV case) */
Int padded; /* flag whether this frame has been padded */
/* Actual syntax elements for VOP (standard) */
Int predictionType; /* VOP prediction type */
Int timeInc; /* VOP time increment (relative to last mtb) */
Int vopCoded;
Int roundingType;
Int intraDCVlcThr;
Int quantizer; /* VOP quantizer */
Int fcodeForward; /* VOP dynamic range of motion vectors */
Int fcodeBackward; /* VOP dynamic range of motion vectors */
Int refSelectCode; /* enhancement layer reference select code */
/* H.263 parameters */
Int gobNumber;
Int gobFrameID;
Int temporalRef; /* temporal reference, roll over at 256 */
Int temporalInterval; /* increase every 256 temporalRef */
} Vop;
typedef struct tagVol
{
Int volID; /* VOL identifier (for tracking) */
Int shortVideoHeader; /* shortVideoHeader mode */
Int GOVStart; /* Insert GOV Header */
Int timeIncrementResolution; /* VOL time increment */
Int nbitsTimeIncRes; /* number of bits for time increment */
Int timeIncrement; /* time increment */
Int moduloTimeBase; /* internal decoder clock */
Int prevModuloTimeBase; /* in case of pre-frameskip */
Int fixedVopRate;
BitstreamEncVideo *stream; /* library bitstream buffer (input buffer) */
/* VOL Dimensions */
Int width; /* Width */
Int height; /* Height */
/* Error Resilience Flags */
Int ResyncMarkerDisable; /* VOL Disable Resynch Markers */
Int useReverseVLC; /* VOL reversible VLCs */
Int dataPartitioning; /* VOL data partitioning */
/* Quantization related parameters */
Int quantPrecision; /* Quantizer precision */
Int quantType; /* MPEG-4 or H.263 Quantization Type */
/* Added loaded quant mat, 05/22/2000 */
Int loadIntraQuantMat; /* Load intra quantization matrix */
Int loadNonIntraQuantMat; /* Load nonintra quantization matrix */
Int iqmat[64]; /* Intra quant.matrix */
Int niqmat[64]; /* Non-intra quant.matrix */
/* Parameters used for scalability */
Int scalability; /* VOL scalability (flag) */
Int scalType; /* temporal = 0, spatial = 1, both = 2 */
Int refVolID; /* VOL id of reference VOL */
Int refSampDir; /* VOL resol. of ref. VOL */
Int horSamp_n; /* VOL hor. resampling of ref. VOL given by */
Int horSamp_m; /* sampfac = hor_samp_n/hor_samp_m */
Int verSamp_n; /* VOL ver. resampling of ref. VOL given by */
Int verSamp_m; /* sampfac = ver_samp_n/ver_samp_m */
Int enhancementType; /* VOL type of enhancement layer */
/* These variables were added since they are used a lot. */
Int nMBPerRow, nMBPerCol; /* number of MBs in each row & column */
Int nTotalMB;
Int nBitsForMBID; /* how many bits required for MB number? */
/* for short video header */
Int nMBinGOB; /* number of MBs in GOB, 05/22/00 */
Int nGOBinVop; /* number of GOB in Vop 05/22/00 */
} Vol;
typedef struct tagMacroBlock
{
Int mb_x; /* X coordinate */
Int mb_y; /* Y coordinate */
Short block[9][64]; /* 4-Y, U and V blocks , and AAN Scale*/
} MacroBlock;
typedef struct tagRunLevelBlock
{
Int run[64]; /* Runlength */
Int level[64]; /* Abs(level) */
Int s[64]; /* sign level */
} RunLevelBlock;
typedef struct tagHeaderInfoDecVideo
{
UChar *Mode; /* Modes INTRA/INTER/etc. */
UChar *CBP; /* MCBPC/CBPY stuff */
} HeaderInfoEncVideo;
typedef Short typeDCStore[6]; /* ACDC */
typedef Short typeDCACStore[4][8];
typedef struct tagMOT
{
Int x; /* half-pel resolution x component */
Int y; /* half-pel resolution y component */
Int sad; /* SAD */
} MOT;
typedef struct tagHintTrackInfo
{
UChar MTB;
UChar LayerID;
UChar CodeType;
UChar RefSelCode;
} HintTrackInfo;
typedef struct tagVideoEncParams
{
//Int Width; /* Input Width */
//Int Height; /* Input Height */
//float FrameRate; /* Input Frame Rate */
UInt TimeIncrementRes; /* timeIncrementRes */
/*VOL Parameters */
Int nLayers;
Int LayerWidth[4]; /* Encoded Width */
Int LayerHeight[4]; /* Encoded Height */
float LayerFrameRate[4]; /* Encoded Frame Rate */
Int LayerBitRate[4]; /* Encoded BitRate */
Int LayerMaxBitRate[4]; /* Maximum Encoded BitRate */
float LayerMaxFrameRate[4]; /* Maximum Encoded Frame Rate */
Int LayerMaxMbsPerSec[4]; /* Maximum mbs per second, according to the specified profile and level */
Int LayerMaxBufferSize[4]; /* Maximum buffer size, according to the specified profile and level */
Bool ResyncMarkerDisable; /* Disable Resync Marker */
Bool DataPartitioning; /* Base Layer Data Partitioning */
Bool ReversibleVLC; /* RVLC when Data Partitioning */
Bool ACDCPrediction; /* AC/DC Prediction */
Int QuantType[4]; /* H263, MPEG2 */
Int InitQuantBvop[4];
Int InitQuantPvop[4];
Int InitQuantIvop[4];
Int ResyncPacketsize;
Int RoundingType;
Int IntraDCVlcThr;
/* Rate Control Parameters */
MP4RateControlType RC_Type; /*Constant Q, M4 constantRate, VM5+, M4RC,MPEG2TM5 */
/* Intra Refresh Parameters */
Int IntraPeriod; /* Intra update period */
Int Refresh; /* Number of MBs refresh in each frame */
/* Other Parameters */
Bool SceneChange_Det; /* scene change detection */
Bool FineFrameSkip_Enabled; /* src rate resolution frame skipping */
Bool VBR_Enabled; /* VBR rate control */
Bool NoFrameSkip_Enabled; /* do not allow frame skip */
Bool NoPreSkip_Enabled; /* do not allow pre-skip */
Bool H263_Enabled; /* H263 Short Header */
Bool GOV_Enabled; /* GOV Header Enabled */
Bool SequenceStartCode; /* This probably should be removed */
Bool FullSearch_Enabled; /* full-pel exhaustive search motion estimation */
Bool HalfPel_Enabled; /* Turn Halfpel ME on or off */
Bool MV8x8_Enabled; /* Enable 8x8 motion vectors */
Bool RD_opt_Enabled; /* Enable operational R-D optimization */
Int GOB_Header_Interval; /* Enable encoding GOB header in H263_WITH_ERR_RES and SHORT_HERDER_WITH_ERR_RES */
Int SearchRange; /* Search range for 16x16 motion vector */
Int MemoryUsage; /* Amount of memory allocated */
Int GetVolHeader[2]; /* Flag to check if Vol Header has been retrieved */
Int BufferSize[2]; /* Buffer Size for Base and Enhance Layers */
Int ProfileLevel[2]; /* Profile and Level for encoding purposes */
float VBV_delay; /* VBV buffer size in the form of delay */
Int maxFrameSize; /* maximum frame size(bits) for H263/Short header mode, k*16384 */
Int profile_table_index; /* index for profile and level tables given the specified profile and level */
} VideoEncParams;
/* platform dependent functions */
typedef struct tagFuncPtr
{
// Int (*SAD_MB_HalfPel)(UChar *ref,UChar *blk,Int dmin_lx,Int xh,Int yh,void *extra_info);
Int(*SAD_MB_HalfPel[4])(UChar*, UChar*, Int, void *);
Int(*SAD_Blk_HalfPel)(UChar *ref, UChar *blk, Int dmin, Int lx, Int rx, Int xh, Int yh, void *extra_info);
Int(*SAD_Macroblock)(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
Int(*SAD_Block)(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
Int(*SAD_MB_PADDING)(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info); /*, 4/21/01 */
void (*ComputeMBSum)(UChar *cur, Int lx, MOT *mot_mb);
void (*ChooseMode)(UChar *Mode, UChar *cur, Int lx, Int min_SAD);
void (*GetHalfPelMBRegion)(UChar *cand, UChar *hmem, Int lx);
void (*blockIdct)(Int *block);
} FuncPtr;
/* 04/09/01, for multipass rate control */
typedef struct tagRDInfo
{
Int QP;
Int actual_bits;
float mad;
float R_D;
} RDInfo;
typedef struct tagMultiPass
{
/* multipass rate control data */
Int target_bits; /* target bits for current frame, = rc->T */
Int actual_bits; /* actual bits for current frame obtained after encoding, = rc->Rc*/
Int QP; /* quantization level for current frame, = rc->Qc*/
Int prev_QP; /* quantization level for previous frame */
Int prev_prev_QP; /* quantization level for previous frame before last*/
float mad; /* mad for current frame, = video->avgMAD*/
Int bitrate; /* bitrate for current frame */
float framerate; /* framerate for current frame*/
Int nRe_Quantized; /* control variable for multipass encoding, */
/* 0 : first pass */
/* 1 : intermediate pass(quantization and VLC loop only) */
/* 2 : final pass(de-quantization, idct, etc) */
/* 3 : macroblock level rate control */
Int encoded_frames; /* counter for all encoded frames */
Int re_encoded_frames; /* counter for all multipass encoded frames*/
Int re_encoded_times; /* counter for all times of multipass frame encoding */
/* Multiple frame prediction*/
RDInfo **pRDSamples; /* pRDSamples[30][32], 30->30fps, 32 -> 5 bit quantizer, 32 candidates*/
Int framePos; /* specific position in previous multiple frames*/
Int frameRange; /* number of overall previous multiple frames */
Int samplesPerFrame[30]; /* number of samples per frame, 30->30fps */
/* Bit allocation for scene change frames and high motion frames */
float sum_mad;
Int counter_BTsrc; /* BT = Bit Transfer, bit transfer from low motion frames or less complicatedly compressed frames */
Int counter_BTdst; /* BT = Bit Transfer, bit transfer to scene change frames or high motion frames or more complicatedly compressed frames */
float sum_QP;
Int diff_counter; /* diff_counter = -diff_counter_BTdst, or diff_counter_BTsrc */
/* For target bitrate or framerate update */
float target_bits_per_frame; /* = C = bitrate/framerate */
float target_bits_per_frame_prev; /* previous C */
float aver_mad; /* so-far average mad could replace sum_mad */
float aver_mad_prev; /* previous average mad */
Int overlapped_win_size; /* transition period of time */
Int encoded_frames_prev; /* previous encoded_frames */
} MultiPass;
/* End */
#ifdef HTFM
typedef struct tagHTFM_Stat
{
Int abs_dif_mad_avg;
UInt countbreak;
Int offsetArray[16];
Int offsetRef[16];
} HTFM_Stat;
#endif
/* Global structure that can be passed around */
typedef struct tagVideoEncData
{
/* VOL Header Initialization */
UChar volInitialize[4]; /* Used to Write VOL Headers */
/* Data For Layers (Scalability) */
Int numberOfLayers; /* Number of Layers */
Vol **vol; /* Data stored for each VOL */
/* Data used for encoding frames */
VideoEncFrameIO *input; /* original input frame */
Vop *currVop; /* Current reconstructed VOP */
Vop *prevBaseVop; /* Previous reference Base Vop */
Vop *nextBaseVop; /* Next reference Base Vop */
Vop *prevEnhanceVop;/* Previous Enhancement Layer Vop */
Vop *forwardRefVop; /* Forward Reference VOP */
Vop *backwardRefVop; /* Backward Reference VOP */
/* scratch memory */
BitstreamEncVideo *bitstream1; /* Used for data partitioning */
BitstreamEncVideo *bitstream2; /* and combined modes as */
BitstreamEncVideo *bitstream3; /* intermediate storages */
UChar *overrunBuffer; /* extra output buffer to prevent current skip due to output buffer overrun*/
Int oBSize; /* size of allocated overrun buffer */
Int dc_scalar_1; /*dc scalar for Y block */
Int dc_scalar_2; /*dc scalar for U, V block*/
/* Annex L Rate Control */
rateControl *rc[4]; /* Pointer to Rate Control structure*/
/* 12/25/00, each R.C. for each layer */
/********* motion compensation related variables ****************/
MOT **mot; /* Motion vectors */
/* where [mbnum][0] = 1MV.
[mbnum][1...4] = 4MVs
[mbnum][5] = backward MV.
[mbnum][6] = delta MV for direct mode.
[mbnum][7] = nothing yet. */
UChar *intraArray; /* Intra Update Arrary */
float sumMAD; /* SAD/MAD for frame */
/* to speedup the SAD calculation */
void *sad_extra_info;
#ifdef HTFM
Int nrmlz_th[48]; /* Threshold for fast SAD calculation using HTFM */
HTFM_Stat htfm_stat; /* For statistics collection */
#endif
/*Tao 04/09/00 For DCT routine */
UChar currYMB[256]; /* interleaved current macroblock in HTFM order */
MacroBlock *outputMB; /* Output MB to VLC encode */
UChar predictedMB[384]; /* scrath memory for predicted value */
RunLevelBlock RLB[6]; /* Run and Level of coefficients! */
Short dataBlock[128]; /* DCT block data before and after quant/dequant*/
UChar bitmaprow[8]; /* Need to keep it for ACDCPrediction, 8 bytes for alignment, need only 6 */
UChar bitmapcol[6][8];
UInt bitmapzz[6][2]; /* for zigzag bitmap */
Int zeroMV; /* flag for zero MV */
Int usePrevQP; /* flag for intraDCVlcThreshold switch decision */
Int QP_prev; /* use for DQUANT calculation */
Int *acPredFlag; /* */
typeDCStore *predDC; /* The DC coeffs for each MB */
typeDCACStore *predDCAC_row;
typeDCACStore *predDCAC_col;
UChar *sliceNo; /* Slice Number for each MB */
Int header_bits; /* header bits in frmae */
HeaderInfoEncVideo headerInfo; /* MB Header information */
UChar zz_direction; /* direction of zigzag scan */
UChar *QPMB; /* Quantizer value for each MB */
/* Miscellaneous data points to be passed */
float FrameRate; /* Src frame Rate */
ULong nextModTime; /* expected next frame time */
UInt prevFrameNum[4]; /* previous frame number starting from modTimeRef */
UInt modTimeRef; /* Reference modTime update every I-Vop*/
UInt refTick[4]; /* second aligned referenc tick */
Int relLayerCodeTime[4];/* Next coding time for each Layer relative to highest layer */
ULong modTime; /* Input frame modTime */
Int currLayer; /* Current frame layer */
Int mbnum; /* Macroblock number */
/* slice coding, state variables */
Vop *tempForwRefVop;
Int tempRefSelCode;
Int end_of_buf; /* end of bitstream buffer flag */
Int slice_coding; /* flag for slice based coding */
Int totalSAD; /* So far total SAD for a frame */
Int numIntra; /* So far number of Intra MB */
Int offset; /* So far MB offset */
Int ind_x, ind_y; /* So far MB coordinate */
Int collect;
Int hp_guess;
/*********************************/
HintTrackInfo hintTrackInfo; /* hintTrackInfo */
/* IntraPeriod, Timestamp, etc. */
float nextEncIVop; /* counter til the next I-Vop */
float numVopsInGOP; /* value at the beginning of nextEncIVop */
/* platform dependent functions */
FuncPtr *functionPointer; /* structure containing platform dependent functions */
/* Application controls */
VideoEncControls *videoEncControls;
VideoEncParams *encParams;
MultiPass *pMP[4]; /* for multipass encoding, 4 represents 4 layer encoding */
} VideoEncData;
/*************************************************************/
/* VLC structures */
/*************************************************************/
typedef struct tagVLCtable
{
unsigned int code; /* right justified */
int len;
} VLCtable, *LPVLCtable;
/*************************************************************/
/* Approx DCT */
/*************************************************************/
typedef struct struct_approxDCT approxDCT;
struct struct_approxDCT
{
Void(*BlockDCT8x8)(Int *, Int *, UChar *, UChar *, Int, Int);
Void(*BlockDCT8x8Intra)(Int *, Int *, UChar *, UChar *, Int, Int);
Void(*BlockDCT8x8wSub)(Int *, Int *, UChar *, UChar *, Int, Int);
};
/*************************************************************/
/* QP structure */
/*************************************************************/
struct QPstruct
{
Int QPx2 ;
Int QP;
Int QPdiv2;
Int QPx2plus;
Int Addition;
};
#endif /* _MP4LIB_INT_H_ */
|