OpenCores
URL https://opencores.org/ocsvn/bluespec-h264/bluespec-h264/trunk

Subversion Repositories bluespec-h264

[/] [bluespec-h264/] [trunk/] [test/] [decoder/] [ldecod/] [src/] [block.c] - Blame information for rev 100

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 jamey.hick 
 
2 
/*!
3 
 ***********************************************************************
4 
 *  \file
5 
 *      block.c
6 
 *
7 
 *  \brief
8 
 *      Block functions
9 
 *
10 
 *  \author
11 
 *      Main contributors (see contributors.h for copyright, address and affiliation details)
12 
 *      - Inge Lille-Langoy          <inge.lille-langoy@telenor.com>
13 
 *      - Rickard Sjoberg            <rickard.sjoberg@era.ericsson.se>
14 
 ***********************************************************************
15 
 */
16 
 
17 
#include "contributors.h"
18 
 
19 
#include <stdlib.h>
20 
#include <string.h>
21 
 
22 
#include "global.h"
23 
#include "block.h"
24 
#include "image.h"
25 
#include "mb_access.h"
26 
 
27 
 
28 
#define Q_BITS          15
29 
 
30 
static const int quant_coef[6][4][4] = {
31 
  {{13107, 8066,13107, 8066},{ 8066, 5243, 8066, 5243},{13107, 8066,13107, 8066},{ 8066, 5243, 8066, 5243}},
32 
  {{11916, 7490,11916, 7490},{ 7490, 4660, 7490, 4660},{11916, 7490,11916, 7490},{ 7490, 4660, 7490, 4660}},
33 
  {{10082, 6554,10082, 6554},{ 6554, 4194, 6554, 4194},{10082, 6554,10082, 6554},{ 6554, 4194, 6554, 4194}},
34 
  {{ 9362, 5825, 9362, 5825},{ 5825, 3647, 5825, 3647},{ 9362, 5825, 9362, 5825},{ 5825, 3647, 5825, 3647}},
35 
  {{ 8192, 5243, 8192, 5243},{ 5243, 3355, 5243, 3355},{ 8192, 5243, 8192, 5243},{ 5243, 3355, 5243, 3355}},
36 
  {{ 7282, 4559, 7282, 4559},{ 4559, 2893, 4559, 2893},{ 7282, 4559, 7282, 4559},{ 4559, 2893, 4559, 2893}}
37 
};
38 
static const int A[4][4] = {
39 
  { 16, 20, 16, 20},
40 
  { 20, 25, 20, 25},
41 
  { 16, 20, 16, 20},
42 
  { 20, 25, 20, 25}
43 
};
44 
 
45 
int quant_intra_default[16] = {
46 
 6,13,20,28,
47 
13,20,28,32,
48 
20,28,32,37,
49 
28,32,37,42
50 
};
51 
 
52 
int quant_inter_default[16] = {
53 
10,14,20,24,
54 
14,20,24,27,
55 
20,24,27,30,
56 
24,27,30,34
57 
};
58 
 
59 
int quant8_intra_default[64] = {
60 
 6,10,13,16,18,23,25,27,
61 
10,11,16,18,23,25,27,29,
62 
13,16,18,23,25,27,29,31,
63 
16,18,23,25,27,29,31,33,
64 
18,23,25,27,29,31,33,36,
65 
23,25,27,29,31,33,36,38,
66 
25,27,29,31,33,36,38,40,
67 
27,29,31,33,36,38,40,42
68 
};
69 
 
70 
int quant8_inter_default[64] = {
71 
 9,13,15,17,19,21,22,24,
72 
13,13,17,19,21,22,24,25,
73 
15,17,19,21,22,24,25,27,
74 
17,19,21,22,24,25,27,28,
75 
19,21,22,24,25,27,28,30,
76 
21,22,24,25,27,28,30,32,
77 
22,24,25,27,28,30,32,33,
78 
24,25,27,28,30,32,33,35
79 
};
80 
 
81 
int quant_org[16] = { //to be use if no q matrix is chosen
82 
16,16,16,16,
83 
16,16,16,16,
84 
16,16,16,16,
85 
16,16,16,16
86 
};
87 
 
88 
int quant8_org[64] = { //to be use if no q matrix is chosen
89 
16,16,16,16,16,16,16,16,
90 
16,16,16,16,16,16,16,16,
91 
16,16,16,16,16,16,16,16,
92 
16,16,16,16,16,16,16,16,
93 
16,16,16,16,16,16,16,16,
94 
16,16,16,16,16,16,16,16,
95 
16,16,16,16,16,16,16,16,
96 
16,16,16,16,16,16,16,16
97 
};
98 
 
99 
// Notation for comments regarding prediction and predictors.
100 
// The pels of the 4x4 block are labelled a..p. The predictor pels above
101 
// are labelled A..H, from the left I..L, and from above left X, as follows:
102 
//
103 
//  X A B C D E F G H
104 
//  I a b c d
105 
//  J e f g h
106 
//  K i j k l
107 
//  L m n o p
108 
//
109 
 
110 
// Predictor array index definitions
111 
#define P_X (PredPel[0])
112 
#define P_A (PredPel[1])
113 
#define P_B (PredPel[2])
114 
#define P_C (PredPel[3])
115 
#define P_D (PredPel[4])
116 
#define P_E (PredPel[5])
117 
#define P_F (PredPel[6])
118 
#define P_G (PredPel[7])
119 
#define P_H (PredPel[8])
120 
#define P_I (PredPel[9])
121 
#define P_J (PredPel[10])
122 
#define P_K (PredPel[11])
123 
#define P_L (PredPel[12])
124 
 
125 
/*!
126 
 ***********************************************************************
127 
 * \brief
128 
 *    makes and returns 4x4 blocks with all 5 intra prediction modes
129 
 *
130 
 * \return
131 
 *    DECODING_OK   decoding of intraprediction mode was sucessfull            \n
132 
 *    SEARCH_SYNC   search next sync element as errors while decoding occured
133 
 ***********************************************************************
134 
 */
135 
 
136 
int intrapred( struct img_par *img,  //!< image parameters
137 
               int ioff,             //!< pixel offset X within MB
138 
               int joff,             //!< pixel offset Y within MB
139 
               int img_block_x,      //!< location of block X, multiples of 4
140 
               int img_block_y)      //!< location of block Y, multiples of 4
