LCOV - code coverage report
Current view: top level - libavcodec - motion_est.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2017-12-13 10:57:33 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Motion estimation
       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             : #ifndef AVCODEC_MOTION_EST_H
      22             : #define AVCODEC_MOTION_EST_H
      23             : 
      24             : #include <stdint.h>
      25             : 
      26             : #include "avcodec.h"
      27             : #include "hpeldsp.h"
      28             : #include "qpeldsp.h"
      29             : 
      30             : struct MpegEncContext;
      31             : 
      32             : #if ARCH_IA64 // Limit static arrays to avoid gcc failing "short data segment overflowed"
      33             : #define MAX_MV 1024
      34             : #else
      35             : #define MAX_MV 4096
      36             : #endif
      37             : #define MAX_DMV (2*MAX_MV)
      38             : #define ME_MAP_SIZE 64
      39             : 
      40             : #define FF_ME_ZERO 0
      41             : #define FF_ME_EPZS 1
      42             : #define FF_ME_XONE 2
      43             : 
      44             : /**
      45             :  * Motion estimation context.
      46             :  */
      47             : typedef struct MotionEstContext {
      48             :     AVCodecContext *avctx;
      49             :     int skip;                       ///< set if ME is skipped for the current MB
      50             :     int co_located_mv[4][2];        ///< mv from last P-frame for direct mode ME
      51             :     int direct_basis_mv[4][2];
      52             :     uint8_t *scratchpad;            /**< data area for the ME algo, so that
      53             :                                      * the ME does not need to malloc/free. */
      54             :     uint8_t *best_mb;
      55             :     uint8_t *temp_mb[2];
      56             :     uint8_t *temp;
      57             :     int best_bits;
      58             :     uint32_t *map;                  ///< map to avoid duplicate evaluations
      59             :     uint32_t *score_map;            ///< map to store the scores
      60             :     unsigned map_generation;
      61             :     int pre_penalty_factor;
      62             :     int penalty_factor;             /**< an estimate of the bits required to
      63             :                                      * code a given mv value, e.g. (1,0) takes
      64             :                                      * more bits than (0,0). We have to
      65             :                                      * estimate whether any reduction in
      66             :                                      * residual is worth the extra bits. */
      67             :     int sub_penalty_factor;
      68             :     int mb_penalty_factor;
      69             :     int flags;
      70             :     int sub_flags;
      71             :     int mb_flags;
      72             :     int pre_pass;                   ///< = 1 for the pre pass
      73             :     int dia_size;
      74             :     int xmin;
      75             :     int xmax;
      76             :     int ymin;
      77             :     int ymax;
      78             :     int pred_x;
      79             :     int pred_y;
      80             :     uint8_t *src[4][4];
      81             :     uint8_t *ref[4][4];
      82             :     int stride;
      83             :     int uvstride;
      84             :     /* temp variables for picture complexity calculation */
      85             :     int64_t mc_mb_var_sum_temp;
      86             :     int64_t mb_var_sum_temp;
      87             :     int scene_change_score;
      88             : 
      89             :     op_pixels_func(*hpel_put)[4];
      90             :     op_pixels_func(*hpel_avg)[4];
      91             :     qpel_mc_func(*qpel_put)[16];
      92             :     qpel_mc_func(*qpel_avg)[16];
      93             :     uint8_t (*mv_penalty)[MAX_DMV * 2 + 1]; ///< bit amount needed to encode a MV
      94             :     uint8_t *current_mv_penalty;
      95             :     int (*sub_motion_search)(struct MpegEncContext *s,
      96             :                              int *mx_ptr, int *my_ptr, int dmin,
      97             :                              int src_index, int ref_index,
      98             :                              int size, int h);
      99             : } MotionEstContext;
     100             : 
     101     1428542 : static inline int ff_h263_round_chroma(int x)
     102             : {
     103             :     //FIXME static or not?
     104             :     static const uint8_t h263_chroma_roundtab[16] = {
     105             :     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
     106             :         0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
     107             :     };
     108     1428542 :     return h263_chroma_roundtab[x & 0xf] + (x >> 3);
     109             : }
     110             : 
     111             : int ff_init_me(struct MpegEncContext *s);
     112             : 
     113             : void ff_estimate_p_frame_motion(struct MpegEncContext *s, int mb_x, int mb_y);
     114             : void ff_estimate_b_frame_motion(struct MpegEncContext *s, int mb_x, int mb_y);
     115             : 
     116             : int ff_pre_estimate_p_frame_motion(struct MpegEncContext *s,
     117             :                                    int mb_x, int mb_y);
     118             : 
     119             : int ff_epzs_motion_search(struct MpegEncContext *s, int *mx_ptr, int *my_ptr,
     120             :                           int P[10][2], int src_index, int ref_index,
     121             :                           int16_t (*last_mv)[2], int ref_mv_scale, int size,
     122             :                           int h);
     123             : 
     124             : int ff_get_mb_score(struct MpegEncContext *s, int mx, int my, int src_index,
     125             :                     int ref_index, int size, int h, int add_rate);
     126             : 
     127             : int ff_get_best_fcode(struct MpegEncContext *s,
     128             :                       int16_t (*mv_table)[2], int type);
     129             : 
     130             : void ff_fix_long_p_mvs(struct MpegEncContext *s);
     131             : void ff_fix_long_mvs(struct MpegEncContext *s, uint8_t *field_select_table,
     132             :                      int field_select, int16_t (*mv_table)[2], int f_code,
     133             :                      int type, int truncate);
     134             : 
     135             : #endif /* AVCODEC_MOTION_EST_H */

Generated by: LCOV version 1.13