git.sesse.net Git - ffmpeg/blob - libavcodec/vp9mvs.c

   1 /*
   2  * VP9 compatible video decoder
   3  *
   4  * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
   5  * Copyright (C) 2013 Clément Bœsch <u pkh me>
   6  *
   7  * This file is part of Libav.
   8  *
   9  * Libav is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * Libav is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with Libav; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "internal.h"
  25 #include "vp56.h"
  26 #include "vp9.h"
  27 #include "vp9data.h"
  28
  29 static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
  30                                       VP9Context *s)
  31 {
  32     dst->x = av_clip(src->x, s->min_mv.x, s->max_mv.x);
  33     dst->y = av_clip(src->y, s->min_mv.y, s->max_mv.y);
  34 }
  35
  36 static void find_ref_mvs(VP9Context *s,
  37                          VP56mv *pmv, int ref, int z, int idx, int sb)
  38 {
  39     static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
  40         [BS_64x64] = { {  3, -1 }, { -1,  3 }, {  4, -1 }, { -1,  4 },
  41                        { -1, -1 }, {  0, -1 }, { -1,  0 }, {  6, -1 } },
  42         [BS_64x32] = { {  0, -1 }, { -1,  0 }, {  4, -1 }, { -1,  2 },
  43                        { -1, -1 }, {  0, -3 }, { -3,  0 }, {  2, -1 } },
  44         [BS_32x64] = { { -1,  0 }, {  0, -1 }, { -1,  4 }, {  2, -1 },
  45                        { -1, -1 }, { -3,  0 }, {  0, -3 }, { -1,  2 } },
  46         [BS_32x32] = { {  1, -1 }, { -1,  1 }, {  2, -1 }, { -1,  2 },
  47                        { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
  48         [BS_32x16] = { {  0, -1 }, { -1,  0 }, {  2, -1 }, { -1, -1 },
  49                        { -1,  1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
  50         [BS_16x32] = { { -1,  0 }, {  0, -1 }, { -1,  2 }, { -1, -1 },
  51                        {  1, -1 }, { -3,  0 }, {  0, -3 }, { -3, -3 } },
  52         [BS_16x16] = { {  0, -1 }, { -1,  0 }, {  1, -1 }, { -1,  1 },
  53                        { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
  54         [BS_16x8]  = { {  0, -1 }, { -1,  0 }, {  1, -1 }, { -1, -1 },
  55                        {  0, -2 }, { -2,  0 }, { -2, -1 }, { -1, -2 } },
  56         [BS_8x16]  = { { -1,  0 }, {  0, -1 }, { -1,  1 }, { -1, -1 },
  57                        { -2,  0 }, {  0, -2 }, { -1, -2 }, { -2, -1 } },
  58         [BS_8x8]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
  59                        { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
  60         [BS_8x4]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
  61                        { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
  62         [BS_4x8]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
  63                        { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
  64         [BS_4x4]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
  65                        { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
  66     };
  67     VP9Block *const b = &s->b;
  68     int row = b->row, col = b->col, row7 = b->row7;
  69     const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
  70 #define INVALID_MV 0x80008000U
  71     uint32_t mem = INVALID_MV;
  72     int i;
  73
  74 #define RETURN_DIRECT_MV(mv)                    \
  75     do {                                        \
  76         uint32_t m = AV_RN32A(&mv);             \
  77         if (!idx) {                             \
  78             AV_WN32A(pmv, m);                   \
  79             return;                             \
  80         } else if (mem == INVALID_MV) {         \
  81             mem = m;                            \
  82         } else if (m != mem) {                  \
  83             AV_WN32A(pmv, m);                   \
  84             return;                             \
  85         }                                       \
  86     } while (0)
  87
  88     if (sb >= 0) {
  89         if (sb == 2 || sb == 1) {
  90             RETURN_DIRECT_MV(b->mv[0][z]);
  91         } else if (sb == 3) {
  92             RETURN_DIRECT_MV(b->mv[2][z]);
  93             RETURN_DIRECT_MV(b->mv[1][z]);
  94             RETURN_DIRECT_MV(b->mv[0][z]);
  95         }
  96
  97 #define RETURN_MV(mv)                           \
  98     do {                                        \
  99         if (sb > 0) {                           \
 100             VP56mv tmp;                         \
 101             uint32_t m;                         \
 102             clamp_mv(&tmp, &mv, s);             \
 103             m = AV_RN32A(&tmp);                 \
 104             if (!idx) {                         \
 105                 AV_WN32A(pmv, m);               \
 106                 return;                         \
 107             } else if (mem == INVALID_MV) {     \
 108                 mem = m;                        \
 109             } else if (m != mem) {              \
 110                 AV_WN32A(pmv, m);               \
 111                 return;                         \
 112             }                                   \
 113         } else {                                \
 114             uint32_t m = AV_RN32A(&mv);         \
 115             if (!idx) {                         \
 116                 clamp_mv(pmv, &mv, s);          \
 117                 return;                         \
 118             } else if (mem == INVALID_MV) {     \
 119                 mem = m;                        \
 120             } else if (m != mem) {              \
 121                 clamp_mv(pmv, &mv, s);          \
 122                 return;                         \
 123             }                                   \
 124         }                                       \
 125     } while (0)
 126
 127         if (row > 0) {
 128             VP9MVRefPair *mv = &s->mv[0][(row - 1) * s->sb_cols * 8 + col];
 129
 130             if (mv->ref[0] == ref)
 131                 RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
 132             else if (mv->ref[1] == ref)
 133                 RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
 134         }
 135         if (col > s->tiling.tile_col_start) {
 136             VP9MVRefPair *mv = &s->mv[0][row * s->sb_cols * 8 + col - 1];
 137
 138             if (mv->ref[0] == ref)
 139                 RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
 140             else if (mv->ref[1] == ref)
 141                 RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
 142         }
 143         i = 2;
 144     } else {
 145         i = 0;
 146     }
 147
 148     // previously coded MVs in the neighborhood, using same reference frame
 149     for (; i < 8; i++) {
 150         int c = p[i][0] + col, r = p[i][1] + row;
 151
 152         if (c >= s->tiling.tile_col_start && c < s->cols &&
 153             r >= 0 && r < s->rows) {
 154             VP9MVRefPair *mv = &s->mv[0][r * s->sb_cols * 8 + c];
 155
 156             if (mv->ref[0] == ref)
 157                 RETURN_MV(mv->mv[0]);
 158             else if (mv->ref[1] == ref)
 159                 RETURN_MV(mv->mv[1]);
 160         }
 161     }
 162
 163     // MV at this position in previous frame, using same reference frame
 164     if (s->use_last_frame_mvs) {
 165         VP9MVRefPair *mv = &s->mv[1][row * s->sb_cols * 8 + col];
 166
 167         if (mv->ref[0] == ref)
 168             RETURN_MV(mv->mv[0]);
 169         else if (mv->ref[1] == ref)
 170             RETURN_MV(mv->mv[1]);
 171     }
 172
 173 #define RETURN_SCALE_MV(mv, scale)              \
 174     do {                                        \
 175         if (scale) {                            \
 176             VP56mv mv_temp = { -mv.x, -mv.y };  \
 177             RETURN_MV(mv_temp);                 \
 178         } else {                                \
 179             RETURN_MV(mv);                      \
 180         }                                       \
 181     } while (0)
 182
 183     // previously coded MVs in the neighborhood, using different reference frame
 184     for (i = 0; i < 8; i++) {
 185         int c = p[i][0] + col, r = p[i][1] + row;
 186
 187         if (c >= s->tiling.tile_col_start && c < s->cols &&
 188             r >= 0 && r < s->rows) {
 189             VP9MVRefPair *mv = &s->mv[0][r * s->sb_cols * 8 + c];
 190
 191             if (mv->ref[0] != ref && mv->ref[0] >= 0)
 192                 RETURN_SCALE_MV(mv->mv[0],
 193                                 s->signbias[mv->ref[0]] != s->signbias[ref]);
 194             if (mv->ref[1] != ref && mv->ref[1] >= 0)
 195                 RETURN_SCALE_MV(mv->mv[1],
 196                                 s->signbias[mv->ref[1]] != s->signbias[ref]);
 197         }
 198     }
 199
 200     // MV at this position in previous frame, using different reference frame
 201     if (s->use_last_frame_mvs) {
 202         VP9MVRefPair *mv = &s->mv[1][row * s->sb_cols * 8 + col];
 203
 204         if (mv->ref[0] != ref && mv->ref[0] >= 0)
 205             RETURN_SCALE_MV(mv->mv[0],
 206                             s->signbias[mv->ref[0]] != s->signbias[ref]);
 207         if (mv->ref[1] != ref && mv->ref[1] >= 0)
 208             RETURN_SCALE_MV(mv->mv[1],
 209                             s->signbias[mv->ref[1]] != s->signbias[ref]);
 210     }
 211
 212     AV_ZERO32(pmv);
 213 #undef INVALID_MV
 214 #undef RETURN_MV
 215 #undef RETURN_SCALE_MV
 216 }
 217
 218 static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
 219 {
 220     int bit, sign = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].sign);
 221     int n, c = vp8_rac_get_tree(&s->c, ff_vp9_mv_class_tree,
 222                                 s->prob.p.mv_comp[idx].classes);
 223
 224     s->counts.mv_comp[idx].sign[sign]++;
 225     s->counts.mv_comp[idx].classes[c]++;
 226     if (c) {
 227         int m;
 228
 229         for (n = 0, m = 0; m < c; m++) {
 230             bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].bits[m]);
 231             n  |= bit << m;
 232             s->counts.mv_comp[idx].bits[m][bit]++;
 233         }
 234         n <<= 3;
 235         bit = vp8_rac_get_tree(&s->c, ff_vp9_mv_fp_tree,
 236                                s->prob.p.mv_comp[idx].fp);
 237         n  |= bit << 1;
 238         s->counts.mv_comp[idx].fp[bit]++;
 239         if (hp) {
 240             bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].hp);
 241             s->counts.mv_comp[idx].hp[bit]++;
 242             n |= bit;
 243         } else {
 244             n |= 1;
 245             // bug in libvpx - we count for bw entropy purposes even if the
 246             // bit wasn't coded
 247             s->counts.mv_comp[idx].hp[1]++;
 248         }
 249         n += 8 << c;
 250     } else {
 251         n = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0);
 252         s->counts.mv_comp[idx].class0[n]++;
 253         bit = vp8_rac_get_tree(&s->c, ff_vp9_mv_fp_tree,
 254                                s->prob.p.mv_comp[idx].class0_fp[n]);
 255         s->counts.mv_comp[idx].class0_fp[n][bit]++;
 256         n = (n << 3) | (bit << 1);
 257         if (hp) {
 258             bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0_hp);
 259             s->counts.mv_comp[idx].class0_hp[bit]++;
 260             n |= bit;
 261         } else {
 262             n |= 1;
 263             // bug in libvpx - we count for bw entropy purposes even if the
 264             // bit wasn't coded
 265             s->counts.mv_comp[idx].class0_hp[1]++;
 266         }
 267     }
 268
 269     return sign ? -(n + 1) : (n + 1);
 270 }
 271
 272 void ff_vp9_fill_mv(VP9Context *s, VP56mv *mv, int mode, int sb)
 273 {
 274     VP9Block *const b = &s->b;
 275
 276     if (mode == ZEROMV) {
 277         memset(mv, 0, sizeof(*mv) * 2);
 278     } else {
 279         int hp;
 280
 281         // FIXME cache this value and reuse for other subblocks
 282         find_ref_mvs(s, &mv[0], b->ref[0], 0, mode == NEARMV,
 283                      mode == NEWMV ? -1 : sb);
 284         // FIXME maybe move this code into find_ref_mvs()
 285         if ((mode == NEWMV || sb == -1) &&
 286             !(hp = s->highprecisionmvs &&
 287               abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
 288             if (mv[0].y & 1) {
 289                 if (mv[0].y < 0)
 290                     mv[0].y++;
 291                 else
 292                     mv[0].y--;
 293             }
 294             if (mv[0].x & 1) {
 295                 if (mv[0].x < 0)
 296                     mv[0].x++;
 297                 else
 298                     mv[0].x--;
 299             }
 300         }
 301         if (mode == NEWMV) {
 302             enum MVJoint j = vp8_rac_get_tree(&s->c, ff_vp9_mv_joint_tree,
 303                                               s->prob.p.mv_joint);
 304
 305             s->counts.mv_joint[j]++;
 306             if (j >= MV_JOINT_V)
 307                 mv[0].y += read_mv_component(s, 0, hp);
 308             if (j & 1)
 309                 mv[0].x += read_mv_component(s, 1, hp);
 310         }
 311
 312         if (b->comp) {
 313             // FIXME cache this value and reuse for other subblocks
 314             find_ref_mvs(s, &mv[1], b->ref[1], 1, mode == NEARMV,
 315                          mode == NEWMV ? -1 : sb);
 316             if ((mode == NEWMV || sb == -1) &&
 317                 !(hp = s->highprecisionmvs &&
 318                   abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
 319                 if (mv[1].y & 1) {
 320                     if (mv[1].y < 0)
 321                         mv[1].y++;
 322                     else
 323                         mv[1].y--;
 324                 }
 325                 if (mv[1].x & 1) {
 326                     if (mv[1].x < 0)
 327                         mv[1].x++;
 328                     else
 329                         mv[1].x--;
 330                 }
 331             }
 332             if (mode == NEWMV) {
 333                 enum MVJoint j = vp8_rac_get_tree(&s->c, ff_vp9_mv_joint_tree,
 334                                                   s->prob.p.mv_joint);
 335
 336                 s->counts.mv_joint[j]++;
 337                 if (j >= MV_JOINT_V)
 338                     mv[1].y += read_mv_component(s, 0, hp);
 339                 if (j & 1)
 340                     mv[1].x += read_mv_component(s, 1, hp);
 341             }
 342         }
 343     }
 344 }