141 
{
142 
  int i,j;
143 
  int s0;
144 
  int img_y,img_x;
145 
  imgpel PredPel[13];  // array of predictor pels
146 
 
147 
  imgpel **imgY = dec_picture->imgY;
148 
 
149 
  PixelPos pix_a[4];
150 
  PixelPos pix_b, pix_c, pix_d;
151 
 
152 
  int block_available_up;
153 
  int block_available_left;
154 
  int block_available_up_left;
155 
  int block_available_up_right;
156 
 
157 
  int mb_nr=img->current_mb_nr;
158 
 
159 
  byte predmode = img->ipredmode[img_block_y][img_block_x];
160 
  int jpos0 = joff, jpos1 = joff + 1, jpos2 = joff + 2, jpos3 = joff + 3;
161 
  int ipos0 = ioff, ipos1 = ioff + 1, ipos2 = ioff + 2, ipos3 = ioff + 3;
162 
 
163 
 
164 
  img_x=img_block_x*4;
165 
  img_y=img_block_y*4;
166 
 
167 
  for (i=0;i<4;i++)
168 
  {
169 
    getNeighbour(mb_nr, ioff -1 , joff +i , IS_LUMA, &pix_a[i]);
170 
  }
171 
 
172 
  getNeighbour(mb_nr, ioff    , joff -1 , IS_LUMA, &pix_b);
173 
  getNeighbour(mb_nr, ioff +4 , joff -1 , IS_LUMA, &pix_c);
174 
  getNeighbour(mb_nr, ioff -1 , joff -1 , IS_LUMA, &pix_d);
175 
 
176 
  pix_c.available = pix_c.available && !((ioff==4) && ((joff==4)||(joff==12)));
177 
 
178 
  if (active_pps->constrained_intra_pred_flag)
179 
  {
180 
    for (i=0, block_available_left=1; i<4;i++)
181 
      block_available_left  &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
182 
    block_available_up       = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
183 
    block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
184 
    block_available_up_left  = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
185 
  }
186 
  else
187 
  {
188 
    block_available_left     = pix_a[0].available;
189 
    block_available_up       = pix_b.available;
190 
    block_available_up_right = pix_c.available;
191 
    block_available_up_left  = pix_d.available;
192 
  }
193 
 
194 
  // form predictor pels
195 
  if (block_available_up)
196 
  {
197 
    P_A = imgY[pix_b.pos_y][pix_b.pos_x+0];
198 
    P_B = imgY[pix_b.pos_y][pix_b.pos_x+1];
199 
    P_C = imgY[pix_b.pos_y][pix_b.pos_x+2];
200 
    P_D = imgY[pix_b.pos_y][pix_b.pos_x+3];
201 
 
202 
  }
203 
  else
204 
  {
205 
    P_A = P_B = P_C = P_D = img->dc_pred_value_luma;
206 
  }
207 
 
208 
  if (block_available_up_right)
209 
  {
210 
    P_E = imgY[pix_c.pos_y][pix_c.pos_x+0];
211 
    P_F = imgY[pix_c.pos_y][pix_c.pos_x+1];
212 
    P_G = imgY[pix_c.pos_y][pix_c.pos_x+2];
213 
    P_H = imgY[pix_c.pos_y][pix_c.pos_x+3];
214 
  }
215 
  else
216 
  {
217 
    P_E = P_F = P_G = P_H = P_D;
218 
  }
219 
 
220 
  if (block_available_left)
221 
  {
222 
    P_I = imgY[pix_a[0].pos_y][pix_a[0].pos_x];
223 
    P_J = imgY[pix_a[1].pos_y][pix_a[1].pos_x];
224 
    P_K = imgY[pix_a[2].pos_y][pix_a[2].pos_x];
225 
    P_L = imgY[pix_a[3].pos_y][pix_a[3].pos_x];
226 
  }
227 
  else
228 
  {
229 
    P_I = P_J = P_K = P_L = img->dc_pred_value_luma;
230 
  }
231 
 
232 
  if (block_available_up_left)
233 
  {
234 
    P_X = imgY[pix_d.pos_y][pix_d.pos_x];
235 
  }
236 
  else
237 
  {
238 
    P_X = img->dc_pred_value_luma;
239 
  }
240 
 
241 
 
242 
  switch (predmode)
243 
  {
244 
  case DC_PRED:                         /* DC prediction */
245 
 
246 
    s0 = 0;
247 
    if (block_available_up && block_available_left)
248 
    {
249 
      // no edge
250 
      s0 = (P_A + P_B + P_C + P_D + P_I + P_J + P_K + P_L + 4)/(2*BLOCK_SIZE);
251 
    }
252 
    else if (!block_available_up && block_available_left)
253 
    {
254 
      // upper edge
255 
      s0 = (P_I + P_J + P_K + P_L + 2)/BLOCK_SIZE;
256 
    }
257 
    else if (block_available_up && !block_available_left)
258 
    {
259 
      // left edge
260 
      s0 = (P_A + P_B + P_C + P_D + 2)/BLOCK_SIZE;
261 
    }
262 
    else //if (!block_available_up && !block_available_left)
263 
    {
264 
      // top left corner, nothing to predict from
265 
      s0 = img->dc_pred_value_luma;
266 
    }
267 
 
268 
    for (j=0; j < BLOCK_SIZE; j++)
269 
    {
270 
      for (i=0; i < BLOCK_SIZE; i++)
271 
      {
272 
        // store DC prediction
273 
        img->mpr[j+joff][i+ioff] = (imgpel) s0;
274 
      }
275 
    }
276 
    break;
277 
 
278 
  case VERT_PRED:                       /* vertical prediction from block above */
279 
    if (!block_available_up)
280 
      printf ("warning: Intra_4x4_Vertical prediction mode not allowed at mb %d\n", (int) img->current_mb_nr);
281 
 
282 
    for(j=0;j<BLOCK_SIZE;j++)
283 
      for(i=0;i<BLOCK_SIZE;i++)
284 
        img->mpr[j+joff][i+ioff]=imgY[pix_b.pos_y][pix_b.pos_x+i];/* store predicted 4x4 block */
285 
    break;
286 
 
287 
  case HOR_PRED:                        /* horizontal prediction from left block */
288 
    if (!block_available_left)
289 
      printf ("warning: Intra_4x4_Horizontal prediction mode not allowed at mb %d\n",(int) img->current_mb_nr);
290 
 
291 
    for(j=0;j<BLOCK_SIZE;j++)
292 
      for(i=0;i<BLOCK_SIZE;i++)
293 
        img->mpr[j+joff][i+ioff]=imgY[pix_a[j].pos_y][pix_a[j].pos_x]; /* store predicted 4x4 block */
294 
    break;
295 
 
296 
  case DIAG_DOWN_RIGHT_PRED:
297 
    if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
298 
      printf ("warning: Intra_4x4_Diagonal_Down_Right prediction mode not allowed at mb %d\n",(int) img->current_mb_nr);
299 
 
300 
    img->mpr[jpos3][ipos0] = (imgpel) ((P_L + 2*P_K + P_J + 2) >> 2);
301 
    img->mpr[jpos2][ipos0] =
302 
    img->mpr[jpos3][ipos1] = (imgpel) ((P_K + 2*P_J + P_I + 2) >> 2);
303 
    img->mpr[jpos1][ipos0] =
304 
    img->mpr[jpos2][ipos1] =
305 
    img->mpr[jpos3][ipos2] = (imgpel) ((P_J + 2*P_I + P_X + 2) >> 2);
306 
    img->mpr[jpos0][ipos0] =
307 
    img->mpr[jpos1][ipos1] =
308 
    img->mpr[jpos2][ipos2] =
309 
    img->mpr[jpos3][ipos3] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
310 
    img->mpr[jpos0][ipos1] =
311 
    img->mpr[jpos1][ipos2] =
312 
    img->mpr[jpos2][ipos3] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
313 
    img->mpr[jpos0][ipos2] =
314 
    img->mpr[jpos1][ipos3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
315 
    img->mpr[jpos0][ipos3] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
316 
    break;
317 
 
318 
  case DIAG_DOWN_LEFT_PRED:
319 
    if (!block_available_up)
320 
      printf ("warning: Intra_4x4_Diagonal_Down_Left prediction mode not allowed at mb %d\n",img->current_mb_nr);
321 
 
322 
    img->mpr[jpos0][ipos0] = (imgpel) ((P_A + P_C + 2*(P_B) + 2) >> 2);
323 
    img->mpr[jpos0][ipos1] =
324 
    img->mpr[jpos1][ipos0] = (imgpel) ((P_B + P_D + 2*(P_C) + 2) >> 2);
325 
    img->mpr[jpos0][ipos2] =
326 
    img->mpr[jpos1][ipos1] =
327 
    img->mpr[jpos2][ipos0] = (imgpel) ((P_C + P_E + 2*(P_D) + 2) >> 2);
328 
    img->mpr[jpos0][ipos3] =
329 
    img->mpr[jpos1][ipos2] =
330 
    img->mpr[jpos2][ipos1] =
331 
    img->mpr[jpos3][ipos0] = (imgpel) ((P_D + P_F + 2*(P_E) + 2) >> 2);
332 
    img->mpr[jpos1][ipos3] =
333 
    img->mpr[jpos2][ipos2] =
334 
    img->mpr[jpos3][ipos1] = (imgpel) ((P_E + P_G + 2*(P_F) + 2) >> 2);
335 
    img->mpr[jpos2][ipos3] =
336 
    img->mpr[jpos3][ipos2] = (imgpel) ((P_F + P_H + 2*(P_G) + 2) >> 2);
337 
    img->mpr[jpos3][ipos3] = (imgpel) ((P_G + 3*(P_H) + 2) >> 2);
338 
    break;
339 
 
340 
  case  VERT_RIGHT_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
341 
    if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
342 
      printf ("warning: Intra_4x4_Vertical_Right prediction mode not allowed at mb %d\n",img->current_mb_nr);
343 
 
344 
    img->mpr[jpos0][ipos0] =
345 
    img->mpr[jpos2][ipos1] = (imgpel) ((P_X + P_A + 1) >> 1);
346 
    img->mpr[jpos0][ipos1] =
347 
    img->mpr[jpos2][ipos2] = (imgpel) ((P_A + P_B + 1) >> 1);
348 
    img->mpr[jpos0][ipos2] =
349 
    img->mpr[jpos2][ipos3] = (imgpel) ((P_B + P_C + 1) >> 1);
350 
    img->mpr[jpos0][ipos3] = (imgpel) ((P_C + P_D + 1) >> 1);
351 
    img->mpr[jpos1][ipos0] =
352 
    img->mpr[jpos3][ipos1] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
353 
    img->mpr[jpos1][ipos1] =
354 
    img->mpr[jpos3][ipos2] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
355 
    img->mpr[jpos1][ipos2] =
356 
    img->mpr[jpos3][ipos3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
357 
    img->mpr[jpos1][ipos3] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
358 
    img->mpr[jpos2][ipos0] = (imgpel) ((P_X + 2*P_I + P_J + 2) >> 2);
359 
    img->mpr[jpos3][ipos0] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
360 
    break;
361 
 
362 
  case  VERT_LEFT_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
363 
    if (!block_available_up)
364 
      printf ("warning: Intra_4x4_Vertical_Left prediction mode not allowed at mb %d\n",img->current_mb_nr);
365 
 
366 
    img->mpr[jpos0][ipos0] = (imgpel) ((P_A + P_B + 1) >> 1);
367 
    img->mpr[jpos0][ipos1] =
368 
    img->mpr[jpos2][ipos0] = (imgpel) ((P_B + P_C + 1) >> 1);
369 
    img->mpr[jpos0][ipos2] =
370 
    img->mpr[jpos2][ipos1] = (imgpel) ((P_C + P_D + 1) >> 1);
371 
    img->mpr[jpos0][ipos3] =
372 
    img->mpr[jpos2][ipos2] = (imgpel) ((P_D + P_E + 1) >> 1);
373 
    img->mpr[jpos2][ipos3] = (imgpel) ((P_E + P_F + 1) >> 1);
374 
    img->mpr[jpos1][ipos0] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
375 
    img->mpr[jpos1][ipos1] =
376 
    img->mpr[jpos3][ipos0] = (imgpel) ((P_B + 2*P_C + P_D + 2) >> 2);
377 
    img->mpr[jpos1][ipos2] =
378 
    img->mpr[jpos3][ipos1] = (imgpel) ((P_C + 2*P_D + P_E + 2) >> 2);
379 
    img->mpr[jpos1][ipos3] =
380 
    img->mpr[jpos3][ipos2] = (imgpel) ((P_D + 2*P_E + P_F + 2) >> 2);
381 
    img->mpr[jpos3][ipos3] = (imgpel) ((P_E + 2*P_F + P_G + 2) >> 2);
382 
    break;
383 
 
384 
  case  HOR_UP_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
385 
    if (!block_available_left)
386 
      printf ("warning: Intra_4x4_Horizontal_Up prediction mode not allowed at mb %d\n",img->current_mb_nr);
387 
 
388 
    img->mpr[jpos0][ipos0] = (imgpel) ((P_I + P_J + 1) >> 1);
389 
    img->mpr[jpos0][ipos1] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
390 
    img->mpr[jpos0][ipos2] =
391 
    img->mpr[jpos1][ipos0] = (imgpel) ((P_J + P_K + 1) >> 1);
392 
    img->mpr[jpos0][ipos3] =
393 
    img->mpr[jpos1][ipos1] = (imgpel) ((P_J + 2*P_K + P_L + 2) >> 2);
394 
    img->mpr[jpos1][ipos2] =
395 
    img->mpr[jpos2][ipos0] = (imgpel) ((P_K + P_L + 1) >> 1);
396 
    img->mpr[jpos1][ipos3] =
397 
    img->mpr[jpos2][ipos1] = (imgpel) ((P_K + 2*P_L + P_L + 2) >> 2);
398 
    img->mpr[jpos2][ipos3] =
399 
    img->mpr[jpos3][ipos1] =
400 
    img->mpr[jpos3][ipos0] =
401 
    img->mpr[jpos2][ipos2] =
402 
    img->mpr[jpos3][ipos2] =
403 
    img->mpr[jpos3][ipos3] = (imgpel) P_L;
404 
    break;
405 
 
406 
  case  HOR_DOWN_PRED:/* diagonal prediction -22.5 deg to horizontal plane */
407 
    if ((!block_available_up)||(!block_available_left)||(!block_available_up_left))
408 
      printf ("warning: Intra_4x4_Horizontal_Down prediction mode not allowed at mb %d\n",img->current_mb_nr);
409 
 
410 
    img->mpr[jpos0][ipos0] =
411 
    img->mpr[jpos1][ipos2] = (imgpel) ((P_X + P_I + 1) >> 1);
412 
    img->mpr[jpos0][ipos1] =
413 
    img->mpr[jpos1][ipos3] = (imgpel) ((P_I + 2*P_X + P_A + 2) >> 2);
414 
    img->mpr[jpos0][ipos2] = (imgpel) ((P_X + 2*P_A + P_B + 2) >> 2);
415 
    img->mpr[jpos0][ipos3] = (imgpel) ((P_A + 2*P_B + P_C + 2) >> 2);
416 
    img->mpr[jpos1][ipos0] =
417 
    img->mpr[jpos2][ipos2] = (imgpel) ((P_I + P_J + 1) >> 1);
418 
    img->mpr[jpos1][ipos1] =
419 
    img->mpr[jpos2][ipos3] = (imgpel) ((P_X + 2*P_I + P_J + 2) >> 2);
420 
    img->mpr[jpos2][ipos0] =
421 
    img->mpr[jpos3][ipos2] = (imgpel) ((P_J + P_K + 1) >> 1);
422 
    img->mpr[jpos2][ipos1] =
423 
    img->mpr[jpos3][ipos3] = (imgpel) ((P_I + 2*P_J + P_K + 2) >> 2);
424 
    img->mpr[jpos3][ipos0] = (imgpel) ((P_K + P_L + 1) >> 1);
425 
    img->mpr[jpos3][ipos1] = (imgpel) ((P_J + 2*P_K + P_L + 2) >> 2);
426 
    break;
427 
 
428 
  default:
429 
    printf("Error: illegal intra_4x4 prediction mode: %d\n",predmode);
430 
    return SEARCH_SYNC;
431 
    break;
432 
  }
433 
 
434 
  return DECODING_OK;
435 
}
436 
 
437 
 
438 
/*!
439 
 ***********************************************************************
440 
 * \return
441 
 *    best SAD
442 
 ***********************************************************************
443 
 */
444 
int intrapred_luma_16x16(struct img_par *img, //!< image parameters
445 
                         int predmode)        //!< prediction mode
446 
{
447 
  int s0=0,s1,s2;
448 
 
449 
  int i,j;
450 
 
451 
  int ih,iv;
452 
  int ib,ic,iaa;
453 
 
454 
  imgpel **imgY=dec_picture->imgY;
455 
 
456 
  int mb_nr=img->current_mb_nr;
457 
 
458 
  PixelPos up;          //!< pixel position p(0,-1)
459 
  PixelPos left[17];    //!< pixel positions p(-1, -1..15)
460 
 
461 
  int up_avail, left_avail, left_up_avail;
462 
 
463 
  s1=s2=0;
464 
 
465 
  for (i=0;i<17;i++)
466 
  {
467 
    getNeighbour(mb_nr, -1 ,  i-1 , IS_LUMA, &left[i]);
468 
  }
469 
  getNeighbour(mb_nr, 0     ,  -1 , IS_LUMA, &up);
470 
 
471 
  if (!active_pps->constrained_intra_pred_flag)
472 
  {
473 
    up_avail   = up.available;
474 
    left_avail = left[1].available;
475 
    left_up_avail = left[0].available;
476 
  }
477 
  else
478 
  {
479 
    up_avail      = up.available ? img->intra_block[up.mb_addr] : 0;
480 
    for (i=1, left_avail=1; i<17;i++)
481 
      left_avail  &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
482 
    left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
483 
  }
484 
 
485 
  switch (predmode)
486 
  {
487 
  case VERT_PRED_16:                       // vertical prediction from block above
488 
    if (!up_avail)
489 
      error ("invalid 16x16 intra pred Mode VERT_PRED_16",500);
490 
    for(j=0;j<MB_BLOCK_SIZE;j++)
491 
      for(i=0;i<MB_BLOCK_SIZE;i++)
492 
        img->mpr[j][i]=imgY[up.pos_y][up.pos_x+i];// store predicted 16x16 block
493 
    break;
494 
 
495 
  case HOR_PRED_16:                        // horizontal prediction from left block
496 
    if (!left_avail)
497 
      error ("invalid 16x16 intra pred Mode HOR_PRED_16",500);
498 
    for(j=0;j<MB_BLOCK_SIZE;j++)
499 
      for(i=0;i<MB_BLOCK_SIZE;i++)
500 
        img->mpr[j][i]=imgY[left[j+1].pos_y][left[j+1].pos_x]; // store predicted 16x16 block
501 
    break;
502 
 
503 
  case DC_PRED_16:                         // DC prediction
504 
    s1=s2=0;
505 
    for (i=0; i < MB_BLOCK_SIZE; i++)
506 
    {
507 
      if (up_avail)
508 
        s1 += imgY[up.pos_y][up.pos_x+i];    // sum hor pix
509 
      if (left_avail)
510 
        s2 += imgY[left[i+1].pos_y][left[i+1].pos_x];    // sum vert pix
511 
    }
512 
    if (up_avail && left_avail)
513 
      s0=(s1+s2+16)>>5;       // no edge
514 
    if (!up_avail && left_avail)
515 
      s0=(s2+8)>>4;              // upper edge
516 
    if (up_avail && !left_avail)
517 
      s0=(s1+8)>>4;              // left edge
518 
    if (!up_avail && !left_avail)
519 
      s0=img->dc_pred_value_luma;                            // top left corner, nothing to predict from
520 
    for(i=0;i<MB_BLOCK_SIZE;i++)
521 
      for(j=0;j<MB_BLOCK_SIZE;j++)
522 
      {
523 
        img->mpr[j][i]=(imgpel) s0;
524 
      }
525 
    break;
526 
  case PLANE_16:// 16 bit integer plan pred
527 
    if (!up_avail || !left_up_avail  || !left_avail)
528 
      error ("invalid 16x16 intra pred Mode PLANE_16",500);
529 
 
530 
    ih=0;
531 
    iv=0;
532 
    for (i=1;i<9;i++)
533 
    {
534 
      if (i<8)
535 
        ih += i*(imgY[up.pos_y][up.pos_x+7+i] - imgY[up.pos_y][up.pos_x+7-i]);
536 
      else
537 
        ih += i*(imgY[up.pos_y][up.pos_x+7+i] - imgY[left[0].pos_y][left[0].pos_x]);
538 
 
539 
      iv += i*(imgY[left[8+i].pos_y][left[8+i].pos_x] - imgY[left[8-i].pos_y][left[8-i].pos_x]);
540 
    }
541 
    ib=(5*ih+32)>>6;
542 
    ic=(5*iv+32)>>6;
543 
 
544 
    iaa=16*(imgY[up.pos_y][up.pos_x+15]+imgY[left[16].pos_y][left[16].pos_x]);
545 
    for (j=0;j< MB_BLOCK_SIZE;j++)
546 
    {
547 
      for (i=0;i< MB_BLOCK_SIZE;i++)
548 
      {
549 
        img->mpr[j][i]=(imgpel) iClip1(img->max_imgpel_value,((iaa+(i-7)*ib +(j-7)*ic + 16)>>5));
550 
      }
551 
    }// store plane prediction
552 
    break;
553 
 
554 
  default:
555 
    {                                    // indication of fault in bitstream,exit
556 
      printf("illegal 16x16 intra prediction mode input: %d\n",predmode);
557 
      return SEARCH_SYNC;
558 
    }
559 
  }
560 
 
561 
  return DECODING_OK;
562 
}
563 
 
564 
 
565 
void intrapred_chroma(struct img_par *img, int uv)
566 
{
567 
  int i,j, ii, jj, ioff, joff;
568 
 
569 
  imgpel ***imgUV = dec_picture->imgUV;
570 
 
571 
  int js[4][4];
572 
 
573 
  int pred;
574 
  int ih, iv, ib, ic, iaa;
575 
 
576 
  int      b8, b4;
577 
  int      yuv = dec_picture->chroma_format_idc - 1;
578 
  int      blk_x, blk_y;
579 
  int      block_pos[3][4][4]= //[yuv][b8][b4]
580 
  {
581 
    { {0, 1, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0},{0, 0, 0, 0}},
582 
    { {0, 1, 2, 3},{2, 3, 2, 3},{0, 0, 0, 0},{0, 0, 0, 0}},
583 
    { {0, 1, 2, 3},{1, 1, 3, 3},{2, 3, 2, 3},{3, 3, 3, 3}}
584 
  };
585 
  int      s0, s1, s2, s3;
586 
 
587 
  int mb_nr=img->current_mb_nr;
588 
  Macroblock *currMB = &img->mb_data[img->current_mb_nr];
589 
 
590 
  PixelPos up;        //!< pixel position  p(0,-1)
591 
  PixelPos left[17];  //!< pixel positions p(-1, -1..16)
592 
 
593 
  int up_avail, left_avail[2], left_up_avail;
594 
 
595 
  int cr_MB_x = img->mb_cr_size_x;
596 
  int cr_MB_y = img->mb_cr_size_y;
597 
 
598 
  for (i=0;i<cr_MB_y+1;i++)
599 
  {
600 
    getNeighbour(mb_nr, -1, i-1, IS_CHROMA, &left[i]);
601 
  }
602 
 
603 
  getNeighbour(mb_nr, 0, -1, IS_CHROMA, &up);
604 
 
605 
  if (!active_pps->constrained_intra_pred_flag)
606 
  {
607 
    up_avail      = up.available;
608 
    left_avail[0] = left_avail[1] = left[1].available;
609 
    left_up_avail = left[0].available;
610 
  }
611 
  else
612 
  {
613 
    up_avail = up.available ? img->intra_block[up.mb_addr] : 0;
614 
    for (i=0, left_avail[0]=1; i<cr_MB_y/2;i++)
615 
      left_avail[0]  &= left[i+1].available ? img->intra_block[left[i+1].mb_addr]: 0;
616 
    for (i=cr_MB_y/2, left_avail[1]=1; i<cr_MB_y;i++)
617 
      left_avail[1]  &= left[i+1].available ? img->intra_block[left[i+1].mb_addr]: 0;
618 
    left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
619 
  }
620 
 
621 
 
622 
  if (currMB->c_ipred_mode == DC_PRED_8)
623 
  {
624 
    // DC prediction
625 
    for(b8=0; b8<img->num_blk8x8_uv/2;b8++)
626 
    {
627 
      for (b4=0; b4<4; b4++)
628 
      {
629 
        blk_y = subblk_offset_y[yuv][b8][b4] + 1;
630 
        blk_x = subblk_offset_x[yuv][b8][b4];
631 
 
632 
        s0=s1=s2=s3=0;
633 
        js[b8][b4]=img->dc_pred_value_chroma;
634 
 
635 
        //===== get prediction value =====
636 
        switch (block_pos[yuv][b8][b4])
637 
        {
638 
        case 0:  //===== TOP LEFT =====
639 
          if      (up_avail)       for (i=blk_x;i<(blk_x+4);i++)  s0 += imgUV[uv][up.pos_y][up.pos_x + i];
640 
          if      (left_avail[0])  for (i=blk_y;i<(blk_y+4);i++)  s2 += imgUV[uv][left[i].pos_y][left[i].pos_x];
641 
          if      (up_avail && left_avail[0])         js[b8][b4]  = (s0+s2+4) >> 3;
642 
          else if (up_avail)                          js[b8][b4]  = (s0   +2) >> 2;
643 
          else if (left_avail[0])                     js[b8][b4]  = (s2   +2) >> 2;
644 
          break;
645 
        case 1: //===== TOP RIGHT =====
646 
          if      (up_avail)       for (i=blk_x;i<(blk_x+4);i++)  s1 += imgUV[uv][up.pos_y][up.pos_x + i];
647 
          else if (left_avail[0])  for (i=blk_y;i<(blk_y+4);i++)  s2 += imgUV[uv][left[i].pos_y][left[i].pos_x];
648 
          if      (up_avail)                          js[b8][b4]  = (s1   +2) >> 2;
649 
          else if (left_avail[0])                     js[b8][b4]  = (s2   +2) >> 2;
650 
          break;
651 
        case 2: //===== BOTTOM LEFT =====
652 
          if      (left_avail[1])  for (i=blk_y;i<(blk_y+4);i++)  s3 += imgUV[uv][left[i].pos_y][left[i].pos_x];
653 
          else if (up_avail)       for (i=blk_x;i<(blk_x+4);i++)  s0 += imgUV[uv][up.pos_y][up.pos_x + i];
654 
          if      (left_avail[1])                     js[b8][b4]  = (s3   +2) >> 2;
655 
          else if (up_avail)                          js[b8][b4]  = (s0   +2) >> 2;
656 
          break;
657 
        case 3: //===== BOTTOM RIGHT =====
658 
          if      (up_avail)       for (i=blk_x;i<(blk_x+4);i++)  s1 += imgUV[uv][up.pos_y][up.pos_x + i];
659 
          if      (left_avail[1])  for (i=blk_y;i<(blk_y+4);i++)  s3 += imgUV[uv][left[i].pos_y][left[i].pos_x];
660 
          if      (up_avail && left_avail[1])         js[b8][b4]  = (s1+s3+4) >> 3;
661 
          else if (up_avail)                          js[b8][b4]  = (s1   +2) >> 2;
662 
          else if (left_avail[1])                     js[b8][b4]  = (s3   +2) >> 2;
663 
          break;
664 
        }
665 
      }
666 
    }
667 
  }
668 
  if (PLANE_8 == currMB->c_ipred_mode)
669 
  {
670 
    // plane prediction
671 
    if (!left_up_avail || !left_avail[0] || !left_avail[1] || !up_avail)
672 
      error("unexpected PLANE_8 chroma intra prediction mode",-1);
673 
 
674 
    ih = cr_MB_x/2*(imgUV[uv][up.pos_y][up.pos_x+cr_MB_x-1] - imgUV[uv][left[0].pos_y][left[0].pos_x]);
675 
    for (i=0;i<cr_MB_x/2-1;i++)
676 
      ih += (i+1)*(imgUV[uv][up.pos_y][up.pos_x+cr_MB_x/2  +i] -
677 
      imgUV[uv][up.pos_y][up.pos_x+cr_MB_x/2-2-i]);
678 
 
679 
    iv = cr_MB_y/2*(imgUV[uv][left[cr_MB_y].pos_y][left[cr_MB_y].pos_x] - imgUV[uv][left[0].pos_y][left[0].pos_x]);
680 
    for (i=0;i<cr_MB_y/2-1;i++)
681 
      iv += (i+1)*(imgUV[uv][left[cr_MB_y/2+1+i].pos_y][left[cr_MB_y/2+1+i].pos_x] -
682 
      imgUV[uv][left[cr_MB_y/2-1-i].pos_y][left[cr_MB_y/2-1-i].pos_x]);
683 
 
684 
    ib= ((cr_MB_x == 8?17:5)*ih+2*cr_MB_x)>>(cr_MB_x == 8?5:6);
685 
    ic= ((cr_MB_y == 8?17:5)*iv+2*cr_MB_y)>>(cr_MB_y == 8?5:6);
686 
 
687 
    iaa=16*(imgUV[uv][left[cr_MB_y].pos_y][left[cr_MB_y].pos_x] +
688 
            imgUV[uv][up.pos_y][up.pos_x+cr_MB_x-1]);
689 
 
690 
    for (j=0; j<cr_MB_y; j++)
691 
      for (i=0; i<cr_MB_x; i++)
692 
        img->mpr[j][i]=(imgpel) iClip1(img->max_imgpel_value_uv,((iaa+(i-cr_MB_x/2+1)*ib+(j-cr_MB_y/2+1)*ic+16)>>5));
693 
  }
694 
  else
695 
  {
696 
    switch (currMB->c_ipred_mode)
697 
    {
698 
    case DC_PRED_8:
699 
      for (b8=0;b8<img->num_blk8x8_uv/2;b8++)
700 
      {
701 
        for (b4=0;b4<4;b4++)
702 
        {
703 
          joff = subblk_offset_y[yuv][b8][b4];
704 
          ioff = subblk_offset_x[yuv][b8][b4];
705 
          for (jj=joff; jj<joff + BLOCK_SIZE; jj++)
706 
          for (ii=ioff; ii<ioff + BLOCK_SIZE; ii++)
707 
          {
708 
            img->mpr[jj][ii]=(imgpel) js[b8][b4];
709 
          }
710 
        }
711 
      }
712 
      break;
713 
    case HOR_PRED_8:
714 
      if (!left_avail[0] || !left_avail[1])
715 
        error("unexpected HOR_PRED_8 chroma intra prediction mode",-1);
716 
 
717 
      for (j=0;j<2;j++)
718 
      {
719 
        joff=j*cr_MB_y/2;
720 
        for(i=0;i<2;i++)
721 
        {
722 
          ioff=i*cr_MB_x/2;
723 
          for (jj=joff; jj<joff + cr_MB_y/2; jj++)
724 
          {
725 
            pred = imgUV[uv][left[1+jj].pos_y][left[1+jj].pos_x];
726 
            for (ii=ioff; ii<ioff + cr_MB_x/2; ii++)
727 
              img->mpr[jj][ii]=(imgpel) pred;
728 
          }
729 
        }
730 
      }
731 
      break;
732 
    case VERT_PRED_8:
733 
      if (!up_avail)
734 
        error("unexpected VERT_PRED_8 chroma intra prediction mode",-1);
735 
 
736 
      for (j=0;j<2;j++)
737 
      {
738 
        joff=j*cr_MB_y/2;
739 
        for(i=0;i<2;i++)
740 
        {
741 
          ioff=i*cr_MB_x/2;
742 
          for (ii=ioff; ii<ioff + cr_MB_x/2; ii++)
743 
          {
744 
            pred = imgUV[uv][up.pos_y][up.pos_x+ii];
745 
            for (jj=joff; jj<joff + cr_MB_y/2; jj++)
746 
              img->mpr[jj][ii]=(imgpel) pred;
747 
          }
748 
        }
749 
      }
750 
      break;
751 
    default:
752 
      error("illegal chroma intra prediction mode", 600);
753 
      break;
754 
    }
755 
  }
756 
}
757 
 
758 
/*!
759 
 ***********************************************************************
760 
 * \brief
761 
 *    Inverse 4x4 transformation, transforms cof to m7
762 
 ***********************************************************************
763 
 */
764 
void itrans(struct img_par *img, //!< image parameters
765 
            int ioff,            //!< index to 4x4 block
766 
            int joff,            //!<
767 
            int i0,              //!<
768 
            int j0,
769 
            int chroma)
770 
{
771 
  int i,j;
772 
  int m5[4];
773 
  int m6[4];
774 
 
775 
  Boolean lossless_qpprime = (Boolean) ((img->qp + img->bitdepth_luma_qp_scale)==0 && img->lossless_qpprime_flag==1);
776 
  int max_imgpel_value = chroma ? img->max_imgpel_value_uv : img->max_imgpel_value;
777 
 
778 
  if (!lossless_qpprime)
779 
  {
780 
    // horizontal
781 
    for (j=0;j<BLOCK_SIZE;j++)
782 
    {
783 
      memcpy(&m5[0],&img->cof[i0][j0][j][0], BLOCK_SIZE * sizeof(int));
784 
 
785 
      m6[0] =  m5[0] + m5[2];
786 
      m6[1] =  m5[0] - m5[2];
787 
      m6[2] = (m5[1] >> 1) - m5[3];
788 
      m6[3] =  m5[1] + (m5[3] >> 1);
789 
 
790 
      img->m7[j][0] = m6[0] + m6[3];
791 
      img->m7[j][3] = m6[0] - m6[3];
792 
      img->m7[j][1] = m6[1] + m6[2];
793 
      img->m7[j][2] = m6[1] - m6[2];
794 
    }
795 
    // vertical
796 
    for (i=0;i<BLOCK_SIZE;i++)
797 
    {
798 
      int ipos = i+ioff;
799 
 
800 
      m5[0]=img->m7[0][i];
801 
      m5[1]=img->m7[1][i];
802 
      m5[2]=img->m7[2][i];
803 
      m5[3]=img->m7[3][i];
804 
 
805 
      m6[0] =  m5[0] + m5[2];
806 
      m6[1] =  m5[0] - m5[2];
807 
      m6[2] = (m5[1]>>1) - m5[3];
808 
      m6[3] =  m5[1] + (m5[3]>>1);
809 
 
810 
      img->m7[0][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m6[0] + m6[3] + ((long)img->mpr[    joff][ipos] << DQ_BITS)), DQ_BITS));
811 
      img->m7[1][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m6[1] + m6[2] + ((long)img->mpr[1 + joff][ipos] << DQ_BITS)), DQ_BITS));
812 
      img->m7[2][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m6[1] - m6[2] + ((long)img->mpr[2 + joff][ipos] << DQ_BITS)), DQ_BITS));
