1 // Copyright 2010 Google Inc. All Rights Reserved. 2 // 3 // Use of this source code is governed by a BSD-style license 4 // that can be found in the COPYING file in the root of the source 5 // tree. An additional intellectual property rights grant can be found 6 // in the file PATENTS. All contributing project authors may 7 // be found in the AUTHORS file in the root of the source tree. 8 // ----------------------------------------------------------------------------- 9 // 10 // Frame-reconstruction function. Memory allocation. 11 // 12 // Author: Skal (pascal.massimino (at) gmail.com) 13 14 #include <stdlib.h> 15 #include "./vp8i.h" 16 #include "../utils/utils.h" 17 18 #if defined(__cplusplus) || defined(c_plusplus) 19 extern "C" { 20 #endif 21 22 #define ALIGN_MASK (32 - 1) 23 24 //------------------------------------------------------------------------------ 25 // Filtering 26 27 // kFilterExtraRows[] = How many extra lines are needed on the MB boundary 28 // for caching, given a filtering level. 29 // Simple filter: up to 2 luma samples are read and 1 is written. 30 // Complex filter: up to 4 luma samples are read and 3 are written. Same for 31 // U/V, so it's 8 samples total (because of the 2x upsampling). 32 static const uint8_t kFilterExtraRows[3] = { 0, 2, 8 }; 33 34 static WEBP_INLINE int hev_thresh_from_level(int level, int keyframe) { 35 if (keyframe) { 36 return (level >= 40) ? 2 : (level >= 15) ? 1 : 0; 37 } else { 38 return (level >= 40) ? 3 : (level >= 20) ? 2 : (level >= 15) ? 1 : 0; 39 } 40 } 41 42 static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) { 43 const VP8ThreadContext* const ctx = &dec->thread_ctx_; 44 const int y_bps = dec->cache_y_stride_; 45 VP8FInfo* const f_info = ctx->f_info_ + mb_x; 46 uint8_t* const y_dst = dec->cache_y_ + ctx->id_ * 16 * y_bps + mb_x * 16; 47 const int level = f_info->f_level_; 48 const int ilevel = f_info->f_ilevel_; 49 const int limit = 2 * level + ilevel; 50 if (level == 0) { 51 return; 52 } 53 if (dec->filter_type_ == 1) { // simple 54 if (mb_x > 0) { 55 VP8SimpleHFilter16(y_dst, y_bps, limit + 4); 56 } 57 if (f_info->f_inner_) { 58 VP8SimpleHFilter16i(y_dst, y_bps, limit); 59 } 60 if (mb_y > 0) { 61 VP8SimpleVFilter16(y_dst, y_bps, limit + 4); 62 } 63 if (f_info->f_inner_) { 64 VP8SimpleVFilter16i(y_dst, y_bps, limit); 65 } 66 } else { // complex 67 const int uv_bps = dec->cache_uv_stride_; 68 uint8_t* const u_dst = dec->cache_u_ + ctx->id_ * 8 * uv_bps + mb_x * 8; 69 uint8_t* const v_dst = dec->cache_v_ + ctx->id_ * 8 * uv_bps + mb_x * 8; 70 const int hev_thresh = 71 hev_thresh_from_level(level, dec->frm_hdr_.key_frame_); 72 if (mb_x > 0) { 73 VP8HFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh); 74 VP8HFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh); 75 } 76 if (f_info->f_inner_) { 77 VP8HFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh); 78 VP8HFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh); 79 } 80 if (mb_y > 0) { 81 VP8VFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh); 82 VP8VFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh); 83 } 84 if (f_info->f_inner_) { 85 VP8VFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh); 86 VP8VFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh); 87 } 88 } 89 } 90 91 // Filter the decoded macroblock row (if needed) 92 static void FilterRow(const VP8Decoder* const dec) { 93 int mb_x; 94 const int mb_y = dec->thread_ctx_.mb_y_; 95 assert(dec->thread_ctx_.filter_row_); 96 for (mb_x = dec->tl_mb_x_; mb_x < dec->br_mb_x_; ++mb_x) { 97 DoFilter(dec, mb_x, mb_y); 98 } 99 } 100 101 //------------------------------------------------------------------------------ 102 // Precompute the filtering strength for each segment and each i4x4/i16x16 mode. 103 104 static void PrecomputeFilterStrengths(VP8Decoder* const dec) { 105 if (dec->filter_type_ > 0) { 106 int s; 107 const VP8FilterHeader* const hdr = &dec->filter_hdr_; 108 for (s = 0; s < NUM_MB_SEGMENTS; ++s) { 109 int i4x4; 110 // First, compute the initial level 111 int base_level; 112 if (dec->segment_hdr_.use_segment_) { 113 base_level = dec->segment_hdr_.filter_strength_[s]; 114 if (!dec->segment_hdr_.absolute_delta_) { 115 base_level += hdr->level_; 116 } 117 } else { 118 base_level = hdr->level_; 119 } 120 for (i4x4 = 0; i4x4 <= 1; ++i4x4) { 121 VP8FInfo* const info = &dec->fstrengths_[s][i4x4]; 122 int level = base_level; 123 if (hdr->use_lf_delta_) { 124 // TODO(skal): only CURRENT is handled for now. 125 level += hdr->ref_lf_delta_[0]; 126 if (i4x4) { 127 level += hdr->mode_lf_delta_[0]; 128 } 129 } 130 level = (level < 0) ? 0 : (level > 63) ? 63 : level; 131 info->f_level_ = level; 132 133 if (hdr->sharpness_ > 0) { 134 if (hdr->sharpness_ > 4) { 135 level >>= 2; 136 } else { 137 level >>= 1; 138 } 139 if (level > 9 - hdr->sharpness_) { 140 level = 9 - hdr->sharpness_; 141 } 142 } 143 info->f_ilevel_ = (level < 1) ? 1 : level; 144 info->f_inner_ = 0; 145 } 146 } 147 } 148 } 149 150 //------------------------------------------------------------------------------ 151 // This function is called after a row of macroblocks is finished decoding. 152 // It also takes into account the following restrictions: 153 // * In case of in-loop filtering, we must hold off sending some of the bottom 154 // pixels as they are yet unfiltered. They will be when the next macroblock 155 // row is decoded. Meanwhile, we must preserve them by rotating them in the 156 // cache area. This doesn't hold for the very bottom row of the uncropped 157 // picture of course. 158 // * we must clip the remaining pixels against the cropping area. The VP8Io 159 // struct must have the following fields set correctly before calling put(): 160 161 #define MACROBLOCK_VPOS(mb_y) ((mb_y) * 16) // vertical position of a MB 162 163 // Finalize and transmit a complete row. Return false in case of user-abort. 164 static int FinishRow(VP8Decoder* const dec, VP8Io* const io) { 165 int ok = 1; 166 const VP8ThreadContext* const ctx = &dec->thread_ctx_; 167 const int extra_y_rows = kFilterExtraRows[dec->filter_type_]; 168 const int ysize = extra_y_rows * dec->cache_y_stride_; 169 const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride_; 170 const int y_offset = ctx->id_ * 16 * dec->cache_y_stride_; 171 const int uv_offset = ctx->id_ * 8 * dec->cache_uv_stride_; 172 uint8_t* const ydst = dec->cache_y_ - ysize + y_offset; 173 uint8_t* const udst = dec->cache_u_ - uvsize + uv_offset; 174 uint8_t* const vdst = dec->cache_v_ - uvsize + uv_offset; 175 const int first_row = (ctx->mb_y_ == 0); 176 const int last_row = (ctx->mb_y_ >= dec->br_mb_y_ - 1); 177 int y_start = MACROBLOCK_VPOS(ctx->mb_y_); 178 int y_end = MACROBLOCK_VPOS(ctx->mb_y_ + 1); 179 180 if (ctx->filter_row_) { 181 FilterRow(dec); 182 } 183 184 if (io->put) { 185 if (!first_row) { 186 y_start -= extra_y_rows; 187 io->y = ydst; 188 io->u = udst; 189 io->v = vdst; 190 } else { 191 io->y = dec->cache_y_ + y_offset; 192 io->u = dec->cache_u_ + uv_offset; 193 io->v = dec->cache_v_ + uv_offset; 194 } 195 196 if (!last_row) { 197 y_end -= extra_y_rows; 198 } 199 if (y_end > io->crop_bottom) { 200 y_end = io->crop_bottom; // make sure we don't overflow on last row. 201 } 202 io->a = NULL; 203 if (dec->alpha_data_ != NULL && y_start < y_end) { 204 // TODO(skal): several things to correct here: 205 // * testing presence of alpha with dec->alpha_data_ is not a good idea 206 // * we're actually decompressing the full plane only once. It should be 207 // more obvious from signature. 208 // * we could free alpha_data_ right after this call, but we don't own. 209 io->a = VP8DecompressAlphaRows(dec, y_start, y_end - y_start); 210 if (io->a == NULL) { 211 return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR, 212 "Could not decode alpha data."); 213 } 214 } 215 if (y_start < io->crop_top) { 216 const int delta_y = io->crop_top - y_start; 217 y_start = io->crop_top; 218 assert(!(delta_y & 1)); 219 io->y += dec->cache_y_stride_ * delta_y; 220 io->u += dec->cache_uv_stride_ * (delta_y >> 1); 221 io->v += dec->cache_uv_stride_ * (delta_y >> 1); 222 if (io->a != NULL) { 223 io->a += io->width * delta_y; 224 } 225 } 226 if (y_start < y_end) { 227 io->y += io->crop_left; 228 io->u += io->crop_left >> 1; 229 io->v += io->crop_left >> 1; 230 if (io->a != NULL) { 231 io->a += io->crop_left; 232 } 233 io->mb_y = y_start - io->crop_top; 234 io->mb_w = io->crop_right - io->crop_left; 235 io->mb_h = y_end - y_start; 236 ok = io->put(io); 237 } 238 } 239 // rotate top samples if needed 240 if (ctx->id_ + 1 == dec->num_caches_) { 241 if (!last_row) { 242 memcpy(dec->cache_y_ - ysize, ydst + 16 * dec->cache_y_stride_, ysize); 243 memcpy(dec->cache_u_ - uvsize, udst + 8 * dec->cache_uv_stride_, uvsize); 244 memcpy(dec->cache_v_ - uvsize, vdst + 8 * dec->cache_uv_stride_, uvsize); 245 } 246 } 247 248 return ok; 249 } 250 251 #undef MACROBLOCK_VPOS 252 253 //------------------------------------------------------------------------------ 254 255 int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io) { 256 int ok = 1; 257 VP8ThreadContext* const ctx = &dec->thread_ctx_; 258 if (!dec->use_threads_) { 259 // ctx->id_ and ctx->f_info_ are already set 260 ctx->mb_y_ = dec->mb_y_; 261 ctx->filter_row_ = dec->filter_row_; 262 ok = FinishRow(dec, io); 263 } else { 264 WebPWorker* const worker = &dec->worker_; 265 // Finish previous job *before* updating context 266 ok &= WebPWorkerSync(worker); 267 assert(worker->status_ == OK); 268 if (ok) { // spawn a new deblocking/output job 269 ctx->io_ = *io; 270 ctx->id_ = dec->cache_id_; 271 ctx->mb_y_ = dec->mb_y_; 272 ctx->filter_row_ = dec->filter_row_; 273 if (ctx->filter_row_) { // just swap filter info 274 VP8FInfo* const tmp = ctx->f_info_; 275 ctx->f_info_ = dec->f_info_; 276 dec->f_info_ = tmp; 277 } 278 WebPWorkerLaunch(worker); 279 if (++dec->cache_id_ == dec->num_caches_) { 280 dec->cache_id_ = 0; 281 } 282 } 283 } 284 return ok; 285 } 286 287 //------------------------------------------------------------------------------ 288 // Finish setting up the decoding parameter once user's setup() is called. 289 290 VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) { 291 // Call setup() first. This may trigger additional decoding features on 'io'. 292 // Note: Afterward, we must call teardown() not matter what. 293 if (io->setup && !io->setup(io)) { 294 VP8SetError(dec, VP8_STATUS_USER_ABORT, "Frame setup failed"); 295 return dec->status_; 296 } 297 298 // Disable filtering per user request 299 if (io->bypass_filtering) { 300 dec->filter_type_ = 0; 301 } 302 // TODO(skal): filter type / strength / sharpness forcing 303 304 // Define the area where we can skip in-loop filtering, in case of cropping. 305 // 306 // 'Simple' filter reads two luma samples outside of the macroblock and 307 // and filters one. It doesn't filter the chroma samples. Hence, we can 308 // avoid doing the in-loop filtering before crop_top/crop_left position. 309 // For the 'Complex' filter, 3 samples are read and up to 3 are filtered. 310 // Means: there's a dependency chain that goes all the way up to the 311 // top-left corner of the picture (MB #0). We must filter all the previous 312 // macroblocks. 313 // TODO(skal): add an 'approximate_decoding' option, that won't produce 314 // a 1:1 bit-exactness for complex filtering? 315 { 316 const int extra_pixels = kFilterExtraRows[dec->filter_type_]; 317 if (dec->filter_type_ == 2) { 318 // For complex filter, we need to preserve the dependency chain. 319 dec->tl_mb_x_ = 0; 320 dec->tl_mb_y_ = 0; 321 } else { 322 // For simple filter, we can filter only the cropped region. 323 // We include 'extra_pixels' on the other side of the boundary, since 324 // vertical or horizontal filtering of the previous macroblock can 325 // modify some abutting pixels. 326 dec->tl_mb_x_ = (io->crop_left - extra_pixels) >> 4; 327 dec->tl_mb_y_ = (io->crop_top - extra_pixels) >> 4; 328 if (dec->tl_mb_x_ < 0) dec->tl_mb_x_ = 0; 329 if (dec->tl_mb_y_ < 0) dec->tl_mb_y_ = 0; 330 } 331 // We need some 'extra' pixels on the right/bottom. 332 dec->br_mb_y_ = (io->crop_bottom + 15 + extra_pixels) >> 4; 333 dec->br_mb_x_ = (io->crop_right + 15 + extra_pixels) >> 4; 334 if (dec->br_mb_x_ > dec->mb_w_) { 335 dec->br_mb_x_ = dec->mb_w_; 336 } 337 if (dec->br_mb_y_ > dec->mb_h_) { 338 dec->br_mb_y_ = dec->mb_h_; 339 } 340 } 341 PrecomputeFilterStrengths(dec); 342 return VP8_STATUS_OK; 343 } 344 345 int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) { 346 int ok = 1; 347 if (dec->use_threads_) { 348 ok = WebPWorkerSync(&dec->worker_); 349 } 350 351 if (io->teardown) { 352 io->teardown(io); 353 } 354 return ok; 355 } 356 357 //------------------------------------------------------------------------------ 358 // For multi-threaded decoding we need to use 3 rows of 16 pixels as delay line. 359 // 360 // Reason is: the deblocking filter cannot deblock the bottom horizontal edges 361 // immediately, and needs to wait for first few rows of the next macroblock to 362 // be decoded. Hence, deblocking is lagging behind by 4 or 8 pixels (depending 363 // on strength). 364 // With two threads, the vertical positions of the rows being decoded are: 365 // Decode: [ 0..15][16..31][32..47][48..63][64..79][... 366 // Deblock: [ 0..11][12..27][28..43][44..59][... 367 // If we use two threads and two caches of 16 pixels, the sequence would be: 368 // Decode: [ 0..15][16..31][ 0..15!!][16..31][ 0..15][... 369 // Deblock: [ 0..11][12..27!!][-4..11][12..27][... 370 // The problem occurs during row [12..15!!] that both the decoding and 371 // deblocking threads are writing simultaneously. 372 // With 3 cache lines, one get a safe write pattern: 373 // Decode: [ 0..15][16..31][32..47][ 0..15][16..31][32..47][0.. 374 // Deblock: [ 0..11][12..27][28..43][-4..11][12..27][28... 375 // Note that multi-threaded output _without_ deblocking can make use of two 376 // cache lines of 16 pixels only, since there's no lagging behind. The decoding 377 // and output process have non-concurrent writing: 378 // Decode: [ 0..15][16..31][ 0..15][16..31][... 379 // io->put: [ 0..15][16..31][ 0..15][... 380 381 #define MT_CACHE_LINES 3 382 #define ST_CACHE_LINES 1 // 1 cache row only for single-threaded case 383 384 // Initialize multi/single-thread worker 385 static int InitThreadContext(VP8Decoder* const dec) { 386 dec->cache_id_ = 0; 387 if (dec->use_threads_) { 388 WebPWorker* const worker = &dec->worker_; 389 if (!WebPWorkerReset(worker)) { 390 return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY, 391 "thread initialization failed."); 392 } 393 worker->data1 = dec; 394 worker->data2 = (void*)&dec->thread_ctx_.io_; 395 worker->hook = (WebPWorkerHook)FinishRow; 396 dec->num_caches_ = 397 (dec->filter_type_ > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1; 398 } else { 399 dec->num_caches_ = ST_CACHE_LINES; 400 } 401 return 1; 402 } 403 404 #undef MT_CACHE_LINES 405 #undef ST_CACHE_LINES 406 407 //------------------------------------------------------------------------------ 408 // Memory setup 409 410 static int AllocateMemory(VP8Decoder* const dec) { 411 const int num_caches = dec->num_caches_; 412 const int mb_w = dec->mb_w_; 413 // Note: we use 'size_t' when there's no overflow risk, uint64_t otherwise. 414 const size_t intra_pred_mode_size = 4 * mb_w * sizeof(uint8_t); 415 const size_t top_size = (16 + 8 + 8) * mb_w; 416 const size_t mb_info_size = (mb_w + 1) * sizeof(VP8MB); 417 const size_t f_info_size = 418 (dec->filter_type_ > 0) ? 419 mb_w * (dec->use_threads_ ? 2 : 1) * sizeof(VP8FInfo) 420 : 0; 421 const size_t yuv_size = YUV_SIZE * sizeof(*dec->yuv_b_); 422 const size_t coeffs_size = 384 * sizeof(*dec->coeffs_); 423 const size_t cache_height = (16 * num_caches 424 + kFilterExtraRows[dec->filter_type_]) * 3 / 2; 425 const size_t cache_size = top_size * cache_height; 426 // alpha_size is the only one that scales as width x height. 427 const uint64_t alpha_size = (dec->alpha_data_ != NULL) ? 428 (uint64_t)dec->pic_hdr_.width_ * dec->pic_hdr_.height_ : 0ULL; 429 const uint64_t needed = (uint64_t)intra_pred_mode_size 430 + top_size + mb_info_size + f_info_size 431 + yuv_size + coeffs_size 432 + cache_size + alpha_size + ALIGN_MASK; 433 uint8_t* mem; 434 435 if (needed != (size_t)needed) return 0; // check for overflow 436 if (needed > dec->mem_size_) { 437 free(dec->mem_); 438 dec->mem_size_ = 0; 439 dec->mem_ = WebPSafeMalloc(needed, sizeof(uint8_t)); 440 if (dec->mem_ == NULL) { 441 return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY, 442 "no memory during frame initialization."); 443 } 444 // down-cast is ok, thanks to WebPSafeAlloc() above. 445 dec->mem_size_ = (size_t)needed; 446 } 447 448 mem = (uint8_t*)dec->mem_; 449 dec->intra_t_ = (uint8_t*)mem; 450 mem += intra_pred_mode_size; 451 452 dec->y_t_ = (uint8_t*)mem; 453 mem += 16 * mb_w; 454 dec->u_t_ = (uint8_t*)mem; 455 mem += 8 * mb_w; 456 dec->v_t_ = (uint8_t*)mem; 457 mem += 8 * mb_w; 458 459 dec->mb_info_ = ((VP8MB*)mem) + 1; 460 mem += mb_info_size; 461 462 dec->f_info_ = f_info_size ? (VP8FInfo*)mem : NULL; 463 mem += f_info_size; 464 dec->thread_ctx_.id_ = 0; 465 dec->thread_ctx_.f_info_ = dec->f_info_; 466 if (dec->use_threads_) { 467 // secondary cache line. The deblocking process need to make use of the 468 // filtering strength from previous macroblock row, while the new ones 469 // are being decoded in parallel. We'll just swap the pointers. 470 dec->thread_ctx_.f_info_ += mb_w; 471 } 472 473 mem = (uint8_t*)((uintptr_t)(mem + ALIGN_MASK) & ~ALIGN_MASK); 474 assert((yuv_size & ALIGN_MASK) == 0); 475 dec->yuv_b_ = (uint8_t*)mem; 476 mem += yuv_size; 477 478 dec->coeffs_ = (int16_t*)mem; 479 mem += coeffs_size; 480 481 dec->cache_y_stride_ = 16 * mb_w; 482 dec->cache_uv_stride_ = 8 * mb_w; 483 { 484 const int extra_rows = kFilterExtraRows[dec->filter_type_]; 485 const int extra_y = extra_rows * dec->cache_y_stride_; 486 const int extra_uv = (extra_rows / 2) * dec->cache_uv_stride_; 487 dec->cache_y_ = ((uint8_t*)mem) + extra_y; 488 dec->cache_u_ = dec->cache_y_ 489 + 16 * num_caches * dec->cache_y_stride_ + extra_uv; 490 dec->cache_v_ = dec->cache_u_ 491 + 8 * num_caches * dec->cache_uv_stride_ + extra_uv; 492 dec->cache_id_ = 0; 493 } 494 mem += cache_size; 495 496 // alpha plane 497 dec->alpha_plane_ = alpha_size ? (uint8_t*)mem : NULL; 498 mem += alpha_size; 499 assert(mem <= (uint8_t*)dec->mem_ + dec->mem_size_); 500 501 // note: left-info is initialized once for all. 502 memset(dec->mb_info_ - 1, 0, mb_info_size); 503 504 // initialize top 505 memset(dec->intra_t_, B_DC_PRED, intra_pred_mode_size); 506 507 return 1; 508 } 509 510 static void InitIo(VP8Decoder* const dec, VP8Io* io) { 511 // prepare 'io' 512 io->mb_y = 0; 513 io->y = dec->cache_y_; 514 io->u = dec->cache_u_; 515 io->v = dec->cache_v_; 516 io->y_stride = dec->cache_y_stride_; 517 io->uv_stride = dec->cache_uv_stride_; 518 io->a = NULL; 519 } 520 521 int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) { 522 if (!InitThreadContext(dec)) return 0; // call first. Sets dec->num_caches_. 523 if (!AllocateMemory(dec)) return 0; 524 InitIo(dec, io); 525 VP8DspInit(); // Init critical function pointers and look-up tables. 526 return 1; 527 } 528 529 //------------------------------------------------------------------------------ 530 // Main reconstruction function. 531 532 static const int kScan[16] = { 533 0 + 0 * BPS, 4 + 0 * BPS, 8 + 0 * BPS, 12 + 0 * BPS, 534 0 + 4 * BPS, 4 + 4 * BPS, 8 + 4 * BPS, 12 + 4 * BPS, 535 0 + 8 * BPS, 4 + 8 * BPS, 8 + 8 * BPS, 12 + 8 * BPS, 536 0 + 12 * BPS, 4 + 12 * BPS, 8 + 12 * BPS, 12 + 12 * BPS 537 }; 538 539 static WEBP_INLINE int CheckMode(VP8Decoder* const dec, int mode) { 540 if (mode == B_DC_PRED) { 541 if (dec->mb_x_ == 0) { 542 return (dec->mb_y_ == 0) ? B_DC_PRED_NOTOPLEFT : B_DC_PRED_NOLEFT; 543 } else { 544 return (dec->mb_y_ == 0) ? B_DC_PRED_NOTOP : B_DC_PRED; 545 } 546 } 547 return mode; 548 } 549 550 static WEBP_INLINE void Copy32b(uint8_t* dst, uint8_t* src) { 551 *(uint32_t*)dst = *(uint32_t*)src; 552 } 553 554 void VP8ReconstructBlock(VP8Decoder* const dec) { 555 int j; 556 uint8_t* const y_dst = dec->yuv_b_ + Y_OFF; 557 uint8_t* const u_dst = dec->yuv_b_ + U_OFF; 558 uint8_t* const v_dst = dec->yuv_b_ + V_OFF; 559 560 // Rotate in the left samples from previously decoded block. We move four 561 // pixels at a time for alignment reason, and because of in-loop filter. 562 if (dec->mb_x_ > 0) { 563 for (j = -1; j < 16; ++j) { 564 Copy32b(&y_dst[j * BPS - 4], &y_dst[j * BPS + 12]); 565 } 566 for (j = -1; j < 8; ++j) { 567 Copy32b(&u_dst[j * BPS - 4], &u_dst[j * BPS + 4]); 568 Copy32b(&v_dst[j * BPS - 4], &v_dst[j * BPS + 4]); 569 } 570 } else { 571 for (j = 0; j < 16; ++j) { 572 y_dst[j * BPS - 1] = 129; 573 } 574 for (j = 0; j < 8; ++j) { 575 u_dst[j * BPS - 1] = 129; 576 v_dst[j * BPS - 1] = 129; 577 } 578 // Init top-left sample on left column too 579 if (dec->mb_y_ > 0) { 580 y_dst[-1 - BPS] = u_dst[-1 - BPS] = v_dst[-1 - BPS] = 129; 581 } 582 } 583 { 584 // bring top samples into the cache 585 uint8_t* const top_y = dec->y_t_ + dec->mb_x_ * 16; 586 uint8_t* const top_u = dec->u_t_ + dec->mb_x_ * 8; 587 uint8_t* const top_v = dec->v_t_ + dec->mb_x_ * 8; 588 const int16_t* coeffs = dec->coeffs_; 589 int n; 590 591 if (dec->mb_y_ > 0) { 592 memcpy(y_dst - BPS, top_y, 16); 593 memcpy(u_dst - BPS, top_u, 8); 594 memcpy(v_dst - BPS, top_v, 8); 595 } else if (dec->mb_x_ == 0) { 596 // we only need to do this init once at block (0,0). 597 // Afterward, it remains valid for the whole topmost row. 598 memset(y_dst - BPS - 1, 127, 16 + 4 + 1); 599 memset(u_dst - BPS - 1, 127, 8 + 1); 600 memset(v_dst - BPS - 1, 127, 8 + 1); 601 } 602 603 // predict and add residuals 604 605 if (dec->is_i4x4_) { // 4x4 606 uint32_t* const top_right = (uint32_t*)(y_dst - BPS + 16); 607 608 if (dec->mb_y_ > 0) { 609 if (dec->mb_x_ >= dec->mb_w_ - 1) { // on rightmost border 610 top_right[0] = top_y[15] * 0x01010101u; 611 } else { 612 memcpy(top_right, top_y + 16, sizeof(*top_right)); 613 } 614 } 615 // replicate the top-right pixels below 616 top_right[BPS] = top_right[2 * BPS] = top_right[3 * BPS] = top_right[0]; 617 618 // predict and add residues for all 4x4 blocks in turn. 619 for (n = 0; n < 16; n++) { 620 uint8_t* const dst = y_dst + kScan[n]; 621 VP8PredLuma4[dec->imodes_[n]](dst); 622 if (dec->non_zero_ac_ & (1 << n)) { 623 VP8Transform(coeffs + n * 16, dst, 0); 624 } else if (dec->non_zero_ & (1 << n)) { // only DC is present 625 VP8TransformDC(coeffs + n * 16, dst); 626 } 627 } 628 } else { // 16x16 629 const int pred_func = CheckMode(dec, dec->imodes_[0]); 630 VP8PredLuma16[pred_func](y_dst); 631 if (dec->non_zero_) { 632 for (n = 0; n < 16; n++) { 633 uint8_t* const dst = y_dst + kScan[n]; 634 if (dec->non_zero_ac_ & (1 << n)) { 635 VP8Transform(coeffs + n * 16, dst, 0); 636 } else if (dec->non_zero_ & (1 << n)) { // only DC is present 637 VP8TransformDC(coeffs + n * 16, dst); 638 } 639 } 640 } 641 } 642 { 643 // Chroma 644 const int pred_func = CheckMode(dec, dec->uvmode_); 645 VP8PredChroma8[pred_func](u_dst); 646 VP8PredChroma8[pred_func](v_dst); 647 648 if (dec->non_zero_ & 0x0f0000) { // chroma-U 649 const int16_t* const u_coeffs = dec->coeffs_ + 16 * 16; 650 if (dec->non_zero_ac_ & 0x0f0000) { 651 VP8TransformUV(u_coeffs, u_dst); 652 } else { 653 VP8TransformDCUV(u_coeffs, u_dst); 654 } 655 } 656 if (dec->non_zero_ & 0xf00000) { // chroma-V 657 const int16_t* const v_coeffs = dec->coeffs_ + 20 * 16; 658 if (dec->non_zero_ac_ & 0xf00000) { 659 VP8TransformUV(v_coeffs, v_dst); 660 } else { 661 VP8TransformDCUV(v_coeffs, v_dst); 662 } 663 } 664 665 // stash away top samples for next block 666 if (dec->mb_y_ < dec->mb_h_ - 1) { 667 memcpy(top_y, y_dst + 15 * BPS, 16); 668 memcpy(top_u, u_dst + 7 * BPS, 8); 669 memcpy(top_v, v_dst + 7 * BPS, 8); 670 } 671 } 672 } 673 // Transfer reconstructed samples from yuv_b_ cache to final destination. 674 { 675 const int y_offset = dec->cache_id_ * 16 * dec->cache_y_stride_; 676 const int uv_offset = dec->cache_id_ * 8 * dec->cache_uv_stride_; 677 uint8_t* const y_out = dec->cache_y_ + dec->mb_x_ * 16 + y_offset; 678 uint8_t* const u_out = dec->cache_u_ + dec->mb_x_ * 8 + uv_offset; 679 uint8_t* const v_out = dec->cache_v_ + dec->mb_x_ * 8 + uv_offset; 680 for (j = 0; j < 16; ++j) { 681 memcpy(y_out + j * dec->cache_y_stride_, y_dst + j * BPS, 16); 682 } 683 for (j = 0; j < 8; ++j) { 684 memcpy(u_out + j * dec->cache_uv_stride_, u_dst + j * BPS, 8); 685 memcpy(v_out + j * dec->cache_uv_stride_, v_dst + j * BPS, 8); 686 } 687 } 688 } 689 690 //------------------------------------------------------------------------------ 691 692 #if defined(__cplusplus) || defined(c_plusplus) 693 } // extern "C" 694 #endif 695