LCOV - code coverage report
Current view: top level - libavcodec - h264_mb_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 139 196 70.9 %
Date: 2017-12-15 18:13:28 Functions: 5 5 100.0 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... decoder
       3             :  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #undef FUNC
      23             : #undef PIXEL_SHIFT
      24             : 
      25             : #if SIMPLE
      26             : #   define FUNC(n) AV_JOIN(n ## _simple_, BITS)
      27             : #   define PIXEL_SHIFT (BITS >> 4)
      28             : #else
      29             : #   define FUNC(n) n ## _complex
      30             : #   define PIXEL_SHIFT h->pixel_shift
      31             : #endif
      32             : 
      33             : #undef  CHROMA_IDC
      34             : #define CHROMA_IDC 1
      35             : #include "h264_mc_template.c"
      36             : 
      37             : #undef  CHROMA_IDC
      38             : #define CHROMA_IDC 2
      39             : #include "h264_mc_template.c"
      40             : 
      41    12301198 : static av_noinline void FUNC(hl_decode_mb)(const H264Context *h, H264SliceContext *sl)
      42             : {
      43    12301198 :     const int mb_x    = sl->mb_x;
      44    12301198 :     const int mb_y    = sl->mb_y;
      45    12301198 :     const int mb_xy   = sl->mb_xy;
      46    12301198 :     const int mb_type = h->cur_pic.mb_type[mb_xy];
      47             :     uint8_t *dest_y, *dest_cb, *dest_cr;
      48             :     int linesize, uvlinesize /*dct_offset*/;
      49             :     int i, j;
      50    12301198 :     const int *block_offset = &h->block_offset[0];
      51    12301198 :     const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->ps.sps->transform_bypass);
      52             :     void (*idct_add)(uint8_t *dst, int16_t *block, int stride);
      53    12301198 :     const int block_h   = 16 >> h->chroma_y_shift;
      54    12301198 :     const int chroma422 = CHROMA422(h);
      55             : 
      56    12301198 :     dest_y  = h->cur_pic.f->data[0] + ((mb_x << PIXEL_SHIFT)     + mb_y * sl->linesize)  * 16;
      57    12301198 :     dest_cb = h->cur_pic.f->data[1] +  (mb_x << PIXEL_SHIFT) * 8 + mb_y * sl->uvlinesize * block_h;
      58    12301198 :     dest_cr = h->cur_pic.f->data[2] +  (mb_x << PIXEL_SHIFT) * 8 + mb_y * sl->uvlinesize * block_h;
      59             : 
      60    12301198 :     h->vdsp.prefetch(dest_y  + (sl->mb_x & 3) * 4 * sl->linesize   + (64 << PIXEL_SHIFT), sl->linesize,       4);
      61    12301198 :     h->vdsp.prefetch(dest_cb + (sl->mb_x & 7)     * sl->uvlinesize + (64 << PIXEL_SHIFT), dest_cr - dest_cb, 2);
      62             : 
      63    12301198 :     h->list_counts[mb_xy] = sl->list_count;
      64             : 
      65     5597230 :     if (!SIMPLE && MB_FIELD(sl)) {
      66     4297479 :         linesize     = sl->mb_linesize = sl->linesize * 2;
      67     4297479 :         uvlinesize   = sl->mb_uvlinesize = sl->uvlinesize * 2;
      68     4297479 :         block_offset = &h->block_offset[48];
      69     4297479 :         if (mb_y & 1) { // FIXME move out of this function?
      70     2146721 :             dest_y  -= sl->linesize * 15;
      71     2146721 :             dest_cb -= sl->uvlinesize * (block_h - 1);
      72     2146721 :             dest_cr -= sl->uvlinesize * (block_h - 1);
      73             :         }
      74     4297479 :         if (FRAME_MBAFF(h)) {
      75             :             int list;
      76     1347966 :             for (list = 0; list < sl->list_count; list++) {
      77      732224 :                 if (!USES_LIST(mb_type, list))
      78      179296 :                     continue;
      79      552928 :                 if (IS_16X16(mb_type)) {
      80      257052 :                     int8_t *ref = &sl->ref_cache[list][scan8[0]];
      81      257052 :                     fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (sl->mb_y & 1), 1);
      82             :                 } else {
      83     1479380 :                     for (i = 0; i < 16; i += 4) {
      84     1183504 :                         int ref = sl->ref_cache[list][scan8[i]];
      85     1183504 :                         if (ref >= 0)
      86     1039583 :                             fill_rectangle(&sl->ref_cache[list][scan8[i]], 2, 2,
      87     1039583 :                                            8, (16 + ref) ^ (sl->mb_y & 1), 1);
      88             :                     }
      89             :                 }
      90             :             }
      91             :         }
      92             :     } else {
      93     8003719 :         linesize   = sl->mb_linesize   = sl->linesize;
      94     8003719 :         uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
      95             :         // dct_offset = s->linesize * 16;
      96             :     }
      97             : 
      98     5597230 :     if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
      99       23105 :         const int bit_depth = h->ps.sps->bit_depth_luma;
     100       23105 :         if (PIXEL_SHIFT) {
     101             :             int j;
     102             :             GetBitContext gb;
     103           0 :             init_get_bits(&gb, sl->intra_pcm_ptr,
     104           0 :                           ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] * bit_depth);
     105             : 
     106           0 :             for (i = 0; i < 16; i++) {
     107           0 :                 uint16_t *tmp_y = (uint16_t *)(dest_y + i * linesize);
     108           0 :                 for (j = 0; j < 16; j++)
     109           0 :                     tmp_y[j] = get_bits(&gb, bit_depth);
     110             :             }
     111             :             if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     112           0 :                 if (!h->ps.sps->chroma_format_idc) {
     113           0 :                     for (i = 0; i < block_h; i++) {
     114           0 :                         uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
     115           0 :                         uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
     116           0 :                         for (j = 0; j < 8; j++) {
     117           0 :                             tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
     118             :                         }
     119             :                     }
     120             :                 } else {
     121           0 :                     for (i = 0; i < block_h; i++) {
     122           0 :                         uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
     123           0 :                         for (j = 0; j < 8; j++)
     124           0 :                             tmp_cb[j] = get_bits(&gb, bit_depth);
     125             :                     }
     126           0 :                     for (i = 0; i < block_h; i++) {
     127           0 :                         uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
     128           0 :                         for (j = 0; j < 8; j++)
     129           0 :                             tmp_cr[j] = get_bits(&gb, bit_depth);
     130             :                     }
     131             :                 }
     132             :             }
     133             :         } else {
     134      392785 :             for (i = 0; i < 16; i++)
     135      369680 :                 memcpy(dest_y + i * linesize, sl->intra_pcm_ptr + i * 16, 16);
     136             :             if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     137       23105 :                 if (!h->ps.sps->chroma_format_idc) {
     138           0 :                     for (i = 0; i < 8; i++) {
     139           0 :                         memset(dest_cb + i * uvlinesize, 1 << (bit_depth - 1), 8);
     140           0 :                         memset(dest_cr + i * uvlinesize, 1 << (bit_depth - 1), 8);
     141             :                     }
     142             :                 } else {
     143       23105 :                     const uint8_t *src_cb = sl->intra_pcm_ptr + 256;
     144       23105 :                     const uint8_t *src_cr = sl->intra_pcm_ptr + 256 + block_h * 8;
     145      207945 :                     for (i = 0; i < block_h; i++) {
     146      184840 :                         memcpy(dest_cb + i * uvlinesize, src_cb + i * 8, 8);
     147      184840 :                         memcpy(dest_cr + i * uvlinesize, src_cr + i * 8, 8);
     148             :                     }
     149             :                 }
     150             :             }
     151             :         }
     152             :     } else {
     153    12278093 :         if (IS_INTRA(mb_type)) {
     154     3667458 :             if (sl->deblocking_filter)
     155     3046851 :                 xchg_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
     156             :                                uvlinesize, 1, 0, SIMPLE, PIXEL_SHIFT);
     157             : 
     158             :             if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     159     3667458 :                 h->hpc.pred8x8[sl->chroma_pred_mode](dest_cb, uvlinesize);
     160     3667458 :                 h->hpc.pred8x8[sl->chroma_pred_mode](dest_cr, uvlinesize);
     161             :             }
     162             : 
     163     3667458 :             hl_decode_mb_predict_luma(h, sl, mb_type, SIMPLE,
     164             :                                       transform_bypass, PIXEL_SHIFT,
     165             :                                       block_offset, linesize, dest_y, 0);
     166             : 
     167     3667458 :             if (sl->deblocking_filter)
     168     3046851 :                 xchg_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
     169             :                                uvlinesize, 0, 0, SIMPLE, PIXEL_SHIFT);
     170             :         } else {
     171     8610635 :             if (chroma422) {
     172       57285 :                 FUNC(hl_motion_422)(h, sl, dest_y, dest_cb, dest_cr,
     173       57285 :                               h->h264qpel.put_h264_qpel_pixels_tab,
     174       57285 :                               h->h264chroma.put_h264_chroma_pixels_tab,
     175       57285 :                               h->h264qpel.avg_h264_qpel_pixels_tab,
     176       57285 :                               h->h264chroma.avg_h264_chroma_pixels_tab,
     177       57285 :                               h->h264dsp.weight_h264_pixels_tab,
     178       57285 :                               h->h264dsp.biweight_h264_pixels_tab);
     179             :             } else {
     180     8553350 :                 FUNC(hl_motion_420)(h, sl, dest_y, dest_cb, dest_cr,
     181     8553350 :                               h->h264qpel.put_h264_qpel_pixels_tab,
     182     8553350 :                               h->h264chroma.put_h264_chroma_pixels_tab,
     183     8553350 :                               h->h264qpel.avg_h264_qpel_pixels_tab,
     184     8553350 :                               h->h264chroma.avg_h264_chroma_pixels_tab,
     185     8553350 :                               h->h264dsp.weight_h264_pixels_tab,
     186     8553350 :                               h->h264dsp.biweight_h264_pixels_tab);
     187             :             }
     188             :         }
     189             : 
     190    12278093 :         hl_decode_mb_idct_luma(h, sl, mb_type, SIMPLE, transform_bypass,
     191             :                                PIXEL_SHIFT, block_offset, linesize, dest_y, 0);
     192             : 
     193    12278093 :         if ((SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) &&
     194    12278093 :             (sl->cbp & 0x30)) {
     195     4818801 :             uint8_t *dest[2] = { dest_cb, dest_cr };
     196     4818801 :             if (transform_bypass) {
     197       21993 :                 if (IS_INTRA(mb_type) && h->ps.sps->profile_idc == 244 &&
     198        4495 :                     (sl->chroma_pred_mode == VERT_PRED8x8 ||
     199        1683 :                      sl->chroma_pred_mode == HOR_PRED8x8)) {
     200        5146 :                     h->hpc.pred8x8_add[sl->chroma_pred_mode](dest[0],
     201             :                                                             block_offset + 16,
     202        2573 :                                                             sl->mb + (16 * 16 * 1 << PIXEL_SHIFT),
     203             :                                                             uvlinesize);
     204        5146 :                     h->hpc.pred8x8_add[sl->chroma_pred_mode](dest[1],
     205             :                                                             block_offset + 32,
     206        2573 :                                                             sl->mb + (16 * 16 * 2 << PIXEL_SHIFT),
     207             :                                                             uvlinesize);
     208             :                 } else {
     209       16608 :                     idct_add = h->h264dsp.h264_add_pixels4_clear;
     210       49824 :                     for (j = 1; j < 3; j++) {
     211      166080 :                         for (i = j * 16; i < j * 16 + 4; i++)
     212      166269 :                             if (sl->non_zero_count_cache[scan8[i]] ||
     213       33405 :                                 dctcoef_get(sl->mb, PIXEL_SHIFT, i * 16))
     214      100174 :                                 idct_add(dest[j - 1] + block_offset[i],
     215      100174 :                                          sl->mb + (i * 16 << PIXEL_SHIFT),
     216             :                                          uvlinesize);
     217       33216 :                         if (chroma422) {
     218           0 :                             for (i = j * 16 + 4; i < j * 16 + 8; i++)
     219           0 :                                 if (sl->non_zero_count_cache[scan8[i + 4]] ||
     220           0 :                                     dctcoef_get(sl->mb, PIXEL_SHIFT, i * 16))
     221           0 :                                     idct_add(dest[j - 1] + block_offset[i + 4],
     222           0 :                                              sl->mb + (i * 16 << PIXEL_SHIFT),
     223             :                                              uvlinesize);
     224             :                         }
     225             :                     }
     226             :                 }
     227             :             } else {
     228             :                 int qp[2];
     229     4799620 :                 if (chroma422) {
     230      675318 :                     qp[0] = sl->chroma_qp[0] + 3;
     231      675318 :                     qp[1] = sl->chroma_qp[1] + 3;
     232             :                 } else {
     233     4124302 :                     qp[0] = sl->chroma_qp[0];
     234     4124302 :                     qp[1] = sl->chroma_qp[1];
     235             :                 }
     236     4799620 :                 if (sl->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 0]])
     237     7049328 :                     h->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + (16 * 16 * 1 << PIXEL_SHIFT),
     238     3524664 :                                                            h->ps.pps->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][qp[0]][0]);
     239     4799620 :                 if (sl->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 1]])
     240     6057174 :                     h->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + (16 * 16 * 2 << PIXEL_SHIFT),
     241     3028587 :                                                            h->ps.pps->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][qp[1]][0]);
     242     9599240 :                 h->h264dsp.h264_idct_add8(dest, block_offset,
     243     4799620 :                                           sl->mb, uvlinesize,
     244     4799620 :                                           sl->non_zero_count_cache);
     245             :             }
     246             :         }
     247             :     }
     248    12301198 : }
     249             : 
     250             : #if !SIMPLE || BITS == 8
     251             : 
     252             : #undef  CHROMA_IDC
     253             : #define CHROMA_IDC 3
     254             : #include "h264_mc_template.c"
     255             : 
     256      129720 : static av_noinline void FUNC(hl_decode_mb_444)(const H264Context *h, H264SliceContext *sl)
     257             : {
     258      129720 :     const int mb_x    = sl->mb_x;
     259      129720 :     const int mb_y    = sl->mb_y;
     260      129720 :     const int mb_xy   = sl->mb_xy;
     261      129720 :     const int mb_type = h->cur_pic.mb_type[mb_xy];
     262             :     uint8_t *dest[3];
     263             :     int linesize;
     264             :     int i, j, p;
     265      129720 :     const int *block_offset = &h->block_offset[0];
     266      129720 :     const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->ps.sps->transform_bypass);
     267      129720 :     const int plane_count      = (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) ? 3 : 1;
     268             : 
     269      518880 :     for (p = 0; p < plane_count; p++) {
     270      778320 :         dest[p] = h->cur_pic.f->data[p] +
     271      389160 :                   ((mb_x << PIXEL_SHIFT) + mb_y * sl->linesize) * 16;
     272      389160 :         h->vdsp.prefetch(dest[p] + (sl->mb_x & 3) * 4 * sl->linesize + (64 << PIXEL_SHIFT),
     273             :                          sl->linesize, 4);
     274             :     }
     275             : 
     276      129720 :     h->list_counts[mb_xy] = sl->list_count;
     277             : 
     278      113400 :     if (!SIMPLE && MB_FIELD(sl)) {
     279           0 :         linesize     = sl->mb_linesize = sl->mb_uvlinesize = sl->linesize * 2;
     280           0 :         block_offset = &h->block_offset[48];
     281           0 :         if (mb_y & 1) // FIXME move out of this function?
     282           0 :             for (p = 0; p < 3; p++)
     283           0 :                 dest[p] -= sl->linesize * 15;
     284           0 :         if (FRAME_MBAFF(h)) {
     285             :             int list;
     286           0 :             for (list = 0; list < sl->list_count; list++) {
     287           0 :                 if (!USES_LIST(mb_type, list))
     288           0 :                     continue;
     289           0 :                 if (IS_16X16(mb_type)) {
     290           0 :                     int8_t *ref = &sl->ref_cache[list][scan8[0]];
     291           0 :                     fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (sl->mb_y & 1), 1);
     292             :                 } else {
     293           0 :                     for (i = 0; i < 16; i += 4) {
     294           0 :                         int ref = sl->ref_cache[list][scan8[i]];
     295           0 :                         if (ref >= 0)
     296           0 :                             fill_rectangle(&sl->ref_cache[list][scan8[i]], 2, 2,
     297           0 :                                            8, (16 + ref) ^ (sl->mb_y & 1), 1);
     298             :                     }
     299             :                 }
     300             :             }
     301             :         }
     302             :     } else {
     303      129720 :         linesize = sl->mb_linesize = sl->mb_uvlinesize = sl->linesize;
     304             :     }
     305             : 
     306      113400 :     if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
     307           0 :         if (PIXEL_SHIFT) {
     308           0 :             const int bit_depth = h->ps.sps->bit_depth_luma;
     309             :             GetBitContext gb;
     310           0 :             init_get_bits(&gb, sl->intra_pcm_ptr, 768 * bit_depth);
     311             : 
     312           0 :             for (p = 0; p < plane_count; p++)
     313           0 :                 for (i = 0; i < 16; i++) {
     314           0 :                     uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);
     315           0 :                     for (j = 0; j < 16; j++)
     316           0 :                         tmp[j] = get_bits(&gb, bit_depth);
     317             :                 }
     318             :         } else {
     319           0 :             for (p = 0; p < plane_count; p++)
     320           0 :                 for (i = 0; i < 16; i++)
     321           0 :                     memcpy(dest[p] + i * linesize,
     322           0 :                            sl->intra_pcm_ptr + p * 256 + i * 16, 16);
     323             :         }
     324             :     } else {
     325      129720 :         if (IS_INTRA(mb_type)) {
     326       21447 :             if (sl->deblocking_filter)
     327       17602 :                 xchg_mb_border(h, sl, dest[0], dest[1], dest[2], linesize,
     328             :                                linesize, 1, 1, SIMPLE, PIXEL_SHIFT);
     329             : 
     330       85788 :             for (p = 0; p < plane_count; p++)
     331       64341 :                 hl_decode_mb_predict_luma(h, sl, mb_type, SIMPLE,
     332             :                                           transform_bypass, PIXEL_SHIFT,
     333             :                                           block_offset, linesize, dest[p], p);
     334             : 
     335       21447 :             if (sl->deblocking_filter)
     336       17602 :                 xchg_mb_border(h, sl, dest[0], dest[1], dest[2], linesize,
     337             :                                linesize, 0, 1, SIMPLE, PIXEL_SHIFT);
     338             :         } else {
     339      108273 :             FUNC(hl_motion_444)(h, sl, dest[0], dest[1], dest[2],
     340      108273 :                       h->h264qpel.put_h264_qpel_pixels_tab,
     341      108273 :                       h->h264chroma.put_h264_chroma_pixels_tab,
     342      108273 :                       h->h264qpel.avg_h264_qpel_pixels_tab,
     343      108273 :                       h->h264chroma.avg_h264_chroma_pixels_tab,
     344      108273 :                       h->h264dsp.weight_h264_pixels_tab,
     345      108273 :                       h->h264dsp.biweight_h264_pixels_tab);
     346             :         }
     347             : 
     348      518880 :         for (p = 0; p < plane_count; p++)
     349      389160 :             hl_decode_mb_idct_luma(h, sl, mb_type, SIMPLE, transform_bypass,
     350             :                                    PIXEL_SHIFT, block_offset, linesize,
     351             :                                    dest[p], p);
     352             :     }
     353      129720 : }
     354             : 
     355             : #endif

Generated by: LCOV version 1.13