813 
      img->m7[3][i] = iClip1(max_imgpel_value, rshift_rnd_sf((m6[0] - m6[3] + ((long)img->mpr[3 + joff][ipos] << DQ_BITS)), DQ_BITS));
814 
    }
815 
  }
816 
  else
817 
  {
818 
      for (j=0;j<BLOCK_SIZE;j++)
819 
        for (i=0;i<BLOCK_SIZE ;i++)
820 
        img->m7[j][i] = iClip1(max_imgpel_value, (img->cof[i0][j0][j][i]+(long)img->mpr[j+joff][i+ioff]));
821 
  }
822 
}
823 
 
824 
/*!
825 
 ************************************************************************
826 
 * \brief
827 
 *    For mapping the q-matrix to the active id and calculate quantisation values
828 
 *
829 
 * \param pps
830 
 *    Picture parameter set
831 
 * \param sps
832 
 *    Sequence parameter set
833 
 *
834 
 ************************************************************************
835 
 */
836 
void AssignQuantParam(pic_parameter_set_rbsp_t* pps, seq_parameter_set_rbsp_t* sps)
837 
{
838 
  int i;
839 
 
840 
  if(!pps->pic_scaling_matrix_present_flag && !sps->seq_scaling_matrix_present_flag)
841 
  {
842 
    for(i=0; i<8; i++)
843 
      qmatrix[i] = (i<6) ? quant_org:quant8_org;
844 
  }
845 
  else
846 
  {
847 
    if(sps->seq_scaling_matrix_present_flag) // check sps first
848 
    {
849 
      for(i=0; i<8; i++)
850 
      {
851 
        if(i<6)
852 
        {
853 
          if(!sps->seq_scaling_list_present_flag[i]) // fall-back rule A
854 
          {
855 
            if((i==0) || (i==3))
856 
              qmatrix[i] = (i==0) ? quant_intra_default:quant_inter_default;
857 
            else
858 
              qmatrix[i] = qmatrix[i-1];
859 
          }
860 
          else
861 
          {
862 
            if(sps->UseDefaultScalingMatrix4x4Flag[i])
863 
              qmatrix[i] = (i<3) ? quant_intra_default:quant_inter_default;
864 
            else
865 
              qmatrix[i] = sps->ScalingList4x4[i];
866 
          }
867 
        }
868 
        else
869 
        {
870 
          if(!sps->seq_scaling_list_present_flag[i] || sps->UseDefaultScalingMatrix8x8Flag[i-6]) // fall-back rule A
871 
            qmatrix[i] = (i==6) ? quant8_intra_default:quant8_inter_default;
872 
          else
873 
            qmatrix[i] = sps->ScalingList8x8[i-6];
874 
        }
875 
      }
876 
    }
877 
 
878 
    if(pps->pic_scaling_matrix_present_flag) // then check pps
879 
    {
880 
      for(i=0; i<8; i++)
881 
      {
882 
        if(i<6)
883 
        {
884 
          if(!pps->pic_scaling_list_present_flag[i]) // fall-back rule B
885 
          {
886 
            if((i==0) || (i==3))
887 
            {
888 
              if(!sps->seq_scaling_matrix_present_flag)
889 
                qmatrix[i] = (i==0) ? quant_intra_default:quant_inter_default;
890 
            }
891 
            else
892 
              qmatrix[i] = qmatrix[i-1];
893 
          }
894 
          else
895 
          {
896 
            if(pps->UseDefaultScalingMatrix4x4Flag[i])
897 
              qmatrix[i] = (i<3) ? quant_intra_default:quant_inter_default;
898 
            else
899 
              qmatrix[i] = pps->ScalingList4x4[i];
900 
          }
901 
        }
902 
        else
903 
        {
904 
          if(!pps->pic_scaling_list_present_flag[i]) // fall-back rule B
905 
          {
906 
            if(!sps->seq_scaling_matrix_present_flag)
907 
              qmatrix[i] = (i==6) ? quant8_intra_default:quant8_inter_default;
908 
          }
909 
          else if(pps->UseDefaultScalingMatrix8x8Flag[i-6])
910 
            qmatrix[i] = (i==6) ? quant8_intra_default:quant8_inter_default;
911 
          else
912 
            qmatrix[i] = pps->ScalingList8x8[i-6];
913 
        }
914 
      }
915 
    }
916 
  }
917 
 
918 
  CalculateQuantParam();
919 
  if(pps->transform_8x8_mode_flag)
920 
    CalculateQuant8Param();
921 
}
922 
 
