1/* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18/* 19------------------------------------------------------------------------------ 20 INPUT AND OUTPUT DEFINITIONS 21 22 Inputs: 23 xpos = x half-pixel of (x,y) coordinates within a VOP; motion 24 compensated coordinates; native data type 25 ypos = y half-pixel of (x,y) coordinates within a VOP; motion 26 compensated coordinates; native data type 27 comp = pointer to 8-bit compensated prediction values within a VOP; 28 computed by this module (i/o); full-pel resolution; 8-bit data 29 c_prev = pointer to previous 8-bit prediction values within a VOP; 30 values range from (0-255); full-pel resolution; 8-bit data 31 sh_d = pointer to residual values used to compensate the predicted 32 value; values range from (-512 to 511); full-pel resolution; 33 native data type 34 width = width of the VOP in pixels (x axis); full-pel resolution; 35 native data type 36 height = height of the VOP in pixels (y axis); full-pel resolution; 37 native data type 38 rnd1 = rounding value for case when one dimension uses half-pel 39 resolution; native data type 40 rnd2 = rounding value for case when two dimensions uses half-pel 41 resolution; native data type 42 43 Outputs: 44 returns 1 45 46 Local Stores/Buffers/Pointers Needed: 47 None 48 49 Global Stores/Buffers/Pointers Needed: 50 None 51 52 Pointers and Buffers Modified: 53 comp = buffer contains newly computed compensated prediction values 54 55 Local Stores Modified: 56 None 57 58 Global Stores Modified: 59 None 60 61------------------------------------------------------------------------------ 62 FUNCTION DESCRIPTION 63 64 Summary: 65 66 This function performs motion compensated prediction for the case where 67 the motion vector points to a block outside the VOP. The function interpolates 68 the pixels that are outside the VOP using the boundary pixels for the block. 69 Once the values are interpolated, the pixel values are computed for a block 70 in the current VOP. The prediction values are generated by averaging pixel 71 values in the previous VOP; the block position in the previous frame is 72 computed from the current block's motion vector. The computed pixel values 73 are calculated by adding the prediction values to the block residual values. 74 75 Details: 76 77 First, this functions determines which VOP boundary(ies) the motion vector 78 is outside, i.e., left, right, top, bottom. xpos is compared to the left and 79 right boundaries; ypos is compared to the top and bottom boundaries. The number 80 of block pixels inside the the boundary in the x and y directions are stored 81 in endx and endy, respectively. If the entire block is inside the x or y 82 boundary, the respectively end is set to 0. 83 84 After the boundaries are tested, any pixels lying outside a boundary are 85 interpolated from the boundary pixels. For example, if the block is outside the 86 bottom boundary, boundary pixels alone the bottom of the VOP as used to 87 interpolated those pixels lying outside the bottom boundary. The interpolation 88 used is a simple column-wise or row-wise copy of the boundary pixels (inside the 89 block) depending on which boundary the block is outside. In our example, each 90 boundary pixel would be copied column-wise to the pixel beneath it. If the 91 block was outside right boundary, the boundary pixels would be copied row-wise 92 to the pixel to the right of it. If the block was outside both an x and y 93 boundary, the boundary pixels would be copied row-wise for the portion of the 94 block outside the x boundary, and column-wise for the portion of the block 95 outside the y boundary. And so on. 96 97 Once the pixel interpolation is complete, the motion compensated output values 98 (comp[]) are calculed from the motion compensated prediction (pred[])values and 99 the residual values (sh_d[]) of the current frame. The prediction values are 100 generated by averaging pixel values in the previous VOP; the block position in 101 the previous frame is computed from the current block's motion vector. The 102 computed pixel values are calculated by adding the prediction values to the 103 block residual values. 104 105*/ 106 107/*---------------------------------------------------------------------------- 108; INCLUDES 109----------------------------------------------------------------------------*/ 110#include "mp4dec_lib.h" 111#include "motion_comp.h" 112 113#define PAD_CORNER { temp = *prev; \ 114 temp |= (temp<<8); \ 115 temp |= (temp<<16); \ 116 *((uint32*)ptr) = temp; \ 117 *((uint32*)(ptr+4)) = temp; \ 118 *((uint32*)(ptr+=16)) = temp; \ 119 *((uint32*)(ptr+4)) = temp; \ 120 *((uint32*)(ptr+=16)) = temp; \ 121 *((uint32*)(ptr+4)) = temp; \ 122 *((uint32*)(ptr+=16)) = temp; \ 123 *((uint32*)(ptr+4)) = temp; \ 124 *((uint32*)(ptr+=16)) = temp; \ 125 *((uint32*)(ptr+4)) = temp; \ 126 *((uint32*)(ptr+=16)) = temp; \ 127 *((uint32*)(ptr+4)) = temp; \ 128 *((uint32*)(ptr+=16)) = temp; \ 129 *((uint32*)(ptr+4)) = temp; \ 130 *((uint32*)(ptr+=16)) = temp; \ 131 *((uint32*)(ptr+4)) = temp; } 132 133#define PAD_ROW { temp = *((uint32*)prev); \ 134 temp2 = *((uint32*)(prev+4)); \ 135 *((uint32*)ptr) = temp;\ 136 *((uint32*)(ptr+4)) = temp2; \ 137 *((uint32*)(ptr+=16)) = temp; \ 138 *((uint32*)(ptr+4)) = temp2;\ 139 *((uint32*)(ptr+=16)) = temp; \ 140 *((uint32*)(ptr+4)) = temp2;\ 141 *((uint32*)(ptr+=16)) = temp; \ 142 *((uint32*)(ptr+4)) = temp2;\ 143 *((uint32*)(ptr+=16)) = temp; \ 144 *((uint32*)(ptr+4)) = temp2;\ 145 *((uint32*)(ptr+=16)) = temp; \ 146 *((uint32*)(ptr+4)) = temp2;\ 147 *((uint32*)(ptr+=16)) = temp; \ 148 *((uint32*)(ptr+4)) = temp2;\ 149 *((uint32*)(ptr+=16)) = temp; \ 150 *((uint32*)(ptr+4)) = temp2;} 151 152#define PAD_EXTRA_4x8 { temp = *((uint32*)(prev+8)); \ 153 *((uint32*)ptr) = temp; \ 154 *((uint32*)(ptr+=16)) = temp; \ 155 *((uint32*)(ptr+=16)) = temp; \ 156 *((uint32*)(ptr+=16)) = temp; \ 157 *((uint32*)(ptr+=16)) = temp; \ 158 *((uint32*)(ptr+=16)) = temp; \ 159 *((uint32*)(ptr+=16)) = temp; \ 160 *((uint32*)(ptr+=16)) = temp; } 161 162#define PAD_COL { temp = *prev; \ 163 temp|=(temp<<8); temp|=(temp<<16); \ 164 *((uint32*)ptr) = temp; \ 165 *((uint32*)(ptr+4)) = temp; \ 166 temp = *(prev+=16); \ 167 temp|=(temp<<8); temp|=(temp<<16); \ 168 *((uint32*)(ptr+=16)) = temp; \ 169 *((uint32*)(ptr+4)) = temp; \ 170 temp = *(prev+=16); \ 171 temp|=(temp<<8); temp|=(temp<<16); \ 172 *((uint32*)(ptr+=16)) = temp; \ 173 *((uint32*)(ptr+4)) = temp; \ 174 temp = *(prev+=16); \ 175 temp|=(temp<<8); temp|=(temp<<16); \ 176 *((uint32*)(ptr+=16)) = temp; \ 177 *((uint32*)(ptr+4)) = temp; \ 178 temp = *(prev+=16); \ 179 temp|=(temp<<8); temp|=(temp<<16); \ 180 *((uint32*)(ptr+=16)) = temp; \ 181 *((uint32*)(ptr+4)) = temp; \ 182 temp = *(prev+=16); \ 183 temp|=(temp<<8); temp|=(temp<<16); \ 184 *((uint32*)(ptr+=16)) = temp; \ 185 *((uint32*)(ptr+4)) = temp; \ 186 temp = *(prev+=16); \ 187 temp|=(temp<<8); temp|=(temp<<16); \ 188 *((uint32*)(ptr+=16)) = temp; \ 189 *((uint32*)(ptr+4)) = temp; \ 190 temp = *(prev+=16); \ 191 temp|=(temp<<8); temp|=(temp<<16); \ 192 *((uint32*)(ptr+=16)) = temp; \ 193 *((uint32*)(ptr+4)) = temp;} 194 195/* copy 8x8 block */ 196#define COPY_BLOCK { *((uint32*)ptr) = *((uint32*)prev); \ 197 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 198 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 199 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 200 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 201 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 202 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 203 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 204 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 205 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 206 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 207 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 208 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 209 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 210 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 211 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); } 212 213#define COPY_12x8 { *((uint32*)ptr) = *((uint32*)prev); \ 214 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 215 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 216 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 217 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 218 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 219 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 220 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 221 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 222 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 223 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 224 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 225 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 226 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 227 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 228 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 229 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 230 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 231 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 232 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 233 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \ 234 *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \ 235 *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \ 236 *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); } 237 238/*---------------------------------------------------------------------------- 239; FUNCTION CODE 240----------------------------------------------------------------------------*/ 241int GetPredOutside( 242 int xpos, /* i */ 243 int ypos, /* i */ 244 uint8 *c_prev, /* i */ 245 uint8 *pred_block, /* i */ 246 int width, /* i */ 247 int height, /* i */ 248 int rnd1, /* i */ 249 int pred_width 250) 251{ 252 /*---------------------------------------------------------------------------- 253 ; Define all local variables 254 ----------------------------------------------------------------------------*/ 255 uint8 *prev; /* pointers to adjacent pixels in the */ 256 uint8 pred[256]; /* storage for padded pixel values, 16x16 */ 257 uint8 *ptr; 258 int xoffset; 259 uint32 temp, temp2; 260 261 /*---------------------------------------------------------------------------- 262 ; Function body here 263 ----------------------------------------------------------------------------*/ 264 /* saturate xpos and ypos */ 265 if (xpos < -16) xpos = -16; 266 if (xpos > ((width - 1) << 1)) xpos = (width - 1) << 1; 267 if (ypos < -16) ypos = -16; 268 if (ypos > ((height - 1) << 1)) ypos = (height - 1) << 1; 269 270 if (xpos < 0) 271 { 272 if (ypos < 0) /* pad top left of frame */ 273 { 274 /* copy the block */ 275 ptr = pred + (8 << 4) + 8; 276 prev = c_prev; 277 COPY_BLOCK 278 279 /* pad the corner */ 280 ptr = pred; 281 prev = pred + (8 << 4) + 8; 282 PAD_CORNER 283 284 /* pad top */ 285 ptr = pred + 8; 286 prev = pred + (8 << 4) + 8; 287 PAD_ROW 288 289 /* pad left */ 290 ptr = pred + (8 << 4); 291 prev = pred + (8 << 4) + 8; 292 PAD_COL 293 294 295 ptr = pred + (((ypos >> 1) + 8) << 4) + (xpos >> 1) + 8; 296 297 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 298 299 return 1; 300 } 301 else if ((ypos >> 1) < (height - B_SIZE)) /* pad left of frame */ 302 { 303 /* copy block */ 304 ptr = pred + 8; 305 prev = c_prev + (ypos >> 1) * width; 306 COPY_BLOCK 307 /* copy extra line */ 308 *((uint32*)(ptr += 16)) = *((uint32*)(prev += width)); 309 *((uint32*)(ptr + 4)) = *((uint32*)(prev + 4)); 310 311 /* pad left */ 312 ptr = pred; 313 prev = pred + 8; 314 PAD_COL 315 /* pad extra line */ 316 temp = *(prev += 16); 317 temp |= (temp << 8); 318 temp |= (temp << 16); 319 *((uint32*)(ptr += 16)) = temp; 320 *((uint32*)(ptr + 4)) = temp; 321 322 ptr = pred + 8 + (xpos >> 1); 323 324 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 325 326 return 1; 327 } 328 else /* pad bottom left of frame */ 329 { 330 /* copy the block */ 331 ptr = pred + 8; /* point to the center */ 332 prev = c_prev + width * (height - 8); 333 COPY_BLOCK 334 335 /* pad the corner */ 336 ptr = pred + (8 << 4); 337 prev = ptr - 8; 338 PAD_CORNER 339 340 /* pad bottom */ 341 ptr = pred + (8 << 4) + 8; 342 prev = ptr - 16; 343 PAD_ROW 344 345 /* pad left */ 346 ptr = pred ; 347 prev = ptr + 8; 348 PAD_COL 349 350 ptr = pred + 8 + (((ypos >> 1) - (height - 8)) << 4) + (xpos >> 1); 351 352 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 353 354 return 1; 355 } 356 } 357 else if ((xpos >> 1) < (width - B_SIZE)) 358 { 359 if (ypos < 0) /* pad top of frame */ 360 { 361 xoffset = xpos >> 1; 362 xoffset = xoffset & 0x3; /* word align ptr */ 363 364 /* copy block */ 365 ptr = pred + (8 << 4); 366 prev = c_prev + (xpos >> 1) - xoffset; 367 368 if (xoffset || (xpos&1)) /* copy extra 4x8 */ 369 { 370 COPY_12x8 371 } 372 else 373 { 374 COPY_BLOCK 375 } 376 377 /* pad top */ 378 ptr = pred; 379 prev = pred + (8 << 4); 380 PAD_ROW 381 if (xoffset || (xpos&1)) /* pad extra 4x8 */ 382 { 383 ptr = pred + 8; 384 PAD_EXTRA_4x8 385 } 386 387 ptr = pred + (((ypos >> 1) + 8) << 4) + xoffset; 388 389 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 390 391 return 1; 392 } 393 else /* pad bottom of frame */ 394 { 395 xoffset = xpos >> 1; 396 xoffset = xoffset & 0x3; /* word align ptr */ 397 /* copy block */ 398 ptr = pred ; 399 prev = c_prev + width * (height - 8) + (xpos >> 1) - xoffset; 400 if (xoffset || (xpos&1)) 401 { 402 COPY_12x8 403 } 404 else 405 { 406 COPY_BLOCK 407 } 408 409 /* pad bottom */ 410 ptr = pred + (8 << 4); 411 prev = ptr - 16; 412 PAD_ROW 413 if (xoffset || (xpos&1)) 414 { 415 ptr = pred + (8 << 4) + 8; 416 PAD_EXTRA_4x8 417 } 418 419 ptr = pred + (((ypos >> 1) - (height - 8)) << 4) + xoffset; 420 421 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 422 423 return 1; 424 } 425 } 426 else 427 { 428 if (ypos < 0) /* pad top right of frame */ 429 { 430 /* copy block */ 431 ptr = pred + (8 << 4); 432 prev = c_prev + width - 8; 433 COPY_BLOCK 434 435 /* pad top-right */ 436 ptr = pred + 8; 437 prev = pred + (8 << 4) + 7; 438 PAD_CORNER 439 440 /* pad top */ 441 ptr = pred ; 442 prev = pred + (8 << 4); 443 PAD_ROW; 444 445 /* pad right */ 446 ptr = pred + (8 << 4) + 8; 447 prev = ptr - 1; 448 PAD_COL; 449 450 ptr = pred + ((8 + (ypos >> 1)) << 4) + (8 - (width - (xpos >> 1))); 451 452 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 453 454 return 1; 455 } 456 else if ((ypos >> 1) < (height - B_SIZE)) /* pad right of frame */ 457 { 458 /* copy block */ 459 ptr = pred; 460 prev = c_prev + (ypos >> 1) * width + width - 8; 461 COPY_BLOCK 462 /* copy extra line */ 463 *((uint32*)(ptr += 16)) = *((uint32*)(prev += width)); 464 *((uint32*)(ptr + 4)) = *((uint32*)(prev + 4)); 465 466 /* pad right */ 467 ptr = pred + 8; 468 prev = ptr - 1; 469 PAD_COL; 470 /* pad extra line */ 471 temp = *(prev += 16); 472 temp |= (temp << 8); 473 temp |= (temp << 16); 474 *((uint32*)(ptr += 16)) = temp; 475 *((uint32*)(ptr + 4)) = temp; 476 477 478 ptr = pred + 8 - (width - (xpos >> 1)); 479 480 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 481 482 return 1; 483 484 } 485 else /* pad bottom right of frame */ 486 { 487 /* copy block */ 488 ptr = pred; 489 prev = c_prev + width * (height - 8) + width - 8; 490 COPY_BLOCK 491 492 /* pad bottom-right */ 493 ptr = pred + (8 << 4) + 8; 494 prev = ptr - 17; 495 PAD_CORNER 496 497 /* pad right */ 498 ptr = pred + 8; 499 prev = ptr - 1; 500 PAD_COL 501 502 /* pad bottom */ 503 ptr = pred + (8 << 4); 504 prev = ptr - 16; 505 PAD_ROW 506 507 ptr = pred + 8 - (width - (xpos >> 1)) + ((8 - (height - (ypos >> 1))) << 4); 508 509 GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1); 510 511 return 1; 512 } 513 } 514} 515