LCOV - code coverage report
Current view: top level - libavcodec - vp9lpf.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 112 112 100.0 %
Date: 2017-12-18 06:23:41 Functions: 3 3 100.0 %

          Line data    Source code
       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 FFmpeg.
       8             :  *
       9             :  * FFmpeg 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             :  * FFmpeg 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 FFmpeg; if not, write to the Free Software
      21             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      22             :  */
      23             : 
      24             : #include "vp9dec.h"
      25             : 
      26      141954 : static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
      27             :                                                uint8_t *lvl, uint8_t (*mask)[4],
      28             :                                                uint8_t *dst, ptrdiff_t ls)
      29             : {
      30      141954 :     int y, x, bytesperpixel = s->bytesperpixel;
      31             : 
      32             :     // filter edges between columns (e.g. block1 | block2)
      33      523378 :     for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
      34      381424 :         uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
      35      381424 :         unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
      36      381424 :         unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
      37      381424 :         unsigned hm = hm1 | hm2 | hm13 | hm23;
      38             : 
      39     2063879 :         for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
      40     1682455 :             if (col || x > 1) {
      41     1630492 :                 if (hm1 & x) {
      42     1107141 :                     int L = *l, H = L >> 4;
      43     1107141 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
      44             : 
      45     1107141 :                     if (hmask1[0] & x) {
      46      321675 :                         if (hmask2[0] & x) {
      47             :                             av_assert2(l[8 << ss_v] == L);
      48      320069 :                             s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
      49             :                         } else {
      50        1606 :                             s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
      51             :                         }
      52      785466 :                     } else if (hm2 & x) {
      53      723187 :                         L = l[8 << ss_v];
      54      723187 :                         H |= (L >> 4) << 8;
      55      723187 :                         E |= s->filter_lut.mblim_lut[L] << 8;
      56      723187 :                         I |= s->filter_lut.lim_lut[L] << 8;
      57     1446374 :                         s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
      58      723187 :                                                [!!(hmask2[1] & x)]
      59      723187 :                                                [0](ptr, ls, E, I, H);
      60             :                     } else {
      61      124558 :                         s->dsp.loop_filter_8[!!(hmask1[1] & x)]
      62       62279 :                                             [0](ptr, ls, E, I, H);
      63             :                     }
      64      523351 :                 } else if (hm2 & x) {
      65       30624 :                     int L = l[8 << ss_v], H = L >> 4;
      66       30624 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
      67             : 
      68       61248 :                     s->dsp.loop_filter_8[!!(hmask2[1] & x)]
      69       30624 :                                         [0](ptr + 8 * ls, ls, E, I, H);
      70             :                 }
      71             :             }
      72     1682455 :             if (ss_h) {
      73      817760 :                 if (x & 0xAA)
      74      341118 :                     l += 2;
      75             :             } else {
      76      864695 :                 if (hm13 & x) {
      77      108275 :                     int L = *l, H = L >> 4;
      78      108275 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
      79             : 
      80      108275 :                     if (hm23 & x) {
      81       62607 :                         L = l[8 << ss_v];
      82       62607 :                         H |= (L >> 4) << 8;
      83       62607 :                         E |= s->filter_lut.mblim_lut[L] << 8;
      84       62607 :                         I |= s->filter_lut.lim_lut[L] << 8;
      85       62607 :                         s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
      86             :                     } else {
      87       45668 :                         s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
      88             :                     }
      89      756420 :                 } else if (hm23 & x) {
      90       37272 :                     int L = l[8 << ss_v], H = L >> 4;
      91       37272 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
      92             : 
      93       37272 :                     s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
      94             :                 }
      95      864695 :                 l++;
      96             :             }
      97             :         }
      98             :     }
      99      141954 : }
     100             : 
     101      141954 : static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
     102             :                                                uint8_t *lvl, uint8_t (*mask)[4],
     103             :                                                uint8_t *dst, ptrdiff_t ls)
     104             : {
     105      141954 :     int y, x, bytesperpixel = s->bytesperpixel;
     106             : 
     107             :     //                                 block1
     108             :     // filter edges between rows (e.g. ------)
     109             :     //                                 block2
     110     1277586 :     for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
     111     1135632 :         uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
     112     1135632 :         unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
     113             : 
     114     2440976 :         for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
     115     1305344 :             if (row || y) {
     116     1239027 :                 if (vm & x) {
     117     1100965 :                     int L = *l, H = L >> 4;
     118     1100965 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
     119             : 
     120     1100965 :                     if (vmask[0] & x) {
     121      324511 :                         if (vmask[0] & (x << (1 + ss_h))) {
     122             :                             av_assert2(l[1 + ss_h] == L);
     123      324192 :                             s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
     124             :                         } else {
     125         319 :                             s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
     126             :                         }
     127      776454 :                     } else if (vm & (x << (1 + ss_h))) {
     128      711461 :                         L = l[1 + ss_h];
     129      711461 :                         H |= (L >> 4) << 8;
     130      711461 :                         E |= s->filter_lut.mblim_lut[L] << 8;
     131      711461 :                         I |= s->filter_lut.lim_lut[L] << 8;
     132     1422922 :                         s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
     133      711461 :                                                [!!(vmask[1] & (x << (1 + ss_h)))]
     134      711461 :                                                [1](ptr, ls, E, I, H);
     135             :                     } else {
     136      129986 :                         s->dsp.loop_filter_8[!!(vmask[1] & x)]
     137       64993 :                                             [1](ptr, ls, E, I, H);
     138             :                     }
     139      138062 :                 } else if (vm & (x << (1 + ss_h))) {
     140       33244 :                     int L = l[1 + ss_h], H = L >> 4;
     141       33244 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
     142             : 
     143       66488 :                     s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
     144       33244 :                                         [1](ptr + 8 * bytesperpixel, ls, E, I, H);
     145             :                 }
     146             :             }
     147     1305344 :             if (!ss_v) {
     148      710408 :                 if (vm3 & x) {
     149      102859 :                     int L = *l, H = L >> 4;
     150      102859 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
     151             : 
     152      102859 :                     if (vm3 & (x << (1 + ss_h))) {
     153       60664 :                         L = l[1 + ss_h];
     154       60664 :                         H |= (L >> 4) << 8;
     155       60664 :                         E |= s->filter_lut.mblim_lut[L] << 8;
     156       60664 :                         I |= s->filter_lut.lim_lut[L] << 8;
     157       60664 :                         s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
     158             :                     } else {
     159       42195 :                         s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
     160             :                     }
     161      607549 :                 } else if (vm3 & (x << (1 + ss_h))) {
     162       39943 :                     int L = l[1 + ss_h], H = L >> 4;
     163       39943 :                     int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
     164             : 
     165       39943 :                     s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
     166             :                 }
     167             :             }
     168             :         }
     169     1135632 :         if (ss_v) {
     170      745568 :             if (y & 1)
     171      372784 :                 lvl += 16;
     172             :         } else {
     173      390064 :             lvl += 8;
     174             :         }
     175             :     }
     176      141954 : }
     177             : 
     178       47318 : void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl,
     179             :                           int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
     180             : {
     181       47318 :     VP9Context *s = avctx->priv_data;
     182       47318 :     AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
     183       47318 :     uint8_t *dst = f->data[0] + yoff;
     184       47318 :     ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
     185       47318 :     uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
     186             :     int p;
     187             : 
     188             :     /* FIXME: In how far can we interleave the v/h loopfilter calls? E.g.
     189             :      * if you think of them as acting on a 8x8 block max, we can interleave
     190             :      * each v/h within the single x loop, but that only works if we work on
     191             :      * 8 pixel blocks, and we won't always do that (we want at least 16px
     192             :      * to use SSE2 optimizations, perhaps 32 for AVX2) */
     193             : 
     194       47318 :     filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
     195       47318 :     filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
     196             : 
     197      141954 :     for (p = 0; p < 2; p++) {
     198       94636 :         dst = f->data[1 + p] + uvoff;
     199       94636 :         filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
     200       94636 :         filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
     201             :     }
     202       47318 : }

Generated by: LCOV version 1.13