923 
/*!
924 
 ************************************************************************
925 
 * \brief
926 
 *    For calculating the quantisation values at frame level
927 
 *
928 
 ************************************************************************
929 
 */
930 
void CalculateQuantParam()
931 
{
932 
  int i, j, k, temp;
933 
 
934 
  for(k=0; k<6; k++)
935 
    for(j=0; j<4; j++)
936 
      for(i=0; i<4; i++)
937 
      {
938 
        temp = (i<<2)+j;
939 
        InvLevelScale4x4Luma_Intra[k][i][j]      = dequant_coef[k][j][i]*qmatrix[0][temp];
940 
        InvLevelScale4x4Chroma_Intra[0][k][i][j] = dequant_coef[k][j][i]*qmatrix[1][temp];
941 
        InvLevelScale4x4Chroma_Intra[1][k][i][j] = dequant_coef[k][j][i]*qmatrix[2][temp];
942 
 
943 
        InvLevelScale4x4Luma_Inter[k][i][j]      = dequant_coef[k][j][i]*qmatrix[3][temp];
944 
        InvLevelScale4x4Chroma_Inter[0][k][i][j] = dequant_coef[k][j][i]*qmatrix[4][temp];
945 
        InvLevelScale4x4Chroma_Inter[1][k][i][j] = dequant_coef[k][j][i]*qmatrix[5][temp];
946 
      }
947 
}
948 
 
