vp8/encoder/temporal_filter.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #include "vp8/common/onyxc_int.h"
  13 #include "onyx_int.h"
  14 #include "vp8/common/systemdependent.h"
  15 #include "quantize.h"
  16 #include "vp8/common/alloccommon.h"
  17 #include "mcomp.h"
  18 #include "firstpass.h"
  19 #include "psnr.h"
  20 #include "vpx_scale/vpxscale.h"
  21 #include "vp8/common/extend.h"
  22 #include "ratectrl.h"
  23 #include "vp8/common/quant_common.h"
  24 #include "segmentation.h"
  25 #include "vpx_mem/vpx_mem.h"
  26 #include "vp8/common/swapyv12buffer.h"
  27 #include "vp8/common/threading.h"
  28 #include "vpx_ports/vpx_timer.h"
  29
  30 #include <math.h>
  31 #include <limits.h>
  32
  33 #define ALT_REF_MC_ENABLED 1    // dis/enable MC in AltRef filtering
  34 #define ALT_REF_SUBPEL_ENABLED 1 // dis/enable subpel in MC AltRef filtering
  35
  36 #if VP8_TEMPORAL_ALT_REF
  37
  38 static void vp8_temporal_filter_predictors_mb_c
  39 (
  40     MACROBLOCKD *x,
  41     unsigned char *y_mb_ptr,
  42     unsigned char *u_mb_ptr,
  43     unsigned char *v_mb_ptr,
  44     int stride,
  45     int mv_row,
  46     int mv_col,
  47     unsigned char *pred
  48 )
  49 {
  50     int offset;
  51     unsigned char *yptr, *uptr, *vptr;
  52
  53     // Y
  54     yptr = y_mb_ptr + (mv_row >> 3) * stride + (mv_col >> 3);
  55
  56     if ((mv_row | mv_col) & 7)
  57     {
  58         x->subpixel_predict16x16(yptr, stride,
  59                                     mv_col & 7, mv_row & 7, &pred[0], 16);
  60     }
  61     else
  62     {
  63         vp8_copy_mem16x16(yptr, stride, &pred[0], 16);
  64     }
  65
  66     // U & V
  67     mv_row >>= 1;
  68     mv_col >>= 1;
  69     stride = (stride + 1) >> 1;
  70     offset = (mv_row >> 3) * stride + (mv_col >> 3);
  71     uptr = u_mb_ptr + offset;
  72     vptr = v_mb_ptr + offset;
  73
  74     if ((mv_row | mv_col) & 7)
  75     {
  76         x->subpixel_predict8x8(uptr, stride,
  77                             mv_col & 7, mv_row & 7, &pred[256], 8);
  78         x->subpixel_predict8x8(vptr, stride,
  79                             mv_col & 7, mv_row & 7, &pred[320], 8);
  80     }
  81     else
  82     {
  83         vp8_copy_mem8x8(uptr, stride, &pred[256], 8);
  84         vp8_copy_mem8x8(vptr, stride, &pred[320], 8);
  85     }
  86 }
  87 void vp8_temporal_filter_apply_c
  88 (
  89     unsigned char *frame1,
  90     unsigned int stride,
  91     unsigned char *frame2,
  92     unsigned int block_size,
  93     int strength,
  94     int filter_weight,
  95     unsigned int *accumulator,
  96     unsigned short *count
  97 )
  98 {
  99     unsigned int i, j, k;
 100     int modifier;
 101     int byte = 0;
 102
 103     for (i = 0,k = 0; i < block_size; i++)
 104     {
 105         for (j = 0; j < block_size; j++, k++)
 106         {
 107
 108             int src_byte = frame1[byte];
 109             int pixel_value = *frame2++;
 110
 111             modifier   = src_byte - pixel_value;
 112             // This is an integer approximation of:
 113             // float coeff = (3.0 * modifer * modifier) / pow(2, strength);
 114             // modifier =  (int)roundf(coeff > 16 ? 0 : 16-coeff);
 115             modifier  *= modifier;
 116             modifier  *= 3;
 117             modifier  += 1 << (strength - 1);
 118             modifier >>= strength;
 119
 120             if (modifier > 16)
 121                 modifier = 16;
 122
 123             modifier = 16 - modifier;
 124             modifier *= filter_weight;
 125
 126             count[k] += modifier;
 127             accumulator[k] += modifier * pixel_value;
 128
 129             byte++;
 130         }
 131
 132         byte += stride - block_size;
 133     }
 134 }
 135
 136 #if ALT_REF_MC_ENABLED
 137
 138 static int vp8_temporal_filter_find_matching_mb_c
 139 (
 140     VP8_COMP *cpi,
 141     YV12_BUFFER_CONFIG *arf_frame,
 142     YV12_BUFFER_CONFIG *frame_ptr,
 143     int mb_offset,
 144     int error_thresh
 145 )
 146 {
 147     MACROBLOCK *x = &cpi->mb;
 148     int step_param;
 149     int sadpb = x->sadperbit16;
 150     int bestsme = INT_MAX;
 151
 152     BLOCK *b = &x->block[0];
 153     BLOCKD *d = &x->e_mbd.block[0];
 154     int_mv best_ref_mv1;
 155     int_mv best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
 156
 157     // Save input state
 158     unsigned char **base_src = b->base_src;
 159     int src = b->src;
 160     int src_stride = b->src_stride;
 161     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
 162     int pre = d->offset;
 163     int pre_stride = x->e_mbd.pre.y_stride;
 164
 165     best_ref_mv1.as_int = 0;
 166     best_ref_mv1_full.as_mv.col = best_ref_mv1.as_mv.col >>3;
 167     best_ref_mv1_full.as_mv.row = best_ref_mv1.as_mv.row >>3;
 168
 169     // Setup frame pointers
 170     b->base_src = &arf_frame->y_buffer;
 171     b->src_stride = arf_frame->y_stride;
 172     b->src = mb_offset;
 173
 174     x->e_mbd.pre.y_buffer = frame_ptr->y_buffer;
 175     x->e_mbd.pre.y_stride = frame_ptr->y_stride;
 176     d->offset = mb_offset;
 177
 178     // Further step/diamond searches as necessary
 179     if (cpi->Speed < 8)
 180     {
 181         step_param = cpi->sf.first_step + (cpi->Speed > 5);
 182     }
 183     else
 184     {
 185         step_param = cpi->sf.first_step + 2;
 186     }
 187
 188     /*cpi->sf.search_method == HEX*/
 189     // TODO Check that the 16x16 vf & sdf are selected here
 190     // Ignore mv costing by sending NULL cost arrays
 191     bestsme = vp8_hex_search(x, b, d, &best_ref_mv1_full, &d->bmi.mv,
 192                              step_param, sadpb,
 193                              &cpi->fn_ptr[BLOCK_16X16],
 194                              NULL, NULL, &best_ref_mv1);
 195
 196 #if ALT_REF_SUBPEL_ENABLED
 197     // Try sub-pixel MC?
 198     //if (bestsme > error_thresh && bestsme < INT_MAX)
 199     {
 200         int distortion;
 201         unsigned int sse;
 202         // Ignore mv costing by sending NULL cost array
 203         bestsme = cpi->find_fractional_mv_step(x, b, d,
 204                                                &d->bmi.mv,
 205                                                &best_ref_mv1,
 206                                                x->errorperbit,
 207                                                &cpi->fn_ptr[BLOCK_16X16],
 208                                                NULL, &distortion, &sse);
 209     }
 210 #endif
 211
 212     // Save input state
 213     b->base_src = base_src;
 214     b->src = src;
 215     b->src_stride = src_stride;
 216     x->e_mbd.pre.y_buffer = base_pre;
 217     d->offset = pre;
 218     x->e_mbd.pre.y_stride = pre_stride;
 219
 220     return bestsme;
 221 }
 222 #endif
 223
 224 static void vp8_temporal_filter_iterate_c
 225 (
 226     VP8_COMP *cpi,
 227     int frame_count,
 228     int alt_ref_index,
 229     int strength
 230 )
 231 {
 232     int byte;
 233     int frame;
 234     int mb_col, mb_row;
 235     unsigned int filter_weight;
 236     int mb_cols = cpi->common.mb_cols;
 237     int mb_rows = cpi->common.mb_rows;
 238     int mb_y_offset = 0;
 239     int mb_uv_offset = 0;
 240     DECLARE_ALIGNED_ARRAY(16, unsigned int, accumulator, 16*16 + 8*8 + 8*8);
 241     DECLARE_ALIGNED_ARRAY(16, unsigned short, count, 16*16 + 8*8 + 8*8);
 242     MACROBLOCKD *mbd = &cpi->mb.e_mbd;
 243     YV12_BUFFER_CONFIG *f = cpi->frames[alt_ref_index];
 244     unsigned char *dst1, *dst2;
 245     DECLARE_ALIGNED_ARRAY(16, unsigned char,  predictor, 16*16 + 8*8 + 8*8);
 246
 247     // Save input state
 248     unsigned char *y_buffer = mbd->pre.y_buffer;
 249     unsigned char *u_buffer = mbd->pre.u_buffer;
 250     unsigned char *v_buffer = mbd->pre.v_buffer;
 251
 252     for (mb_row = 0; mb_row < mb_rows; mb_row++)
 253     {
 254 #if ALT_REF_MC_ENABLED
 255         // Source frames are extended to 16 pixels.  This is different than
 256         //  L/A/G reference frames that have a border of 32 (VP8BORDERINPIXELS)
 257         // A 6 tap filter is used for motion search.  This requires 2 pixels
 258         //  before and 3 pixels after.  So the largest Y mv on a border would
 259         //  then be 16 - 3.  The UV blocks are half the size of the Y and
 260         //  therefore only extended by 8.  The largest mv that a UV block
 261         //  can support is 8 - 3.  A UV mv is half of a Y mv.
 262         //  (16 - 3) >> 1 == 6 which is greater than 8 - 3.
 263         // To keep the mv in play for both Y and UV planes the max that it
 264         //  can be on a border is therefore 16 - 5.
 265         cpi->mb.mv_row_min = -((mb_row * 16) + (16 - 5));
 266         cpi->mb.mv_row_max = ((cpi->common.mb_rows - 1 - mb_row) * 16)
 267                                 + (16 - 5);
 268 #endif
 269
 270         for (mb_col = 0; mb_col < mb_cols; mb_col++)
 271         {
 272             int i, j, k;
 273             int stride;
 274
 275             vpx_memset(accumulator, 0, 384*sizeof(unsigned int));
 276             vpx_memset(count, 0, 384*sizeof(unsigned short));
 277
 278 #if ALT_REF_MC_ENABLED
 279             cpi->mb.mv_col_min = -((mb_col * 16) + (16 - 5));
 280             cpi->mb.mv_col_max = ((cpi->common.mb_cols - 1 - mb_col) * 16)
 281                                     + (16 - 5);
 282 #endif
 283
 284             for (frame = 0; frame < frame_count; frame++)
 285             {
 286                 if (cpi->frames[frame] == NULL)
 287                     continue;
 288
 289                 mbd->block[0].bmi.mv.as_mv.row = 0;
 290                 mbd->block[0].bmi.mv.as_mv.col = 0;
 291
 292                 if (frame == alt_ref_index)
 293                 {
 294                     filter_weight = 2;
 295                 }
 296                 else
 297                 {
 298                     int err = 0;
 299 #if ALT_REF_MC_ENABLED
 300 #define THRESH_LOW   10000
 301 #define THRESH_HIGH  20000
 302                     // Find best match in this frame by MC
 303                     err = vp8_temporal_filter_find_matching_mb_c
 304                               (cpi,
 305                                cpi->frames[alt_ref_index],
 306                                cpi->frames[frame],
 307                                mb_y_offset,
 308                                THRESH_LOW);
 309 #endif
 310                     // Assign higher weight to matching MB if it's error
 311                     // score is lower. If not applying MC default behavior
 312                     // is to weight all MBs equal.
 313                     filter_weight = err<THRESH_LOW
 314                                        ? 2 : err<THRESH_HIGH ? 1 : 0;
 315                 }
 316
 317                 if (filter_weight != 0)
 318                 {
 319                     // Construct the predictors
 320                     vp8_temporal_filter_predictors_mb_c
 321                         (mbd,
 322                          cpi->frames[frame]->y_buffer + mb_y_offset,
 323                          cpi->frames[frame]->u_buffer + mb_uv_offset,
 324                          cpi->frames[frame]->v_buffer + mb_uv_offset,
 325                          cpi->frames[frame]->y_stride,
 326                          mbd->block[0].bmi.mv.as_mv.row,
 327                          mbd->block[0].bmi.mv.as_mv.col,
 328                          predictor);
 329
 330                     // Apply the filter (YUV)
 331                     vp8_temporal_filter_apply
 332                         (f->y_buffer + mb_y_offset,
 333                          f->y_stride,
 334                          predictor,
 335                          16,
 336                          strength,
 337                          filter_weight,
 338                          accumulator,
 339                          count);
 340
 341                     vp8_temporal_filter_apply
 342                         (f->u_buffer + mb_uv_offset,
 343                          f->uv_stride,
 344                          predictor + 256,
 345                          8,
 346                          strength,
 347                          filter_weight,
 348                          accumulator + 256,
 349                          count + 256);
 350
 351                     vp8_temporal_filter_apply
 352                         (f->v_buffer + mb_uv_offset,
 353                          f->uv_stride,
 354                          predictor + 320,
 355                          8,
 356                          strength,
 357                          filter_weight,
 358                          accumulator + 320,
 359                          count + 320);
 360                 }
 361             }
 362
 363             // Normalize filter output to produce AltRef frame
 364             dst1 = cpi->alt_ref_buffer.y_buffer;
 365             stride = cpi->alt_ref_buffer.y_stride;
 366             byte = mb_y_offset;
 367             for (i = 0,k = 0; i < 16; i++)
 368             {
 369                 for (j = 0; j < 16; j++, k++)
 370                 {
 371                     unsigned int pval = accumulator[k] + (count[k] >> 1);
 372                     pval *= cpi->fixed_divide[count[k]];
 373                     pval >>= 19;
 374
 375                     dst1[byte] = (unsigned char)pval;
 376
 377                     // move to next pixel
 378                     byte++;
 379                 }
 380
 381                 byte += stride - 16;
 382             }
 383
 384             dst1 = cpi->alt_ref_buffer.u_buffer;
 385             dst2 = cpi->alt_ref_buffer.v_buffer;
 386             stride = cpi->alt_ref_buffer.uv_stride;
 387             byte = mb_uv_offset;
 388             for (i = 0,k = 256; i < 8; i++)
 389             {
 390                 for (j = 0; j < 8; j++, k++)
 391                 {
 392                     int m=k+64;
 393
 394                     // U
 395                     unsigned int pval = accumulator[k] + (count[k] >> 1);
 396                     pval *= cpi->fixed_divide[count[k]];
 397                     pval >>= 19;
 398                     dst1[byte] = (unsigned char)pval;
 399
 400                     // V
 401                     pval = accumulator[m] + (count[m] >> 1);
 402                     pval *= cpi->fixed_divide[count[m]];
 403                     pval >>= 19;
 404                     dst2[byte] = (unsigned char)pval;
 405
 406                     // move to next pixel
 407                     byte++;
 408                 }
 409
 410                 byte += stride - 8;
 411             }
 412
 413             mb_y_offset += 16;
 414             mb_uv_offset += 8;
 415         }
 416
 417         mb_y_offset += 16*(f->y_stride-mb_cols);
 418         mb_uv_offset += 8*(f->uv_stride-mb_cols);
 419     }
 420
 421     // Restore input state
 422     mbd->pre.y_buffer = y_buffer;
 423     mbd->pre.u_buffer = u_buffer;
 424     mbd->pre.v_buffer = v_buffer;
 425 }
 426
 427 void vp8_temporal_filter_prepare_c
 428 (
 429     VP8_COMP *cpi,
 430     int distance
 431 )
 432 {
 433     int frame = 0;
 434
 435     int num_frames_backward = 0;
 436     int num_frames_forward = 0;
 437     int frames_to_blur_backward = 0;
 438     int frames_to_blur_forward = 0;
 439     int frames_to_blur = 0;
 440     int start_frame = 0;
 441
 442     int strength = cpi->oxcf.arnr_strength;
 443
 444     int blur_type = cpi->oxcf.arnr_type;
 445
 446     int max_frames = cpi->active_arnr_frames;
 447
 448     num_frames_backward = distance;
 449     num_frames_forward = vp8_lookahead_depth(cpi->lookahead)
 450                          - (num_frames_backward + 1);
 451
 452     switch (blur_type)
 453     {
 454     case 1:
 455         /////////////////////////////////////////
 456         // Backward Blur
 457
 458         frames_to_blur_backward = num_frames_backward;
 459
 460         if (frames_to_blur_backward >= max_frames)
 461             frames_to_blur_backward = max_frames - 1;
 462
 463         frames_to_blur = frames_to_blur_backward + 1;
 464         break;
 465
 466     case 2:
 467         /////////////////////////////////////////
 468         // Forward Blur
 469
 470         frames_to_blur_forward = num_frames_forward;
 471
 472         if (frames_to_blur_forward >= max_frames)
 473             frames_to_blur_forward = max_frames - 1;
 474
 475         frames_to_blur = frames_to_blur_forward + 1;
 476         break;
 477
 478     case 3:
 479     default:
 480         /////////////////////////////////////////
 481         // Center Blur
 482         frames_to_blur_forward = num_frames_forward;
 483         frames_to_blur_backward = num_frames_backward;
 484
 485         if (frames_to_blur_forward > frames_to_blur_backward)
 486             frames_to_blur_forward = frames_to_blur_backward;
 487
 488         if (frames_to_blur_backward > frames_to_blur_forward)
 489             frames_to_blur_backward = frames_to_blur_forward;
 490
 491         // When max_frames is even we have 1 more frame backward than forward
 492         if (frames_to_blur_forward > (max_frames - 1) / 2)
 493             frames_to_blur_forward = ((max_frames - 1) / 2);
 494
 495         if (frames_to_blur_backward > (max_frames / 2))
 496             frames_to_blur_backward = (max_frames / 2);
 497
 498         frames_to_blur = frames_to_blur_backward + frames_to_blur_forward + 1;
 499         break;
 500     }
 501
 502     start_frame = distance + frames_to_blur_forward;
 503
 504 #ifdef DEBUGFWG
 505     // DEBUG FWG
 506     printf("max:%d FBCK:%d FFWD:%d ftb:%d ftbbck:%d ftbfwd:%d sei:%d lasei:%d start:%d"
 507            , max_frames
 508            , num_frames_backward
 509            , num_frames_forward
 510            , frames_to_blur
 511            , frames_to_blur_backward
 512            , frames_to_blur_forward
 513            , cpi->source_encode_index
 514            , cpi->last_alt_ref_sei
 515            , start_frame);
 516 #endif
 517
 518     // Setup frame pointers, NULL indicates frame not included in filter
 519     vpx_memset(cpi->frames, 0, max_frames*sizeof(YV12_BUFFER_CONFIG *));
 520     for (frame = 0; frame < frames_to_blur; frame++)
 521     {
 522         int which_buffer =  start_frame - frame;
 523         struct lookahead_entry* buf = vp8_lookahead_peek(cpi->lookahead,
 524                                                          which_buffer,
 525                                                          PEEK_FORWARD);
 526         cpi->frames[frames_to_blur-1-frame] = &buf->img;
 527     }
 528
 529     vp8_temporal_filter_iterate_c (
 530         cpi,
 531         frames_to_blur,
 532         frames_to_blur_backward,
 533         strength );
 534 }
 535 #endif