LCOV - code coverage report
Current view: top level - libavcodec - vp56.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 462 498 92.8 %
Date: 2017-12-13 10:57:33 Functions: 20 20 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2006  Aurelien Jacobs <aurel@gnuage.org>
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : /**
      22             :  * @file
      23             :  * VP5 and VP6 compatible video decoder (common features)
      24             :  */
      25             : 
      26             : #include "avcodec.h"
      27             : #include "bytestream.h"
      28             : #include "internal.h"
      29             : #include "h264chroma.h"
      30             : #include "vp56.h"
      31             : #include "vp56data.h"
      32             : 
      33             : 
      34         960 : void ff_vp56_init_dequant(VP56Context *s, int quantizer)
      35             : {
      36         960 :     s->quantizer = quantizer;
      37         960 :     s->dequant_dc = ff_vp56_dc_dequant[quantizer] << 2;
      38         960 :     s->dequant_ac = ff_vp56_ac_dequant[quantizer] << 2;
      39         960 : }
      40             : 
      41      238185 : static int vp56_get_vectors_predictors(VP56Context *s, int row, int col,
      42             :                                        VP56Frame ref_frame)
      43             : {
      44      238185 :     int nb_pred = 0;
      45      238185 :     VP56mv vect[2] = {{0,0}, {0,0}};
      46             :     int pos, offset;
      47             :     VP56mv mvp;
      48             : 
      49     2438835 :     for (pos=0; pos<12; pos++) {
      50     2277649 :         mvp.x = col + ff_vp56_candidate_predictor_pos[pos][0];
      51     2277649 :         mvp.y = row + ff_vp56_candidate_predictor_pos[pos][1];
      52     4408028 :         if (mvp.x < 0 || mvp.x >= s->mb_width ||
      53     4045368 :             mvp.y < 0 || mvp.y >= s->mb_height)
      54      362660 :             continue;
      55     1914989 :         offset = mvp.x + s->mb_width*mvp.y;
      56             : 
      57     1914989 :         if (ff_vp56_reference_frame[s->macroblocks[offset].type] != ref_frame)
      58      331615 :             continue;
      59     2876336 :         if ((s->macroblocks[offset].mv.x == vect[0].x &&
      60     1659311 :              s->macroblocks[offset].mv.y == vect[0].y) ||
      61      574071 :             (s->macroblocks[offset].mv.x == 0 &&
      62      207722 :              s->macroblocks[offset].mv.y == 0))
      63     1394050 :             continue;
      64             : 
      65      189324 :         vect[nb_pred++] = s->macroblocks[offset].mv;
      66      189324 :         if (nb_pred > 1) {
      67       76999 :             nb_pred = -1;
      68       76999 :             break;
      69             :         }
      70      112325 :         s->vector_candidate_pos = pos;
      71             :     }
      72             : 
      73      238185 :     s->vector_candidate[0] = vect[0];
      74      238185 :     s->vector_candidate[1] = vect[1];
      75             : 
      76      238185 :     return nb_pred+1;
      77             : }
      78             : 
      79         916 : static void vp56_parse_mb_type_models(VP56Context *s)
      80             : {
      81         916 :     VP56RangeCoder *c = &s->c;
      82         916 :     VP56Model *model = s->modelp;
      83             :     int i, ctx, type;
      84             : 
      85        3664 :     for (ctx=0; ctx<3; ctx++) {
      86        2748 :         if (vp56_rac_get_prob_branchy(c, 174)) {
      87         730 :             int idx = vp56_rac_gets(c, 4);
      88         730 :             memcpy(model->mb_types_stats[ctx],
      89         730 :                    ff_vp56_pre_def_mb_type_stats[idx][ctx],
      90             :                    sizeof(model->mb_types_stats[ctx]));
      91             :         }
      92        2748 :         if (vp56_rac_get_prob_branchy(c, 254)) {
      93        1287 :             for (type=0; type<10; type++) {
      94        3510 :                 for(i=0; i<2; i++) {
      95        2340 :                     if (vp56_rac_get_prob_branchy(c, 205)) {
      96         915 :                         int delta, sign = vp56_rac_get(c);
      97             : 
      98         915 :                         delta = vp56_rac_get_tree(c, ff_vp56_pmbtm_tree,
      99             :                                                   ff_vp56_mb_type_model_model);
     100         915 :                         if (!delta)
     101         139 :                             delta = 4 * vp56_rac_gets(c, 7);
     102         915 :                         model->mb_types_stats[ctx][type][i] += (delta ^ -sign) + sign;
     103             :                     }
     104             :                 }
     105             :             }
     106             :         }
     107             :     }
     108             : 
     109             :     /* compute MB type probability tables based on previous MB type */
     110        3664 :     for (ctx=0; ctx<3; ctx++) {
     111             :         int p[10];
     112             : 
     113       30228 :         for (type=0; type<10; type++)
     114       27480 :             p[type] = 100 * model->mb_types_stats[ctx][type][1];
     115             : 
     116       30228 :         for (type=0; type<10; type++) {
     117             :             int p02, p34, p0234, p17, p56, p89, p5689, p156789;
     118             : 
     119             :             /* conservative MB type probability */
     120       27480 :             model->mb_type[ctx][type][0] = 255 - (255 * model->mb_types_stats[ctx][type][0]) / (1 + model->mb_types_stats[ctx][type][0] + model->mb_types_stats[ctx][type][1]);
     121             : 
     122       27480 :             p[type] = 0;    /* same MB type => weight is null */
     123             : 
     124             :             /* binary tree parsing probabilities */
     125       27480 :             p02 = p[0] + p[2];
     126       27480 :             p34 = p[3] + p[4];
     127       27480 :             p0234 = p02 + p34;
     128       27480 :             p17 = p[1] + p[7];
     129       27480 :             p56 = p[5] + p[6];
     130       27480 :             p89 = p[8] + p[9];
     131       27480 :             p5689 = p56 + p89;
     132       27480 :             p156789 = p17 + p5689;
     133             : 
     134       27480 :             model->mb_type[ctx][type][1] = 1 + 255 * p0234/(1+p0234+p156789);
     135       27480 :             model->mb_type[ctx][type][2] = 1 + 255 * p02  / (1+p0234);
     136       27480 :             model->mb_type[ctx][type][3] = 1 + 255 * p17  / (1+p156789);
     137       27480 :             model->mb_type[ctx][type][4] = 1 + 255 * p[0] / (1+p02);
     138       27480 :             model->mb_type[ctx][type][5] = 1 + 255 * p[3] / (1+p34);
     139       27480 :             model->mb_type[ctx][type][6] = 1 + 255 * p[1] / (1+p17);
     140       27480 :             model->mb_type[ctx][type][7] = 1 + 255 * p56  / (1+p5689);
     141       27480 :             model->mb_type[ctx][type][8] = 1 + 255 * p[5] / (1+p56);
     142       27480 :             model->mb_type[ctx][type][9] = 1 + 255 * p[8] / (1+p89);
     143             : 
     144             :             /* restore initial value */
     145       27480 :             p[type] = 100 * model->mb_types_stats[ctx][type][1];
     146             :         }
     147             :     }
     148         916 : }
     149             : 
     150      235548 : static VP56mb vp56_parse_mb_type(VP56Context *s,
     151             :                                  VP56mb prev_type, int ctx)
     152             : {
     153      235548 :     uint8_t *mb_type_model = s->modelp->mb_type[ctx][prev_type];
     154      235548 :     VP56RangeCoder *c = &s->c;
     155             : 
     156      235548 :     if (vp56_rac_get_prob_branchy(c, mb_type_model[0]))
     157      178876 :         return prev_type;
     158             :     else
     159       56672 :         return vp56_rac_get_tree(c, ff_vp56_pmbt_tree, mb_type_model);
     160             : }
     161             : 
     162       10512 : static void vp56_decode_4mv(VP56Context *s, int row, int col)
     163             : {
     164       10512 :     VP56mv mv = {0,0};
     165             :     int type[4];
     166             :     int b;
     167             : 
     168             :     /* parse each block type */
     169       52560 :     for (b=0; b<4; b++) {
     170       42048 :         type[b] = vp56_rac_gets(&s->c, 2);
     171       42048 :         if (type[b])
     172       33489 :             type[b]++;  /* only returns 0, 2, 3 or 4 (all INTER_PF) */
     173             :     }
     174             : 
     175             :     /* get vectors */
     176       52560 :     for (b=0; b<4; b++) {
     177       42048 :         switch (type[b]) {
     178        8559 :             case VP56_MB_INTER_NOVEC_PF:
     179        8559 :                 s->mv[b] = (VP56mv) {0,0};
     180        8559 :                 break;
     181       12581 :             case VP56_MB_INTER_DELTA_PF:
     182       12581 :                 s->parse_vector_adjustment(s, &s->mv[b]);
     183       12581 :                 break;
     184       12468 :             case VP56_MB_INTER_V1_PF:
     185       12468 :                 s->mv[b] = s->vector_candidate[0];
     186       12468 :                 break;
     187        8440 :             case VP56_MB_INTER_V2_PF:
     188        8440 :                 s->mv[b] = s->vector_candidate[1];
     189        8440 :                 break;
     190             :         }
     191       42048 :         mv.x += s->mv[b].x;
     192       42048 :         mv.y += s->mv[b].y;
     193             :     }
     194             : 
     195             :     /* this is the one selected for the whole MB for prediction */
     196       10512 :     s->macroblocks[row * s->mb_width + col].mv = s->mv[3];
     197             : 
     198             :     /* chroma vectors are average luma vectors */
     199       10512 :     if (s->avctx->codec->id == AV_CODEC_ID_VP5) {
     200        1972 :         s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2);
     201        1972 :         s->mv[4].y = s->mv[5].y = RSHIFT(mv.y,2);
     202             :     } else {
     203        8540 :         s->mv[4] = s->mv[5] = (VP56mv) {mv.x/4, mv.y/4};
     204             :     }
     205       10512 : }
     206             : 
     207      235548 : static VP56mb vp56_decode_mv(VP56Context *s, int row, int col)
     208             : {
     209      235548 :     VP56mv *mv, vect = {0,0};
     210             :     int ctx, b;
     211             : 
     212      235548 :     ctx = vp56_get_vectors_predictors(s, row, col, VP56_FRAME_PREVIOUS);
     213      235548 :     s->mb_type = vp56_parse_mb_type(s, s->mb_type, ctx);
     214      235548 :     s->macroblocks[row * s->mb_width + col].type = s->mb_type;
     215             : 
     216      235548 :     switch (s->mb_type) {
     217       36868 :         case VP56_MB_INTER_V1_PF:
     218       36868 :             mv = &s->vector_candidate[0];
     219       36868 :             break;
     220             : 
     221       11518 :         case VP56_MB_INTER_V2_PF:
     222       11518 :             mv = &s->vector_candidate[1];
     223       11518 :             break;
     224             : 
     225        1037 :         case VP56_MB_INTER_V1_GF:
     226        1037 :             vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
     227        1037 :             mv = &s->vector_candidate[0];
     228        1037 :             break;
     229             : 
     230         160 :         case VP56_MB_INTER_V2_GF:
     231         160 :             vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
     232         160 :             mv = &s->vector_candidate[1];
     233         160 :             break;
     234             : 
     235       14426 :         case VP56_MB_INTER_DELTA_PF:
     236       14426 :             s->parse_vector_adjustment(s, &vect);
     237       14426 :             mv = &vect;
     238       14426 :             break;
     239             : 
     240        1440 :         case VP56_MB_INTER_DELTA_GF:
     241        1440 :             vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
     242        1440 :             s->parse_vector_adjustment(s, &vect);
     243        1440 :             mv = &vect;
     244        1440 :             break;
     245             : 
     246       10512 :         case VP56_MB_INTER_4V:
     247       10512 :             vp56_decode_4mv(s, row, col);
     248       10512 :             return s->mb_type;
     249             : 
     250      159587 :         default:
     251      159587 :             mv = &vect;
     252      159587 :             break;
     253             :     }
     254             : 
     255      225036 :     s->macroblocks[row*s->mb_width + col].mv = *mv;
     256             : 
     257             :     /* same vector for all blocks */
     258     1575252 :     for (b=0; b<6; b++)
     259     1350216 :         s->mv[b] = *mv;
     260             : 
     261      225036 :     return s->mb_type;
     262             : }
     263             : 
     264         373 : static VP56mb vp56_conceal_mv(VP56Context *s, int row, int col)
     265             : {
     266         373 :     VP56mv *mv, vect = {0,0};
     267             :     int b;
     268             : 
     269         373 :     s->mb_type = VP56_MB_INTER_NOVEC_PF;
     270         373 :     s->macroblocks[row * s->mb_width + col].type = s->mb_type;
     271             : 
     272         373 :     mv = &vect;
     273             : 
     274         373 :     s->macroblocks[row*s->mb_width + col].mv = *mv;
     275             : 
     276             :     /* same vector for all blocks */
     277        2611 :     for (b=0; b<6; b++)
     278        2238 :         s->mv[b] = *mv;
     279             : 
     280         373 :     return s->mb_type;
     281             : }
     282             : 
     283      245731 : static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame)
     284             : {
     285      245731 :     int idx = s->idct_scantable[0];
     286             :     int b;
     287             : 
     288     1720117 :     for (b=0; b<6; b++) {
     289     1474386 :         VP56RefDc *ab = &s->above_blocks[s->above_block_idx[b]];
     290     1474386 :         VP56RefDc *lb = &s->left_block[ff_vp56_b6to4[b]];
     291     1474386 :         int count = 0;
     292     1474386 :         int dc = 0;
     293             :         int i;
     294             : 
     295     1474386 :         if (ref_frame == lb->ref_frame) {
     296     1388770 :             dc += lb->dc_coeff;
     297     1388770 :             count++;
     298             :         }
     299     1474386 :         if (ref_frame == ab->ref_frame) {
     300     1357234 :             dc += ab->dc_coeff;
     301     1357234 :             count++;
     302             :         }
     303     1474386 :         if (s->avctx->codec->id == AV_CODEC_ID_VP5)
     304     2703168 :             for (i=0; i<2; i++)
     305     1802112 :                 if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) {
     306       72112 :                     dc += ab[-1+2*i].dc_coeff;
     307       72112 :                     count++;
     308             :                 }
     309     1474386 :         if (count == 0)
     310       18280 :             dc = s->prev_dc[ff_vp56_b2p[b]][ref_frame];
     311     1456106 :         else if (count == 2)
     312     1362010 :             dc /= 2;
     313             : 
     314     1474386 :         s->block_coeff[b][idx] += dc;
     315     1474386 :         s->prev_dc[ff_vp56_b2p[b]][ref_frame] = s->block_coeff[b][idx];
     316     1474386 :         ab->dc_coeff = s->block_coeff[b][idx];
     317     1474386 :         ab->ref_frame = ref_frame;
     318     1474386 :         lb->dc_coeff = s->block_coeff[b][idx];
     319     1474386 :         lb->ref_frame = ref_frame;
     320     1474386 :         s->block_coeff[b][idx] *= s->dequant_dc;
     321             :     }
     322      245731 : }
     323             : 
     324      423178 : static void vp56_deblock_filter(VP56Context *s, uint8_t *yuv,
     325             :                                 ptrdiff_t stride, int dx, int dy)
     326             : {
     327      423178 :     int t = ff_vp56_filter_threshold[s->quantizer];
     328      423178 :     if (dx)  s->vp56dsp.edge_filter_hor(yuv +         10-dx , stride, t);
     329      423178 :     if (dy)  s->vp56dsp.edge_filter_ver(yuv + stride*(10-dy), stride, t);
     330      423178 : }
     331             : 
     332      443452 : static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src,
     333             :                     ptrdiff_t stride, int x, int y)
     334             : {
     335      443452 :     uint8_t *dst = s->frames[VP56_FRAME_CURRENT]->data[plane] + s->block_offset[b];
     336             :     uint8_t *src_block;
     337             :     int src_offset;
     338      443452 :     int overlap_offset = 0;
     339      443452 :     int mask = s->vp56_coord_div[b] - 1;
     340      443452 :     int deblock_filtering = s->deblock_filtering;
     341             :     int dx;
     342             :     int dy;
     343             : 
     344      886904 :     if (s->avctx->skip_loop_filter >= AVDISCARD_ALL ||
     345      443452 :         (s->avctx->skip_loop_filter >= AVDISCARD_NONKEY
     346           0 :          && !s->frames[VP56_FRAME_CURRENT]->key_frame))
     347           0 :         deblock_filtering = 0;
     348             : 
     349      443452 :     dx = s->mv[b].x / s->vp56_coord_div[b];
     350      443452 :     dy = s->mv[b].y / s->vp56_coord_div[b];
     351             : 
     352      443452 :     if (b >= 4) {
     353      139612 :         x /= 2;
     354      139612 :         y /= 2;
     355             :     }
     356      443452 :     x += dx - 2;
     357      443452 :     y += dy - 2;
     358             : 
     359      443452 :     if (x<0 || x+12>=s->plane_width[plane] ||
     360      413024 :         y<0 || y+12>=s->plane_height[plane]) {
     361       99672 :         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
     362       49836 :                                  src + s->block_offset[b] + (dy-2)*stride + (dx-2),
     363             :                                  stride, stride,
     364             :                                  12, 12, x, y,
     365             :                                  s->plane_width[plane],
     366             :                                  s->plane_height[plane]);
     367       49836 :         src_block = s->edge_emu_buffer;
     368       49836 :         src_offset = 2 + 2*stride;
     369      393616 :     } else if (deblock_filtering) {
     370             :         /* only need a 12x12 block, but there is no such dsp function, */
     371             :         /* so copy a 16x12 block */
     372      750320 :         s->hdsp.put_pixels_tab[0][0](s->edge_emu_buffer,
     373      375160 :                                      src + s->block_offset[b] + (dy-2)*stride + (dx-2),
     374             :                                      stride, 12);
     375      375160 :         src_block = s->edge_emu_buffer;
     376      375160 :         src_offset = 2 + 2*stride;
     377             :     } else {
     378       18456 :         src_block = src;
     379       18456 :         src_offset = s->block_offset[b] + dy*stride + dx;
     380             :     }
     381             : 
     382      443452 :     if (deblock_filtering)
     383      423178 :         vp56_deblock_filter(s, src_block, stride, dx&7, dy&7);
     384             : 
     385      443452 :     if (s->mv[b].x & mask)
     386      280093 :         overlap_offset += (s->mv[b].x > 0) ? 1 : -1;
     387      443452 :     if (s->mv[b].y & mask)
     388      275066 :         overlap_offset += (s->mv[b].y > 0) ? stride : -stride;
     389             : 
     390      443452 :     if (overlap_offset) {
     391      384445 :         if (s->filter)
     392      168378 :             s->filter(s, dst, src_block, src_offset, src_offset+overlap_offset,
     393             :                       stride, s->mv[b], mask, s->filter_selection, b<4);
     394             :         else
     395      432134 :             s->vp3dsp.put_no_rnd_pixels_l2(dst, src_block+src_offset,
     396      216067 :                                            src_block+src_offset+overlap_offset,
     397             :                                            stride, 8);
     398             :     } else {
     399       59007 :         s->hdsp.put_pixels_tab[1][0](dst, src_block+src_offset, stride, 8);
     400             :     }
     401      443452 : }
     402             : 
     403      245731 : static av_always_inline void vp56_render_mb(VP56Context *s, int row, int col, int is_alpha, VP56mb mb_type)
     404             : {
     405             :     int b, ab, b_max, plane, off;
     406             :     AVFrame *frame_current, *frame_ref;
     407      245731 :     VP56Frame ref_frame = ff_vp56_reference_frame[mb_type];
     408             : 
     409      245731 :     vp56_add_predictors_dc(s, ref_frame);
     410             : 
     411      245731 :     frame_current = s->frames[VP56_FRAME_CURRENT];
     412      245731 :     frame_ref = s->frames[ref_frame];
     413      245731 :     if (mb_type != VP56_MB_INTRA && !frame_ref->data[0])
     414           0 :         return;
     415             : 
     416      245731 :     ab = 6*is_alpha;
     417      245731 :     b_max = 6 - 2*is_alpha;
     418             : 
     419      245731 :     switch (mb_type) {
     420       33512 :         case VP56_MB_INTRA:
     421      231176 :             for (b=0; b<b_max; b++) {
     422      197664 :                 plane = ff_vp56_b2p[b+ab];
     423      395328 :                 s->vp3dsp.idct_put(frame_current->data[plane] + s->block_offset[b],
     424      197664 :                                 s->stride[plane], s->block_coeff[b]);
     425             :             }
     426       33512 :             break;
     427             : 
     428      136259 :         case VP56_MB_INTER_NOVEC_PF:
     429             :         case VP56_MB_INTER_NOVEC_GF:
     430      927121 :             for (b=0; b<b_max; b++) {
     431      790862 :                 plane = ff_vp56_b2p[b+ab];
     432      790862 :                 off = s->block_offset[b];
     433     2372586 :                 s->hdsp.put_pixels_tab[1][0](frame_current->data[plane] + off,
     434     1581724 :                                              frame_ref->data[plane] + off,
     435             :                                              s->stride[plane], 8);
     436     1581724 :                 s->vp3dsp.idct_add(frame_current->data[plane] + off,
     437      790862 :                                 s->stride[plane], s->block_coeff[b]);
     438             :             }
     439      136259 :             break;
     440             : 
     441       75960 :         case VP56_MB_INTER_DELTA_PF:
     442             :         case VP56_MB_INTER_V1_PF:
     443             :         case VP56_MB_INTER_V2_PF:
     444             :         case VP56_MB_INTER_DELTA_GF:
     445             :         case VP56_MB_INTER_4V:
     446             :         case VP56_MB_INTER_V1_GF:
     447             :         case VP56_MB_INTER_V2_GF:
     448      519412 :             for (b=0; b<b_max; b++) {
     449      443452 :                 int x_off = b==1 || b==3 ? 8 : 0;
     450      443452 :                 int y_off = b==2 || b==3 ? 8 : 0;
     451      443452 :                 plane = ff_vp56_b2p[b+ab];
     452      886904 :                 vp56_mc(s, b, plane, frame_ref->data[plane], s->stride[plane],
     453      886904 :                         16*col+x_off, 16*row+y_off);
     454      886904 :                 s->vp3dsp.idct_add(frame_current->data[plane] + s->block_offset[b],
     455      443452 :                                 s->stride[plane], s->block_coeff[b]);
     456             :             }
     457       75960 :             break;
     458             :     }
     459             : 
     460      245731 :     if (is_alpha) {
     461       21204 :         s->block_coeff[4][0] = 0;
     462       21204 :         s->block_coeff[5][0] = 0;
     463             :     }
     464             : }
     465             : 
     466      245359 : static int vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
     467             : {
     468             :     VP56mb mb_type;
     469             :     int ret;
     470             : 
     471      245359 :     if (s->frames[VP56_FRAME_CURRENT]->key_frame)
     472        9811 :         mb_type = VP56_MB_INTRA;
     473             :     else
     474      235548 :         mb_type = vp56_decode_mv(s, row, col);
     475             : 
     476      245359 :     ret = s->parse_coeff(s);
     477      245359 :     if (ret < 0)
     478           1 :         return ret;
     479             : 
     480      245358 :     vp56_render_mb(s, row, col, is_alpha, mb_type);
     481             : 
     482      245358 :     return 0;
     483             : }
     484             : 
     485         373 : static int vp56_conceal_mb(VP56Context *s, int row, int col, int is_alpha)
     486             : {
     487             :     VP56mb mb_type;
     488             : 
     489         373 :     if (s->frames[VP56_FRAME_CURRENT]->key_frame)
     490           0 :         mb_type = VP56_MB_INTRA;
     491             :     else
     492         373 :         mb_type = vp56_conceal_mv(s, row, col);
     493             : 
     494         373 :     vp56_render_mb(s, row, col, is_alpha, mb_type);
     495             : 
     496         373 :     return 0;
     497             : }
     498             : 
     499          14 : static int vp56_size_changed(VP56Context *s)
     500             : {
     501          14 :     AVCodecContext *avctx = s->avctx;
     502          14 :     int stride = s->frames[VP56_FRAME_CURRENT]->linesize[0];
     503             :     int i;
     504             : 
     505          14 :     s->plane_width[0]  = s->plane_width[3]  = avctx->coded_width;
     506          14 :     s->plane_width[1]  = s->plane_width[2]  = avctx->coded_width/2;
     507          14 :     s->plane_height[0] = s->plane_height[3] = avctx->coded_height;
     508          14 :     s->plane_height[1] = s->plane_height[2] = avctx->coded_height/2;
     509             : 
     510          14 :     s->have_undamaged_frame = 0;
     511             : 
     512          70 :     for (i=0; i<4; i++)
     513          56 :         s->stride[i] = s->flip * s->frames[VP56_FRAME_CURRENT]->linesize[i];
     514             : 
     515          14 :     s->mb_width  = (avctx->coded_width +15) / 16;
     516          14 :     s->mb_height = (avctx->coded_height+15) / 16;
     517             : 
     518          14 :     if (s->mb_width > 1000 || s->mb_height > 1000) {
     519           0 :         ff_set_dimensions(avctx, 0, 0);
     520           0 :         av_log(avctx, AV_LOG_ERROR, "picture too big\n");
     521           0 :         return AVERROR_INVALIDDATA;
     522             :     }
     523             : 
     524          14 :     av_reallocp_array(&s->above_blocks, 4*s->mb_width+6,
     525             :                       sizeof(*s->above_blocks));
     526          14 :     av_reallocp_array(&s->macroblocks, s->mb_width*s->mb_height,
     527             :                       sizeof(*s->macroblocks));
     528          14 :     av_free(s->edge_emu_buffer_alloc);
     529          14 :     s->edge_emu_buffer_alloc = av_malloc(16*stride);
     530          14 :     s->edge_emu_buffer = s->edge_emu_buffer_alloc;
     531          14 :     if (!s->above_blocks || !s->macroblocks || !s->edge_emu_buffer_alloc)
     532           0 :         return AVERROR(ENOMEM);
     533          14 :     if (s->flip < 0)
     534           8 :         s->edge_emu_buffer += 15 * stride;
     535             : 
     536          14 :     if (s->alpha_context)
     537           2 :         return vp56_size_changed(s->alpha_context);
     538             : 
     539          12 :     return 0;
     540             : }
     541             : 
     542             : static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *, int, int);
     543             : 
     544         867 : int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     545             :                          AVPacket *avpkt)
     546             : {
     547         867 :     const uint8_t *buf = avpkt->data;
     548         867 :     VP56Context *s = avctx->priv_data;
     549         867 :     AVFrame *const p = s->frames[VP56_FRAME_CURRENT];
     550         867 :     int remaining_buf_size = avpkt->size;
     551         867 :     int av_uninit(alpha_offset);
     552             :     int i, res;
     553             :     int ret;
     554             : 
     555         867 :     if (s->has_alpha) {
     556         186 :         if (remaining_buf_size < 3)
     557           0 :             return AVERROR_INVALIDDATA;
     558         186 :         alpha_offset = bytestream_get_be24(&buf);
     559         186 :         remaining_buf_size -= 3;
     560         186 :         if (remaining_buf_size < alpha_offset)
     561           0 :             return AVERROR_INVALIDDATA;
     562             :     }
     563             : 
     564         867 :     res = s->parse_header(s, buf, remaining_buf_size);
     565         867 :     if (res < 0)
     566           0 :         return res;
     567             : 
     568         867 :     if (res == VP56_SIZE_CHANGE) {
     569          60 :         for (i = 0; i < 4; i++) {
     570          48 :             av_frame_unref(s->frames[i]);
     571          48 :             if (s->alpha_context)
     572           8 :                 av_frame_unref(s->alpha_context->frames[i]);
     573             :         }
     574             :     }
     575             : 
     576         867 :     ret = ff_get_buffer(avctx, p, AV_GET_BUFFER_FLAG_REF);
     577         867 :     if (ret < 0) {
     578           0 :         if (res == VP56_SIZE_CHANGE)
     579           0 :             ff_set_dimensions(avctx, 0, 0);
     580           0 :         return ret;
     581             :     }
     582             : 
     583         867 :     if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
     584          93 :         av_frame_unref(s->alpha_context->frames[VP56_FRAME_CURRENT]);
     585          93 :         if ((ret = av_frame_ref(s->alpha_context->frames[VP56_FRAME_CURRENT], p)) < 0) {
     586           0 :             av_frame_unref(p);
     587           0 :             if (res == VP56_SIZE_CHANGE)
     588           0 :                 ff_set_dimensions(avctx, 0, 0);
     589           0 :             return ret;
     590             :         }
     591             :     }
     592             : 
     593         867 :     if (res == VP56_SIZE_CHANGE) {
     594          12 :         if (vp56_size_changed(s)) {
     595           0 :             av_frame_unref(p);
     596           0 :             return AVERROR_INVALIDDATA;
     597             :         }
     598             :     }
     599             : 
     600         867 :     if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
     601          93 :         int bak_w = avctx->width;
     602          93 :         int bak_h = avctx->height;
     603          93 :         int bak_cw = avctx->coded_width;
     604          93 :         int bak_ch = avctx->coded_height;
     605          93 :         buf += alpha_offset;
     606          93 :         remaining_buf_size -= alpha_offset;
     607             : 
     608          93 :         res = s->alpha_context->parse_header(s->alpha_context, buf, remaining_buf_size);
     609          93 :         if (res != 0) {
     610           0 :             if(res==VP56_SIZE_CHANGE) {
     611           0 :                 av_log(avctx, AV_LOG_ERROR, "Alpha reconfiguration\n");
     612           0 :                 avctx->width  = bak_w;
     613           0 :                 avctx->height = bak_h;
     614           0 :                 avctx->coded_width  = bak_cw;
     615           0 :                 avctx->coded_height = bak_ch;
     616             :             }
     617           0 :             av_frame_unref(p);
     618           0 :             return AVERROR_INVALIDDATA;
     619             :         }
     620             :     }
     621             : 
     622         867 :     s->discard_frame = 0;
     623         867 :     avctx->execute2(avctx, ff_vp56_decode_mbs, 0, 0, (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) + 1);
     624             : 
     625         867 :     if (s->discard_frame)
     626           0 :         return AVERROR_INVALIDDATA;
     627             : 
     628         867 :     if ((res = av_frame_ref(data, p)) < 0)
     629           0 :         return res;
     630         867 :     *got_frame = 1;
     631             : 
     632         867 :     return avpkt->size;
     633             : }
     634             : 
     635         960 : static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
     636             :                               int jobnr, int threadnr)
     637             : {
     638         960 :     VP56Context *s0 = avctx->priv_data;
     639         960 :     int is_alpha = (jobnr == 1);
     640         960 :     VP56Context *s = is_alpha ? s0->alpha_context : s0;
     641         960 :     AVFrame *const p = s->frames[VP56_FRAME_CURRENT];
     642         960 :     int mb_row, mb_col, mb_row_flip, mb_offset = 0;
     643             :     int block, y, uv;
     644             :     ptrdiff_t stride_y, stride_uv;
     645             :     int res;
     646         960 :     int damaged = 0;
     647             : 
     648         960 :     if (p->key_frame) {
     649          44 :         p->pict_type = AV_PICTURE_TYPE_I;
     650          44 :         s->default_models_init(s);
     651        9855 :         for (block=0; block<s->mb_height*s->mb_width; block++)
     652        9811 :             s->macroblocks[block].type = VP56_MB_INTRA;
     653             :     } else {
     654         916 :         p->pict_type = AV_PICTURE_TYPE_P;
     655         916 :         vp56_parse_mb_type_models(s);
     656         916 :         s->parse_vector_models(s);
     657         916 :         s->mb_type = VP56_MB_INTER_NOVEC_PF;
     658             :     }
     659             : 
     660         960 :     if (s->parse_coeff_models(s))
     661           0 :         goto next;
     662             : 
     663         960 :     memset(s->prev_dc, 0, sizeof(s->prev_dc));
     664         960 :     s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
     665         960 :     s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
     666             : 
     667       74448 :     for (block=0; block < 4*s->mb_width+6; block++) {
     668       73488 :         s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
     669       73488 :         s->above_blocks[block].dc_coeff = 0;
     670       73488 :         s->above_blocks[block].not_null_dc = 0;
     671             :     }
     672         960 :     s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
     673         960 :     s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
     674             : 
     675         960 :     stride_y  = p->linesize[0];
     676         960 :     stride_uv = p->linesize[1];
     677             : 
     678         960 :     if (s->flip < 0)
     679         506 :         mb_offset = 7;
     680             : 
     681             :     /* main macroblocks loop */
     682       12362 :     for (mb_row=0; mb_row<s->mb_height; mb_row++) {
     683       11402 :         if (s->flip < 0)
     684        7179 :             mb_row_flip = s->mb_height - mb_row - 1;
     685             :         else
     686        4223 :             mb_row_flip = mb_row;
     687             : 
     688       57010 :         for (block=0; block<4; block++) {
     689       45608 :             s->left_block[block].ref_frame = VP56_FRAME_NONE;
     690       45608 :             s->left_block[block].dc_coeff = 0;
     691       45608 :             s->left_block[block].not_null_dc = 0;
     692             :         }
     693       11402 :         memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
     694       11402 :         memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
     695             : 
     696       11402 :         s->above_block_idx[0] = 1;
     697       11402 :         s->above_block_idx[1] = 2;
     698       11402 :         s->above_block_idx[2] = 1;
     699       11402 :         s->above_block_idx[3] = 2;
     700       11402 :         s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
     701       11402 :         s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
     702             : 
     703       11402 :         s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
     704       11402 :         s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
     705       11402 :         s->block_offset[1] = s->block_offset[0] + 8;
     706       11402 :         s->block_offset[3] = s->block_offset[2] + 8;
     707       11402 :         s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
     708       11402 :         s->block_offset[5] = s->block_offset[4];
     709             : 
     710      257133 :         for (mb_col=0; mb_col<s->mb_width; mb_col++) {
     711      245731 :             if (!damaged) {
     712      245359 :                 int ret = vp56_decode_mb(s, mb_row, mb_col, is_alpha);
     713      245359 :                 if (ret < 0) {
     714           1 :                     damaged = 1;
     715           1 :                     if (!s->have_undamaged_frame || !avctx->error_concealment) {
     716           0 :                         s->discard_frame = 1;
     717           0 :                         return AVERROR_INVALIDDATA;
     718             :                     }
     719             :                 }
     720             :             }
     721      245731 :             if (damaged)
     722         373 :                 vp56_conceal_mb(s, mb_row, mb_col, is_alpha);
     723             : 
     724     1228655 :             for (y=0; y<4; y++) {
     725      982924 :                 s->above_block_idx[y] += 2;
     726      982924 :                 s->block_offset[y] += 16;
     727             :             }
     728             : 
     729      737193 :             for (uv=4; uv<6; uv++) {
     730      491462 :                 s->above_block_idx[uv] += 1;
     731      491462 :                 s->block_offset[uv] += 8;
     732             :             }
     733             :         }
     734             :     }
     735             : 
     736         960 :     if (!damaged)
     737         959 :         s->have_undamaged_frame = 1;
     738             : 
     739         961 : next:
     740         960 :     if (p->key_frame || s->golden_frame) {
     741          77 :         av_frame_unref(s->frames[VP56_FRAME_GOLDEN]);
     742          77 :         if ((res = av_frame_ref(s->frames[VP56_FRAME_GOLDEN], p)) < 0)
     743           0 :             return res;
     744             :     }
     745             : 
     746         960 :     av_frame_unref(s->frames[VP56_FRAME_PREVIOUS]);
     747         960 :     FFSWAP(AVFrame *, s->frames[VP56_FRAME_CURRENT],
     748             :                       s->frames[VP56_FRAME_PREVIOUS]);
     749         960 :     return 0;
     750             : }
     751             : 
     752          15 : av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
     753             : {
     754          15 :     VP56Context *s = avctx->priv_data;
     755          15 :     return ff_vp56_init_context(avctx, s, flip, has_alpha);
     756             : }
     757             : 
     758          19 : av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s,
     759             :                                   int flip, int has_alpha)
     760             : {
     761             :     int i;
     762             : 
     763          19 :     s->avctx = avctx;
     764          19 :     avctx->pix_fmt = has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
     765          19 :     if (avctx->skip_alpha) avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     766             : 
     767          19 :     ff_h264chroma_init(&s->h264chroma, 8);
     768          19 :     ff_hpeldsp_init(&s->hdsp, avctx->flags);
     769          19 :     ff_videodsp_init(&s->vdsp, 8);
     770          19 :     ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
     771        1235 :     for (i = 0; i < 64; i++) {
     772             : #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
     773        1216 :         s->idct_scantable[i] = TRANSPOSE(ff_zigzag_direct[i]);
     774             : #undef TRANSPOSE
     775             :     }
     776             : 
     777          95 :     for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
     778          76 :         s->frames[i] = av_frame_alloc();
     779          76 :         if (!s->frames[i]) {
     780           0 :             ff_vp56_free(avctx);
     781           0 :             return AVERROR(ENOMEM);
     782             :         }
     783             :     }
     784          19 :     s->edge_emu_buffer_alloc = NULL;
     785             : 
     786          19 :     s->above_blocks = NULL;
     787          19 :     s->macroblocks = NULL;
     788          19 :     s->quantizer = -1;
     789          19 :     s->deblock_filtering = 1;
     790          19 :     s->golden_frame = 0;
     791             : 
     792          19 :     s->filter = NULL;
     793             : 
     794          19 :     s->has_alpha = has_alpha;
     795             : 
     796          19 :     s->modelp = &s->model;
     797             : 
     798          19 :     if (flip) {
     799           9 :         s->flip = -1;
     800           9 :         s->frbi = 2;
     801           9 :         s->srbi = 0;
     802             :     } else {
     803          10 :         s->flip = 1;
     804          10 :         s->frbi = 0;
     805          10 :         s->srbi = 2;
     806             :     }
     807             : 
     808          19 :     return 0;
     809             : }
     810             : 
     811          15 : av_cold int ff_vp56_free(AVCodecContext *avctx)
     812             : {
     813          15 :     VP56Context *s = avctx->priv_data;
     814          15 :     return ff_vp56_free_context(s);
     815             : }
     816             : 
     817          19 : av_cold int ff_vp56_free_context(VP56Context *s)
     818             : {
     819             :     int i;
     820             : 
     821          19 :     av_freep(&s->above_blocks);
     822          19 :     av_freep(&s->macroblocks);
     823          19 :     av_freep(&s->edge_emu_buffer_alloc);
     824             : 
     825          95 :     for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
     826          76 :         av_frame_free(&s->frames[i]);
     827             : 
     828          19 :     return 0;
     829             : }

Generated by: LCOV version 1.13