949 
/*!
950 
 ***********************************************************************
951 
 * \brief
952 
 *    Luma DC inverse transform
953 
 ***********************************************************************
954 
 */
955 
void itrans_2(struct img_par *img) //!< image parameters
956 
{
957 
  int i,j;
958 
  int M5[4];
959 
  int M6[4];
960 
 
961 
  int qp_per = (img->qp + img->bitdepth_luma_qp_scale - MIN_QP)/6;
962 
  int qp_rem = (img->qp + img->bitdepth_luma_qp_scale - MIN_QP)%6;
963 
 
964 
  // horizontal
965 
  for (j=0;j<4;j++)
966 
  {
967 
    M5[0]=img->cof[0][j][0][0];
968 
    M5[1]=img->cof[1][j][0][0];
969 
    M5[2]=img->cof[2][j][0][0];
970 
    M5[3]=img->cof[3][j][0][0];
971 
 
972 
    M6[0]=M5[0]+M5[2];
973 
    M6[1]=M5[0]-M5[2];
974 
    M6[2]=M5[1]-M5[3];
975 
    M6[3]=M5[1]+M5[3];
976 
 
977 
    img->cof[0][j][0][0] = M6[0]+M6[3];
978 
    img->cof[1][j][0][0] = M6[1]+M6[2];
979 
    img->cof[2][j][0][0] = M6[1]-M6[2];
980 
    img->cof[3][j][0][0] = M6[0]-M6[3];
981 
  }
982 
 
983 
  // vertical
984 
  for (i=0;i<4;i++)
985 
  {
986 
    M5[0]=img->cof[i][0][0][0];
987 
    M5[1]=img->cof[i][1][0][0];
988 
    M5[2]=img->cof[i][2][0][0];
989 
    M5[3]=img->cof[i][3][0][0];
990 
 
991 
    M6[0]=M5[0]+M5[2];
992 
    M6[1]=M5[0]-M5[2];
993 
    M6[2]=M5[1]-M5[3];
994 
    M6[3]=M5[1]+M5[3];
995 
 
996 
    img->cof[i][0][0][0] = rshift_rnd((((M6[0]+M6[3])*InvLevelScale4x4Luma_Intra[qp_rem][0][0]) << qp_per), 6);
997 
    img->cof[i][1][0][0] = rshift_rnd((((M6[1]+M6[2])*InvLevelScale4x4Luma_Intra[qp_rem][0][0]) << qp_per), 6);
998 
    img->cof[i][2][0][0] = rshift_rnd((((M6[1]-M6[2])*InvLevelScale4x4Luma_Intra[qp_rem][0][0]) << qp_per), 6);
999 
    img->cof[i][3][0][0] = rshift_rnd((((M6[0]-M6[3])*InvLevelScale4x4Luma_Intra[qp_rem][0][0]) << qp_per), 6);
1000 
  }
1001 
}
1002 
 
