Coverage Report

Created: 2022-08-24 06:17

/src/x265/source/encoder/bitcost.h
Line
Count
Source (jump to first uncovered line)
1
/*****************************************************************************
2
 * Copyright (C) 2013-2020 MulticoreWare, Inc
3
 *
4
 * Authors: Steve Borho <steve@borho.org>
5
 *
6
 * This program is free software; you can redistribute it and/or modify
7
 * it under the terms of the GNU General Public License as published by
8
 * the Free Software Foundation; either version 2 of the License, or
9
 * (at your option) any later version.
10
 *
11
 * This program 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
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
19
 *
20
 * This program is also available under a commercial proprietary license.
21
 * For more information, contact us at license @ x265.com.
22
 *****************************************************************************/
23
24
#ifndef X265_BITCOST_H
25
#define X265_BITCOST_H
26
27
#include "common.h"
28
#include "threading.h"
29
#include "mv.h"
30
31
namespace X265_NS {
32
// private x265 namespace
33
34
class BitCost
35
{
36
public:
37
38
0
    BitCost() : m_cost_mvx(0), m_cost_mvy(0), m_cost(0), m_mvp(0) {}
39
40
    void setQP(unsigned int qp);
41
42
0
    void setMVP(const MV& mvp)                      { m_mvp = mvp; m_cost_mvx = m_cost - mvp.x; m_cost_mvy = m_cost - mvp.y; }
43
44
    // return bit cost of motion vector difference, multiplied by lambda
45
0
    inline uint16_t mvcost(const MV& mv) const      { return m_cost_mvx[mv.x] + m_cost_mvy[mv.y]; }
46
47
    // return bit cost of motion vector difference, without lambda
48
    inline uint32_t bitcost(const MV& mv) const
49
0
    {
50
0
        return (uint32_t)(s_bitsizes[mv.x - m_mvp.x] +
51
0
                          s_bitsizes[mv.y - m_mvp.y] + 0.5f);
52
0
    }
53
54
    static inline uint32_t bitcost(const MV& mv, const MV& mvp)
55
0
    {
56
0
        return (uint32_t)(s_bitsizes[mv.x - mvp.x] +
57
0
                          s_bitsizes[mv.y - mvp.y] + 0.5f);
58
0
    }
59
60
    static void destroy();
61
62
protected:
63
64
    uint16_t *m_cost_mvx;
65
66
    uint16_t *m_cost_mvy;
67
68
    uint16_t *m_cost;
69
70
    uint16_t *m_fpelMvCosts[4];
71
72
    MV        m_mvp;
73
74
    BitCost& operator =(const BitCost&);
75
76
private:
77
78
    /* default log2_max_mv_length_horizontal and log2_max_mv_length_horizontal
79
     * are 15, specified in quarter-pel luma sample units. making the maximum
80
     * signaled ful-pel motion distance 4096, max qpel is 32768 */
81
    enum { BC_MAX_MV = (1 << 15) };
82
83
    enum { BC_MAX_QP = 82 };
84
85
    static float *s_bitsizes;
86
87
    static uint16_t *s_costs[BC_MAX_QP];
88
89
    static uint16_t *s_fpelMvCosts[BC_MAX_QP][4];
90
91
    static Lock s_costCalcLock;
92
93
    static void CalculateLogs();
94
};
95
}
96
97
#endif // ifndef X265_BITCOST_H