1 /*!
2 *************************************************************************************
3 * \file rdoq_cavlc.c
4 *
5 * \brief
6 * Rate Distortion Optimized Quantization based on VCEG-AH21 related to CAVLC
7 *************************************************************************************
8 */
9
10 #include "contributors.h"
11
12 #include <math.h>
13 #include <float.h>
14
15 #include "global.h"
16 #include "image.h"
17 #include "fmo.h"
18 #include "macroblock.h"
19 #include "mb_access.h"
20 #include "rdoq.h"
21 #include "block.h"
22
23 /*!
24 ************************************************************************
25 * \brief
26 * estimate VLC for Coeff Level
27 ************************************************************************
28 */
estSyntaxElement_Level_VLC1(SyntaxElement * se)29 int estSyntaxElement_Level_VLC1(SyntaxElement *se)
30 {
31 int level = se->value1;
32 int sign = (level < 0 ? 1 : 0);
33 int levabs = iabs(level);
34
35 if (levabs < 8)
36 {
37 se->len = levabs * 2 + sign - 1;
38 }
39 else if (levabs < 16)
40 {
41 // escape code1
42 se->len = 19;
43 }
44 else
45 {
46 // escape code2
47 se->len = 28;
48 }
49
50 return (se->len);
51 }
52
53
54
55 /*!
56 ************************************************************************
57 * \brief
58 * estimate VLC for Coeff Level
59 ************************************************************************
60 */
estSyntaxElement_Level_VLCN(SyntaxElement * se,int vlc)61 int estSyntaxElement_Level_VLCN(SyntaxElement *se, int vlc)//, DataPartition *this_dataPart)
62 {
63 int level = se->value1;
64 int levabs = iabs(level) - 1;
65
66 int shift = vlc - 1;
67 int escape = (15 << shift);
68
69 if (levabs < escape)
70 {
71 se->len = ((levabs) >> shift) + 1 + vlc;
72 }
73 else
74 {
75 se->len = 28;
76 }
77
78 return (se->len);
79 }
80
cmp(const void * arg1,const void * arg2)81 int cmp(const void *arg1, const void *arg2)
82 {
83 if(((levelDataStruct *)arg2)->levelDouble != ((levelDataStruct *)arg1)->levelDouble)
84 return (((levelDataStruct *)arg2)->levelDouble - ((levelDataStruct *)arg1)->levelDouble);
85 else
86 return (((levelDataStruct *)arg1)->coeff_ctr - ((levelDataStruct *)arg2)->coeff_ctr);
87 }
88
89 /*!
90 ************************************************************************
91 * \brief
92 * estimate CAVLC bits
93 ************************************************************************
94 */
est_CAVLC_bits(VideoParameters * p_Vid,int level_to_enc[16],int sign_to_enc[16],int nnz,int block_type)95 int est_CAVLC_bits (VideoParameters *p_Vid, int level_to_enc[16], int sign_to_enc[16], int nnz, int block_type)
96 {
97 int no_bits = 0;
98 SyntaxElement se;
99
100 int coeff_ctr, scan_pos = 0;
101 int k, level = 1, run = -1, vlcnum;
102 int numcoeff = 0, lastcoeff = 0, numtrailingones = 0;
103 int numones = 0, totzeros = 0, zerosleft, numcoef;
104 int numcoeff_vlc;
105 int level_two_or_higher;
106 int max_coeff_num = 0, cdc = (block_type == CHROMA_DC ? 1 : 0);
107 int yuv = p_Vid->yuv_format - 1;
108 static const int incVlc[] = {0, 3, 6, 12, 24, 48, 32768}; // maximum vlc = 6
109
110 int pLevel[16] = {0};
111 int pRun[16] = {0};
112
113 static const int Token_lentab[3][4][17] =
114 {
115 {
116 { 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
117 { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
118 { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
119 { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}
120 },
121 {
122 { 2, 6, 6, 7, 8, 8, 9,11,11,12,12,12,13,13,13,14,14},
123 { 0, 2, 5, 6, 6, 7, 8, 9,11,11,12,12,13,13,14,14,14},
124 { 0, 0, 3, 6, 6, 7, 8, 9,11,11,12,12,13,13,13,14,14},
125 { 0, 0, 0, 4, 4, 5, 6, 6, 7, 9,11,11,12,13,13,13,14}
126 },
127 {
128 { 4, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 9,10,10,10,10},
129 { 0, 4, 5, 5, 5, 5, 6, 6, 7, 8, 8, 9, 9, 9,10,10,10},
130 { 0, 0, 4, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,10,10,10},
131 { 0, 0, 0, 4, 4, 4, 4, 4, 5, 6, 7, 8, 8, 9,10,10,10}
132 }
133 };
134
135 static const int Totalzeros_lentab[TOTRUN_NUM][16] =
136 {
137 { 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
138 { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
139 { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
140 { 5,3,4,4,3,3,3,4,3,4,5,5,5},
141 { 4,4,4,3,3,3,3,3,4,5,4,5},
142 { 6,5,3,3,3,3,3,3,4,3,6},
143 { 6,5,3,3,3,2,3,4,3,6},
144 { 6,4,5,3,2,2,3,3,6},
145 { 6,6,4,2,2,3,2,5},
146 { 5,5,3,2,2,2,4},
147 { 4,4,3,3,1,3},
148 { 4,4,2,1,3},
149 { 3,3,1,2},
150 { 2,2,1},
151 { 1,1},
152 };
153 static const int Run_lentab[TOTRUN_NUM][16] =
154 {
155 {1,1},
156 {1,2,2},
157 {2,2,2,2},
158 {2,2,2,3,3},
159 {2,2,3,3,3,3},
160 {2,3,3,3,3,3,3},
161 {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
162 };
163 static const int Token_lentab_cdc[3][4][17] =
164 {
165 //YUV420
166 {{ 2, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
167 { 0, 1, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
168 { 0, 0, 3, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
169 { 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
170 //YUV422
171 {{ 1, 7, 7, 9, 9,10,11,12,13, 0, 0, 0, 0, 0, 0, 0, 0},
172 { 0, 2, 7, 7, 9,10,11,12,12, 0, 0, 0, 0, 0, 0, 0, 0},
173 { 0, 0, 3, 7, 7, 9,10,11,12, 0, 0, 0, 0, 0, 0, 0, 0},
174 { 0, 0, 0, 5, 6, 7, 7,10,11, 0, 0, 0, 0, 0, 0, 0, 0}},
175 //YUV444
176 {{ 1, 6, 8, 9,10,11,13,13,13,14,14,15,15,16,16,16,16},
177 { 0, 2, 6, 8, 9,10,11,13,13,14,14,15,15,15,16,16,16},
178 { 0, 0, 3, 7, 8, 9,10,11,13,13,14,14,15,15,16,16,16},
179 { 0, 0, 0, 5, 6, 7, 8, 9,10,11,13,14,14,15,15,16,16}}
180 };
181 static const int Totalzeros_lentab_cdc[3][TOTRUN_NUM][16] =
182 {
183 //YUV420
184 {{ 1,2,3,3},
185 { 1,2,2},
186 { 1,1}},
187 //YUV422
188 {{ 1,3,3,4,4,4,5,5},
189 { 3,2,3,3,3,3,3},
190 { 3,3,2,2,3,3},
191 { 3,2,2,2,3},
192 { 2,2,2,2},
193 { 2,2,1},
194 { 1,1}},
195 //YUV444
196 {{ 1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
197 { 3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
198 { 4,3,3,3,4,4,3,3,4,5,5,6,5,6},
199 { 5,3,4,4,3,3,3,4,3,4,5,5,5},
200 { 4,4,4,3,3,3,3,3,4,5,4,5},
201 { 6,5,3,3,3,3,3,3,4,3,6},
202 { 6,5,3,3,3,2,3,4,3,6},
203 { 6,4,5,3,2,2,3,3,6},
204 { 6,6,4,2,2,3,2,5},
205 { 5,5,3,2,2,2,4},
206 { 4,4,3,3,1,3},
207 { 4,4,2,1,3},
208 { 3,3,1,2},
209 { 2,2,1},
210 { 1,1}}
211 };
212
213 max_coeff_num = ( (block_type == CHROMA_DC) ? p_Vid->num_cdc_coeff :
214 ( (block_type == LUMA_INTRA16x16AC || block_type == CB_INTRA16x16AC || block_type == CR_INTRA16x16AC || block_type == CHROMA_AC) ? 15 : 16) );
215
216 //convert zigzag scan to (run, level) pairs
217 for (coeff_ctr = 0; coeff_ctr < max_coeff_num; coeff_ctr++)
218 {
219 run++;
220 level = level_to_enc[coeff_ctr];
221 if (level != 0)
222 {
223 pLevel[scan_pos] = isignab(level, sign_to_enc[coeff_ctr]);
224 pRun [scan_pos] = run;
225 ++scan_pos;
226 run = -1; // reset zero level counter
227 }
228 }
229
230 level = 1;
231 for(k = 0; (k < max_coeff_num) && level != 0; k++)
232 {
233 level = pLevel[k]; // level
234 run = pRun[k]; // run
235
236 if (level)
237 {
238 totzeros += run; // lets add run always (even if zero) to avoid conditional
239 if (iabs(level) == 1)
240 {
241 numones ++;
242 numtrailingones ++;
243 numtrailingones = imin(numtrailingones, 3); // clip to 3
244 }
245 else
246 {
247 numtrailingones = 0;
248 }
249 numcoeff ++;
250 lastcoeff = k;
251 }
252 }
253
254 if (!cdc)
255 {
256 numcoeff_vlc = (nnz < 2) ? 0 : ((nnz < 4) ? 1 : ((nnz < 8) ? 2 : 3));
257 }
258 else
259 {
260 // chroma DC (has its own VLC)
261 // numcoeff_vlc not relevant
262 numcoeff_vlc = 0;
263 }
264
265 se.value1 = numcoeff;
266 se.value2 = numtrailingones;
267 se.len = numcoeff_vlc; /* use len to pass vlcnum */
268
269 if (!cdc)
270 {
271 if (se.len == 3)
272 no_bits += 6; // 4 + 2 bit FLC
273 else
274 no_bits += Token_lentab[se.len][se.value2][se.value1];
275 }
276 else
277 no_bits += Token_lentab_cdc[yuv][se.value2][se.value1];
278
279 if (!numcoeff)
280 return no_bits;
281 else
282 {
283 if (numtrailingones)
284 no_bits += numtrailingones;
285
286 // encode levels
287 level_two_or_higher = (numcoeff > 3 && numtrailingones == 3) ? 0 : 1;
288
289 vlcnum = (numcoeff > 10 && numtrailingones < 3) ? 1 : 0;
290
291 for (k = lastcoeff - numtrailingones; k >= 0; k--)
292 {
293 level = pLevel[k]; // level
294
295 se.value1 = level;
296
297 if (level_two_or_higher)
298 {
299 level_two_or_higher = 0;
300 if (se.value1 > 0)
301 se.value1 --;
302 else
303 se.value1 ++;
304 }
305
306 // encode level
307 if (vlcnum == 0)
308 estSyntaxElement_Level_VLC1(&se);
309 else
310 estSyntaxElement_Level_VLCN(&se, vlcnum);
311
312 // update VLC table
313 if (iabs(level) > incVlc[vlcnum])
314 vlcnum++;
315
316 if ((k == lastcoeff - numtrailingones) && iabs(level) > 3)
317 vlcnum = 2;
318
319 no_bits += se.len;
320 }
321
322 // encode total zeroes
323 if (numcoeff < max_coeff_num)
324 {
325 se.value1 = totzeros;
326
327 vlcnum = numcoeff-1;
328
329 se.len = vlcnum;
330
331 if (!cdc)
332 no_bits += Totalzeros_lentab[se.len][se.value1];
333 else
334 no_bits += Totalzeros_lentab_cdc[yuv][se.len][se.value1];
335 }
336
337 // encode run before each coefficient
338 zerosleft = totzeros;
339 numcoef = numcoeff;
340 for (k = lastcoeff; k >= 0; k--)
341 {
342 run = pRun[k]; // run
343
344 se.value1 = run;
345
346 // for last coeff, run is remaining totzeros
347 // when zerosleft is zero, remaining coeffs have 0 run
348 if ((!zerosleft) || (numcoeff <= 1 ))
349 break;
350
351 if (numcoef > 1 && zerosleft)
352 {
353 vlcnum = imin(zerosleft - 1, RUNBEFORE_NUM_M1);
354 se.len = vlcnum;
355 no_bits += Run_lentab[se.len][se.value1];
356 zerosleft -= run;
357 numcoef --;
358 }
359 }
360 }
361
362 return no_bits;
363 }
364
365
366 /*!
367 ****************************************************************************
368 * \brief
369 * estimate run and level for CAVLC
370 ****************************************************************************
371 */
est_RunLevel_CAVLC(Macroblock * currMB,levelDataStruct * levelData,int * levelTrellis,int block_type,int b8,int b4,int coeff_num,double lambda)372 void est_RunLevel_CAVLC(Macroblock *currMB, levelDataStruct *levelData, int *levelTrellis, int block_type,
373 int b8, int b4, int coeff_num, double lambda)
374 {
375 int k, lastnonzero = -1, coeff_ctr;
376 int level_to_enc[16] = {0}, sign_to_enc[16] = {0};
377 int cstat, bestcstat = 0;
378 int nz_coeff=0;
379 double lagr, lagrAcc = 0, minlagr = 0;
380 VideoParameters *p_Vid = currMB->p_Vid;
381
382 int subblock_x = ((b8 & 0x1) == 0) ? (((b4 & 0x1) == 0) ? 0 : 1) : (((b4 & 0x1) == 0) ? 2 : 3);
383 // horiz. position for coeff_count context
384 int subblock_y = (b8 < 2) ? ((b4 < 2) ? 0 : 1) :((b4 < 2) ? 2 : 3);
385 // vert. position for coeff_count context
386 int nnz;
387 levelDataStruct *dataLevel = &levelData[0];
388
389 if (block_type != CHROMA_AC)
390 nnz = predict_nnz(currMB, LUMA, subblock_x, subblock_y);
391 else
392 nnz = predict_nnz_chroma(currMB, currMB->subblock_x >> 2, (currMB->subblock_y >> 2) + 4);
393
394 for (coeff_ctr=0;coeff_ctr < coeff_num;coeff_ctr++)
395 {
396 levelTrellis[coeff_ctr] = 0;
397
398 for(k=0; k < dataLevel->noLevels; k++)
399 {
400 dataLevel->errLevel[k] /= 32768;
401 }
402
403 lagrAcc += dataLevel->errLevel[imax(0, dataLevel->noLevels - 1)];
404
405 level_to_enc[coeff_ctr] = dataLevel->pre_level;
406 sign_to_enc[coeff_ctr] = dataLevel->sign;
407
408 if(dataLevel->noLevels > 1)
409 {
410 dataLevel->coeff_ctr = coeff_ctr;
411 lastnonzero = coeff_ctr;
412 }
413 else
414 dataLevel->coeff_ctr = -1;
415 dataLevel++;
416 }
417
418 if(lastnonzero != -1)
419 {
420 //sort the coefficients based on their absolute value
421 qsort(levelData, lastnonzero + 1, sizeof(levelDataStruct), cmp);
422 dataLevel = &levelData[lastnonzero];
423
424 for(coeff_ctr = lastnonzero; coeff_ctr >= 0; coeff_ctr--) // go over all coeff
425 {
426 if(dataLevel->noLevels == 1)
427 {
428 dataLevel--;
429 continue;
430 }
431
432 lagrAcc -= dataLevel->errLevel[dataLevel->noLevels-1];
433 for(cstat=0; cstat<dataLevel->noLevels; cstat++) // go over all states of cur coeff k
434 {
435 level_to_enc[dataLevel->coeff_ctr] = dataLevel->level[cstat];
436 lagr = lagrAcc + dataLevel->errLevel[cstat];
437 lagr += lambda * est_CAVLC_bits( p_Vid, level_to_enc, sign_to_enc, nnz, block_type);
438 if(cstat==0 || lagr<minlagr)
439 {
440 minlagr = lagr;
441 bestcstat = cstat;
442 }
443 }
444
445 lagrAcc += dataLevel->errLevel[bestcstat];
446 level_to_enc[dataLevel->coeff_ctr] = dataLevel->level[bestcstat];
447 dataLevel--;
448 }
449
450 for(coeff_ctr = 0; coeff_ctr <= lastnonzero; coeff_ctr++)
451 {
452 levelTrellis[coeff_ctr] = level_to_enc[coeff_ctr];
453 if (level_to_enc[coeff_ctr] != 0)
454 nz_coeff++;
455 }
456 }
457
458 p_Vid->nz_coeff [p_Vid->current_mb_nr ][subblock_x][subblock_y] = nz_coeff;
459 }
460
461 /*!
462 ****************************************************************************
463 * \brief
464 * Initialize levelData
465 ****************************************************************************
466 */
init_trellis_data_4x4_CAVLC(Macroblock * currMB,int ** tblock,int block_x,int qp_per,int qp_rem,LevelQuantParams ** q_params,const byte * p_scan,levelDataStruct * dataLevel,int type)467 void init_trellis_data_4x4_CAVLC(Macroblock *currMB, int **tblock, int block_x, int qp_per, int qp_rem, LevelQuantParams **q_params,
468 const byte *p_scan, levelDataStruct *dataLevel, int type)
469 {
470 Slice *currSlice = currMB->p_Slice;
471 int i, j, coeff_ctr;
472 int *m7;
473 int end_coeff_ctr = ( ( type == LUMA_4x4 ) ? 16 : 15 );
474 int q_bits = Q_BITS + qp_per;
475 int q_offset = ( 1 << (q_bits - 1) );
476 int scaled_coeff, level, lowerInt, k;
477 double err, estErr;
478
479
480 for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
481 {
482 i = *p_scan++; // horizontal position
483 j = *p_scan++; // vertical position
484
485 m7 = &tblock[j][block_x + i];
486
487 if (*m7 == 0)
488 {
489 dataLevel->levelDouble = 0;
490 dataLevel->level[0] = 0;
491 dataLevel->noLevels = 1;
492 err = 0.0;
493 dataLevel->errLevel[0] = 0.0;
494 dataLevel->pre_level = 0;
495 dataLevel->sign = 0;
496 }
497 else
498 {
499 estErr = ((double) estErr4x4[qp_rem][j][i]) / currSlice->norm_factor_4x4;
500
501 scaled_coeff = iabs(*m7) * q_params[j][i].ScaleComp;
502 dataLevel->levelDouble = scaled_coeff;
503 level = (scaled_coeff >> q_bits);
504
505 lowerInt = ((scaled_coeff - (level << q_bits)) < q_offset )? 1 : 0;
506
507 dataLevel->level[0] = 0;
508 if (level == 0 && lowerInt == 1)
509 {
510 dataLevel->noLevels = 1;
511 }
512 else if (level == 0 && lowerInt == 0)
513 {
514 dataLevel->level[1] = 1;
515 dataLevel->noLevels = 2;
516 }
517 else if (level > 0 && lowerInt == 1)
518 {
519 dataLevel->level[1] = level;
520 dataLevel->noLevels = 2;
521 }
522 else
523 {
524 dataLevel->level[1] = level;
525 dataLevel->level[2] = level + 1;
526 dataLevel->noLevels = 3;
527 }
528
529 for (k = 0; k < dataLevel->noLevels; k++)
530 {
531 err = (double)(dataLevel->level[k] << q_bits) - (double)scaled_coeff;
532 dataLevel->errLevel[k] = (err * err * estErr);
533 }
534
535 if(dataLevel->noLevels == 1)
536 dataLevel->pre_level = 0;
537 else
538 dataLevel->pre_level = (iabs (*m7) * q_params[j][i].ScaleComp + q_params[j][i].OffsetComp) >> q_bits;
539 dataLevel->sign = isign(*m7);
540 }
541 dataLevel++;
542 }
543 }
544
545 /*!
546 ****************************************************************************
547 * \brief
548 * Initialize levelData for Luma DC
549 ****************************************************************************
550 */
init_trellis_data_DC_CAVLC(Macroblock * currMB,int ** tblock,int qp_per,int qp_rem,LevelQuantParams * q_params,const byte * p_scan,levelDataStruct * dataLevel)551 void init_trellis_data_DC_CAVLC(Macroblock *currMB, int **tblock, int qp_per, int qp_rem,
552 LevelQuantParams *q_params, const byte *p_scan,
553 levelDataStruct *dataLevel)
554 {
555 Slice *currSlice = currMB->p_Slice;
556 int i, j, coeff_ctr, end_coeff_ctr = 16;
557 int q_bits = Q_BITS + qp_per + 1;
558 int q_offset = ( 1 << (q_bits - 1) );
559 int scaled_coeff, level, lowerInt, k;
560 int *m7;
561 double err, estErr = (double) estErr4x4[qp_rem][0][0] / currSlice->norm_factor_4x4; // note that we could also use int64
562
563 for (coeff_ctr = 0; coeff_ctr < end_coeff_ctr; coeff_ctr++)
564 {
565 i = *p_scan++; // horizontal position
566 j = *p_scan++; // vertical position
567 m7 = &tblock[j][i];
568
569 if (*m7 == 0)
570 {
571 dataLevel->levelDouble = 0;
572 dataLevel->level[0] = 0;
573 dataLevel->noLevels = 1;
574 err = 0.0;
575 dataLevel->errLevel[0] = 0.0;
576 dataLevel->pre_level = 0;
577 dataLevel->sign = 0;
578 }
579 else
580 {
581 scaled_coeff = iabs(*m7) * q_params->ScaleComp;
582 dataLevel->levelDouble = scaled_coeff;
583 level = (scaled_coeff >> q_bits);
584
585 lowerInt=( (scaled_coeff - (level<<q_bits)) < q_offset )? 1 : 0;
586
587 dataLevel->level[0] = 0;
588 if (level == 0 && lowerInt == 1)
589 {
590 dataLevel->noLevels = 1;
591 }
592 else if (level == 0 && lowerInt == 0)
593 {
594 dataLevel->level[1] = 1;
595 dataLevel->noLevels = 2;
596 }
597 else if (level > 0 && lowerInt == 1)
598 {
599 dataLevel->level[1] = level;
600 dataLevel->noLevels = 2;
601 }
602 else
603 {
604 dataLevel->level[1] = level;
605 dataLevel->level[2] = level + 1;
606 dataLevel->noLevels = 3;
607 }
608
609 for (k = 0; k < dataLevel->noLevels; k++)
610 {
611 err = (double)(dataLevel->level[k] << q_bits) - (double)scaled_coeff;
612 dataLevel->errLevel[k] = (err * err * estErr);
613 }
614
615 if(dataLevel->noLevels == 1)
616 dataLevel->pre_level = 0;
617 else
618 dataLevel->pre_level = (iabs (*m7) * q_params->ScaleComp + q_params->OffsetComp) >> q_bits;
619 dataLevel->sign = isign(*m7);
620 }
621 dataLevel++;
622 }
623 }
624
625 /*!
626 ****************************************************************************
627 * \brief
628 * Initialize levelData
629 ****************************************************************************
630 */
init_trellis_data_8x8_CAVLC(Macroblock * currMB,int ** tblock,int block_x,int qp_per,int qp_rem,LevelQuantParams ** q_params,const byte * p_scan,levelDataStruct levelData[4][16])631 void init_trellis_data_8x8_CAVLC(Macroblock *currMB, int **tblock, int block_x, int qp_per, int qp_rem, LevelQuantParams **q_params,
632 const byte *p_scan, levelDataStruct levelData[4][16])
633 {
634 Slice *currSlice = currMB->p_Slice;
635 int i, j, block, coeff_ctr;
636 int *m7;
637 int q_bits = Q_BITS_8 + qp_per;
638 int q_offset = ( 1 << (q_bits - 1) );
639 double err, estErr;
640 int scaled_coeff, level, lowerInt, k;
641
642 levelDataStruct *dataLevel = &levelData[0][0];
643
644 for (coeff_ctr = 0; coeff_ctr < 16; coeff_ctr++)
645 {
646 for (block = 0; block < 4; block++)
647 {
648 i = *p_scan++; // horizontal position
649 j = *p_scan++; // vertical position
650
651 m7 = &tblock[j][block_x + i];
652
653 dataLevel = &levelData[block][coeff_ctr];
654 if (*m7 == 0)
655 {
656 dataLevel->levelDouble = 0;
657 dataLevel->level[0] = 0;
658 dataLevel->noLevels = 1;
659 err = 0.0;
660 dataLevel->errLevel[0] = 0.0;
661 dataLevel->pre_level = 0;
662 dataLevel->sign = 0;
663 }
664 else
665 {
666 estErr = (double) estErr8x8[qp_rem][j][i] / currSlice->norm_factor_8x8;
667
668 scaled_coeff = iabs(*m7) * q_params[j][i].ScaleComp;
669 dataLevel->levelDouble = scaled_coeff;
670 level = (scaled_coeff >> q_bits);
671
672 lowerInt = ((scaled_coeff - (level << q_bits)) < q_offset ) ? 1 : 0;
673
674 dataLevel->level[0] = 0;
675 if (level == 0 && lowerInt == 1)
676 {
677 dataLevel->noLevels = 1;
678 }
679 else if (level == 0 && lowerInt == 0)
680 {
681 dataLevel->level[1] = 1;
682 dataLevel->noLevels = 2;
683 }
684 else if (level > 0 && lowerInt == 1)
685 {
686 if (level > 1)
687 {
688 dataLevel->level[1] = level - 1;
689 dataLevel->level[2] = level;
690 dataLevel->noLevels = 3;
691 }
692 else
693 {
694 dataLevel->level[1] = level;
695 dataLevel->noLevels = 2;
696 }
697 }
698 else
699 {
700 dataLevel->level[1] = level;
701 dataLevel->level[2] = level + 1;
702 dataLevel->noLevels = 3;
703 }
704
705 for (k = 0; k < dataLevel->noLevels; k++)
706 {
707 err = (double)(dataLevel->level[k] << q_bits) - (double)scaled_coeff;
708 dataLevel->errLevel[k] = err * err * estErr;
709 }
710
711 if(dataLevel->noLevels == 1)
712 dataLevel->pre_level = 0;
713 else
714 dataLevel->pre_level = (iabs (*m7) * q_params[j][i].ScaleComp + q_params[j][i].OffsetComp) >> q_bits;
715 dataLevel->sign = isign(*m7);
716 }
717 }
718 }
719 }
720
721
722