1003 
 
1004 
void itrans_sp(struct img_par *img,  //!< image parameters
1005 
               int ioff,             //!< index to 4x4 block
1006 
               int joff,             //!<
1007 
               int i0,               //!<
1008 
               int j0)               //!<
1009 
{
1010 
  int i,j,i1,j1;
1011 
  int m5[4];
1012 
  int m6[4];
1013 
  int predicted_block[BLOCK_SIZE][BLOCK_SIZE],ilev;
1014 
 
1015 
  int qp_per = (img->qp-MIN_QP)/6;
1016 
  int qp_rem = (img->qp-MIN_QP)%6;
1017 
  int q_bits    = Q_BITS+qp_per;
1018 
 
1019 
  int qp_per_sp = (img->qpsp-MIN_QP)/6;
1020 
  int qp_rem_sp = (img->qpsp-MIN_QP)%6;
1021 
  int q_bits_sp = Q_BITS+qp_per_sp;
1022 
  int qp_const2 = (1<<q_bits_sp)/2;  //sp_pred
1023 
  if (img->type == SI_SLICE) //ES modified
1024 
  {
1025 
    qp_per = (img->qpsp-MIN_QP)/6;
1026 
    qp_rem = (img->qpsp-MIN_QP)%6;
1027 
    q_bits = Q_BITS+qp_per;
1028 
  }
1029 
 
1030 
  for (j=0; j< BLOCK_SIZE; j++)
1031 
  for (i=0; i< BLOCK_SIZE; i++)
1032 
      predicted_block[i][j]=img->mpr[j+joff][i+ioff];
1033 
  for (j=0; j < BLOCK_SIZE; j++)
1034 
  {
1035 
    for (i=0; i < 2; i++)
1036 
    {
1037 
      i1=3-i;
1038 
      m5[i]=predicted_block[i][j]+predicted_block[i1][j];
1039 
      m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
1040 
    }
1041 
    predicted_block[0][j]=(m5[0]+m5[1]);
1042 
    predicted_block[2][j]=(m5[0]-m5[1]);
1043 
    predicted_block[1][j]=m5[3]*2+m5[2];
1044 
    predicted_block[3][j]=m5[3]-m5[2]*2;
1045 
  }
1046 
 
1047 
  //  Vertival transform
1048 
 
1049 
  for (i=0; i < BLOCK_SIZE; i++)
1050 
  {
1051 
    for (j=0; j < 2; j++)
1052 
    {
1053 
      j1=3-j;
1054 
      m5[j]=predicted_block[i][j]+predicted_block[i][j1];
1055 
      m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
1056 
    }
1057 
    predicted_block[i][0]=(m5[0]+m5[1]);
1058 
    predicted_block[i][2]=(m5[0]-m5[1]);
1059 
    predicted_block[i][1]=m5[3]*2+m5[2];
1060 
    predicted_block[i][3]=m5[3]-m5[2]*2;
1061 
  }
1062 
 
1063 
  for (j=0;j<BLOCK_SIZE;j++)
1064 
  for (i=0;i<BLOCK_SIZE;i++)
1065 
  {
1066 
    // recovering coefficient since they are already dequantized earlier
1067 
    img->cof[i0][j0][j][i]=(img->cof[i0][j0][j][i] >> qp_per) / dequant_coef[qp_rem][i][j];
1068 
    if(img->sp_switch || img->type==SI_SLICE)  //M.W. patched for SI
1069 
    {
1070 
      ilev=(iabs(predicted_block[i][j]) * quant_coef[qp_rem_sp][i][j] + qp_const2) >> q_bits_sp; //ES added
1071 
      ilev= isignab(ilev,predicted_block[i][j])+ img->cof[i0][j0][j][i];                           //ES added
1072 
      img->cof[i0][j0][j][i] = isignab(iabs(ilev) * dequant_coef[qp_rem_sp][i][j] << qp_per_sp ,ilev) ; //ES added
1073 
    }                                                                                             //ES added
1074 
    else
1075 
    {                                                                                          //ES added
1076 
      ilev=((img->cof[i0][j0][j][i]*dequant_coef[qp_rem][i][j]*A[i][j]<< qp_per) >>6)+predicted_block[i][j] ;
1077 
      img->cof[i0][j0][j][i]=isignab((iabs(ilev) * quant_coef[qp_rem_sp][i][j] + qp_const2) >> q_bits_sp, ilev) * dequant_coef[qp_rem_sp][i][j] << qp_per_sp;
1078 
    }
1079 
  }
1080 
  // horizontal
1081 
  for (j=0;j<BLOCK_SIZE;j++)
1082 
  {
1083 
    for (i=0;i<BLOCK_SIZE;i++)
1084 
    {
1085 
      m5[i]=img->cof[i0][j0][j][i];
1086 
    }
1087 
    m6[0]=(m5[0]+m5[2]);
1088 
    m6[1]=(m5[0]-m5[2]);
1089 
    m6[2]=(m5[1]>>1)-m5[3];
1090 
    m6[3]=m5[1]+(m5[3]>>1);
1091 
 
1092 
    for (i=0;i<2;i++)
1093 
    {
1094 
      i1=3-i;
1095 
      img->m7[j][i]=m6[i]+m6[i1];
1096 
      img->m7[j][i1]=m6[i]-m6[i1];
1097 
    }
1098 
  }
1099 
  // vertical
1100 
  for (i=0;i<BLOCK_SIZE;i++)
1101 
  {
1102 
    for (j=0;j<BLOCK_SIZE;j++)
1103 
      m5[j]=img->m7[j][i];
1104 
 
1105 
    m6[0]=(m5[0]+m5[2]);
1106 
    m6[1]=(m5[0]-m5[2]);
1107 
    m6[2]=(m5[1]>>1)-m5[3];
1108 
    m6[3]=m5[1]+(m5[3]>>1);
1109 
 
1110 
    for (j=0;j<2;j++)
1111 
    {
1112 
      j1=3-j;
1113 
      img->m7[j][i] =iClip1(img->max_imgpel_value,rshift_rnd_sf((m6[j]+m6[j1]),DQ_BITS));
1114 
      img->m7[j1][i]=iClip1(img->max_imgpel_value,rshift_rnd_sf((m6[j]-m6[j1]),DQ_BITS));
1115 
    }
1116 
  }
1117 
}
1118 
 
