LCOV - code coverage report
Current view: top level - libavcodec - mpeg4video.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 75 100 75.0 %
Date: 2017-12-14 08:27:08 Functions: 5 5 100.0 %

          Line data    Source code
       1             : /*
       2             :  * MPEG-4 decoder / encoder common code
       3             :  * Copyright (c) 2000,2001 Fabrice Bellard
       4             :  * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : #include "mpegutils.h"
      24             : #include "mpegvideo.h"
      25             : #include "mpeg4video.h"
      26             : #include "mpeg4data.h"
      27             : 
      28             : uint8_t ff_mpeg4_static_rl_table_store[3][2][2 * MAX_RUN + MAX_LEVEL + 3];
      29             : 
      30       11288 : int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s)
      31             : {
      32       11288 :     switch (s->pict_type) {
      33        1437 :     case AV_PICTURE_TYPE_I:
      34        1437 :         return 16;
      35        3746 :     case AV_PICTURE_TYPE_P:
      36             :     case AV_PICTURE_TYPE_S:
      37        3746 :         return s->f_code + 15;
      38        6105 :     case AV_PICTURE_TYPE_B:
      39        6105 :         return FFMAX3(s->f_code, s->b_code, 2) + 15;
      40           0 :     default:
      41           0 :         return -1;
      42             :     }
      43             : }
      44             : 
      45        7615 : void ff_mpeg4_clean_buffers(MpegEncContext *s)
      46             : {
      47             :     int c_wrap, c_xy, l_wrap, l_xy;
      48             : 
      49        7615 :     l_wrap = s->b8_stride;
      50        7615 :     l_xy   = (2 * s->mb_y - 1) * l_wrap + s->mb_x * 2 - 1;
      51        7615 :     c_wrap = s->mb_stride;
      52        7615 :     c_xy   = (s->mb_y - 1) * c_wrap + s->mb_x - 1;
      53             : 
      54             :     /* clean AC */
      55        7615 :     memset(s->ac_val[0] + l_xy, 0, (l_wrap * 2 + 1) * 16 * sizeof(int16_t));
      56        7615 :     memset(s->ac_val[1] + c_xy, 0, (c_wrap     + 1) * 16 * sizeof(int16_t));
      57        7615 :     memset(s->ac_val[2] + c_xy, 0, (c_wrap     + 1) * 16 * sizeof(int16_t));
      58             : 
      59             :     /* clean MV */
      60             :     // we can't clear the MVs as they might be needed by a B-frame
      61        7615 :     s->last_mv[0][0][0] =
      62        7615 :     s->last_mv[0][0][1] =
      63        7615 :     s->last_mv[1][0][0] =
      64        7615 :     s->last_mv[1][0][1] = 0;
      65        7615 : }
      66             : 
      67             : #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
      68             : #define tab_bias (tab_size / 2)
      69             : 
      70             : // used by MPEG-4 and rv10 decoder
      71        2168 : void ff_mpeg4_init_direct_mv(MpegEncContext *s)
      72             : {
      73             :     int i;
      74      140920 :     for (i = 0; i < tab_size; i++) {
      75      138752 :         s->direct_scale_mv[0][i] = (i - tab_bias) * s->pb_time / s->pp_time;
      76      277504 :         s->direct_scale_mv[1][i] = (i - tab_bias) * (s->pb_time - s->pp_time) /
      77      138752 :                                    s->pp_time;
      78             :     }
      79        2168 : }
      80             : 
      81      586373 : static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx,
      82             :                                               int my, int i)
      83             : {
      84      586373 :     int xy           = s->block_index[i];
      85      586373 :     uint16_t time_pp = s->pp_time;
      86      586373 :     uint16_t time_pb = s->pb_time;
      87             :     int p_mx, p_my;
      88             : 
      89      586373 :     p_mx = s->next_picture.motion_val[0][xy][0];
      90      586373 :     if ((unsigned)(p_mx + tab_bias) < tab_size) {
      91      565682 :         s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
      92      716819 :         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
      93      716819 :                             : s->direct_scale_mv[1][p_mx + tab_bias];
      94             :     } else {
      95       20691 :         s->mv[0][i][0] = p_mx * time_pb / time_pp + mx;
      96       33735 :         s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
      97       33735 :                             : p_mx * (time_pb - time_pp) / time_pp;
      98             :     }
      99      586373 :     p_my = s->next_picture.motion_val[0][xy][1];
     100      586373 :     if ((unsigned)(p_my + tab_bias) < tab_size) {
     101      566072 :         s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
     102      712891 :         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
     103      712891 :                             : s->direct_scale_mv[1][p_my + tab_bias];
     104             :     } else {
     105       20301 :         s->mv[0][i][1] = p_my * time_pb / time_pp + my;
     106       30326 :         s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
     107       30326 :                             : p_my * (time_pb - time_pp) / time_pp;
     108             :     }
     109      586373 : }
     110             : 
     111             : #undef tab_size
     112             : #undef tab_bias
     113             : 
     114             : /**
     115             :  * @return the mb_type
     116             :  */
     117      302918 : int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
     118             : {
     119      302918 :     const int mb_index          = s->mb_x + s->mb_y * s->mb_stride;
     120      302918 :     const int colocated_mb_type = s->next_picture.mb_type[mb_index];
     121             :     uint16_t time_pp;
     122             :     uint16_t time_pb;
     123             :     int i;
     124             : 
     125             :     // FIXME avoid divides
     126             :     // try special case with shifts for 1 and 3 B-frames?
     127             : 
     128      302918 :     if (IS_8X8(colocated_mb_type)) {
     129       94485 :         s->mv_type = MV_TYPE_8X8;
     130      472425 :         for (i = 0; i < 4; i++)
     131      377940 :             ff_mpeg4_set_one_direct_mv(s, mx, my, i);
     132       94485 :         return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
     133      208433 :     } else if (IS_INTERLACED(colocated_mb_type)) {
     134           0 :         s->mv_type = MV_TYPE_FIELD;
     135           0 :         for (i = 0; i < 2; i++) {
     136           0 :             int field_select = s->next_picture.ref_index[0][4 * mb_index + 2 * i];
     137           0 :             s->field_select[0][i] = field_select;
     138           0 :             s->field_select[1][i] = i;
     139           0 :             if (s->top_field_first) {
     140           0 :                 time_pp = s->pp_field_time - field_select + i;
     141           0 :                 time_pb = s->pb_field_time - field_select + i;
     142             :             } else {
     143           0 :                 time_pp = s->pp_field_time + field_select - i;
     144           0 :                 time_pb = s->pb_field_time + field_select - i;
     145             :             }
     146           0 :             s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0] *
     147           0 :                              time_pb / time_pp + mx;
     148           0 :             s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1] *
     149           0 :                              time_pb / time_pp + my;
     150           0 :             s->mv[1][i][0] = mx ? s->mv[0][i][0] -
     151           0 :                                   s->p_field_mv_table[i][0][mb_index][0]
     152           0 :                                 : s->p_field_mv_table[i][0][mb_index][0] *
     153           0 :                                   (time_pb - time_pp) / time_pp;
     154           0 :             s->mv[1][i][1] = my ? s->mv[0][i][1] -
     155           0 :                                   s->p_field_mv_table[i][0][mb_index][1]
     156           0 :                                 : s->p_field_mv_table[i][0][mb_index][1] *
     157           0 :                                   (time_pb - time_pp) / time_pp;
     158             :         }
     159           0 :         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 |
     160             :                MB_TYPE_L0L1    | MB_TYPE_INTERLACED;
     161             :     } else {
     162      208433 :         ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
     163      208433 :         s->mv[0][1][0] =
     164      208433 :         s->mv[0][2][0] =
     165      208433 :         s->mv[0][3][0] = s->mv[0][0][0];
     166      208433 :         s->mv[0][1][1] =
     167      208433 :         s->mv[0][2][1] =
     168      208433 :         s->mv[0][3][1] = s->mv[0][0][1];
     169      208433 :         s->mv[1][1][0] =
     170      208433 :         s->mv[1][2][0] =
     171      208433 :         s->mv[1][3][0] = s->mv[1][0][0];
     172      208433 :         s->mv[1][1][1] =
     173      208433 :         s->mv[1][2][1] =
     174      208433 :         s->mv[1][3][1] = s->mv[1][0][1];
     175      416866 :         if ((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) ||
     176      208433 :             !s->quarter_sample)
     177      179275 :             s->mv_type = MV_TYPE_16X16;
     178             :         else
     179       29158 :             s->mv_type = MV_TYPE_8X8;
     180             :         // Note see prev line
     181      208433 :         return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1;
     182             :     }
     183             : }

Generated by: LCOV version 1.13