swscale: fix gbrap to gbrap alpha scaling
[ffmpeg.git] / libavcodec / vp9prob.c
1 /*
2  * VP9 compatible video decoder
3  *
4  * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
5  * Copyright (C) 2013 Clément Bœsch <u pkh me>
6  *
7  * This file is part of Libav.
8  *
9  * Libav is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * Libav is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with Libav; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include "vp56.h"
25 #include "vp9.h"
26 #include "vp9data.h"
27
28 static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
29                                         int max_count, int update_factor)
30 {
31     unsigned ct = ct0 + ct1, p2, p1;
32
33     if (!ct)
34         return;
35
36     p1 = *p;
37     p2 = ((ct0 << 8) + (ct >> 1)) / ct;
38     p2 = av_clip(p2, 1, 255);
39     ct = FFMIN(ct, max_count);
40     update_factor = FASTDIV(update_factor * ct, max_count);
41
42     // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
43     *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
44 }
45
46 void ff_vp9_adapt_probs(VP9Context *s)
47 {
48     int i, j, k, l, m;
49     ProbContext *p = &s->prob_ctx[s->framectxid].p;
50     int uf = (s->keyframe || s->intraonly || !s->last_keyframe) ? 112 : 128;
51
52     // coefficients
53     for (i = 0; i < 4; i++)
54         for (j = 0; j < 2; j++)
55             for (k = 0; k < 2; k++)
56                 for (l = 0; l < 6; l++)
57                     for (m = 0; m < 6; m++) {
58                         uint8_t *pp = s->prob_ctx[s->framectxid].coef[i][j][k][l][m];
59                         unsigned *e = s->counts.eob[i][j][k][l][m];
60                         unsigned *c = s->counts.coef[i][j][k][l][m];
61
62                         if (l == 0 && m >= 3) // dc only has 3 pt
63                             break;
64
65                         adapt_prob(&pp[0], e[0], e[1], 24, uf);
66                         adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
67                         adapt_prob(&pp[2], c[1], c[2], 24, uf);
68                     }
69
70     if (s->keyframe || s->intraonly) {
71         memcpy(p->skip,  s->prob.p.skip,  sizeof(p->skip));
72         memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
73         memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
74         memcpy(p->tx8p,  s->prob.p.tx8p,  sizeof(p->tx8p));
75         return;
76     }
77
78     // skip flag
79     for (i = 0; i < 3; i++)
80         adapt_prob(&p->skip[i], s->counts.skip[i][0],
81                    s->counts.skip[i][1], 20, 128);
82
83     // intra/inter flag
84     for (i = 0; i < 4; i++)
85         adapt_prob(&p->intra[i], s->counts.intra[i][0],
86                    s->counts.intra[i][1], 20, 128);
87
88     // comppred flag
89     if (s->comppredmode == PRED_SWITCHABLE) {
90         for (i = 0; i < 5; i++)
91             adapt_prob(&p->comp[i], s->counts.comp[i][0],
92                        s->counts.comp[i][1], 20, 128);
93     }
94
95     // reference frames
96     if (s->comppredmode != PRED_SINGLEREF) {
97         for (i = 0; i < 5; i++)
98             adapt_prob(&p->comp_ref[i], s->counts.comp_ref[i][0],
99                        s->counts.comp_ref[i][1], 20, 128);
100     }
101
102     if (s->comppredmode != PRED_COMPREF) {
103         for (i = 0; i < 5; i++) {
104             uint8_t *pp = p->single_ref[i];
105             unsigned (*c)[2] = s->counts.single_ref[i];
106
107             adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
108             adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
109         }
110     }
111
112     // block partitioning
113     for (i = 0; i < 4; i++)
114         for (j = 0; j < 4; j++) {
115             uint8_t *pp = p->partition[i][j];
116             unsigned *c = s->counts.partition[i][j];
117
118             adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
119             adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
120             adapt_prob(&pp[2], c[2], c[3], 20, 128);
121         }
122
123     // tx size
124     if (s->txfmmode == TX_SWITCHABLE) {
125         for (i = 0; i < 2; i++) {
126             unsigned *c16 = s->counts.tx16p[i], *c32 = s->counts.tx32p[i];
127
128             adapt_prob(&p->tx8p[i], s->counts.tx8p[i][0],
129                        s->counts.tx8p[i][1], 20, 128);
130             adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
131             adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
132             adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
133             adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
134             adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
135         }
136     }
137
138     // interpolation filter
139     if (s->filtermode == FILTER_SWITCHABLE) {
140         for (i = 0; i < 4; i++) {
141             uint8_t *pp = p->filter[i];
142             unsigned *c = s->counts.filter[i];
143
144             adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
145             adapt_prob(&pp[1], c[1], c[2], 20, 128);
146         }
147     }
148
149     // inter modes
150     for (i = 0; i < 7; i++) {
151         uint8_t *pp = p->mv_mode[i];
152         unsigned *c = s->counts.mv_mode[i];
153
154         adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
155         adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
156         adapt_prob(&pp[2], c[1], c[3], 20, 128);
157     }
158
159     // mv joints
160     {
161         uint8_t *pp = p->mv_joint;
162         unsigned *c = s->counts.mv_joint;
163
164         adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
165         adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
166         adapt_prob(&pp[2], c[2], c[3], 20, 128);
167     }
168
169     // mv components
170     for (i = 0; i < 2; i++) {
171         uint8_t *pp;
172         unsigned *c, (*c2)[2], sum;
173
174         adapt_prob(&p->mv_comp[i].sign, s->counts.mv_comp[i].sign[0],
175                    s->counts.mv_comp[i].sign[1], 20, 128);
176
177         pp  = p->mv_comp[i].classes;
178         c   = s->counts.mv_comp[i].classes;
179         sum = c[1] + c[2] + c[3] + c[4] + c[5] +
180               c[6] + c[7] + c[8] + c[9] + c[10];
181         adapt_prob(&pp[0], c[0], sum, 20, 128);
182         sum -= c[1];
183         adapt_prob(&pp[1], c[1], sum, 20, 128);
184         sum -= c[2] + c[3];
185         adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
186         adapt_prob(&pp[3], c[2], c[3], 20, 128);
187         sum -= c[4] + c[5];
188         adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
189         adapt_prob(&pp[5], c[4], c[5], 20, 128);
190         sum -= c[6];
191         adapt_prob(&pp[6], c[6], sum, 20, 128);
192         adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
193         adapt_prob(&pp[8], c[7], c[8], 20, 128);
194         adapt_prob(&pp[9], c[9], c[10], 20, 128);
195
196         adapt_prob(&p->mv_comp[i].class0, s->counts.mv_comp[i].class0[0],
197                    s->counts.mv_comp[i].class0[1], 20, 128);
198         pp = p->mv_comp[i].bits;
199         c2 = s->counts.mv_comp[i].bits;
200         for (j = 0; j < 10; j++)
201             adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
202
203         for (j = 0; j < 2; j++) {
204             pp = p->mv_comp[i].class0_fp[j];
205             c  = s->counts.mv_comp[i].class0_fp[j];
206             adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
207             adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
208             adapt_prob(&pp[2], c[2], c[3], 20, 128);
209         }
210         pp = p->mv_comp[i].fp;
211         c  = s->counts.mv_comp[i].fp;
212         adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
213         adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
214         adapt_prob(&pp[2], c[2], c[3], 20, 128);
215
216         if (s->highprecisionmvs) {
217             adapt_prob(&p->mv_comp[i].class0_hp,
218                        s->counts.mv_comp[i].class0_hp[0],
219                        s->counts.mv_comp[i].class0_hp[1], 20, 128);
220             adapt_prob(&p->mv_comp[i].hp, s->counts.mv_comp[i].hp[0],
221                        s->counts.mv_comp[i].hp[1], 20, 128);
222         }
223     }
224
225     // y intra modes
226     for (i = 0; i < 4; i++) {
227         uint8_t *pp = p->y_mode[i];
228         unsigned *c = s->counts.y_mode[i], sum, s2;
229
230         sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
231         adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
232         sum -= c[TM_VP8_PRED];
233         adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
234         sum -= c[VERT_PRED];
235         adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
236         s2   = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
237         sum -= s2;
238         adapt_prob(&pp[3], s2, sum, 20, 128);
239         s2 -= c[HOR_PRED];
240         adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
241         adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED],
242                    20, 128);
243         sum -= c[DIAG_DOWN_LEFT_PRED];
244         adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
245         sum -= c[VERT_LEFT_PRED];
246         adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
247         adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
248     }
249
250     // uv intra modes
251     for (i = 0; i < 10; i++) {
252         uint8_t *pp = p->uv_mode[i];
253         unsigned *c = s->counts.uv_mode[i], sum, s2;
254
255         sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
256         adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
257         sum -= c[TM_VP8_PRED];
258         adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
259         sum -= c[VERT_PRED];
260         adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
261         s2   = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
262         sum -= s2;
263         adapt_prob(&pp[3], s2, sum, 20, 128);
264         s2 -= c[HOR_PRED];
265         adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
266         adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED],
267                    20, 128);
268         sum -= c[DIAG_DOWN_LEFT_PRED];
269         adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
270         sum -= c[VERT_LEFT_PRED];
271         adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
272         adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
273     }
274 }