1119 
/*!
1120 
 ***********************************************************************
1121 
 * \brief
1122 
 *    The routine performs transform,quantization,inverse transform, adds the diff.
1123 
 *    to the prediction and writes the result to the decoded luma frame. Includes the
1124 
 *    RD constrained quantization also.
1125 
 *
1126 
 * \par Input:
1127 
 *    block_x,block_y: Block position inside a macro block (0,4,8,12).
1128 
 *
1129 
 * \par Output:
1130 
 *    nonzero: 0 if no levels are nonzero.  1 if there are nonzero levels. \n
1131 
 *    coeff_cost: Counter for nonzero coefficients, used to discard expencive levels.
1132 
 ************************************************************************
1133 
 */
1134 
void copyblock_sp(struct img_par *img,int block_x,int block_y)
1135 
{
1136 
  int i,j,i1,j1,m5[4],m6[4];
1137 
 
1138 
  int predicted_block[BLOCK_SIZE][BLOCK_SIZE];
1139 
  int qp_per = (img->qpsp-MIN_QP)/6;
1140 
  int qp_rem = (img->qpsp-MIN_QP)%6;
1141 
  int q_bits    = Q_BITS+qp_per;
1142 
  int qp_const2=(1<<q_bits)/2;  //sp_pred
1143 
 
1144 
 
1145 
  //  Horizontal transform
1146 
  for (j=0; j< BLOCK_SIZE; j++)
1147 
  for (i=0; i< BLOCK_SIZE; i++)
1148 
    predicted_block[i][j]=img->mpr[j+block_y][i+block_x];
1149 
 
1150 
  for (j=0; j < BLOCK_SIZE; j++)
1151 
  {
1152 
    for (i=0; i < 2; i++)
1153 
    {
1154 
      i1=3-i;
1155 
      m5[i]=predicted_block[i][j]+predicted_block[i1][j];
1156 
      m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
1157 
    }
1158 
    predicted_block[0][j]=(m5[0]+m5[1]);
1159 
    predicted_block[2][j]=(m5[0]-m5[1]);
1160 
    predicted_block[1][j]=m5[3]*2+m5[2];
1161 
    predicted_block[3][j]=m5[3]-m5[2]*2;
1162 
  }
1163 
 
1164 
  //  Vertival transform
1165 
 
1166 
  for (i=0; i < BLOCK_SIZE; i++)
1167 
  {
1168 
    for (j=0; j < 2; j++)
1169 
    {
1170 
      j1=3-j;
1171 
      m5[j]=predicted_block[i][j]+predicted_block[i][j1];
1172 
      m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
1173 
    }
1174 
    predicted_block[i][0]=(m5[0]+m5[1]);
1175 
    predicted_block[i][2]=(m5[0]-m5[1]);
1176 
    predicted_block[i][1]=m5[3]*2+m5[2];
1177 
    predicted_block[i][3]=m5[3]-m5[2]*2;
1178 
  }
1179 
 
1180 
  // Quant
1181 
  for (j=0;j < BLOCK_SIZE; j++)
1182 
  for (i=0; i < BLOCK_SIZE; i++)
1183 
    img->m7[j][i]=isignab((iabs(predicted_block[i][j])* quant_coef[qp_rem][i][j]+qp_const2)>> q_bits,predicted_block[i][j])*dequant_coef[qp_rem][i][j]<<qp_per;
1184 
 
1185 
  //     IDCT.
1186 
  //     horizontal
1187 
 
1188 
  for (j=0;j<BLOCK_SIZE;j++)
1189 
  {
1190 
    for (i=0;i<BLOCK_SIZE;i++)
1191 
    {
1192 
      m5[i]=img->m7[j][i];
1193 
    }
1194 
    m6[0]=(m5[0]+m5[2]);
1195 
    m6[1]=(m5[0]-m5[2]);
1196 
    m6[2]=(m5[1]>>1)-m5[3];
1197 
    m6[3]=m5[1]+(m5[3]>>1);
1198 
 
1199 
    for (i=0;i<2;i++)
1200 
    {
1201 
      i1=3-i;
1202 
      img->m7[j][i]=m6[i]+m6[i1];
1203 
      img->m7[j][i1]=m6[i]-m6[i1];
1204 
    }
1205 
  }
1206 
  // vertical
1207 
  for (i=0;i<BLOCK_SIZE;i++)
1208 
  {
1209 
    for (j=0;j<BLOCK_SIZE;j++)
1210 
      m5[j]=img->m7[j][i];
1211 
 
1212 
    m6[0]=(m5[0]+m5[2]);
1213 
    m6[1]=(m5[0]-m5[2]);
1214 
    m6[2]=(m5[1]>>1)-m5[3];
1215 
    m6[3]=m5[1]+(m5[3]>>1);
1216 
 
1217 
    for (j=0;j<2;j++)
1218 
    {
1219 
      j1=3-j;
1220 
      img->m7[j][i] =iClip1(img->max_imgpel_value,rshift_rnd_sf((m6[j]+m6[j1]),DQ_BITS));
1221 
      img->m7[j1][i]=iClip1(img->max_imgpel_value,rshift_rnd_sf((m6[j]-m6[j1]),DQ_BITS));
1222 
    }
1223 
  }
1224 
 
1225 
  //  Decoded block moved to frame memory
1226 
 
1227 
  for (j=0; j < BLOCK_SIZE; j++)
1228 
    for (i=0; i < BLOCK_SIZE; i++)
1229 
      dec_picture->imgY[img->pix_y+block_y+j][img->pix_x+block_x+i]=(imgpel) img->m7[j][i];
1230 
 
1231 
}
1232 
 
1233 
void itrans_sp_chroma(struct img_par *img,int ll)
1234 
{
1235 
  int i,j,i1,j2,ilev,n2,n1,j1,mb_y;
1236 
  int m5[BLOCK_SIZE];
1237 
  int predicted_chroma_block[MB_BLOCK_SIZE/2][MB_BLOCK_SIZE/2],mp1[BLOCK_SIZE];
1238 
  int qp_per,qp_rem,q_bits;
1239 
  int qp_per_sp,qp_rem_sp,q_bits_sp,qp_const2;
1240 
 
1241 
  qp_per    = ((img->qp<0?img->qp:QP_SCALE_CR[img->qp])-MIN_QP)/6;
1242 
  qp_rem    = ((img->qp<0?img->qp:QP_SCALE_CR[img->qp])-MIN_QP)%6;
1243 
  q_bits    = Q_BITS+qp_per;
1244 
 
1245 
  qp_per_sp    = ((img->qpsp<0?img->qpsp:QP_SCALE_CR[img->qpsp])-MIN_QP)/6;
1246 
  qp_rem_sp    = ((img->qpsp<0?img->qpsp:QP_SCALE_CR[img->qpsp])-MIN_QP)%6;
1247 
  q_bits_sp    = Q_BITS+qp_per_sp;
1248 
  qp_const2=(1<<q_bits_sp)/2;  //sp_pred
1249 
 
1250 
  if (img->type == SI_SLICE)
1251 
  {
1252 
    qp_per    = ((img->qpsp < 0 ? img->qpsp : QP_SCALE_CR[img->qpsp]) - MIN_QP) / 6;
1253 
    qp_rem    = ((img->qpsp < 0 ? img->qpsp : QP_SCALE_CR[img->qpsp]) - MIN_QP) % 6;
1254 
    q_bits    = Q_BITS + qp_per;
1255 
  }
1256 
 
1257 
  for (j=0; j < MB_BLOCK_SIZE/2; j++)
1258 
  for (i=0; i < MB_BLOCK_SIZE/2; i++)
1259 
  {
1260 
    predicted_chroma_block[i][j]=img->mpr[j][i];
1261 
    img->mpr[j][i]=0;
1262 
  }
1263 
  for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
1264 
  {
1265 
    for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
1266 
    {
1267 
      //  Horizontal transform.
1268 
      for (j=0; j < BLOCK_SIZE; j++)
1269 
      {
1270 
        mb_y=n2+j;
1271 
        for (i=0; i < 2; i++)
1272 
        {
1273 
          i1=3-i;
1274 
          m5[i]=predicted_chroma_block[i+n1][mb_y]+predicted_chroma_block[i1+n1][mb_y];
1275 
          m5[i1]=predicted_chroma_block[i+n1][mb_y]-predicted_chroma_block[i1+n1][mb_y];
1276 
        }
1277 
        predicted_chroma_block[n1][mb_y]  =(m5[0]+m5[1]);
1278 
        predicted_chroma_block[n1+2][mb_y]=(m5[0]-m5[1]);
1279 
        predicted_chroma_block[n1+1][mb_y]=m5[3]*2+m5[2];
1280 
        predicted_chroma_block[n1+3][mb_y]=m5[3]-m5[2]*2;
1281 
      }
1282 
 
1283 
      //  Vertical transform.
1284 
 
1285 
      for (i=0; i < BLOCK_SIZE; i++)
1286 
      {
1287 
        j1=n1+i;
1288 
        for (j=0; j < 2; j++)
1289 
        {
1290 
          j2=3-j;
1291 
          m5[j]=predicted_chroma_block[j1][n2+j]+predicted_chroma_block[j1][n2+j2];
1292 
          m5[j2]=predicted_chroma_block[j1][n2+j]-predicted_chroma_block[j1][n2+j2];
1293 
        }
1294 
        predicted_chroma_block[j1][n2+0]=(m5[0]+m5[1]);
1295 
        predicted_chroma_block[j1][n2+2]=(m5[0]-m5[1]);
1296 
        predicted_chroma_block[j1][n2+1]=m5[3]*2+m5[2];
1297 
        predicted_chroma_block[j1][n2+3]=m5[3]-m5[2]*2;
1298 
      }
1299 
    }
1300 
  }
1301 
 
1302 
  //     2X2 transform of DC coeffs.
1303 
  mp1[0]=(predicted_chroma_block[0][0]+predicted_chroma_block[4][0]+predicted_chroma_block[0][4]+predicted_chroma_block[4][4]);
1304 
  mp1[1]=(predicted_chroma_block[0][0]-predicted_chroma_block[4][0]+predicted_chroma_block[0][4]-predicted_chroma_block[4][4]);
1305 
  mp1[2]=(predicted_chroma_block[0][0]+predicted_chroma_block[4][0]-predicted_chroma_block[0][4]-predicted_chroma_block[4][4]);
1306 
  mp1[3]=(predicted_chroma_block[0][0]-predicted_chroma_block[4][0]-predicted_chroma_block[0][4]+predicted_chroma_block[4][4]);
1307 
 
1308 
  for (n1=0; n1 < 2; n1 ++)
1309 
  for (n2=0; n2 < 2; n2 ++)
1310 
  {
1311 
    if (img->sp_switch || img->type==SI_SLICE)  //M.W. patched for SI
1312 
    {
1313 
      //quantization fo predicted block
1314 
      ilev=(iabs (mp1[n1+n2*2]) * quant_coef[qp_rem_sp][0][0] + 2 * qp_const2) >> (q_bits_sp + 1);
1315 
      //addition
1316 
      ilev=img->cof[n1+ll][4+n2][0][0]+isignab(ilev,mp1[n1+n2*2]);
1317 
      //dequantization
1318 
      mp1[n1+n2*2] =ilev*dequant_coef[qp_rem_sp][0][0]<<qp_per_sp;
1319 
    }
1320 
    else
1321 
    {
1322 
      ilev=((img->cof[n1+ll][4+n2][0][0]*dequant_coef[qp_rem][0][0]*A[0][0]<< qp_per) >>5)+mp1[n1+n2*2] ;
1323 
      mp1[n1+n2*2]=isignab((iabs(ilev)* quant_coef[qp_rem_sp][0][0]+ 2 * qp_const2)>> (q_bits_sp+1),ilev)*dequant_coef[qp_rem_sp][0][0]<<qp_per_sp;
1324 
    }
1325 
  }
1326 
 
1327 
 
1328 
  for (n2=0; n2 < 2; n2 ++)
1329 
  for (n1=0; n1 < 2; n1 ++)
1330 
  for (i=0;i< BLOCK_SIZE; i++)
1331 
  for (j=0;j< BLOCK_SIZE; j++)
1332 
  {
1333 
  // recovering coefficient since they are already dequantized earlier
1334 
    img->cof[n1+ll][4+n2][j][i] = (img->cof[n1+ll][4+n2][j][i] >> qp_per) / dequant_coef[qp_rem][i][j];
1335 
 
1336 
    if (img->sp_switch || img->type==SI_SLICE)  //M.W. patched for SI
1337 
    {
1338 
      //quantization of the predicted block
1339 
      ilev =  (iabs(predicted_chroma_block[n1*BLOCK_SIZE+i][n2*BLOCK_SIZE+j]) * quant_coef[qp_rem_sp][i][j] + qp_const2) >> q_bits_sp;
1340 
      //addition of the residual
1341 
      ilev = isignab(ilev,predicted_chroma_block[n1*BLOCK_SIZE+i][n2*BLOCK_SIZE+j]) + img->cof[n1+ll][4+n2][j][i];
1342 
      // Inverse quantization
1343 
      img->cof[n1+ll][4+n2][j][i] = ilev * dequant_coef[qp_rem_sp][i][j] << qp_per_sp  ;
1344 
    }
1345 
    else
1346 
    {
1347 
      //dequantization and addition of the predicted block
1348 
      ilev=((img->cof[n1+ll][4+n2][j][i]*dequant_coef[qp_rem][i][j]*A[i][j]<< qp_per) >>6)+predicted_chroma_block[n1*BLOCK_SIZE+i][n2*BLOCK_SIZE+j] ;
1349 
      //quantization and dequantization
1350 
      img->cof[n1+ll][4+n2][j][i] = isignab((iabs(ilev) * quant_coef[qp_rem_sp][i][j] + qp_const2)>> q_bits_sp,ilev)*dequant_coef[qp_rem_sp][i][j]<<qp_per_sp;
1351 
    }
1352 
  }
1353 
  img->cof[0+ll][4][0][0]=(mp1[0]+mp1[1]+mp1[2]+mp1[3])>>1;
1354 
  img->cof[1+ll][4][0][0]=(mp1[0]-mp1[1]+mp1[2]-mp1[3])>>1;
1355 
  img->cof[0+ll][5][0][0]=(mp1[0]+mp1[1]-mp1[2]-mp1[3])>>1;
1356 
  img->cof[1+ll][5][0][0]=(mp1[0]-mp1[1]-mp1[2]+mp1[3])>>1;
1357 
}
1358 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.