Bug Summary

File:root/firefox-clang/third_party/dav1d/src/decode.c
Warning:line 3591, column 56
The left operand of '+' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name decode.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/libdav1d -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/libdav1d -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D DAV1D_API= -D STACK_ALIGNMENT=16 -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /root/firefox-clang/media/libdav1d -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/media/libdav1d -I /root/firefox-clang/third_party/dav1d -I /root/firefox-clang/third_party/dav1d/include -I /root/firefox-clang/third_party/dav1d/include/dav1d -I /root/firefox-clang/third_party/dav1d/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-character-conversion -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c /root/firefox-clang/third_party/dav1d/src/decode.c
1/*
2 * Copyright © 2018-2021, VideoLAN and dav1d authors
3 * Copyright © 2018, Two Orioles, LLC
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright notice, this
10 * list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include "config.h"
29
30#include <errno(*__errno_location ()).h>
31#include <limits.h>
32#include <string.h>
33#include <stdio.h>
34#include <inttypes.h>
35
36#include "dav1d/data.h"
37
38#include "common/frame.h"
39#include "common/intops.h"
40
41#include "src/ctx.h"
42#include "src/decode.h"
43#include "src/dequant_tables.h"
44#include "src/env.h"
45#include "src/filmgrain.h"
46#include "src/log.h"
47#include "src/qm.h"
48#include "src/recon.h"
49#include "src/ref.h"
50#include "src/tables.h"
51#include "src/thread_task.h"
52#include "src/warpmv.h"
53
54static void init_quant_tables(const Dav1dSequenceHeader *const seq_hdr,
55 const Dav1dFrameHeader *const frame_hdr,
56 const int qidx, uint16_t (*dq)[3][2])
57{
58 for (int i = 0; i < (frame_hdr->segmentation.enabled ? 8 : 1); i++) {
59 const int yac = frame_hdr->segmentation.enabled ?
60 iclip_u8(qidx + frame_hdr->segmentation.seg_data.d[i].delta_q) : qidx;
61 const int ydc = iclip_u8(yac + frame_hdr->quant.ydc_delta);
62 const int uac = iclip_u8(yac + frame_hdr->quant.uac_delta);
63 const int udc = iclip_u8(yac + frame_hdr->quant.udc_delta);
64 const int vac = iclip_u8(yac + frame_hdr->quant.vac_delta);
65 const int vdc = iclip_u8(yac + frame_hdr->quant.vdc_delta);
66
67 dq[i][0][0] = dav1d_dq_tbl[seq_hdr->hbd][ydc][0];
68 dq[i][0][1] = dav1d_dq_tbl[seq_hdr->hbd][yac][1];
69 dq[i][1][0] = dav1d_dq_tbl[seq_hdr->hbd][udc][0];
70 dq[i][1][1] = dav1d_dq_tbl[seq_hdr->hbd][uac][1];
71 dq[i][2][0] = dav1d_dq_tbl[seq_hdr->hbd][vdc][0];
72 dq[i][2][1] = dav1d_dq_tbl[seq_hdr->hbd][vac][1];
73 }
74}
75
76static int read_mv_component_diff(MsacContext *const msac,
77 CdfMvComponent *const mv_comp,
78 const int mv_prec)
79{
80 const int sign = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(msac, mv_comp->sign);
81 const int cl = dav1d_msac_decode_symbol_adapt16(msac, mv_comp->classes, 10)((msac)->symbol_adapt16(msac, mv_comp->classes, 10));
82 int up, fp = 3, hp = 1;
83
84 if (!cl) {
85 up = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(msac, mv_comp->class0);
86 if (mv_prec >= 0) { // !force_integer_mv
87 fp = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(msac, mv_comp->class0_fp[up], 3);
88 if (mv_prec > 0) // allow_high_precision_mv
89 hp = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(msac, mv_comp->class0_hp);
90 }
91 } else {
92 up = 1 << cl;
93 for (int n = 0; n < cl; n++)
94 up |= dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(msac, mv_comp->classN[n]) << n;
95 if (mv_prec >= 0) { // !force_integer_mv
96 fp = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(msac, mv_comp->classN_fp, 3);
97 if (mv_prec > 0) // allow_high_precision_mv
98 hp = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(msac, mv_comp->classN_hp);
99 }
100 }
101
102 const int diff = ((up << 3) | (fp << 1) | hp) + 1;
103
104 return sign ? -diff : diff;
105}
106
107static void read_mv_residual(Dav1dTileState *const ts, mv *const ref_mv,
108 const int mv_prec)
109{
110 MsacContext *const msac = &ts->msac;
111 const enum MVJoint mv_joint =
112 dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(msac, ts->cdf.mv.joint, N_MV_JOINTS - 1);
113 if (mv_joint & MV_JOINT_V)
114 ref_mv->y += read_mv_component_diff(msac, &ts->cdf.mv.comp[0], mv_prec);
115 if (mv_joint & MV_JOINT_H)
116 ref_mv->x += read_mv_component_diff(msac, &ts->cdf.mv.comp[1], mv_prec);
117}
118
119static void read_tx_tree(Dav1dTaskContext *const t,
120 const enum RectTxfmSize from,
121 const int depth, uint16_t *const masks,
122 const int x_off, const int y_off)
123{
124 const Dav1dFrameContext *const f = t->f;
125 const int bx4 = t->bx & 31, by4 = t->by & 31;
126 const TxfmInfo *const t_dim = &dav1d_txfm_dimensions[from];
127 const int txw = t_dim->lw, txh = t_dim->lh;
128 int is_split;
129
130 if (depth < 2 && from > (int) TX_4X4) {
131 const int cat = 2 * (TX_64X64 - t_dim->max) - depth;
132 const int a = t->a->tx[bx4] < txw;
133 const int l = t->l.tx[by4] < txh;
134
135 is_split = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&t->ts->msac,
136 t->ts->cdf.m.txpart[cat][a + l]);
137 if (is_split)
138 masks[depth] |= 1 << (y_off * 4 + x_off);
139 } else {
140 is_split = 0;
141 }
142
143 if (is_split && t_dim->max > TX_8X8) {
144 const enum RectTxfmSize sub = t_dim->sub;
145 const TxfmInfo *const sub_t_dim = &dav1d_txfm_dimensions[sub];
146 const int txsw = sub_t_dim->w, txsh = sub_t_dim->h;
147
148 read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 0, y_off * 2 + 0);
149 t->bx += txsw;
150 if (txw >= txh && t->bx < f->bw)
151 read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 1, y_off * 2 + 0);
152 t->bx -= txsw;
153 t->by += txsh;
154 if (txh >= txw && t->by < f->bh) {
155 read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 0, y_off * 2 + 1);
156 t->bx += txsw;
157 if (txw >= txh && t->bx < f->bw)
158 read_tx_tree(t, sub, depth + 1, masks,
159 x_off * 2 + 1, y_off * 2 + 1);
160 t->bx -= txsw;
161 }
162 t->by -= txsh;
163 } else {
164 dav1d_memset_pow2[t_dim->lw](&t->a->tx[bx4], is_split ? TX_4X4 : txw);
165 dav1d_memset_pow2[t_dim->lh](&t->l.tx[by4], is_split ? TX_4X4 : txh);
166 }
167}
168
169static int neg_deinterleave(int diff, int ref, int max) {
170 if (!ref) return diff;
171 if (ref >= (max - 1)) return max - diff - 1;
172 if (2 * ref < max) {
173 if (diff <= 2 * ref) {
174 if (diff & 1)
175 return ref + ((diff + 1) >> 1);
176 else
177 return ref - (diff >> 1);
178 }
179 return diff;
180 } else {
181 if (diff <= 2 * (max - ref - 1)) {
182 if (diff & 1)
183 return ref + ((diff + 1) >> 1);
184 else
185 return ref - (diff >> 1);
186 }
187 return max - (diff + 1);
188 }
189}
190
191static void find_matching_ref(const Dav1dTaskContext *const t,
192 const enum EdgeFlags intra_edge_flags,
193 const int bw4, const int bh4,
194 const int w4, const int h4,
195 const int have_left, const int have_top,
196 const int ref, uint64_t masks[2])
197{
198 /*const*/ refmvs_block *const *r = &t->rt.r[(t->by & 31) + 5];
199 int count = 0;
200 int have_topleft = have_top && have_left;
201 int have_topright = imax(bw4, bh4) < 32 &&
202 have_top && t->bx + bw4 < t->ts->tiling.col_end &&
203 (intra_edge_flags & EDGE_I444_TOP_HAS_RIGHT);
204
205#define bs(rp) dav1d_block_dimensions[(rp)->bs]
206#define matches(rp) ((rp)->ref.ref[0] == ref + 1 && (rp)->ref.ref[1] == -1)
207
208 if (have_top) {
209 const refmvs_block *r2 = &r[-1][t->bx];
210 if (matches(r2)) {
211 masks[0] |= 1;
212 count = 1;
213 }
214 int aw4 = bs(r2)[0];
215 if (aw4 >= bw4) {
216 const int off = t->bx & (aw4 - 1);
217 if (off) have_topleft = 0;
218 if (aw4 - off > bw4) have_topright = 0;
219 } else {
220 unsigned mask = 1 << aw4;
221 for (int x = aw4; x < w4; x += aw4) {
222 r2 += aw4;
223 if (matches(r2)) {
224 masks[0] |= mask;
225 if (++count >= 8) return;
226 }
227 aw4 = bs(r2)[0];
228 mask <<= aw4;
229 }
230 }
231 }
232 if (have_left) {
233 /*const*/ refmvs_block *const *r2 = r;
234 if (matches(&r2[0][t->bx - 1])) {
235 masks[1] |= 1;
236 if (++count >= 8) return;
237 }
238 int lh4 = bs(&r2[0][t->bx - 1])[1];
239 if (lh4 >= bh4) {
240 if (t->by & (lh4 - 1)) have_topleft = 0;
241 } else {
242 unsigned mask = 1 << lh4;
243 for (int y = lh4; y < h4; y += lh4) {
244 r2 += lh4;
245 if (matches(&r2[0][t->bx - 1])) {
246 masks[1] |= mask;
247 if (++count >= 8) return;
248 }
249 lh4 = bs(&r2[0][t->bx - 1])[1];
250 mask <<= lh4;
251 }
252 }
253 }
254 if (have_topleft && matches(&r[-1][t->bx - 1])) {
255 masks[1] |= 1ULL << 32;
256 if (++count >= 8) return;
257 }
258 if (have_topright && matches(&r[-1][t->bx + bw4])) {
259 masks[0] |= 1ULL << 32;
260 }
261#undef matches
262}
263
264static void derive_warpmv(const Dav1dTaskContext *const t,
265 const int bw4, const int bh4,
266 const uint64_t masks[2], const union mv mv,
267 Dav1dWarpedMotionParams *const wmp)
268{
269 int pts[8][2 /* in, out */][2 /* x, y */], np = 0;
270 /*const*/ refmvs_block *const *r = &t->rt.r[(t->by & 31) + 5];
271
272#define add_sample(dx, dy, sx, sy, rp)do { pts[np][0][0] = 16 * (2 * dx + sx * bs(rp)[0]) - 8; pts[
np][0][1] = 16 * (2 * dy + sy * bs(rp)[1]) - 8; pts[np][1][0]
= pts[np][0][0] + (rp)->mv.mv[0].x; pts[np][1][1] = pts[np
][0][1] + (rp)->mv.mv[0].y; np++; } while (0) do { \
273 pts[np][0][0] = 16 * (2 * dx + sx * bs(rp)[0]) - 8; \
274 pts[np][0][1] = 16 * (2 * dy + sy * bs(rp)[1]) - 8; \
275 pts[np][1][0] = pts[np][0][0] + (rp)->mv.mv[0].x; \
276 pts[np][1][1] = pts[np][0][1] + (rp)->mv.mv[0].y; \
277 np++; \
278} while (0)
279
280 // use masks[] to find the projectable motion vectors in the edges
281 if ((unsigned) masks[0] == 1 && !(masks[1] >> 32)) {
282 const int off = t->bx & (bs(&r[-1][t->bx])[0] - 1);
283 add_sample(-off, 0, 1, -1, &r[-1][t->bx])do { pts[np][0][0] = 16 * (2 * -off + 1 * bs(&r[-1][t->
bx])[0]) - 8; pts[np][0][1] = 16 * (2 * 0 + -1 * bs(&r[-1
][t->bx])[1]) - 8; pts[np][1][0] = pts[np][0][0] + (&r
[-1][t->bx])->mv.mv[0].x; pts[np][1][1] = pts[np][0][1]
+ (&r[-1][t->bx])->mv.mv[0].y; np++; } while (0);
284 } else for (unsigned off = 0, xmask = (uint32_t) masks[0]; np < 8 && xmask;) { // top
285 const int tz = ctz(xmask);
286 off += tz;
287 xmask >>= tz;
288 add_sample(off, 0, 1, -1, &r[-1][t->bx + off])do { pts[np][0][0] = 16 * (2 * off + 1 * bs(&r[-1][t->
bx + off])[0]) - 8; pts[np][0][1] = 16 * (2 * 0 + -1 * bs(&
r[-1][t->bx + off])[1]) - 8; pts[np][1][0] = pts[np][0][0]
+ (&r[-1][t->bx + off])->mv.mv[0].x; pts[np][1][1]
= pts[np][0][1] + (&r[-1][t->bx + off])->mv.mv[0].
y; np++; } while (0);
289 xmask &= ~1;
290 }
291 if (np < 8 && masks[1] == 1) {
292 const int off = t->by & (bs(&r[0][t->bx - 1])[1] - 1);
293 add_sample(0, -off, -1, 1, &r[-off][t->bx - 1])do { pts[np][0][0] = 16 * (2 * 0 + -1 * bs(&r[-off][t->
bx - 1])[0]) - 8; pts[np][0][1] = 16 * (2 * -off + 1 * bs(&
r[-off][t->bx - 1])[1]) - 8; pts[np][1][0] = pts[np][0][0]
+ (&r[-off][t->bx - 1])->mv.mv[0].x; pts[np][1][1]
= pts[np][0][1] + (&r[-off][t->bx - 1])->mv.mv[0].
y; np++; } while (0);
294 } else for (unsigned off = 0, ymask = (uint32_t) masks[1]; np < 8 && ymask;) { // left
295 const int tz = ctz(ymask);
296 off += tz;
297 ymask >>= tz;
298 add_sample(0, off, -1, 1, &r[off][t->bx - 1])do { pts[np][0][0] = 16 * (2 * 0 + -1 * bs(&r[off][t->
bx - 1])[0]) - 8; pts[np][0][1] = 16 * (2 * off + 1 * bs(&
r[off][t->bx - 1])[1]) - 8; pts[np][1][0] = pts[np][0][0] +
(&r[off][t->bx - 1])->mv.mv[0].x; pts[np][1][1] = pts
[np][0][1] + (&r[off][t->bx - 1])->mv.mv[0].y; np++
; } while (0);
299 ymask &= ~1;
300 }
301 if (np < 8 && masks[1] >> 32) // top/left
302 add_sample(0, 0, -1, -1, &r[-1][t->bx - 1])do { pts[np][0][0] = 16 * (2 * 0 + -1 * bs(&r[-1][t->bx
- 1])[0]) - 8; pts[np][0][1] = 16 * (2 * 0 + -1 * bs(&r[
-1][t->bx - 1])[1]) - 8; pts[np][1][0] = pts[np][0][0] + (
&r[-1][t->bx - 1])->mv.mv[0].x; pts[np][1][1] = pts
[np][0][1] + (&r[-1][t->bx - 1])->mv.mv[0].y; np++;
} while (0);
303 if (np < 8 && masks[0] >> 32) // top/right
304 add_sample(bw4, 0, 1, -1, &r[-1][t->bx + bw4])do { pts[np][0][0] = 16 * (2 * bw4 + 1 * bs(&r[-1][t->
bx + bw4])[0]) - 8; pts[np][0][1] = 16 * (2 * 0 + -1 * bs(&
r[-1][t->bx + bw4])[1]) - 8; pts[np][1][0] = pts[np][0][0]
+ (&r[-1][t->bx + bw4])->mv.mv[0].x; pts[np][1][1]
= pts[np][0][1] + (&r[-1][t->bx + bw4])->mv.mv[0].
y; np++; } while (0);
305 assert(np > 0 && np <= 8)((void) sizeof ((np > 0 && np <= 8) ? 1 : 0), __extension__
({ if (np > 0 && np <= 8) ; else __assert_fail
("np > 0 && np <= 8", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 305, __extension__ __PRETTY_FUNCTION__); }));
306#undef bs
307
308 // select according to motion vector difference against a threshold
309 int mvd[8], ret = 0;
310 const int thresh = 4 * iclip(imax(bw4, bh4), 4, 28);
311 for (int i = 0; i < np; i++) {
312 mvd[i] = abs(pts[i][1][0] - pts[i][0][0] - mv.x) +
313 abs(pts[i][1][1] - pts[i][0][1] - mv.y);
314 if (mvd[i] > thresh)
315 mvd[i] = -1;
316 else
317 ret++;
318 }
319 if (!ret) {
320 ret = 1;
321 } else for (int i = 0, j = np - 1, k = 0; k < np - ret; k++, i++, j--) {
322 while (mvd[i] != -1) i++;
323 while (mvd[j] == -1) j--;
324 assert(i != j)((void) sizeof ((i != j) ? 1 : 0), __extension__ ({ if (i != j
) ; else __assert_fail ("i != j", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 324, __extension__ __PRETTY_FUNCTION__); }));
325 if (i > j) break;
326 // replace the discarded samples;
327 mvd[i] = mvd[j];
328 memcpy(pts[i], pts[j], sizeof(*pts));
329 }
330
331 if (!dav1d_find_affine_int(pts, ret, bw4, bh4, mv, wmp, t->bx, t->by) &&
332 !dav1d_get_shear_params(wmp))
333 {
334 wmp->type = DAV1D_WM_TYPE_AFFINE;
335 } else
336 wmp->type = DAV1D_WM_TYPE_IDENTITY;
337}
338
339static inline int findoddzero(const uint8_t *buf, int len) {
340 for (int n = 0; n < len; n++)
341 if (!buf[n * 2]) return 1;
342 return 0;
343}
344
345// meant to be SIMD'able, so that theoretical complexity of this function
346// times block size goes from w4*h4 to w4+h4-1
347// a and b are previous two lines containing (a) top/left entries or (b)
348// top/left entries, with a[0] being either the first top or first left entry,
349// depending on top_offset being 1 or 0, and b being the first top/left entry
350// for whichever has one. left_offset indicates whether the (len-1)th entry
351// has a left neighbour.
352// output is order[] and ctx for each member of this diagonal.
353static void order_palette(const uint8_t *pal_idx, const ptrdiff_t stride,
354 const int i, const int first, const int last,
355 uint8_t (*const order)[8], uint8_t *const ctx)
356{
357 int have_top = i > first;
358
359 assert(pal_idx)((void) sizeof ((pal_idx) ? 1 : 0), __extension__ ({ if (pal_idx
) ; else __assert_fail ("pal_idx", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 359, __extension__ __PRETTY_FUNCTION__); }));
360 pal_idx += first + (i - first) * stride;
361 for (int j = first, n = 0; j >= last; have_top = 1, j--, n++, pal_idx += stride - 1) {
362 const int have_left = j > 0;
363
364 assert(have_left || have_top)((void) sizeof ((have_left || have_top) ? 1 : 0), __extension__
({ if (have_left || have_top) ; else __assert_fail ("have_left || have_top"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 364, __extension__
__PRETTY_FUNCTION__); }));
365
366#define add(v_in) do { \
367 const int v = v_in; \
368 assert((unsigned)v < 8U)((void) sizeof (((unsigned)v < 8U) ? 1 : 0), __extension__
({ if ((unsigned)v < 8U) ; else __assert_fail ("(unsigned)v < 8U"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 368, __extension__
__PRETTY_FUNCTION__); })); \
369 order[n][o_idx++] = v; \
370 mask |= 1 << v; \
371 } while (0)
372
373 unsigned mask = 0;
374 int o_idx = 0;
375 if (!have_left) {
376 ctx[n] = 0;
377 add(pal_idx[-stride]);
378 } else if (!have_top) {
379 ctx[n] = 0;
380 add(pal_idx[-1]);
381 } else {
382 const int l = pal_idx[-1], t = pal_idx[-stride], tl = pal_idx[-(stride + 1)];
383 const int same_t_l = t == l;
384 const int same_t_tl = t == tl;
385 const int same_l_tl = l == tl;
386 const int same_all = same_t_l & same_t_tl & same_l_tl;
387
388 if (same_all) {
389 ctx[n] = 4;
390 add(t);
391 } else if (same_t_l) {
392 ctx[n] = 3;
393 add(t);
394 add(tl);
395 } else if (same_t_tl | same_l_tl) {
396 ctx[n] = 2;
397 add(tl);
398 add(same_t_tl ? l : t);
399 } else {
400 ctx[n] = 1;
401 add(imin(t, l));
402 add(imax(t, l));
403 add(tl);
404 }
405 }
406 for (unsigned m = 1, bit = 0; m < 0x100; m <<= 1, bit++)
407 if (!(mask & m))
408 order[n][o_idx++] = bit;
409 assert(o_idx == 8)((void) sizeof ((o_idx == 8) ? 1 : 0), __extension__ ({ if (o_idx
== 8) ; else __assert_fail ("o_idx == 8", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 409, __extension__ __PRETTY_FUNCTION__); }));
410#undef add
411 }
412}
413
414static void read_pal_indices(Dav1dTaskContext *const t,
415 uint8_t *const pal_idx,
416 const int pal_sz, const int pl,
417 const int w4, const int h4,
418 const int bw4, const int bh4)
419{
420 Dav1dTileState *const ts = t->ts;
421 const ptrdiff_t stride = bw4 * 4;
422 assert(pal_idx)((void) sizeof ((pal_idx) ? 1 : 0), __extension__ ({ if (pal_idx
) ; else __assert_fail ("pal_idx", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 422, __extension__ __PRETTY_FUNCTION__); }));
423 uint8_t *const pal_tmp = t->scratch.pal_idx_uv;
424 pal_tmp[0] = dav1d_msac_decode_uniform(&ts->msac, pal_sz);
425 uint16_t (*const color_map_cdf)[8] =
426 ts->cdf.m.color_map[pl][pal_sz - 2];
427 uint8_t (*const order)[8] = t->scratch.pal_order;
428 uint8_t *const ctx = t->scratch.pal_ctx;
429 for (int i = 1; i < 4 * (w4 + h4) - 1; i++) {
430 // top/left-to-bottom/right diagonals ("wave-front")
431 const int first = imin(i, w4 * 4 - 1);
432 const int last = imax(0, i - h4 * 4 + 1);
433 order_palette(pal_tmp, stride, i, first, last, order, ctx);
434 for (int j = first, m = 0; j >= last; j--, m++) {
435 const int color_idx = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac,
436 color_map_cdf[ctx[m]], pal_sz - 1);
437 pal_tmp[(i - j) * stride + j] = order[m][color_idx];
438 }
439 }
440
441 t->c->pal_dsp.pal_idx_finish(pal_idx, pal_tmp, bw4 * 4, bh4 * 4,
442 w4 * 4, h4 * 4);
443}
444
445static void read_vartx_tree(Dav1dTaskContext *const t,
446 Av1Block *const b, const enum BlockSize bs,
447 const int bx4, const int by4)
448{
449 const Dav1dFrameContext *const f = t->f;
450 const uint8_t *const b_dim = dav1d_block_dimensions[bs];
451 const int bw4 = b_dim[0], bh4 = b_dim[1];
452
453 // var-tx tree coding
454 uint16_t tx_split[2] = { 0 };
455 b->max_ytx = dav1d_max_txfm_size_for_bs[bs][0];
456 if (!b->skip && (f->frame_hdr->segmentation.lossless[b->seg_id] ||
457 b->max_ytx == TX_4X4))
458 {
459 b->max_ytx = b->uvtx = TX_4X4;
460 if (f->frame_hdr->txfm_mode == DAV1D_TX_SWITCHABLE) {
461 dav1d_memset_pow2[b_dim[2]](&t->a->tx[bx4], TX_4X4);
462 dav1d_memset_pow2[b_dim[3]](&t->l.tx[by4], TX_4X4);
463 }
464 } else if (f->frame_hdr->txfm_mode != DAV1D_TX_SWITCHABLE || b->skip) {
465 if (f->frame_hdr->txfm_mode == DAV1D_TX_SWITCHABLE) {
466 dav1d_memset_pow2[b_dim[2]](&t->a->tx[bx4], b_dim[2 + 0]);
467 dav1d_memset_pow2[b_dim[3]](&t->l.tx[by4], b_dim[2 + 1]);
468 }
469 b->uvtx = dav1d_max_txfm_size_for_bs[bs][f->cur.p.layout];
470 } else {
471 assert(bw4 <= 16 || bh4 <= 16 || b->max_ytx == TX_64X64)((void) sizeof ((bw4 <= 16 || bh4 <= 16 || b->max_ytx
== TX_64X64) ? 1 : 0), __extension__ ({ if (bw4 <= 16 || bh4
<= 16 || b->max_ytx == TX_64X64) ; else __assert_fail (
"bw4 <= 16 || bh4 <= 16 || b->max_ytx == TX_64X64", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 471, __extension__ __PRETTY_FUNCTION__); }));
472 int y, x, y_off, x_off;
473 const TxfmInfo *const ytx = &dav1d_txfm_dimensions[b->max_ytx];
474 for (y = 0, y_off = 0; y < bh4; y += ytx->h, y_off++) {
475 for (x = 0, x_off = 0; x < bw4; x += ytx->w, x_off++) {
476 read_tx_tree(t, b->max_ytx, 0, tx_split, x_off, y_off);
477 // contexts are updated inside read_tx_tree()
478 t->bx += ytx->w;
479 }
480 t->bx -= x;
481 t->by += ytx->h;
482 }
483 t->by -= y;
484 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
485 printf("Post-vartxtree[%x/%x]: r=%d\n",
486 tx_split[0], tx_split[1], t->ts->msac.rng);
487 b->uvtx = dav1d_max_txfm_size_for_bs[bs][f->cur.p.layout];
488 }
489 assert(!(tx_split[0] & ~0x33))((void) sizeof ((!(tx_split[0] & ~0x33)) ? 1 : 0), __extension__
({ if (!(tx_split[0] & ~0x33)) ; else __assert_fail ("!(tx_split[0] & ~0x33)"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 489, __extension__
__PRETTY_FUNCTION__); }));
490 b->tx_split0 = (uint8_t)tx_split[0];
491 b->tx_split1 = tx_split[1];
492}
493
494static inline unsigned get_prev_frame_segid(const Dav1dFrameContext *const f,
495 const int by, const int bx,
496 const int w4, int h4,
497 const uint8_t *ref_seg_map,
498 const ptrdiff_t stride)
499{
500 assert(f->frame_hdr->primary_ref_frame != DAV1D_PRIMARY_REF_NONE)((void) sizeof ((f->frame_hdr->primary_ref_frame != 7) ?
1 : 0), __extension__ ({ if (f->frame_hdr->primary_ref_frame
!= 7) ; else __assert_fail ("f->frame_hdr->primary_ref_frame != DAV1D_PRIMARY_REF_NONE"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 500, __extension__
__PRETTY_FUNCTION__); }));
501
502 unsigned seg_id = 8;
503 ref_seg_map += by * stride + bx;
504 do {
505 for (int x = 0; x < w4; x++)
506 seg_id = imin(seg_id, ref_seg_map[x]);
507 ref_seg_map += stride;
508 } while (--h4 > 0 && seg_id);
509 assert(seg_id < 8)((void) sizeof ((seg_id < 8) ? 1 : 0), __extension__ ({ if
(seg_id < 8) ; else __assert_fail ("seg_id < 8", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 509, __extension__ __PRETTY_FUNCTION__); }));
510
511 return seg_id;
512}
513
514static inline void splat_oneref_mv(const Dav1dContext *const c,
515 Dav1dTaskContext *const t,
516 const enum BlockSize bs,
517 const Av1Block *const b,
518 const int bw4, const int bh4)
519{
520 const enum InterPredMode mode = b->inter_mode;
521 const refmvs_block ALIGN(tmpl, 16)tmpl __attribute__((aligned(16))) = (refmvs_block) {
522 .ref.ref = { b->ref[0] + 1, b->interintra_type ? 0 : -1 },
523 .mv.mv[0] = b->mv[0],
524 .bs = bs,
525 .mf = (mode == GLOBALMV && imin(bw4, bh4) >= 2) | ((mode == NEWMV) * 2),
526 };
527 c->refmvs_dsp.splat_mv(&t->rt.r[(t->by & 31) + 5], &tmpl, t->bx, bw4, bh4);
528}
529
530static inline void splat_intrabc_mv(const Dav1dContext *const c,
531 Dav1dTaskContext *const t,
532 const enum BlockSize bs,
533 const Av1Block *const b,
534 const int bw4, const int bh4)
535{
536 const refmvs_block ALIGN(tmpl, 16)tmpl __attribute__((aligned(16))) = (refmvs_block) {
537 .ref.ref = { 0, -1 },
538 .mv.mv[0] = b->mv[0],
539 .bs = bs,
540 .mf = 0,
541 };
542 c->refmvs_dsp.splat_mv(&t->rt.r[(t->by & 31) + 5], &tmpl, t->bx, bw4, bh4);
543}
544
545static inline void splat_tworef_mv(const Dav1dContext *const c,
546 Dav1dTaskContext *const t,
547 const enum BlockSize bs,
548 const Av1Block *const b,
549 const int bw4, const int bh4)
550{
551 assert(bw4 >= 2 && bh4 >= 2)((void) sizeof ((bw4 >= 2 && bh4 >= 2) ? 1 : 0)
, __extension__ ({ if (bw4 >= 2 && bh4 >= 2) ; else
__assert_fail ("bw4 >= 2 && bh4 >= 2", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 551, __extension__ __PRETTY_FUNCTION__); }));
552 const enum CompInterPredMode mode = b->inter_mode;
553 const refmvs_block ALIGN(tmpl, 16)tmpl __attribute__((aligned(16))) = (refmvs_block) {
554 .ref.ref = { b->ref[0] + 1, b->ref[1] + 1 },
555 .mv.mv = { b->mv[0], b->mv[1] },
556 .bs = bs,
557 .mf = (mode == GLOBALMV_GLOBALMV) | !!((1 << mode) & (0xbc)) * 2,
558 };
559 c->refmvs_dsp.splat_mv(&t->rt.r[(t->by & 31) + 5], &tmpl, t->bx, bw4, bh4);
560}
561
562static inline void splat_intraref(const Dav1dContext *const c,
563 Dav1dTaskContext *const t,
564 const enum BlockSize bs,
565 const int bw4, const int bh4)
566{
567 const refmvs_block ALIGN(tmpl, 16)tmpl __attribute__((aligned(16))) = (refmvs_block) {
568 .ref.ref = { 0, -1 },
569 .mv.mv[0].n = INVALID_MV0x80008000,
570 .bs = bs,
571 .mf = 0,
572 };
573 c->refmvs_dsp.splat_mv(&t->rt.r[(t->by & 31) + 5], &tmpl, t->bx, bw4, bh4);
574}
575
576static void mc_lowest_px(int *const dst, const int by4, const int bh4,
577 const int mvy, const int ss_ver,
578 const struct ScalableMotionParams *const smp)
579{
580 const int v_mul = 4 >> ss_ver;
581 if (!smp->scale) {
582 const int my = mvy >> (3 + ss_ver), dy = mvy & (15 >> !ss_ver);
583 *dst = imax(*dst, (by4 + bh4) * v_mul + my + 4 * !!dy);
584 } else {
585 int y = (by4 * v_mul << 4) + mvy * (1 << !ss_ver);
586 const int64_t tmp = (int64_t)(y) * smp->scale + (smp->scale - 0x4000) * 8;
587 y = apply_sign64((int)((llabs(tmp) + 128) >> 8), tmp) + 32;
588 const int bottom = ((y + (bh4 * v_mul - 1) * smp->step) >> 10) + 1 + 4;
589 *dst = imax(*dst, bottom);
590 }
591}
592
593static ALWAYS_INLINE__attribute__((always_inline)) inline void affine_lowest_px(Dav1dTaskContext *const t, int *const dst,
594 const uint8_t *const b_dim,
595 const Dav1dWarpedMotionParams *const wmp,
596 const int ss_ver, const int ss_hor)
597{
598 const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver;
599 assert(!((b_dim[0] * h_mul) & 7) && !((b_dim[1] * v_mul) & 7))((void) sizeof ((!((b_dim[0] * h_mul) & 7) && !((
b_dim[1] * v_mul) & 7)) ? 1 : 0), __extension__ ({ if (!(
(b_dim[0] * h_mul) & 7) && !((b_dim[1] * v_mul) &
7)) ; else __assert_fail ("!((b_dim[0] * h_mul) & 7) && !((b_dim[1] * v_mul) & 7)"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 599, __extension__
__PRETTY_FUNCTION__); }));
600 const int32_t *const mat = wmp->matrix;
601 const int y = b_dim[1] * v_mul - 8; // lowest y
602
603 const int src_y = t->by * 4 + ((y + 4) << ss_ver);
604 const int64_t mat5_y = (int64_t) mat[5] * src_y + mat[1];
605 // check left- and right-most blocks
606 for (int x = 0; x < b_dim[0] * h_mul; x += imax(8, b_dim[0] * h_mul - 8)) {
607 // calculate transformation relative to center of 8x8 block in
608 // luma pixel units
609 const int src_x = t->bx * 4 + ((x + 4) << ss_hor);
610 const int64_t mvy = ((int64_t) mat[4] * src_x + mat5_y) >> ss_ver;
611 const int dy = (int) (mvy >> 16) - 4;
612 *dst = imax(*dst, dy + 4 + 8);
613 }
614}
615
616static NOINLINE__attribute__((noinline)) void affine_lowest_px_luma(Dav1dTaskContext *const t, int *const dst,
617 const uint8_t *const b_dim,
618 const Dav1dWarpedMotionParams *const wmp)
619{
620 affine_lowest_px(t, dst, b_dim, wmp, 0, 0);
621}
622
623static NOINLINE__attribute__((noinline)) void affine_lowest_px_chroma(Dav1dTaskContext *const t, int *const dst,
624 const uint8_t *const b_dim,
625 const Dav1dWarpedMotionParams *const wmp)
626{
627 const Dav1dFrameContext *const f = t->f;
628 assert(f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400)((void) sizeof ((f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400
) ? 1 : 0), __extension__ ({ if (f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400
) ; else __assert_fail ("f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 628, __extension__
__PRETTY_FUNCTION__); }));
629 if (f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I444)
630 affine_lowest_px_luma(t, dst, b_dim, wmp);
631 else
632 affine_lowest_px(t, dst, b_dim, wmp, f->cur.p.layout & DAV1D_PIXEL_LAYOUT_I420, 1);
633}
634
635static void obmc_lowest_px(Dav1dTaskContext *const t,
636 int (*const dst)[2], const int is_chroma,
637 const uint8_t *const b_dim,
638 const int bx4, const int by4, const int w4, const int h4)
639{
640 assert(!(t->bx & 1) && !(t->by & 1))((void) sizeof ((!(t->bx & 1) && !(t->by &
1)) ? 1 : 0), __extension__ ({ if (!(t->bx & 1) &&
!(t->by & 1)) ; else __assert_fail ("!(t->bx & 1) && !(t->by & 1)"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 640, __extension__
__PRETTY_FUNCTION__); }));
641 const Dav1dFrameContext *const f = t->f;
642 /*const*/ refmvs_block **r = &t->rt.r[(t->by & 31) + 5];
643 const int ss_ver = is_chroma && f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I420;
644 const int ss_hor = is_chroma && f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
645 const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver;
646
647 if (t->by > t->ts->tiling.row_start &&
648 (!is_chroma || b_dim[0] * h_mul + b_dim[1] * v_mul >= 16))
649 {
650 for (int i = 0, x = 0; x < w4 && i < imin(b_dim[2], 4); ) {
651 // only odd blocks are considered for overlap handling, hence +1
652 const refmvs_block *const a_r = &r[-1][t->bx + x + 1];
653 const uint8_t *const a_b_dim = dav1d_block_dimensions[a_r->bs];
654
655 if (a_r->ref.ref[0] > 0) {
656 const int oh4 = imin(b_dim[1], 16) >> 1;
657 mc_lowest_px(&dst[a_r->ref.ref[0] - 1][is_chroma], t->by,
658 (oh4 * 3 + 3) >> 2, a_r->mv.mv[0].y, ss_ver,
659 &f->svc[a_r->ref.ref[0] - 1][1]);
660 i++;
661 }
662 x += imax(a_b_dim[0], 2);
663 }
664 }
665
666 if (t->bx > t->ts->tiling.col_start)
667 for (int i = 0, y = 0; y < h4 && i < imin(b_dim[3], 4); ) {
668 // only odd blocks are considered for overlap handling, hence +1
669 const refmvs_block *const l_r = &r[y + 1][t->bx - 1];
670 const uint8_t *const l_b_dim = dav1d_block_dimensions[l_r->bs];
671
672 if (l_r->ref.ref[0] > 0) {
673 const int oh4 = iclip(l_b_dim[1], 2, b_dim[1]);
674 mc_lowest_px(&dst[l_r->ref.ref[0] - 1][is_chroma],
675 t->by + y, oh4, l_r->mv.mv[0].y, ss_ver,
676 &f->svc[l_r->ref.ref[0] - 1][1]);
677 i++;
678 }
679 y += imax(l_b_dim[1], 2);
680 }
681}
682
683static int decode_b(Dav1dTaskContext *const t,
684 const enum BlockLevel bl,
685 const enum BlockSize bs,
686 const enum BlockPartition bp,
687 const enum EdgeFlags intra_edge_flags) {
688 Dav1dTileState *const ts = t->ts;
689 const Dav1dFrameContext *const f = t->f;
690 Av1Block b_mem, *const b = t->frame_thread.pass ?
691 &f->frame_thread.b[t->by * f->b4_stride + t->bx] : &b_mem;
692 const uint8_t *const b_dim = dav1d_block_dimensions[bs];
693 const int bx4 = t->bx & 31, by4 = t->by & 31;
694 const int ss_ver = f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I420;
695 const int ss_hor = f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
696 const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver;
697 const int bw4 = b_dim[0], bh4 = b_dim[1];
698 const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by);
699 const int cbw4 = (bw4 + ss_hor) >> ss_hor, cbh4 = (bh4 + ss_ver) >> ss_ver;
700 const int have_left = t->bx > ts->tiling.col_start;
701 const int have_top = t->by > ts->tiling.row_start;
702 const int has_chroma = f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400 &&
703 (bw4 > ss_hor || t->bx & 1) &&
704 (bh4 > ss_ver || t->by & 1);
705
706 if (t->frame_thread.pass == 2) {
707 if (b->intra) {
708 f->bd_fn.recon_b_intra(t, bs, intra_edge_flags, b);
709
710 const enum IntraPredMode y_mode_nofilt =
711 b->y_mode == FILTER_PRED ? DC_PRED : b->y_mode;
712#define set_ctx(rep_macro) \
713 rep_macro(edge->mode, off, y_mode_nofilt); \
714 rep_macro(edge->intra, off, 1)
715 BlockContext *edge = t->a;
716 for (int i = 0, off = bx4; i < 2; i++, off = by4, edge = &t->l) {
717 case_set(b_dim[2 + i])switch (b_dim[2 + i]) { case 0: set_ctx(set_ctx1); break; case
1: set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break
; case 3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16
); break; case 5: set_ctx(set_ctx32); break; default: ((void)
sizeof ((0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail
("0", "/root/firefox-clang/third_party/dav1d/src/decode.c", 717
, __extension__ __PRETTY_FUNCTION__); })); };
718 }
719#undef set_ctx
720 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
721 refmvs_block *const r = &t->rt.r[(t->by & 31) + 5 + bh4 - 1][t->bx];
722 for (int x = 0; x < bw4; x++) {
723 r[x].ref.ref[0] = 0;
724 r[x].bs = bs;
725 }
726 refmvs_block *const *rr = &t->rt.r[(t->by & 31) + 5];
727 for (int y = 0; y < bh4 - 1; y++) {
728 rr[y][t->bx + bw4 - 1].ref.ref[0] = 0;
729 rr[y][t->bx + bw4 - 1].bs = bs;
730 }
731 }
732
733 if (has_chroma) {
734 uint8_t uv_mode = b->uv_mode;
735 dav1d_memset_pow2[ulog2(cbw4)](&t->a->uvmode[cbx4], uv_mode);
736 dav1d_memset_pow2[ulog2(cbh4)](&t->l.uvmode[cby4], uv_mode);
737 }
738 } else {
739 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) /* not intrabc */ &&
740 b->comp_type == COMP_INTER_NONE && b->motion_mode == MM_WARP)
741 {
742 if (b->matrix[0] == INT16_MIN(-32767-1)) {
743 t->warpmv.type = DAV1D_WM_TYPE_IDENTITY;
744 } else {
745 t->warpmv.type = DAV1D_WM_TYPE_AFFINE;
746 t->warpmv.matrix[2] = b->matrix[0] + 0x10000;
747 t->warpmv.matrix[3] = b->matrix[1];
748 t->warpmv.matrix[4] = b->matrix[2];
749 t->warpmv.matrix[5] = b->matrix[3] + 0x10000;
750 dav1d_set_affine_mv2d(bw4, bh4, b->mv2d, &t->warpmv,
751 t->bx, t->by);
752 dav1d_get_shear_params(&t->warpmv);
753#define signabs(v) v < 0 ? '-' : ' ', abs(v)
754 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
755 printf("[ %c%x %c%x %c%x\n %c%x %c%x %c%x ]\n"
756 "alpha=%c%x, beta=%c%x, gamma=%c%x, delta=%c%x, mv=y:%d,x:%d\n",
757 signabs(t->warpmv.matrix[0]),
758 signabs(t->warpmv.matrix[1]),
759 signabs(t->warpmv.matrix[2]),
760 signabs(t->warpmv.matrix[3]),
761 signabs(t->warpmv.matrix[4]),
762 signabs(t->warpmv.matrix[5]),
763 signabs(t->warpmv.u.p.alpha),
764 signabs(t->warpmv.u.p.beta),
765 signabs(t->warpmv.u.p.gamma),
766 signabs(t->warpmv.u.p.delta),
767 b->mv2d.y, b->mv2d.x);
768#undef signabs
769 }
770 }
771 if (f->bd_fn.recon_b_inter(t, bs, b)) return -1;
772
773 const uint8_t *const filter = dav1d_filter_dir[b->filter2d];
774 BlockContext *edge = t->a;
775 for (int i = 0, off = bx4; i < 2; i++, off = by4, edge = &t->l) {
776#define set_ctx(rep_macro) \
777 rep_macro(edge->filter[0], off, filter[0]); \
778 rep_macro(edge->filter[1], off, filter[1]); \
779 rep_macro(edge->intra, off, 0)
780 case_set(b_dim[2 + i])switch (b_dim[2 + i]) { case 0: set_ctx(set_ctx1); break; case
1: set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break
; case 3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16
); break; case 5: set_ctx(set_ctx32); break; default: ((void)
sizeof ((0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail
("0", "/root/firefox-clang/third_party/dav1d/src/decode.c", 780
, __extension__ __PRETTY_FUNCTION__); })); };
781#undef set_ctx
782 }
783
784 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
785 refmvs_block *const r = &t->rt.r[(t->by & 31) + 5 + bh4 - 1][t->bx];
786 const int ref1 = b->ref[0] + 1;
787 const union mv mv1 = b->mv[0];
788 for (int x = 0; x < bw4; x++) {
789 r[x].ref.ref[0] = ref1;
790 r[x].mv.mv[0] = mv1;
791 r[x].bs = bs;
792 }
793 refmvs_block *const *rr = &t->rt.r[(t->by & 31) + 5];
794 for (int y = 0; y < bh4 - 1; y++) {
795 rr[y][t->bx + bw4 - 1].ref.ref[0] = ref1;
796 rr[y][t->bx + bw4 - 1].mv.mv[0] = mv1;
797 rr[y][t->bx + bw4 - 1].bs = bs;
798 }
799 }
800
801 if (has_chroma) {
802 dav1d_memset_pow2[ulog2(cbw4)](&t->a->uvmode[cbx4], DC_PRED);
803 dav1d_memset_pow2[ulog2(cbh4)](&t->l.uvmode[cby4], DC_PRED);
804 }
805 }
806 return 0;
807 }
808
809 const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver;
810
811 b->bl = bl;
812 b->bp = bp;
813 b->bs = bs;
814
815 const Dav1dSegmentationData *seg = NULL((void*)0);
816
817 // segment_id (if seg_feature for skip/ref/gmv is enabled)
818 int seg_pred = 0;
819 if (f->frame_hdr->segmentation.enabled) {
820 if (!f->frame_hdr->segmentation.update_map) {
821 if (f->prev_segmap) {
822 unsigned seg_id = get_prev_frame_segid(f, t->by, t->bx, w4, h4,
823 f->prev_segmap,
824 f->b4_stride);
825 if (seg_id >= 8) return -1;
826 b->seg_id = seg_id;
827 } else {
828 b->seg_id = 0;
829 }
830 seg = &f->frame_hdr->segmentation.seg_data.d[b->seg_id];
831 } else if (f->frame_hdr->segmentation.seg_data.preskip) {
832 if (f->frame_hdr->segmentation.temporal &&
833 (seg_pred = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
834 ts->cdf.m.seg_pred[t->a->seg_pred[bx4] +
835 t->l.seg_pred[by4]])))
836 {
837 // temporal predicted seg_id
838 if (f->prev_segmap) {
839 unsigned seg_id = get_prev_frame_segid(f, t->by, t->bx,
840 w4, h4,
841 f->prev_segmap,
842 f->b4_stride);
843 if (seg_id >= 8) return -1;
844 b->seg_id = seg_id;
845 } else {
846 b->seg_id = 0;
847 }
848 } else {
849 int seg_ctx;
850 const unsigned pred_seg_id =
851 get_cur_frame_segid(t->by, t->bx, have_top, have_left,
852 &seg_ctx, f->cur_segmap, f->b4_stride);
853 const unsigned diff = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac,
854 ts->cdf.m.seg_id[seg_ctx],
855 DAV1D_MAX_SEGMENTS8 - 1);
856 const unsigned last_active_seg_id =
857 f->frame_hdr->segmentation.seg_data.last_active_segid;
858 b->seg_id = neg_deinterleave(diff, pred_seg_id,
859 last_active_seg_id + 1);
860 if (b->seg_id > last_active_seg_id) b->seg_id = 0; // error?
861 if (b->seg_id >= DAV1D_MAX_SEGMENTS8) b->seg_id = 0; // error?
862 }
863
864 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
865 printf("Post-segid[preskip;%d]: r=%d\n",
866 b->seg_id, ts->msac.rng);
867
868 seg = &f->frame_hdr->segmentation.seg_data.d[b->seg_id];
869 }
870 } else {
871 b->seg_id = 0;
872 }
873
874 // skip_mode
875 if ((!seg || (!seg->globalmv && seg->ref == -1 && !seg->skip)) &&
876 f->frame_hdr->skip_mode_enabled && imin(bw4, bh4) > 1)
877 {
878 const int smctx = t->a->skip_mode[bx4] + t->l.skip_mode[by4];
879 b->skip_mode = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
880 ts->cdf.m.skip_mode[smctx]);
881 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
882 printf("Post-skipmode[%d]: r=%d\n", b->skip_mode, ts->msac.rng);
883 } else {
884 b->skip_mode = 0;
885 }
886
887 // skip
888 if (b->skip_mode || (seg && seg->skip)) {
889 b->skip = 1;
890 } else {
891 const int sctx = t->a->skip[bx4] + t->l.skip[by4];
892 b->skip = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac, ts->cdf.m.skip[sctx]);
893 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
894 printf("Post-skip[%d]: r=%d\n", b->skip, ts->msac.rng);
895 }
896
897 // segment_id
898 if (f->frame_hdr->segmentation.enabled &&
899 f->frame_hdr->segmentation.update_map &&
900 !f->frame_hdr->segmentation.seg_data.preskip)
901 {
902 if (!b->skip && f->frame_hdr->segmentation.temporal &&
903 (seg_pred = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
904 ts->cdf.m.seg_pred[t->a->seg_pred[bx4] +
905 t->l.seg_pred[by4]])))
906 {
907 // temporal predicted seg_id
908 if (f->prev_segmap) {
909 unsigned seg_id = get_prev_frame_segid(f, t->by, t->bx, w4, h4,
910 f->prev_segmap,
911 f->b4_stride);
912 if (seg_id >= 8) return -1;
913 b->seg_id = seg_id;
914 } else {
915 b->seg_id = 0;
916 }
917 } else {
918 int seg_ctx;
919 const unsigned pred_seg_id =
920 get_cur_frame_segid(t->by, t->bx, have_top, have_left,
921 &seg_ctx, f->cur_segmap, f->b4_stride);
922 if (b->skip) {
923 b->seg_id = pred_seg_id;
924 } else {
925 const unsigned diff = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac,
926 ts->cdf.m.seg_id[seg_ctx],
927 DAV1D_MAX_SEGMENTS8 - 1);
928 const unsigned last_active_seg_id =
929 f->frame_hdr->segmentation.seg_data.last_active_segid;
930 b->seg_id = neg_deinterleave(diff, pred_seg_id,
931 last_active_seg_id + 1);
932 if (b->seg_id > last_active_seg_id) b->seg_id = 0; // error?
933 }
934 if (b->seg_id >= DAV1D_MAX_SEGMENTS8) b->seg_id = 0; // error?
935 }
936
937 seg = &f->frame_hdr->segmentation.seg_data.d[b->seg_id];
938
939 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
940 printf("Post-segid[postskip;%d]: r=%d\n",
941 b->seg_id, ts->msac.rng);
942 }
943
944 // cdef index
945 if (!b->skip) {
946 const int idx = f->seq_hdr->sb128 ? ((t->bx & 16) >> 4) +
947 ((t->by & 16) >> 3) : 0;
948 if (t->cur_sb_cdef_idx_ptr[idx] == -1) {
949 const int v = dav1d_msac_decode_bools(&ts->msac,
950 f->frame_hdr->cdef.n_bits);
951 t->cur_sb_cdef_idx_ptr[idx] = v;
952 if (bw4 > 16) t->cur_sb_cdef_idx_ptr[idx + 1] = v;
953 if (bh4 > 16) t->cur_sb_cdef_idx_ptr[idx + 2] = v;
954 if (bw4 == 32 && bh4 == 32) t->cur_sb_cdef_idx_ptr[idx + 3] = v;
955
956 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
957 printf("Post-cdef_idx[%d]: r=%d\n",
958 *t->cur_sb_cdef_idx_ptr, ts->msac.rng);
959 }
960 }
961
962 // delta-q/lf
963 if (!((t->bx | t->by) & (31 >> !f->seq_hdr->sb128))) {
964 const int prev_qidx = ts->last_qidx;
965 const int have_delta_q = f->frame_hdr->delta.q.present &&
966 (bs != (f->seq_hdr->sb128 ? BS_128x128 : BS_64x64) || !b->skip);
967
968 uint32_t prev_delta_lf = ts->last_delta_lf.u32;
969
970 if (have_delta_q) {
971 int delta_q = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
972 ts->cdf.m.delta_q, 3);
973 if (delta_q == 3) {
974 const int n_bits = 1 + dav1d_msac_decode_bools(&ts->msac, 3);
975 delta_q = dav1d_msac_decode_bools(&ts->msac, n_bits) +
976 1 + (1 << n_bits);
977 }
978 if (delta_q) {
979 if (dav1d_msac_decode_bool_equidav1d_msac_decode_bool_equi_sse2(&ts->msac)) delta_q = -delta_q;
980 delta_q *= 1 << f->frame_hdr->delta.q.res_log2;
981 }
982 ts->last_qidx = iclip(ts->last_qidx + delta_q, 1, 255);
983 if (have_delta_q && DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
984 printf("Post-delta_q[%d->%d]: r=%d\n",
985 delta_q, ts->last_qidx, ts->msac.rng);
986
987 if (f->frame_hdr->delta.lf.present) {
988 const int n_lfs = f->frame_hdr->delta.lf.multi ?
989 f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400 ? 4 : 2 : 1;
990
991 for (int i = 0; i < n_lfs; i++) {
992 int delta_lf = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
993 ts->cdf.m.delta_lf[i + f->frame_hdr->delta.lf.multi], 3);
994 if (delta_lf == 3) {
995 const int n_bits = 1 + dav1d_msac_decode_bools(&ts->msac, 3);
996 delta_lf = dav1d_msac_decode_bools(&ts->msac, n_bits) +
997 1 + (1 << n_bits);
998 }
999 if (delta_lf) {
1000 if (dav1d_msac_decode_bool_equidav1d_msac_decode_bool_equi_sse2(&ts->msac))
1001 delta_lf = -delta_lf;
1002 delta_lf *= 1 << f->frame_hdr->delta.lf.res_log2;
1003 }
1004 ts->last_delta_lf.i8[i] =
1005 iclip(ts->last_delta_lf.i8[i] + delta_lf, -63, 63);
1006 if (have_delta_q && DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1007 printf("Post-delta_lf[%d:%d]: r=%d\n", i, delta_lf,
1008 ts->msac.rng);
1009 }
1010 }
1011 }
1012 if (ts->last_qidx == f->frame_hdr->quant.yac) {
1013 // assign frame-wide q values to this sb
1014 ts->dq = f->dq;
1015 } else if (ts->last_qidx != prev_qidx) {
1016 // find sb-specific quant parameters
1017 init_quant_tables(f->seq_hdr, f->frame_hdr, ts->last_qidx, ts->dqmem);
1018 ts->dq = ts->dqmem;
1019 }
1020 if (!ts->last_delta_lf.u32) {
1021 // assign frame-wide lf values to this sb
1022 ts->lflvl = f->lf.lvl;
1023 } else if (ts->last_delta_lf.u32 != prev_delta_lf) {
1024 // find sb-specific lf lvl parameters
1025 ts->lflvl = ts->lflvlmem;
1026 dav1d_calc_lf_values(ts->lflvlmem, f->frame_hdr, ts->last_delta_lf.i8);
1027 }
1028 }
1029
1030 if (b->skip_mode) {
1031 b->intra = 0;
1032 } else if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
1033 if (seg && (seg->ref >= 0 || seg->globalmv)) {
1034 b->intra = !seg->ref;
1035 } else {
1036 const int ictx = get_intra_ctx(t->a, &t->l, by4, bx4,
1037 have_top, have_left);
1038 b->intra = !dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1039 ts->cdf.m.intra[ictx]);
1040 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1041 printf("Post-intra[%d]: r=%d\n", b->intra, ts->msac.rng);
1042 }
1043 } else if (f->frame_hdr->allow_intrabc) {
1044 b->intra = !dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac, ts->cdf.m.intrabc);
1045 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1046 printf("Post-intrabcflag[%d]: r=%d\n", b->intra, ts->msac.rng);
1047 } else {
1048 b->intra = 1;
1049 }
1050
1051 // intra/inter-specific stuff
1052 if (b->intra) {
1053 uint16_t *const ymode_cdf = IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) ?
1054 ts->cdf.m.y_mode[dav1d_ymode_size_context[bs]] :
1055 ts->cdf.kfym[dav1d_intra_mode_context[t->a->mode[bx4]]]
1056 [dav1d_intra_mode_context[t->l.mode[by4]]];
1057 b->y_mode = dav1d_msac_decode_symbol_adapt16(&ts->msac, ymode_cdf,((&ts->msac)->symbol_adapt16(&ts->msac, ymode_cdf
, N_INTRA_PRED_MODES - 1))
1058 N_INTRA_PRED_MODES - 1)((&ts->msac)->symbol_adapt16(&ts->msac, ymode_cdf
, N_INTRA_PRED_MODES - 1));
1059 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1060 printf("Post-ymode[%d]: r=%d\n", b->y_mode, ts->msac.rng);
1061
1062 // angle delta
1063 if (b_dim[2] + b_dim[3] >= 2 && b->y_mode >= VERT_PRED &&
1064 b->y_mode <= VERT_LEFT_PRED)
1065 {
1066 uint16_t *const acdf = ts->cdf.m.angle_delta[b->y_mode - VERT_PRED];
1067 const int angle = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac, acdf, 6);
1068 b->y_angle = angle - 3;
1069 } else {
1070 b->y_angle = 0;
1071 }
1072
1073 if (has_chroma) {
1074 const int cfl_allowed = f->frame_hdr->segmentation.lossless[b->seg_id] ?
1075 cbw4 == 1 && cbh4 == 1 : !!(cfl_allowed_mask & (1 << bs));
1076 uint16_t *const uvmode_cdf = ts->cdf.m.uv_mode[cfl_allowed][b->y_mode];
1077 b->uv_mode = dav1d_msac_decode_symbol_adapt16(&ts->msac, uvmode_cdf,((&ts->msac)->symbol_adapt16(&ts->msac, uvmode_cdf
, N_UV_INTRA_PRED_MODES - 1 - !cfl_allowed))
1078 N_UV_INTRA_PRED_MODES - 1 - !cfl_allowed)((&ts->msac)->symbol_adapt16(&ts->msac, uvmode_cdf
, N_UV_INTRA_PRED_MODES - 1 - !cfl_allowed));
1079 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1080 printf("Post-uvmode[%d]: r=%d\n", b->uv_mode, ts->msac.rng);
1081
1082 b->uv_angle = 0;
1083 if (b->uv_mode == CFL_PRED) {
1084#define SIGN(a) (!!(a) + ((a) > 0))
1085 const int sign = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac,
1086 ts->cdf.m.cfl_sign, 7) + 1;
1087 const int sign_u = sign * 0x56 >> 8, sign_v = sign - sign_u * 3;
1088 assert(sign_u == sign / 3)((void) sizeof ((sign_u == sign / 3) ? 1 : 0), __extension__ (
{ if (sign_u == sign / 3) ; else __assert_fail ("sign_u == sign / 3"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 1088,
__extension__ __PRETTY_FUNCTION__); }));
1089 if (sign_u) {
1090 const int ctx = (sign_u == 2) * 3 + sign_v;
1091 b->cfl_alpha[0] = dav1d_msac_decode_symbol_adapt16(&ts->msac,((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.cfl_alpha[ctx], 15))
1092 ts->cdf.m.cfl_alpha[ctx], 15)((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.cfl_alpha[ctx], 15)) + 1;
1093 if (sign_u == 1) b->cfl_alpha[0] = -b->cfl_alpha[0];
1094 } else {
1095 b->cfl_alpha[0] = 0;
1096 }
1097 if (sign_v) {
1098 const int ctx = (sign_v == 2) * 3 + sign_u;
1099 b->cfl_alpha[1] = dav1d_msac_decode_symbol_adapt16(&ts->msac,((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.cfl_alpha[ctx], 15))
1100 ts->cdf.m.cfl_alpha[ctx], 15)((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.cfl_alpha[ctx], 15)) + 1;
1101 if (sign_v == 1) b->cfl_alpha[1] = -b->cfl_alpha[1];
1102 } else {
1103 b->cfl_alpha[1] = 0;
1104 }
1105#undef SIGN
1106 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1107 printf("Post-uvalphas[%d/%d]: r=%d\n",
1108 b->cfl_alpha[0], b->cfl_alpha[1], ts->msac.rng);
1109 } else if (b_dim[2] + b_dim[3] >= 2 && b->uv_mode >= VERT_PRED &&
1110 b->uv_mode <= VERT_LEFT_PRED)
1111 {
1112 uint16_t *const acdf = ts->cdf.m.angle_delta[b->uv_mode - VERT_PRED];
1113 const int angle = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac, acdf, 6);
1114 b->uv_angle = angle - 3;
1115 }
1116 }
1117
1118 b->pal_sz[0] = b->pal_sz[1] = 0;
1119 if (f->frame_hdr->allow_screen_content_tools &&
1120 imax(bw4, bh4) <= 16 && bw4 + bh4 >= 4)
1121 {
1122 const int sz_ctx = b_dim[2] + b_dim[3] - 2;
1123 if (b->y_mode == DC_PRED) {
1124 const int pal_ctx = (t->a->pal_sz[bx4] > 0) + (t->l.pal_sz[by4] > 0);
1125 const int use_y_pal = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1126 ts->cdf.m.pal_y[sz_ctx][pal_ctx]);
1127 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1128 printf("Post-y_pal[%d]: r=%d\n", use_y_pal, ts->msac.rng);
1129 if (use_y_pal)
1130 f->bd_fn.read_pal_plane(t, b, 0, sz_ctx, bx4, by4);
1131 }
1132
1133 if (has_chroma && b->uv_mode == DC_PRED) {
1134 const int pal_ctx = b->pal_sz[0] > 0;
1135 const int use_uv_pal = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1136 ts->cdf.m.pal_uv[pal_ctx]);
1137 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1138 printf("Post-uv_pal[%d]: r=%d\n", use_uv_pal, ts->msac.rng);
1139 if (use_uv_pal) // see aomedia bug 2183 for why we use luma coordinates
1140 f->bd_fn.read_pal_uv(t, b, sz_ctx, bx4, by4);
1141 }
1142 }
1143
1144 if (b->y_mode == DC_PRED && !b->pal_sz[0] &&
1145 imax(b_dim[2], b_dim[3]) <= 3 && f->seq_hdr->filter_intra)
1146 {
1147 const int is_filter = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1148 ts->cdf.m.use_filter_intra[bs]);
1149 if (is_filter) {
1150 b->y_mode = FILTER_PRED;
1151 b->y_angle = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac,
1152 ts->cdf.m.filter_intra, 4);
1153 }
1154 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1155 printf("Post-filterintramode[%d/%d]: r=%d\n",
1156 b->y_mode, b->y_angle, ts->msac.rng);
1157 }
1158
1159 if (b->pal_sz[0]) {
1160 uint8_t *pal_idx;
1161 if (t->frame_thread.pass) {
1162 const int p = t->frame_thread.pass & 1;
1163 assert(ts->frame_thread[p].pal_idx)((void) sizeof ((ts->frame_thread[p].pal_idx) ? 1 : 0), __extension__
({ if (ts->frame_thread[p].pal_idx) ; else __assert_fail (
"ts->frame_thread[p].pal_idx", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 1163, __extension__ __PRETTY_FUNCTION__); }));
1164 pal_idx = ts->frame_thread[p].pal_idx;
1165 ts->frame_thread[p].pal_idx += bw4 * bh4 * 8;
1166 } else
1167 pal_idx = t->scratch.pal_idx_y;
1168 read_pal_indices(t, pal_idx, b->pal_sz[0], 0, w4, h4, bw4, bh4);
1169 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1170 printf("Post-y-pal-indices: r=%d\n", ts->msac.rng);
1171 }
1172
1173 if (has_chroma && b->pal_sz[1]) {
1174 uint8_t *pal_idx;
1175 if (t->frame_thread.pass) {
1176 const int p = t->frame_thread.pass & 1;
1177 assert(ts->frame_thread[p].pal_idx)((void) sizeof ((ts->frame_thread[p].pal_idx) ? 1 : 0), __extension__
({ if (ts->frame_thread[p].pal_idx) ; else __assert_fail (
"ts->frame_thread[p].pal_idx", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 1177, __extension__ __PRETTY_FUNCTION__); }));
1178 pal_idx = ts->frame_thread[p].pal_idx;
1179 ts->frame_thread[p].pal_idx += cbw4 * cbh4 * 8;
1180 } else
1181 pal_idx = t->scratch.pal_idx_uv;
1182 read_pal_indices(t, pal_idx, b->pal_sz[1], 1, cw4, ch4, cbw4, cbh4);
1183 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1184 printf("Post-uv-pal-indices: r=%d\n", ts->msac.rng);
1185 }
1186
1187 const TxfmInfo *t_dim;
1188 if (f->frame_hdr->segmentation.lossless[b->seg_id]) {
1189 b->tx = b->uvtx = (int) TX_4X4;
1190 t_dim = &dav1d_txfm_dimensions[TX_4X4];
1191 } else {
1192 b->tx = dav1d_max_txfm_size_for_bs[bs][0];
1193 b->uvtx = dav1d_max_txfm_size_for_bs[bs][f->cur.p.layout];
1194 t_dim = &dav1d_txfm_dimensions[b->tx];
1195 if (f->frame_hdr->txfm_mode == DAV1D_TX_SWITCHABLE && t_dim->max > TX_4X4) {
1196 const int tctx = get_tx_ctx(t->a, &t->l, t_dim, by4, bx4);
1197 uint16_t *const tx_cdf = ts->cdf.m.txsz[t_dim->max - 1][tctx];
1198 int depth = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac, tx_cdf,
1199 imin(t_dim->max, 2));
1200
1201 while (depth--) {
1202 b->tx = t_dim->sub;
1203 t_dim = &dav1d_txfm_dimensions[b->tx];
1204 }
1205 }
1206 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1207 printf("Post-tx[%d]: r=%d\n", b->tx, ts->msac.rng);
1208 }
1209
1210 // reconstruction
1211 if (t->frame_thread.pass == 1) {
1212 f->bd_fn.read_coef_blocks(t, bs, b);
1213 } else {
1214 f->bd_fn.recon_b_intra(t, bs, intra_edge_flags, b);
1215 }
1216
1217 if (f->frame_hdr->loopfilter.level_y[0] ||
1218 f->frame_hdr->loopfilter.level_y[1])
1219 {
1220 dav1d_create_lf_mask_intra(t->lf_mask, f->lf.level, f->b4_stride,
1221 (const uint8_t (*)[8][2])
1222 &ts->lflvl[b->seg_id][0][0][0],
1223 t->bx, t->by, f->w4, f->h4, bs,
1224 b->tx, b->uvtx, f->cur.p.layout,
1225 &t->a->tx_lpf_y[bx4], &t->l.tx_lpf_y[by4],
1226 has_chroma ? &t->a->tx_lpf_uv[cbx4] : NULL((void*)0),
1227 has_chroma ? &t->l.tx_lpf_uv[cby4] : NULL((void*)0));
1228 }
1229 // update contexts
1230 const enum IntraPredMode y_mode_nofilt =
1231 b->y_mode == FILTER_PRED ? DC_PRED : b->y_mode;
1232 BlockContext *edge = t->a;
1233 for (int i = 0, off = bx4; i < 2; i++, off = by4, edge = &t->l) {
1234 int t_lsz = ((uint8_t *) &t_dim->lw)[i]; // lw then lh
1235#define set_ctx(rep_macro) \
1236 rep_macro(edge->tx_intra, off, t_lsz); \
1237 rep_macro(edge->tx, off, t_lsz); \
1238 rep_macro(edge->mode, off, y_mode_nofilt); \
1239 rep_macro(edge->pal_sz, off, b->pal_sz[0]); \
1240 rep_macro(edge->seg_pred, off, seg_pred); \
1241 rep_macro(edge->skip_mode, off, 0); \
1242 rep_macro(edge->intra, off, 1); \
1243 rep_macro(edge->skip, off, b->skip); \
1244 /* see aomedia bug 2183 for why we use luma coordinates here */ \
1245 rep_macro(t->pal_sz_uv[i], off, (has_chroma ? b->pal_sz[1] : 0)); \
1246 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) { \
1247 rep_macro(edge->comp_type, off, COMP_INTER_NONE); \
1248 rep_macro(edge->ref[0], off, ((uint8_t) -1)); \
1249 rep_macro(edge->ref[1], off, ((uint8_t) -1)); \
1250 rep_macro(edge->filter[0], off, DAV1D_N_SWITCHABLE_FILTERS); \
1251 rep_macro(edge->filter[1], off, DAV1D_N_SWITCHABLE_FILTERS); \
1252 }
1253 case_set(b_dim[2 + i])switch (b_dim[2 + i]) { case 0: set_ctx(set_ctx1); break; case
1: set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break
; case 3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16
); break; case 5: set_ctx(set_ctx32); break; default: ((void)
sizeof ((0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail
("0", "/root/firefox-clang/third_party/dav1d/src/decode.c", 1253
, __extension__ __PRETTY_FUNCTION__); })); };
1254#undef set_ctx
1255 }
1256 if (b->pal_sz[0])
1257 f->bd_fn.copy_pal_block_y(t, bx4, by4, bw4, bh4);
1258 if (has_chroma) {
1259 uint8_t uv_mode = b->uv_mode;
1260 dav1d_memset_pow2[ulog2(cbw4)](&t->a->uvmode[cbx4], uv_mode);
1261 dav1d_memset_pow2[ulog2(cbh4)](&t->l.uvmode[cby4], uv_mode);
1262 if (b->pal_sz[1])
1263 f->bd_fn.copy_pal_block_uv(t, bx4, by4, bw4, bh4);
1264 }
1265 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) || f->frame_hdr->allow_intrabc)
1266 splat_intraref(f->c, t, bs, bw4, bh4);
1267 } else if (IS_KEY_OR_INTRA(f->frame_hdr)(!((f->frame_hdr)->frame_type & 1))) {
1268 // intra block copy
1269 refmvs_candidate mvstack[8];
1270 int n_mvs, ctx;
1271 dav1d_refmvs_find(&t->rt, mvstack, &n_mvs, &ctx,
1272 (union refmvs_refpair) { .ref = { 0, -1 }},
1273 bs, intra_edge_flags, t->by, t->bx);
1274
1275 if (mvstack[0].mv.mv[0].n)
1276 b->mv[0] = mvstack[0].mv.mv[0];
1277 else if (mvstack[1].mv.mv[0].n)
1278 b->mv[0] = mvstack[1].mv.mv[0];
1279 else {
1280 if (t->by - (16 << f->seq_hdr->sb128) < ts->tiling.row_start) {
1281 b->mv[0].y = 0;
1282 b->mv[0].x = -(512 << f->seq_hdr->sb128) - 2048;
1283 } else {
1284 b->mv[0].y = -(512 << f->seq_hdr->sb128);
1285 b->mv[0].x = 0;
1286 }
1287 }
1288
1289 const union mv ref = b->mv[0];
1290 read_mv_residual(ts, &b->mv[0], -1);
1291
1292 // clip intrabc motion vector to decoded parts of current tile
1293 int border_left = ts->tiling.col_start * 4;
1294 int border_top = ts->tiling.row_start * 4;
1295 if (has_chroma) {
1296 if (bw4 < 2 && ss_hor)
1297 border_left += 4;
1298 if (bh4 < 2 && ss_ver)
1299 border_top += 4;
1300 }
1301 int src_left = t->bx * 4 + (b->mv[0].x >> 3);
1302 int src_top = t->by * 4 + (b->mv[0].y >> 3);
1303 int src_right = src_left + bw4 * 4;
1304 int src_bottom = src_top + bh4 * 4;
1305 const int border_right = ((ts->tiling.col_end + (bw4 - 1)) & ~(bw4 - 1)) * 4;
1306
1307 // check against left or right tile boundary and adjust if necessary
1308 if (src_left < border_left) {
1309 src_right += border_left - src_left;
1310 src_left += border_left - src_left;
1311 } else if (src_right > border_right) {
1312 src_left -= src_right - border_right;
1313 src_right -= src_right - border_right;
1314 }
1315 // check against top tile boundary and adjust if necessary
1316 if (src_top < border_top) {
1317 src_bottom += border_top - src_top;
1318 src_top += border_top - src_top;
1319 }
1320
1321 const int sbx = (t->bx >> (4 + f->seq_hdr->sb128)) << (6 + f->seq_hdr->sb128);
1322 const int sby = (t->by >> (4 + f->seq_hdr->sb128)) << (6 + f->seq_hdr->sb128);
1323 const int sb_size = 1 << (6 + f->seq_hdr->sb128);
1324 // check for overlap with current superblock
1325 if (src_bottom > sby && src_right > sbx) {
1326 if (src_top - border_top >= src_bottom - sby) {
1327 // if possible move src up into the previous suberblock row
1328 src_top -= src_bottom - sby;
1329 src_bottom -= src_bottom - sby;
1330 } else if (src_left - border_left >= src_right - sbx) {
1331 // if possible move src left into the previous suberblock
1332 src_left -= src_right - sbx;
1333 src_right -= src_right - sbx;
1334 }
1335 }
1336 // move src up if it is below current superblock row
1337 if (src_bottom > sby + sb_size) {
1338 src_top -= src_bottom - (sby + sb_size);
1339 src_bottom -= src_bottom - (sby + sb_size);
1340 }
1341 // error out if mv still overlaps with the current superblock
1342 if (src_bottom > sby && src_right > sbx)
1343 return -1;
1344
1345 b->mv[0].x = (src_left - t->bx * 4) * 8;
1346 b->mv[0].y = (src_top - t->by * 4) * 8;
1347
1348 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1349 printf("Post-dmv[%d/%d,ref=%d/%d|%d/%d]: r=%d\n",
1350 b->mv[0].y, b->mv[0].x, ref.y, ref.x,
1351 mvstack[0].mv.mv[0].y, mvstack[0].mv.mv[0].x, ts->msac.rng);
1352 read_vartx_tree(t, b, bs, bx4, by4);
1353
1354 // reconstruction
1355 if (t->frame_thread.pass == 1) {
1356 f->bd_fn.read_coef_blocks(t, bs, b);
1357 b->filter2d = FILTER_2D_BILINEAR;
1358 } else {
1359 if (f->bd_fn.recon_b_inter(t, bs, b)) return -1;
1360 }
1361
1362 splat_intrabc_mv(f->c, t, bs, b, bw4, bh4);
1363 BlockContext *edge = t->a;
1364 for (int i = 0, off = bx4; i < 2; i++, off = by4, edge = &t->l) {
1365#define set_ctx(rep_macro) \
1366 rep_macro(edge->tx_intra, off, b_dim[2 + i]); \
1367 rep_macro(edge->mode, off, DC_PRED); \
1368 rep_macro(edge->pal_sz, off, 0); \
1369 /* see aomedia bug 2183 for why this is outside if (has_chroma) */ \
1370 rep_macro(t->pal_sz_uv[i], off, 0); \
1371 rep_macro(edge->seg_pred, off, seg_pred); \
1372 rep_macro(edge->skip_mode, off, 0); \
1373 rep_macro(edge->intra, off, 0); \
1374 rep_macro(edge->skip, off, b->skip)
1375 case_set(b_dim[2 + i])switch (b_dim[2 + i]) { case 0: set_ctx(set_ctx1); break; case
1: set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break
; case 3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16
); break; case 5: set_ctx(set_ctx32); break; default: ((void)
sizeof ((0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail
("0", "/root/firefox-clang/third_party/dav1d/src/decode.c", 1375
, __extension__ __PRETTY_FUNCTION__); })); };
1376#undef set_ctx
1377 }
1378 if (has_chroma) {
1379 dav1d_memset_pow2[ulog2(cbw4)](&t->a->uvmode[cbx4], DC_PRED);
1380 dav1d_memset_pow2[ulog2(cbh4)](&t->l.uvmode[cby4], DC_PRED);
1381 }
1382 } else {
1383 // inter-specific mode/mv coding
1384 int is_comp, has_subpel_filter;
1385
1386 if (b->skip_mode) {
1387 is_comp = 1;
1388 } else if ((!seg || (seg->ref == -1 && !seg->globalmv && !seg->skip)) &&
1389 f->frame_hdr->switchable_comp_refs && imin(bw4, bh4) > 1)
1390 {
1391 const int ctx = get_comp_ctx(t->a, &t->l, by4, bx4,
1392 have_top, have_left);
1393 is_comp = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1394 ts->cdf.m.comp[ctx]);
1395 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1396 printf("Post-compflag[%d]: r=%d\n", is_comp, ts->msac.rng);
1397 } else {
1398 is_comp = 0;
1399 }
1400
1401 if (b->skip_mode) {
1402 b->ref[0] = f->frame_hdr->skip_mode_refs[0];
1403 b->ref[1] = f->frame_hdr->skip_mode_refs[1];
1404 b->comp_type = COMP_INTER_AVG;
1405 b->inter_mode = NEARESTMV_NEARESTMV;
1406 b->drl_idx = NEAREST_DRL;
1407 has_subpel_filter = 0;
1408
1409 refmvs_candidate mvstack[8];
1410 int n_mvs, ctx;
1411 dav1d_refmvs_find(&t->rt, mvstack, &n_mvs, &ctx,
1412 (union refmvs_refpair) { .ref = {
1413 b->ref[0] + 1, b->ref[1] + 1 }},
1414 bs, intra_edge_flags, t->by, t->bx);
1415
1416 b->mv[0] = mvstack[0].mv.mv[0];
1417 b->mv[1] = mvstack[0].mv.mv[1];
1418 fix_mv_precision(f->frame_hdr, &b->mv[0]);
1419 fix_mv_precision(f->frame_hdr, &b->mv[1]);
1420 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1421 printf("Post-skipmodeblock[mv=1:y=%d,x=%d,2:y=%d,x=%d,refs=%d+%d\n",
1422 b->mv[0].y, b->mv[0].x, b->mv[1].y, b->mv[1].x,
1423 b->ref[0], b->ref[1]);
1424 } else if (is_comp) {
1425 const int dir_ctx = get_comp_dir_ctx(t->a, &t->l, by4, bx4,
1426 have_top, have_left);
1427 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1428 ts->cdf.m.comp_dir[dir_ctx]))
1429 {
1430 // bidir - first reference (fw)
1431 const int ctx1 = av1_get_fwd_ref_ctx(t->a, &t->l, by4, bx4,
1432 have_top, have_left);
1433 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1434 ts->cdf.m.comp_fwd_ref[0][ctx1]))
1435 {
1436 const int ctx2 = av1_get_fwd_ref_2_ctx(t->a, &t->l, by4, bx4,
1437 have_top, have_left);
1438 b->ref[0] = 2 + dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1439 ts->cdf.m.comp_fwd_ref[2][ctx2]);
1440 } else {
1441 const int ctx2 = av1_get_fwd_ref_1_ctx(t->a, &t->l, by4, bx4,
1442 have_top, have_left);
1443 b->ref[0] = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1444 ts->cdf.m.comp_fwd_ref[1][ctx2]);
1445 }
1446
1447 // second reference (bw)
1448 const int ctx3 = av1_get_bwd_ref_ctx(t->a, &t->l, by4, bx4,
1449 have_top, have_left);
1450 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1451 ts->cdf.m.comp_bwd_ref[0][ctx3]))
1452 {
1453 b->ref[1] = 6;
1454 } else {
1455 const int ctx4 = av1_get_bwd_ref_1_ctx(t->a, &t->l, by4, bx4,
1456 have_top, have_left);
1457 b->ref[1] = 4 + dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1458 ts->cdf.m.comp_bwd_ref[1][ctx4]);
1459 }
1460 } else {
1461 // unidir
1462 const int uctx_p = av1_get_uni_p_ctxav1_get_ref_ctx(t->a, &t->l, by4, bx4,
1463 have_top, have_left);
1464 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1465 ts->cdf.m.comp_uni_ref[0][uctx_p]))
1466 {
1467 b->ref[0] = 4;
1468 b->ref[1] = 6;
1469 } else {
1470 const int uctx_p1 = av1_get_uni_p1_ctx(t->a, &t->l, by4, bx4,
1471 have_top, have_left);
1472 b->ref[0] = 0;
1473 b->ref[1] = 1 + dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1474 ts->cdf.m.comp_uni_ref[1][uctx_p1]);
1475 if (b->ref[1] == 2) {
1476 const int uctx_p2 = av1_get_uni_p2_ctxav1_get_fwd_ref_2_ctx(t->a, &t->l, by4, bx4,
1477 have_top, have_left);
1478 b->ref[1] += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1479 ts->cdf.m.comp_uni_ref[2][uctx_p2]);
1480 }
1481 }
1482 }
1483 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1484 printf("Post-refs[%d/%d]: r=%d\n",
1485 b->ref[0], b->ref[1], ts->msac.rng);
1486
1487 refmvs_candidate mvstack[8];
1488 int n_mvs, ctx;
1489 dav1d_refmvs_find(&t->rt, mvstack, &n_mvs, &ctx,
1490 (union refmvs_refpair) { .ref = {
1491 b->ref[0] + 1, b->ref[1] + 1 }},
1492 bs, intra_edge_flags, t->by, t->bx);
1493
1494 b->inter_mode = dav1d_msac_decode_symbol_adapt8dav1d_msac_decode_symbol_adapt8_sse2(&ts->msac,
1495 ts->cdf.m.comp_inter_mode[ctx],
1496 N_COMP_INTER_PRED_MODES - 1);
1497 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1498 printf("Post-compintermode[%d,ctx=%d,n_mvs=%d]: r=%d\n",
1499 b->inter_mode, ctx, n_mvs, ts->msac.rng);
1500
1501 const uint8_t *const im = dav1d_comp_inter_pred_modes[b->inter_mode];
1502 b->drl_idx = NEAREST_DRL;
1503 if (b->inter_mode == NEWMV_NEWMV) {
1504 if (n_mvs > 1) { // NEARER, NEAR or NEARISH
1505 const int drl_ctx_v1 = get_drl_context(mvstack, 0);
1506 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1507 ts->cdf.m.drl_bit[drl_ctx_v1]);
1508 if (b->drl_idx == NEARER_DRL && n_mvs > 2) {
1509 const int drl_ctx_v2 = get_drl_context(mvstack, 1);
1510 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1511 ts->cdf.m.drl_bit[drl_ctx_v2]);
1512 }
1513 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1514 printf("Post-drlidx[%d,n_mvs=%d]: r=%d\n",
1515 b->drl_idx, n_mvs, ts->msac.rng);
1516 }
1517 } else if (im[0] == NEARMV || im[1] == NEARMV) {
1518 b->drl_idx = NEARER_DRL;
1519 if (n_mvs > 2) { // NEAR or NEARISH
1520 const int drl_ctx_v2 = get_drl_context(mvstack, 1);
1521 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1522 ts->cdf.m.drl_bit[drl_ctx_v2]);
1523 if (b->drl_idx == NEAR_DRL && n_mvs > 3) {
1524 const int drl_ctx_v3 = get_drl_context(mvstack, 2);
1525 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1526 ts->cdf.m.drl_bit[drl_ctx_v3]);
1527 }
1528 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1529 printf("Post-drlidx[%d,n_mvs=%d]: r=%d\n",
1530 b->drl_idx, n_mvs, ts->msac.rng);
1531 }
1532 }
1533 assert(b->drl_idx >= NEAREST_DRL && b->drl_idx <= NEARISH_DRL)((void) sizeof ((b->drl_idx >= NEAREST_DRL && b
->drl_idx <= NEARISH_DRL) ? 1 : 0), __extension__ ({ if
(b->drl_idx >= NEAREST_DRL && b->drl_idx <=
NEARISH_DRL) ; else __assert_fail ("b->drl_idx >= NEAREST_DRL && b->drl_idx <= NEARISH_DRL"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 1533,
__extension__ __PRETTY_FUNCTION__); }));
1534
1535#define assign_comp_mv(idx) \
1536 switch (im[idx]) { \
1537 case NEARMV: \
1538 case NEARESTMV: \
1539 b->mv[idx] = mvstack[b->drl_idx].mv.mv[idx]; \
1540 fix_mv_precision(f->frame_hdr, &b->mv[idx]); \
1541 break; \
1542 case GLOBALMV: \
1543 has_subpel_filter |= \
1544 f->frame_hdr->gmv[b->ref[idx]].type == DAV1D_WM_TYPE_TRANSLATION; \
1545 b->mv[idx] = get_gmv_2d(&f->frame_hdr->gmv[b->ref[idx]], \
1546 t->bx, t->by, bw4, bh4, f->frame_hdr); \
1547 break; \
1548 case NEWMV: \
1549 b->mv[idx] = mvstack[b->drl_idx].mv.mv[idx]; \
1550 const int mv_prec = f->frame_hdr->hp - f->frame_hdr->force_integer_mv; \
1551 read_mv_residual(ts, &b->mv[idx], mv_prec); \
1552 break; \
1553 }
1554 has_subpel_filter = imin(bw4, bh4) == 1 ||
1555 b->inter_mode != GLOBALMV_GLOBALMV;
1556 assign_comp_mv(0);
1557 assign_comp_mv(1);
1558#undef assign_comp_mv
1559 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1560 printf("Post-residual_mv[1:y=%d,x=%d,2:y=%d,x=%d]: r=%d\n",
1561 b->mv[0].y, b->mv[0].x, b->mv[1].y, b->mv[1].x,
1562 ts->msac.rng);
1563
1564 // jnt_comp vs. seg vs. wedge
1565 int is_segwedge = 0;
1566 if (f->seq_hdr->masked_compound) {
1567 const int mask_ctx = get_mask_comp_ctx(t->a, &t->l, by4, bx4);
1568
1569 is_segwedge = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1570 ts->cdf.m.mask_comp[mask_ctx]);
1571 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1572 printf("Post-segwedge_vs_jntavg[%d,ctx=%d]: r=%d\n",
1573 is_segwedge, mask_ctx, ts->msac.rng);
1574 }
1575
1576 if (!is_segwedge) {
1577 if (f->seq_hdr->jnt_comp) {
1578 const int jnt_ctx =
1579 get_jnt_comp_ctx(f->seq_hdr->order_hint_n_bits,
1580 f->cur.frame_hdr->frame_offset,
1581 f->refp[b->ref[0]].p.frame_hdr->frame_offset,
1582 f->refp[b->ref[1]].p.frame_hdr->frame_offset,
1583 t->a, &t->l, by4, bx4);
1584 b->comp_type = COMP_INTER_WEIGHTED_AVG +
1585 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1586 ts->cdf.m.jnt_comp[jnt_ctx]);
1587 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1588 printf("Post-jnt_comp[%d,ctx=%d[ac:%d,ar:%d,lc:%d,lr:%d]]: r=%d\n",
1589 b->comp_type == COMP_INTER_AVG,
1590 jnt_ctx, t->a->comp_type[bx4], t->a->ref[0][bx4],
1591 t->l.comp_type[by4], t->l.ref[0][by4],
1592 ts->msac.rng);
1593 } else {
1594 b->comp_type = COMP_INTER_AVG;
1595 }
1596 } else {
1597 if (wedge_allowed_mask & (1 << bs)) {
1598 const int ctx = dav1d_wedge_ctx_lut[bs];
1599 b->comp_type = COMP_INTER_WEDGE -
1600 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1601 ts->cdf.m.wedge_comp[ctx]);
1602 if (b->comp_type == COMP_INTER_WEDGE)
1603 b->wedge_idx = dav1d_msac_decode_symbol_adapt16(&ts->msac,((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.wedge_idx[ctx], 15))
1604 ts->cdf.m.wedge_idx[ctx], 15)((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.wedge_idx[ctx], 15));
1605 } else {
1606 b->comp_type = COMP_INTER_SEG;
1607 }
1608 b->mask_sign = dav1d_msac_decode_bool_equidav1d_msac_decode_bool_equi_sse2(&ts->msac);
1609 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1610 printf("Post-seg/wedge[%d,wedge_idx=%d,sign=%d]: r=%d\n",
1611 b->comp_type == COMP_INTER_WEDGE,
1612 b->wedge_idx, b->mask_sign, ts->msac.rng);
1613 }
1614 } else {
1615 b->comp_type = COMP_INTER_NONE;
1616
1617 // ref
1618 if (seg && seg->ref > 0) {
1619 b->ref[0] = seg->ref - 1;
1620 } else if (seg && (seg->globalmv || seg->skip)) {
1621 b->ref[0] = 0;
1622 } else {
1623 const int ctx1 = av1_get_ref_ctx(t->a, &t->l, by4, bx4,
1624 have_top, have_left);
1625 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1626 ts->cdf.m.ref[0][ctx1]))
1627 {
1628 const int ctx2 = av1_get_ref_2_ctxav1_get_bwd_ref_ctx(t->a, &t->l, by4, bx4,
1629 have_top, have_left);
1630 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1631 ts->cdf.m.ref[1][ctx2]))
1632 {
1633 b->ref[0] = 6;
1634 } else {
1635 const int ctx3 = av1_get_ref_6_ctxav1_get_bwd_ref_1_ctx(t->a, &t->l, by4, bx4,
1636 have_top, have_left);
1637 b->ref[0] = 4 + dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1638 ts->cdf.m.ref[5][ctx3]);
1639 }
1640 } else {
1641 const int ctx2 = av1_get_ref_3_ctxav1_get_fwd_ref_ctx(t->a, &t->l, by4, bx4,
1642 have_top, have_left);
1643 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1644 ts->cdf.m.ref[2][ctx2]))
1645 {
1646 const int ctx3 = av1_get_ref_5_ctxav1_get_fwd_ref_2_ctx(t->a, &t->l, by4, bx4,
1647 have_top, have_left);
1648 b->ref[0] = 2 + dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1649 ts->cdf.m.ref[4][ctx3]);
1650 } else {
1651 const int ctx3 = av1_get_ref_4_ctxav1_get_fwd_ref_1_ctx(t->a, &t->l, by4, bx4,
1652 have_top, have_left);
1653 b->ref[0] = dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1654 ts->cdf.m.ref[3][ctx3]);
1655 }
1656 }
1657 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1658 printf("Post-ref[%d]: r=%d\n", b->ref[0], ts->msac.rng);
1659 }
1660 b->ref[1] = -1;
1661
1662 refmvs_candidate mvstack[8];
1663 int n_mvs, ctx;
1664 dav1d_refmvs_find(&t->rt, mvstack, &n_mvs, &ctx,
1665 (union refmvs_refpair) { .ref = { b->ref[0] + 1, -1 }},
1666 bs, intra_edge_flags, t->by, t->bx);
1667
1668 // mode parsing and mv derivation from ref_mvs
1669 if ((seg && (seg->skip || seg->globalmv)) ||
1670 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1671 ts->cdf.m.newmv_mode[ctx & 7]))
1672 {
1673 if ((seg && (seg->skip || seg->globalmv)) ||
1674 !dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1675 ts->cdf.m.globalmv_mode[(ctx >> 3) & 1]))
1676 {
1677 b->inter_mode = GLOBALMV;
1678 b->mv[0] = get_gmv_2d(&f->frame_hdr->gmv[b->ref[0]],
1679 t->bx, t->by, bw4, bh4, f->frame_hdr);
1680 has_subpel_filter = imin(bw4, bh4) == 1 ||
1681 f->frame_hdr->gmv[b->ref[0]].type == DAV1D_WM_TYPE_TRANSLATION;
1682 } else {
1683 has_subpel_filter = 1;
1684 if (dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1685 ts->cdf.m.refmv_mode[(ctx >> 4) & 15]))
1686 { // NEAREST, NEARER, NEAR or NEARISH
1687 b->inter_mode = NEARMV;
1688 b->drl_idx = NEARER_DRL;
1689 if (n_mvs > 2) { // NEARER, NEAR or NEARISH
1690 const int drl_ctx_v2 = get_drl_context(mvstack, 1);
1691 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1692 ts->cdf.m.drl_bit[drl_ctx_v2]);
1693 if (b->drl_idx == NEAR_DRL && n_mvs > 3) { // NEAR or NEARISH
1694 const int drl_ctx_v3 =
1695 get_drl_context(mvstack, 2);
1696 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1697 ts->cdf.m.drl_bit[drl_ctx_v3]);
1698 }
1699 }
1700 } else {
1701 b->inter_mode = NEARESTMV;
1702 b->drl_idx = NEAREST_DRL;
1703 }
1704 assert(b->drl_idx >= NEAREST_DRL && b->drl_idx <= NEARISH_DRL)((void) sizeof ((b->drl_idx >= NEAREST_DRL && b
->drl_idx <= NEARISH_DRL) ? 1 : 0), __extension__ ({ if
(b->drl_idx >= NEAREST_DRL && b->drl_idx <=
NEARISH_DRL) ; else __assert_fail ("b->drl_idx >= NEAREST_DRL && b->drl_idx <= NEARISH_DRL"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 1704,
__extension__ __PRETTY_FUNCTION__); }));
1705 b->mv[0] = mvstack[b->drl_idx].mv.mv[0];
1706 if (b->drl_idx < NEAR_DRL)
1707 fix_mv_precision(f->frame_hdr, &b->mv[0]);
1708 }
1709
1710 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1711 printf("Post-intermode[%d,drl=%d,mv=y:%d,x:%d,n_mvs=%d]: r=%d\n",
1712 b->inter_mode, b->drl_idx, b->mv[0].y, b->mv[0].x, n_mvs,
1713 ts->msac.rng);
1714 } else {
1715 has_subpel_filter = 1;
1716 b->inter_mode = NEWMV;
1717 b->drl_idx = NEAREST_DRL;
1718 if (n_mvs > 1) { // NEARER, NEAR or NEARISH
1719 const int drl_ctx_v1 = get_drl_context(mvstack, 0);
1720 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1721 ts->cdf.m.drl_bit[drl_ctx_v1]);
1722 if (b->drl_idx == NEARER_DRL && n_mvs > 2) { // NEAR or NEARISH
1723 const int drl_ctx_v2 = get_drl_context(mvstack, 1);
1724 b->drl_idx += dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1725 ts->cdf.m.drl_bit[drl_ctx_v2]);
1726 }
1727 }
1728 assert(b->drl_idx >= NEAREST_DRL && b->drl_idx <= NEARISH_DRL)((void) sizeof ((b->drl_idx >= NEAREST_DRL && b
->drl_idx <= NEARISH_DRL) ? 1 : 0), __extension__ ({ if
(b->drl_idx >= NEAREST_DRL && b->drl_idx <=
NEARISH_DRL) ; else __assert_fail ("b->drl_idx >= NEAREST_DRL && b->drl_idx <= NEARISH_DRL"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 1728,
__extension__ __PRETTY_FUNCTION__); }));
1729 if (n_mvs > 1) {
1730 b->mv[0] = mvstack[b->drl_idx].mv.mv[0];
1731 } else {
1732 assert(!b->drl_idx)((void) sizeof ((!b->drl_idx) ? 1 : 0), __extension__ ({ if
(!b->drl_idx) ; else __assert_fail ("!b->drl_idx", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 1732, __extension__ __PRETTY_FUNCTION__); }));
1733 b->mv[0] = mvstack[0].mv.mv[0];
1734 fix_mv_precision(f->frame_hdr, &b->mv[0]);
1735 }
1736 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1737 printf("Post-intermode[%d,drl=%d]: r=%d\n",
1738 b->inter_mode, b->drl_idx, ts->msac.rng);
1739 const int mv_prec = f->frame_hdr->hp - f->frame_hdr->force_integer_mv;
1740 read_mv_residual(ts, &b->mv[0], mv_prec);
1741 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1742 printf("Post-residualmv[mv=y:%d,x:%d]: r=%d\n",
1743 b->mv[0].y, b->mv[0].x, ts->msac.rng);
1744 }
1745
1746 // interintra flags
1747 const int ii_sz_grp = dav1d_ymode_size_context[bs];
1748 if (f->seq_hdr->inter_intra &&
1749 interintra_allowed_mask & (1 << bs) &&
1750 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1751 ts->cdf.m.interintra[ii_sz_grp]))
1752 {
1753 b->interintra_mode = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
1754 ts->cdf.m.interintra_mode[ii_sz_grp],
1755 N_INTER_INTRA_PRED_MODES - 1);
1756 const int wedge_ctx = dav1d_wedge_ctx_lut[bs];
1757 b->interintra_type = INTER_INTRA_BLEND +
1758 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
1759 ts->cdf.m.interintra_wedge[wedge_ctx]);
1760 if (b->interintra_type == INTER_INTRA_WEDGE)
1761 b->wedge_idx = dav1d_msac_decode_symbol_adapt16(&ts->msac,((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.wedge_idx[wedge_ctx], 15))
1762 ts->cdf.m.wedge_idx[wedge_ctx], 15)((&ts->msac)->symbol_adapt16(&ts->msac, ts->
cdf.m.wedge_idx[wedge_ctx], 15));
1763 } else {
1764 b->interintra_type = INTER_INTRA_NONE;
1765 }
1766 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12 && f->seq_hdr->inter_intra &&
1767 interintra_allowed_mask & (1 << bs))
1768 {
1769 printf("Post-interintra[t=%d,m=%d,w=%d]: r=%d\n",
1770 b->interintra_type, b->interintra_mode,
1771 b->wedge_idx, ts->msac.rng);
1772 }
1773
1774 // motion variation
1775 if (f->frame_hdr->switchable_motion_mode &&
1776 b->interintra_type == INTER_INTRA_NONE && imin(bw4, bh4) >= 2 &&
1777 // is not warped global motion
1778 !(!f->frame_hdr->force_integer_mv && b->inter_mode == GLOBALMV &&
1779 f->frame_hdr->gmv[b->ref[0]].type > DAV1D_WM_TYPE_TRANSLATION) &&
1780 // has overlappable neighbours
1781 ((have_left && findoddzero(&t->l.intra[by4 + 1], h4 >> 1)) ||
1782 (have_top && findoddzero(&t->a->intra[bx4 + 1], w4 >> 1))))
1783 {
1784 // reaching here means the block allows obmc - check warp by
1785 // finding matching-ref blocks in top/left edges
1786 uint64_t mask[2] = { 0, 0 };
1787 find_matching_ref(t, intra_edge_flags, bw4, bh4, w4, h4,
1788 have_left, have_top, b->ref[0], mask);
1789 const int allow_warp = !f->svc[b->ref[0]][0].scale &&
1790 !f->frame_hdr->force_integer_mv &&
1791 f->frame_hdr->warp_motion && (mask[0] | mask[1]);
1792
1793 b->motion_mode = allow_warp ?
1794 dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
1795 ts->cdf.m.motion_mode[bs], 2) :
1796 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac, ts->cdf.m.obmc[bs]);
1797 if (b->motion_mode == MM_WARP) {
1798 has_subpel_filter = 0;
1799 derive_warpmv(t, bw4, bh4, mask, b->mv[0], &t->warpmv);
1800#define signabs(v) v < 0 ? '-' : ' ', abs(v)
1801 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1802 printf("[ %c%x %c%x %c%x\n %c%x %c%x %c%x ]\n"
1803 "alpha=%c%x, beta=%c%x, gamma=%c%x, delta=%c%x, "
1804 "mv=y:%d,x:%d\n",
1805 signabs(t->warpmv.matrix[0]),
1806 signabs(t->warpmv.matrix[1]),
1807 signabs(t->warpmv.matrix[2]),
1808 signabs(t->warpmv.matrix[3]),
1809 signabs(t->warpmv.matrix[4]),
1810 signabs(t->warpmv.matrix[5]),
1811 signabs(t->warpmv.u.p.alpha),
1812 signabs(t->warpmv.u.p.beta),
1813 signabs(t->warpmv.u.p.gamma),
1814 signabs(t->warpmv.u.p.delta),
1815 b->mv[0].y, b->mv[0].x);
1816#undef signabs
1817 if (t->frame_thread.pass) {
1818 if (t->warpmv.type == DAV1D_WM_TYPE_AFFINE) {
1819 b->matrix[0] = t->warpmv.matrix[2] - 0x10000;
1820 b->matrix[1] = t->warpmv.matrix[3];
1821 b->matrix[2] = t->warpmv.matrix[4];
1822 b->matrix[3] = t->warpmv.matrix[5] - 0x10000;
1823 } else {
1824 b->matrix[0] = INT16_MIN(-32767-1);
1825 }
1826 }
1827 }
1828
1829 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1830 printf("Post-motionmode[%d]: r=%d [mask: 0x%" PRIx64"l" "x" "/0x%"
1831 PRIx64"l" "x" "]\n", b->motion_mode, ts->msac.rng, mask[0],
1832 mask[1]);
1833 } else {
1834 b->motion_mode = MM_TRANSLATION;
1835 }
1836 }
1837
1838 // subpel filter
1839 enum Dav1dFilterMode filter[2];
1840 if (f->frame_hdr->subpel_filter_mode == DAV1D_FILTER_SWITCHABLE) {
1841 if (has_subpel_filter) {
1842 const int comp = b->comp_type != COMP_INTER_NONE;
1843 const int ctx1 = get_filter_ctx(t->a, &t->l, comp, 0, b->ref[0],
1844 by4, bx4);
1845 filter[0] = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
1846 ts->cdf.m.filter[0][ctx1],
1847 DAV1D_N_SWITCHABLE_FILTERS - 1);
1848 if (f->seq_hdr->dual_filter) {
1849 const int ctx2 = get_filter_ctx(t->a, &t->l, comp, 1,
1850 b->ref[0], by4, bx4);
1851 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1852 printf("Post-subpel_filter1[%d,ctx=%d]: r=%d\n",
1853 filter[0], ctx1, ts->msac.rng);
1854 filter[1] = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
1855 ts->cdf.m.filter[1][ctx2],
1856 DAV1D_N_SWITCHABLE_FILTERS - 1);
1857 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1858 printf("Post-subpel_filter2[%d,ctx=%d]: r=%d\n",
1859 filter[1], ctx2, ts->msac.rng);
1860 } else {
1861 filter[1] = filter[0];
1862 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
1863 printf("Post-subpel_filter[%d,ctx=%d]: r=%d\n",
1864 filter[0], ctx1, ts->msac.rng);
1865 }
1866 } else {
1867 filter[0] = filter[1] = DAV1D_FILTER_8TAP_REGULAR;
1868 }
1869 } else {
1870 filter[0] = filter[1] = f->frame_hdr->subpel_filter_mode;
1871 }
1872 b->filter2d = dav1d_filter_2d[filter[1]][filter[0]];
1873
1874 read_vartx_tree(t, b, bs, bx4, by4);
1875
1876 // reconstruction
1877 if (t->frame_thread.pass == 1) {
1878 f->bd_fn.read_coef_blocks(t, bs, b);
1879 } else {
1880 if (f->bd_fn.recon_b_inter(t, bs, b)) return -1;
1881 }
1882
1883 if (f->frame_hdr->loopfilter.level_y[0] ||
1884 f->frame_hdr->loopfilter.level_y[1])
1885 {
1886 const int is_globalmv =
1887 b->inter_mode == (is_comp ? GLOBALMV_GLOBALMV : GLOBALMV);
1888 const uint8_t (*const lf_lvls)[8][2] = (const uint8_t (*)[8][2])
1889 &ts->lflvl[b->seg_id][0][b->ref[0] + 1][!is_globalmv];
1890 const uint16_t tx_split[2] = { b->tx_split0, b->tx_split1 };
1891 enum RectTxfmSize ytx = b->max_ytx, uvtx = b->uvtx;
1892 if (f->frame_hdr->segmentation.lossless[b->seg_id]) {
1893 ytx = (enum RectTxfmSize) TX_4X4;
1894 uvtx = (enum RectTxfmSize) TX_4X4;
1895 }
1896 dav1d_create_lf_mask_inter(t->lf_mask, f->lf.level, f->b4_stride, lf_lvls,
1897 t->bx, t->by, f->w4, f->h4, b->skip, bs,
1898 ytx, tx_split, uvtx, f->cur.p.layout,
1899 &t->a->tx_lpf_y[bx4], &t->l.tx_lpf_y[by4],
1900 has_chroma ? &t->a->tx_lpf_uv[cbx4] : NULL((void*)0),
1901 has_chroma ? &t->l.tx_lpf_uv[cby4] : NULL((void*)0));
1902 }
1903
1904 // context updates
1905 if (is_comp)
1906 splat_tworef_mv(f->c, t, bs, b, bw4, bh4);
1907 else
1908 splat_oneref_mv(f->c, t, bs, b, bw4, bh4);
1909 BlockContext *edge = t->a;
1910 for (int i = 0, off = bx4; i < 2; i++, off = by4, edge = &t->l) {
1911#define set_ctx(rep_macro) \
1912 rep_macro(edge->seg_pred, off, seg_pred); \
1913 rep_macro(edge->skip_mode, off, b->skip_mode); \
1914 rep_macro(edge->intra, off, 0); \
1915 rep_macro(edge->skip, off, b->skip); \
1916 rep_macro(edge->pal_sz, off, 0); \
1917 /* see aomedia bug 2183 for why this is outside if (has_chroma) */ \
1918 rep_macro(t->pal_sz_uv[i], off, 0); \
1919 rep_macro(edge->tx_intra, off, b_dim[2 + i]); \
1920 rep_macro(edge->comp_type, off, b->comp_type); \
1921 rep_macro(edge->filter[0], off, filter[0]); \
1922 rep_macro(edge->filter[1], off, filter[1]); \
1923 rep_macro(edge->mode, off, b->inter_mode); \
1924 rep_macro(edge->ref[0], off, b->ref[0]); \
1925 rep_macro(edge->ref[1], off, ((uint8_t) b->ref[1]))
1926 case_set(b_dim[2 + i])switch (b_dim[2 + i]) { case 0: set_ctx(set_ctx1); break; case
1: set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break
; case 3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16
); break; case 5: set_ctx(set_ctx32); break; default: ((void)
sizeof ((0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail
("0", "/root/firefox-clang/third_party/dav1d/src/decode.c", 1926
, __extension__ __PRETTY_FUNCTION__); })); };
1927#undef set_ctx
1928 }
1929 if (has_chroma) {
1930 dav1d_memset_pow2[ulog2(cbw4)](&t->a->uvmode[cbx4], DC_PRED);
1931 dav1d_memset_pow2[ulog2(cbh4)](&t->l.uvmode[cby4], DC_PRED);
1932 }
1933 }
1934
1935 // update contexts
1936 if (f->frame_hdr->segmentation.enabled &&
1937 f->frame_hdr->segmentation.update_map)
1938 {
1939 uint8_t *seg_ptr = &f->cur_segmap[t->by * f->b4_stride + t->bx];
1940#define set_ctx(rep_macro) \
1941 for (int y = 0; y < bh4; y++) { \
1942 rep_macro(seg_ptr, 0, b->seg_id); \
1943 seg_ptr += f->b4_stride; \
1944 }
1945 case_set(b_dim[2])switch (b_dim[2]) { case 0: set_ctx(set_ctx1); break; case 1:
set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break; case
3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16); break
; case 5: set_ctx(set_ctx32); break; default: ((void) sizeof (
(0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail ("0"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 1945,
__extension__ __PRETTY_FUNCTION__); })); };
1946#undef set_ctx
1947 }
1948 if (!b->skip) {
1949 uint16_t (*noskip_mask)[2] = &t->lf_mask->noskip_mask[by4 >> 1];
1950 const unsigned mask = (~0U >> (32 - bw4)) << (bx4 & 15);
1951 const int bx_idx = (bx4 & 16) >> 4;
1952 for (int y = 0; y < bh4; y += 2, noskip_mask++) {
1953 (*noskip_mask)[bx_idx] |= mask;
1954 if (bw4 == 32) // this should be mask >> 16, but it's 0xffffffff anyway
1955 (*noskip_mask)[1] |= mask;
1956 }
1957 }
1958
1959 if (t->frame_thread.pass == 1 && !b->intra && IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
1960 const int sby = (t->by - ts->tiling.row_start) >> f->sb_shift;
1961 int (*const lowest_px)[2] = ts->lowest_pixel[sby];
1962
1963 // keep track of motion vectors for each reference
1964 if (b->comp_type == COMP_INTER_NONE) {
1965 // y
1966 if (imin(bw4, bh4) > 1 &&
1967 ((b->inter_mode == GLOBALMV && f->gmv_warp_allowed[b->ref[0]]) ||
1968 (b->motion_mode == MM_WARP && t->warpmv.type > DAV1D_WM_TYPE_TRANSLATION)))
1969 {
1970 affine_lowest_px_luma(t, &lowest_px[b->ref[0]][0], b_dim,
1971 b->motion_mode == MM_WARP ? &t->warpmv :
1972 &f->frame_hdr->gmv[b->ref[0]]);
1973 } else {
1974 mc_lowest_px(&lowest_px[b->ref[0]][0], t->by, bh4, b->mv[0].y,
1975 0, &f->svc[b->ref[0]][1]);
1976 if (b->motion_mode == MM_OBMC) {
1977 obmc_lowest_px(t, lowest_px, 0, b_dim, bx4, by4, w4, h4);
1978 }
1979 }
1980
1981 // uv
1982 if (has_chroma) {
1983 // sub8x8 derivation
1984 int is_sub8x8 = bw4 == ss_hor || bh4 == ss_ver;
1985 refmvs_block *const *r;
1986 if (is_sub8x8) {
1987 assert(ss_hor == 1)((void) sizeof ((ss_hor == 1) ? 1 : 0), __extension__ ({ if (
ss_hor == 1) ; else __assert_fail ("ss_hor == 1", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 1987, __extension__ __PRETTY_FUNCTION__); }));
1988 r = &t->rt.r[(t->by & 31) + 5];
1989 if (bw4 == 1) is_sub8x8 &= r[0][t->bx - 1].ref.ref[0] > 0;
1990 if (bh4 == ss_ver) is_sub8x8 &= r[-1][t->bx].ref.ref[0] > 0;
1991 if (bw4 == 1 && bh4 == ss_ver)
1992 is_sub8x8 &= r[-1][t->bx - 1].ref.ref[0] > 0;
1993 }
1994
1995 // chroma prediction
1996 if (is_sub8x8) {
1997 assert(ss_hor == 1)((void) sizeof ((ss_hor == 1) ? 1 : 0), __extension__ ({ if (
ss_hor == 1) ; else __assert_fail ("ss_hor == 1", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 1997, __extension__ __PRETTY_FUNCTION__); }));
1998 if (bw4 == 1 && bh4 == ss_ver) {
1999 const refmvs_block *const rr = &r[-1][t->bx - 1];
2000 mc_lowest_px(&lowest_px[rr->ref.ref[0] - 1][1],
2001 t->by - 1, bh4, rr->mv.mv[0].y, ss_ver,
2002 &f->svc[rr->ref.ref[0] - 1][1]);
2003 }
2004 if (bw4 == 1) {
2005 const refmvs_block *const rr = &r[0][t->bx - 1];
2006 mc_lowest_px(&lowest_px[rr->ref.ref[0] - 1][1],
2007 t->by, bh4, rr->mv.mv[0].y, ss_ver,
2008 &f->svc[rr->ref.ref[0] - 1][1]);
2009 }
2010 if (bh4 == ss_ver) {
2011 const refmvs_block *const rr = &r[-1][t->bx];
2012 mc_lowest_px(&lowest_px[rr->ref.ref[0] - 1][1],
2013 t->by - 1, bh4, rr->mv.mv[0].y, ss_ver,
2014 &f->svc[rr->ref.ref[0] - 1][1]);
2015 }
2016 mc_lowest_px(&lowest_px[b->ref[0]][1], t->by, bh4,
2017 b->mv[0].y, ss_ver, &f->svc[b->ref[0]][1]);
2018 } else {
2019 if (imin(cbw4, cbh4) > 1 &&
2020 ((b->inter_mode == GLOBALMV && f->gmv_warp_allowed[b->ref[0]]) ||
2021 (b->motion_mode == MM_WARP && t->warpmv.type > DAV1D_WM_TYPE_TRANSLATION)))
2022 {
2023 affine_lowest_px_chroma(t, &lowest_px[b->ref[0]][1], b_dim,
2024 b->motion_mode == MM_WARP ? &t->warpmv :
2025 &f->frame_hdr->gmv[b->ref[0]]);
2026 } else {
2027 mc_lowest_px(&lowest_px[b->ref[0]][1],
2028 t->by & ~ss_ver, bh4 << (bh4 == ss_ver),
2029 b->mv[0].y, ss_ver, &f->svc[b->ref[0]][1]);
2030 if (b->motion_mode == MM_OBMC) {
2031 obmc_lowest_px(t, lowest_px, 1, b_dim, bx4, by4, w4, h4);
2032 }
2033 }
2034 }
2035 }
2036 } else {
2037 // y
2038 for (int i = 0; i < 2; i++) {
2039 if (b->inter_mode == GLOBALMV_GLOBALMV && f->gmv_warp_allowed[b->ref[i]]) {
2040 affine_lowest_px_luma(t, &lowest_px[b->ref[i]][0], b_dim,
2041 &f->frame_hdr->gmv[b->ref[i]]);
2042 } else {
2043 mc_lowest_px(&lowest_px[b->ref[i]][0], t->by, bh4,
2044 b->mv[i].y, 0, &f->svc[b->ref[i]][1]);
2045 }
2046 }
2047
2048 // uv
2049 if (has_chroma) for (int i = 0; i < 2; i++) {
2050 if (b->inter_mode == GLOBALMV_GLOBALMV &&
2051 imin(cbw4, cbh4) > 1 && f->gmv_warp_allowed[b->ref[i]])
2052 {
2053 affine_lowest_px_chroma(t, &lowest_px[b->ref[i]][1], b_dim,
2054 &f->frame_hdr->gmv[b->ref[i]]);
2055 } else {
2056 mc_lowest_px(&lowest_px[b->ref[i]][1], t->by, bh4,
2057 b->mv[i].y, ss_ver, &f->svc[b->ref[i]][1]);
2058 }
2059 }
2060 }
2061 }
2062
2063 return 0;
2064}
2065
2066#if __has_feature(memory_sanitizer)0
2067
2068#include <sanitizer/msan_interface.h>
2069
2070static int checked_decode_b(Dav1dTaskContext *const t,
2071 const enum BlockLevel bl,
2072 const enum BlockSize bs,
2073 const enum BlockPartition bp,
2074 const enum EdgeFlags intra_edge_flags)
2075{
2076 const Dav1dFrameContext *const f = t->f;
2077 const int err = decode_b(t, bl, bs, bp, intra_edge_flags);
2078
2079 if (err == 0 && !(t->frame_thread.pass & 1)) {
2080 const int ss_ver = f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I420;
2081 const int ss_hor = f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
2082 const uint8_t *const b_dim = dav1d_block_dimensions[bs];
2083 const int bw4 = b_dim[0], bh4 = b_dim[1];
2084 const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by);
2085 const int has_chroma = f->seq_hdr->layout != DAV1D_PIXEL_LAYOUT_I400 &&
2086 (bw4 > ss_hor || t->bx & 1) &&
2087 (bh4 > ss_ver || t->by & 1);
2088
2089 for (int p = 0; p < 1 + 2 * has_chroma; p++) {
2090 const int ss_ver = p && f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I420;
2091 const int ss_hor = p && f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
2092 const ptrdiff_t stride = f->cur.stride[!!p];
2093 const int bx = t->bx & ~ss_hor;
2094 const int by = t->by & ~ss_ver;
2095 const int width = w4 << (2 - ss_hor + (bw4 == ss_hor));
2096 const int height = h4 << (2 - ss_ver + (bh4 == ss_ver));
2097
2098 const uint8_t *data = f->cur.data[p] + (by << (2 - ss_ver)) * stride +
2099 (bx << (2 - ss_hor + !!f->seq_hdr->hbd));
2100
2101 for (int y = 0; y < height; data += stride, y++) {
2102 const size_t line_sz = width << !!f->seq_hdr->hbd;
2103 if (__msan_test_shadow(data, line_sz) != -1) {
2104 fprintf(stderrstderr, "B[%d](%d, %d) w4:%d, h4:%d, row:%d\n",
2105 p, bx, by, w4, h4, y);
2106 __msan_check_mem_is_initialized(data, line_sz);
2107 }
2108 }
2109 }
2110 }
2111
2112 return err;
2113}
2114
2115#define decode_b checked_decode_b
2116
2117#endif /* defined(__has_feature) */
2118
2119static int decode_sb(Dav1dTaskContext *const t, const enum BlockLevel bl,
2120 const EdgeNode *const node)
2121{
2122 const Dav1dFrameContext *const f = t->f;
2123 Dav1dTileState *const ts = t->ts;
2124 const int hsz = 16 >> bl;
2125 const int have_h_split = f->bw > t->bx + hsz;
2126 const int have_v_split = f->bh > t->by + hsz;
2127
2128 if (!have_h_split && !have_v_split) {
2129 assert(bl < BL_8X8)((void) sizeof ((bl < BL_8X8) ? 1 : 0), __extension__ ({ if
(bl < BL_8X8) ; else __assert_fail ("bl < BL_8X8", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2129, __extension__ __PRETTY_FUNCTION__); }));
2130 return decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 0)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[0])));
2131 }
2132
2133 uint16_t *pc;
2134 enum BlockPartition bp;
2135 int ctx, bx8, by8;
2136 if (t->frame_thread.pass != 2) {
2137 if (0 && bl == BL_64X64)
2138 printf("poc=%d,y=%d,x=%d,bl=%d,r=%d\n",
2139 f->frame_hdr->frame_offset, t->by, t->bx, bl, ts->msac.rng);
2140 bx8 = (t->bx & 31) >> 1;
2141 by8 = (t->by & 31) >> 1;
2142 ctx = get_partition_ctx(t->a, &t->l, bl, by8, bx8);
2143 pc = ts->cdf.m.partition[bl][ctx];
2144 }
2145
2146 if (have_h_split && have_v_split) {
2147 if (t->frame_thread.pass == 2) {
2148 const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx];
2149 bp = b->bl == bl ? b->bp : PARTITION_SPLIT;
2150 } else {
2151 bp = dav1d_msac_decode_symbol_adapt16(&ts->msac, pc,((&ts->msac)->symbol_adapt16(&ts->msac, pc, dav1d_partition_type_count
[bl]))
2152 dav1d_partition_type_count[bl])((&ts->msac)->symbol_adapt16(&ts->msac, pc, dav1d_partition_type_count
[bl]));
2153 if (f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I422 &&
2154 (bp == PARTITION_V || bp == PARTITION_V4 ||
2155 bp == PARTITION_T_LEFT_SPLIT || bp == PARTITION_T_RIGHT_SPLIT))
2156 {
2157 return 1;
2158 }
2159 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
2160 printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n",
2161 f->frame_hdr->frame_offset, t->by, t->bx, bl, ctx, bp,
2162 ts->msac.rng);
2163 }
2164 const uint8_t *const b = dav1d_block_sizes[bl][bp];
2165
2166 switch (bp) {
2167 case PARTITION_NONE:
2168 if (decode_b(t, bl, b[0], PARTITION_NONE, node->o))
2169 return -1;
2170 break;
2171 case PARTITION_H:
2172 if (decode_b(t, bl, b[0], PARTITION_H, node->h[0]))
2173 return -1;
2174 t->by += hsz;
2175 if (decode_b(t, bl, b[0], PARTITION_H, node->h[1]))
2176 return -1;
2177 t->by -= hsz;
2178 break;
2179 case PARTITION_V:
2180 if (decode_b(t, bl, b[0], PARTITION_V, node->v[0]))
2181 return -1;
2182 t->bx += hsz;
2183 if (decode_b(t, bl, b[0], PARTITION_V, node->v[1]))
2184 return -1;
2185 t->bx -= hsz;
2186 break;
2187 case PARTITION_SPLIT:
2188 if (bl == BL_8X8) {
2189 const EdgeTip *const tip = (const EdgeTip *) node;
2190 assert(hsz == 1)((void) sizeof ((hsz == 1) ? 1 : 0), __extension__ ({ if (hsz
== 1) ; else __assert_fail ("hsz == 1", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2190, __extension__ __PRETTY_FUNCTION__); }));
2191 if (decode_b(t, bl, BS_4x4, PARTITION_SPLIT, EDGE_ALL_TR_AND_BL))
2192 return -1;
2193 const enum Filter2d tl_filter = t->tl_4x4_filter;
2194 t->bx++;
2195 if (decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[0]))
2196 return -1;
2197 t->bx--;
2198 t->by++;
2199 if (decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[1]))
2200 return -1;
2201 t->bx++;
2202 t->tl_4x4_filter = tl_filter;
2203 if (decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[2]))
2204 return -1;
2205 t->bx--;
2206 t->by--;
2207#if ARCH_X86_641
2208 if (t->frame_thread.pass) {
2209 /* In 8-bit mode with 2-pass decoding the coefficient buffer
2210 * can end up misaligned due to skips here. Work around
2211 * the issue by explicitly realigning the buffer. */
2212 const int p = t->frame_thread.pass & 1;
2213 ts->frame_thread[p].cf =
2214 (void*)(((uintptr_t)ts->frame_thread[p].cf + 63) & ~63);
2215 }
2216#endif
2217 } else {
2218 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 0)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[0]))))
2219 return 1;
2220 t->bx += hsz;
2221 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 1)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[1]))))
2222 return 1;
2223 t->bx -= hsz;
2224 t->by += hsz;
2225 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 2)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[2]))))
2226 return 1;
2227 t->bx += hsz;
2228 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 3)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[3]))))
2229 return 1;
2230 t->bx -= hsz;
2231 t->by -= hsz;
2232 }
2233 break;
2234 case PARTITION_T_TOP_SPLIT: {
2235 if (decode_b(t, bl, b[0], PARTITION_T_TOP_SPLIT, EDGE_ALL_TR_AND_BL))
2236 return -1;
2237 t->bx += hsz;
2238 if (decode_b(t, bl, b[0], PARTITION_T_TOP_SPLIT, node->v[1]))
2239 return -1;
2240 t->bx -= hsz;
2241 t->by += hsz;
2242 if (decode_b(t, bl, b[1], PARTITION_T_TOP_SPLIT, node->h[1]))
2243 return -1;
2244 t->by -= hsz;
2245 break;
2246 }
2247 case PARTITION_T_BOTTOM_SPLIT: {
2248 if (decode_b(t, bl, b[0], PARTITION_T_BOTTOM_SPLIT, node->h[0]))
2249 return -1;
2250 t->by += hsz;
2251 if (decode_b(t, bl, b[1], PARTITION_T_BOTTOM_SPLIT, node->v[0]))
2252 return -1;
2253 t->bx += hsz;
2254 if (decode_b(t, bl, b[1], PARTITION_T_BOTTOM_SPLIT, 0))
2255 return -1;
2256 t->bx -= hsz;
2257 t->by -= hsz;
2258 break;
2259 }
2260 case PARTITION_T_LEFT_SPLIT: {
2261 if (decode_b(t, bl, b[0], PARTITION_T_LEFT_SPLIT, EDGE_ALL_TR_AND_BL))
2262 return -1;
2263 t->by += hsz;
2264 if (decode_b(t, bl, b[0], PARTITION_T_LEFT_SPLIT, node->h[1]))
2265 return -1;
2266 t->by -= hsz;
2267 t->bx += hsz;
2268 if (decode_b(t, bl, b[1], PARTITION_T_LEFT_SPLIT, node->v[1]))
2269 return -1;
2270 t->bx -= hsz;
2271 break;
2272 }
2273 case PARTITION_T_RIGHT_SPLIT: {
2274 if (decode_b(t, bl, b[0], PARTITION_T_RIGHT_SPLIT, node->v[0]))
2275 return -1;
2276 t->bx += hsz;
2277 if (decode_b(t, bl, b[1], PARTITION_T_RIGHT_SPLIT, node->h[0]))
2278 return -1;
2279 t->by += hsz;
2280 if (decode_b(t, bl, b[1], PARTITION_T_RIGHT_SPLIT, 0))
2281 return -1;
2282 t->by -= hsz;
2283 t->bx -= hsz;
2284 break;
2285 }
2286 case PARTITION_H4: {
2287 const EdgeBranch *const branch = (const EdgeBranch *) node;
2288 if (decode_b(t, bl, b[0], PARTITION_H4, node->h[0]))
2289 return -1;
2290 t->by += hsz >> 1;
2291 if (decode_b(t, bl, b[0], PARTITION_H4, branch->h4))
2292 return -1;
2293 t->by += hsz >> 1;
2294 if (decode_b(t, bl, b[0], PARTITION_H4, EDGE_ALL_LEFT_HAS_BOTTOM))
2295 return -1;
2296 t->by += hsz >> 1;
2297 if (t->by < f->bh)
2298 if (decode_b(t, bl, b[0], PARTITION_H4, node->h[1]))
2299 return -1;
2300 t->by -= hsz * 3 >> 1;
2301 break;
2302 }
2303 case PARTITION_V4: {
2304 const EdgeBranch *const branch = (const EdgeBranch *) node;
2305 if (decode_b(t, bl, b[0], PARTITION_V4, node->v[0]))
2306 return -1;
2307 t->bx += hsz >> 1;
2308 if (decode_b(t, bl, b[0], PARTITION_V4, branch->v4))
2309 return -1;
2310 t->bx += hsz >> 1;
2311 if (decode_b(t, bl, b[0], PARTITION_V4, EDGE_ALL_TOP_HAS_RIGHT))
2312 return -1;
2313 t->bx += hsz >> 1;
2314 if (t->bx < f->bw)
2315 if (decode_b(t, bl, b[0], PARTITION_V4, node->v[1]))
2316 return -1;
2317 t->bx -= hsz * 3 >> 1;
2318 break;
2319 }
2320 default: assert(0)((void) sizeof ((0) ? 1 : 0), __extension__ ({ if (0) ; else __assert_fail
("0", "/root/firefox-clang/third_party/dav1d/src/decode.c", 2320
, __extension__ __PRETTY_FUNCTION__); }));
2321 }
2322 } else if (have_h_split) {
2323 unsigned is_split;
2324 if (t->frame_thread.pass == 2) {
2325 const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx];
2326 is_split = b->bl != bl;
2327 } else {
2328 is_split = dav1d_msac_decode_booldav1d_msac_decode_bool_sse2(&ts->msac,
2329 gather_top_partition_prob(pc, bl));
2330 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
2331 printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n",
2332 f->frame_hdr->frame_offset, t->by, t->bx, bl, ctx,
2333 is_split ? PARTITION_SPLIT : PARTITION_H, ts->msac.rng);
2334 }
2335
2336 assert(bl < BL_8X8)((void) sizeof ((bl < BL_8X8) ? 1 : 0), __extension__ ({ if
(bl < BL_8X8) ; else __assert_fail ("bl < BL_8X8", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2336, __extension__ __PRETTY_FUNCTION__); }));
2337 if (is_split) {
2338 bp = PARTITION_SPLIT;
2339 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 0)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[0])))) return 1;
2340 t->bx += hsz;
2341 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 1)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[1])))) return 1;
2342 t->bx -= hsz;
2343 } else {
2344 bp = PARTITION_H;
2345 if (decode_b(t, bl, dav1d_block_sizes[bl][PARTITION_H][0],
2346 PARTITION_H, node->h[0]))
2347 return -1;
2348 }
2349 } else {
2350 assert(have_v_split)((void) sizeof ((have_v_split) ? 1 : 0), __extension__ ({ if (
have_v_split) ; else __assert_fail ("have_v_split", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2350, __extension__ __PRETTY_FUNCTION__); }));
2351 unsigned is_split;
2352 if (t->frame_thread.pass == 2) {
2353 const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx];
2354 is_split = b->bl != bl;
2355 } else {
2356 is_split = dav1d_msac_decode_booldav1d_msac_decode_bool_sse2(&ts->msac,
2357 gather_left_partition_prob(pc, bl));
2358 if (f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I422 && !is_split)
2359 return 1;
2360 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
2361 printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n",
2362 f->frame_hdr->frame_offset, t->by, t->bx, bl, ctx,
2363 is_split ? PARTITION_SPLIT : PARTITION_V, ts->msac.rng);
2364 }
2365
2366 assert(bl < BL_8X8)((void) sizeof ((bl < BL_8X8) ? 1 : 0), __extension__ ({ if
(bl < BL_8X8) ; else __assert_fail ("bl < BL_8X8", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2366, __extension__ __PRETTY_FUNCTION__); }));
2367 if (is_split) {
2368 bp = PARTITION_SPLIT;
2369 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 0)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[0])))) return 1;
2370 t->by += hsz;
2371 if (decode_sb(t, bl + 1, INTRA_EDGE_SPLIT(node, 2)((const EdgeNode*)((uintptr_t)(node) + ((const EdgeBranch*)(node
))->split_offset[2])))) return 1;
2372 t->by -= hsz;
2373 } else {
2374 bp = PARTITION_V;
2375 if (decode_b(t, bl, dav1d_block_sizes[bl][PARTITION_V][0],
2376 PARTITION_V, node->v[0]))
2377 return -1;
2378 }
2379 }
2380
2381 if (t->frame_thread.pass != 2 && (bp != PARTITION_SPLIT || bl == BL_8X8)) {
2382#define set_ctx(rep_macro) \
2383 rep_macro(t->a->partition, bx8, dav1d_al_part_ctx[0][bl][bp]); \
2384 rep_macro(t->l.partition, by8, dav1d_al_part_ctx[1][bl][bp])
2385 case_set_upto16(ulog2(hsz))switch (ulog2(hsz)) { case 0: set_ctx(set_ctx1); break; case 1
: set_ctx(set_ctx2); break; case 2: set_ctx(set_ctx4); break;
case 3: set_ctx(set_ctx8); break; case 4: set_ctx(set_ctx16)
; break; default: ((void) sizeof ((0) ? 1 : 0), __extension__
({ if (0) ; else __assert_fail ("0", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2385, __extension__ __PRETTY_FUNCTION__); })); };
2386#undef set_ctx
2387 }
2388
2389 return 0;
2390}
2391
2392static void reset_context(BlockContext *const ctx, const int keyframe, const int pass) {
2393 memset(ctx->intra, keyframe, sizeof(ctx->intra));
2394 memset(ctx->uvmode, DC_PRED, sizeof(ctx->uvmode));
2395 if (keyframe)
2396 memset(ctx->mode, DC_PRED, sizeof(ctx->mode));
2397
2398 if (pass == 2) return;
2399
2400 memset(ctx->partition, 0, sizeof(ctx->partition));
2401 memset(ctx->skip, 0, sizeof(ctx->skip));
2402 memset(ctx->skip_mode, 0, sizeof(ctx->skip_mode));
2403 memset(ctx->tx_lpf_y, 2, sizeof(ctx->tx_lpf_y));
2404 memset(ctx->tx_lpf_uv, 1, sizeof(ctx->tx_lpf_uv));
2405 memset(ctx->tx_intra, -1, sizeof(ctx->tx_intra));
2406 memset(ctx->tx, TX_64X64, sizeof(ctx->tx));
2407 if (!keyframe) {
2408 memset(ctx->ref, -1, sizeof(ctx->ref));
2409 memset(ctx->comp_type, 0, sizeof(ctx->comp_type));
2410 memset(ctx->mode, NEARESTMV, sizeof(ctx->mode));
2411 }
2412 memset(ctx->lcoef, 0x40, sizeof(ctx->lcoef));
2413 memset(ctx->ccoef, 0x40, sizeof(ctx->ccoef));
2414 memset(ctx->filter, DAV1D_N_SWITCHABLE_FILTERS, sizeof(ctx->filter));
2415 memset(ctx->seg_pred, 0, sizeof(ctx->seg_pred));
2416 memset(ctx->pal_sz, 0, sizeof(ctx->pal_sz));
2417}
2418
2419// { Y+U+V, Y+U } * 4
2420static const uint8_t ss_size_mul[4][2] = {
2421 [DAV1D_PIXEL_LAYOUT_I400] = { 4, 4 },
2422 [DAV1D_PIXEL_LAYOUT_I420] = { 6, 5 },
2423 [DAV1D_PIXEL_LAYOUT_I422] = { 8, 6 },
2424 [DAV1D_PIXEL_LAYOUT_I444] = { 12, 8 },
2425};
2426
2427static void setup_tile(Dav1dTileState *const ts,
2428 const Dav1dFrameContext *const f,
2429 const uint8_t *const data, const size_t sz,
2430 const int tile_row, const int tile_col,
2431 const unsigned tile_start_off)
2432{
2433 const int col_sb_start = f->frame_hdr->tiling.col_start_sb[tile_col];
2434 const int col_sb128_start = col_sb_start >> !f->seq_hdr->sb128;
2435 const int col_sb_end = f->frame_hdr->tiling.col_start_sb[tile_col + 1];
2436 const int row_sb_start = f->frame_hdr->tiling.row_start_sb[tile_row];
2437 const int row_sb_end = f->frame_hdr->tiling.row_start_sb[tile_row + 1];
2438 const int sb_shift = f->sb_shift;
2439
2440 const uint8_t *const size_mul = ss_size_mul[f->cur.p.layout];
2441 for (int p = 0; p < 2; p++) {
2442 ts->frame_thread[p].pal_idx = f->frame_thread.pal_idx ?
2443 &f->frame_thread.pal_idx[(size_t)tile_start_off * size_mul[1] / 8] :
2444 NULL((void*)0);
2445 ts->frame_thread[p].cbi = f->frame_thread.cbi ?
2446 &f->frame_thread.cbi[(size_t)tile_start_off * size_mul[0] / 64] :
2447 NULL((void*)0);
2448 ts->frame_thread[p].cf = f->frame_thread.cf ?
2449 (uint8_t*)f->frame_thread.cf +
2450 (((size_t)tile_start_off * size_mul[0]) >> !f->seq_hdr->hbd) :
2451 NULL((void*)0);
2452 }
2453
2454 dav1d_cdf_thread_copy(&ts->cdf, &f->in_cdf);
2455 ts->last_qidx = f->frame_hdr->quant.yac;
2456 ts->last_delta_lf.u32 = 0;
2457
2458 dav1d_msac_init(&ts->msac, data, sz, f->frame_hdr->disable_cdf_update);
2459
2460 ts->tiling.row = tile_row;
2461 ts->tiling.col = tile_col;
2462 ts->tiling.col_start = col_sb_start << sb_shift;
2463 ts->tiling.col_end = imin(col_sb_end << sb_shift, f->bw);
2464 ts->tiling.row_start = row_sb_start << sb_shift;
2465 ts->tiling.row_end = imin(row_sb_end << sb_shift, f->bh);
2466
2467 // Reference Restoration Unit (used for exp coding)
2468 int sb_idx, unit_idx;
2469 if (f->frame_hdr->width[0] != f->frame_hdr->width[1]) {
2470 // vertical components only
2471 sb_idx = (ts->tiling.row_start >> 5) * f->sr_sb128w;
2472 unit_idx = (ts->tiling.row_start & 16) >> 3;
2473 } else {
2474 sb_idx = (ts->tiling.row_start >> 5) * f->sb128w + col_sb128_start;
2475 unit_idx = ((ts->tiling.row_start & 16) >> 3) +
2476 ((ts->tiling.col_start & 16) >> 4);
2477 }
2478 for (int p = 0; p < 3; p++) {
2479 if (!((f->lf.restore_planes >> p) & 1U))
2480 continue;
2481
2482 if (f->frame_hdr->width[0] != f->frame_hdr->width[1]) {
2483 const int ss_hor = p && f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
2484 const int d = f->frame_hdr->super_res.width_scale_denominator;
2485 const int unit_size_log2 = f->frame_hdr->restoration.unit_size[!!p];
2486 const int rnd = (8 << unit_size_log2) - 1, shift = unit_size_log2 + 3;
2487 const int x = ((4 * ts->tiling.col_start * d >> ss_hor) + rnd) >> shift;
2488 const int px_x = x << (unit_size_log2 + ss_hor);
2489 const int u_idx = unit_idx + ((px_x & 64) >> 6);
2490 const int sb128x = px_x >> 7;
2491 if (sb128x >= f->sr_sb128w) continue;
2492 ts->lr_ref[p] = &f->lf.lr_mask[sb_idx + sb128x].lr[p][u_idx];
2493 } else {
2494 ts->lr_ref[p] = &f->lf.lr_mask[sb_idx].lr[p][unit_idx];
2495 }
2496
2497 ts->lr_ref[p]->filter_v[0] = 3;
2498 ts->lr_ref[p]->filter_v[1] = -7;
2499 ts->lr_ref[p]->filter_v[2] = 15;
2500 ts->lr_ref[p]->filter_h[0] = 3;
2501 ts->lr_ref[p]->filter_h[1] = -7;
2502 ts->lr_ref[p]->filter_h[2] = 15;
2503 ts->lr_ref[p]->sgr_weights[0] = -32;
2504 ts->lr_ref[p]->sgr_weights[1] = 31;
2505 }
2506
2507 if (f->c->n_tc > 1) {
2508 for (int p = 0; p < 2; p++)
2509 atomic_init__c11_atomic_init(&ts->progress[p], row_sb_start);
2510 }
2511}
2512
2513static void read_restoration_info(Dav1dTaskContext *const t,
2514 Av1RestorationUnit *const lr, const int p,
2515 const enum Dav1dRestorationType frame_type)
2516{
2517 const Dav1dFrameContext *const f = t->f;
2518 Dav1dTileState *const ts = t->ts;
2519 const Av1RestorationUnit *const lr_ref = ts->lr_ref[p];
2520
2521 if (frame_type == DAV1D_RESTORATION_SWITCHABLE) {
2522 const int filter = dav1d_msac_decode_symbol_adapt4dav1d_msac_decode_symbol_adapt4_sse2(&ts->msac,
2523 ts->cdf.m.restore_switchable, 2);
2524 lr->type = filter + !!filter; /* NONE/WIENER/SGRPROJ */
2525 } else {
2526 const unsigned type =
2527 dav1d_msac_decode_bool_adaptdav1d_msac_decode_bool_adapt_sse2(&ts->msac,
2528 frame_type == DAV1D_RESTORATION_WIENER ?
2529 ts->cdf.m.restore_wiener : ts->cdf.m.restore_sgrproj);
2530 lr->type = type ? frame_type : DAV1D_RESTORATION_NONE;
2531 }
2532
2533 if (lr->type == DAV1D_RESTORATION_WIENER) {
2534 lr->filter_v[0] = p ? 0 :
2535 dav1d_msac_decode_subexp(&ts->msac,
2536 lr_ref->filter_v[0] + 5, 16, 1) - 5;
2537 lr->filter_v[1] =
2538 dav1d_msac_decode_subexp(&ts->msac,
2539 lr_ref->filter_v[1] + 23, 32, 2) - 23;
2540 lr->filter_v[2] =
2541 dav1d_msac_decode_subexp(&ts->msac,
2542 lr_ref->filter_v[2] + 17, 64, 3) - 17;
2543
2544 lr->filter_h[0] = p ? 0 :
2545 dav1d_msac_decode_subexp(&ts->msac,
2546 lr_ref->filter_h[0] + 5, 16, 1) - 5;
2547 lr->filter_h[1] =
2548 dav1d_msac_decode_subexp(&ts->msac,
2549 lr_ref->filter_h[1] + 23, 32, 2) - 23;
2550 lr->filter_h[2] =
2551 dav1d_msac_decode_subexp(&ts->msac,
2552 lr_ref->filter_h[2] + 17, 64, 3) - 17;
2553 memcpy(lr->sgr_weights, lr_ref->sgr_weights, sizeof(lr->sgr_weights));
2554 ts->lr_ref[p] = lr;
2555 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
2556 printf("Post-lr_wiener[pl=%d,v[%d,%d,%d],h[%d,%d,%d]]: r=%d\n",
2557 p, lr->filter_v[0], lr->filter_v[1],
2558 lr->filter_v[2], lr->filter_h[0],
2559 lr->filter_h[1], lr->filter_h[2], ts->msac.rng);
2560 } else if (lr->type == DAV1D_RESTORATION_SGRPROJ) {
2561 const unsigned idx = dav1d_msac_decode_bools(&ts->msac, 4);
2562 const uint16_t *const sgr_params = dav1d_sgr_params[idx];
2563 lr->type += idx;
2564 lr->sgr_weights[0] = sgr_params[0] ? dav1d_msac_decode_subexp(&ts->msac,
2565 lr_ref->sgr_weights[0] + 96, 128, 4) - 96 : 0;
2566 lr->sgr_weights[1] = sgr_params[1] ? dav1d_msac_decode_subexp(&ts->msac,
2567 lr_ref->sgr_weights[1] + 32, 128, 4) - 32 : 95;
2568 memcpy(lr->filter_v, lr_ref->filter_v, sizeof(lr->filter_v));
2569 memcpy(lr->filter_h, lr_ref->filter_h, sizeof(lr->filter_h));
2570 ts->lr_ref[p] = lr;
2571 if (DEBUG_BLOCK_INFO0 && f->frame_hdr->frame_offset == 2 &&
t->by >= 0 && t->by < 4 && t->
bx >= 8 && t->bx < 12)
2572 printf("Post-lr_sgrproj[pl=%d,idx=%d,w[%d,%d]]: r=%d\n",
2573 p, idx, lr->sgr_weights[0],
2574 lr->sgr_weights[1], ts->msac.rng);
2575 }
2576}
2577
2578// modeled after the equivalent function in aomdec:decodeframe.c
2579static int check_trailing_bits_after_symbol_coder(const MsacContext *const msac) {
2580 // check marker bit (single 1), followed by zeroes
2581 const int n_bits = -(msac->cnt + 14);
2582 assert(n_bits <= 0)((void) sizeof ((n_bits <= 0) ? 1 : 0), __extension__ ({ if
(n_bits <= 0) ; else __assert_fail ("n_bits <= 0", "/root/firefox-clang/third_party/dav1d/src/decode.c"
, 2582, __extension__ __PRETTY_FUNCTION__); })); // this assumes we errored out when cnt <= -15 in caller
2583 const int n_bytes = (n_bits + 7) >> 3;
2584 const uint8_t *p = &msac->buf_pos[n_bytes];
2585 const int pattern = 128 >> ((n_bits - 1) & 7);
2586 if ((p[-1] & (2 * pattern - 1)) != pattern)
2587 return 1;
2588
2589 // check remainder zero bytes
2590 for (; p < msac->buf_end; p++)
2591 if (*p)
2592 return 1;
2593
2594 return 0;
2595}
2596
2597int dav1d_decode_tile_sbrow(Dav1dTaskContext *const t) {
2598 const Dav1dFrameContext *const f = t->f;
2599 const enum BlockLevel root_bl = f->seq_hdr->sb128 ? BL_128X128 : BL_64X64;
2600 Dav1dTileState *const ts = t->ts;
2601 const Dav1dContext *const c = f->c;
2602 const int sb_step = f->sb_step;
2603 const int tile_row = ts->tiling.row, tile_col = ts->tiling.col;
2604 const int col_sb_start = f->frame_hdr->tiling.col_start_sb[tile_col];
2605 const int col_sb128_start = col_sb_start >> !f->seq_hdr->sb128;
2606
2607 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) || f->frame_hdr->allow_intrabc) {
2608 dav1d_refmvs_tile_sbrow_init(&t->rt, &f->rf, ts->tiling.col_start,
2609 ts->tiling.col_end, ts->tiling.row_start,
2610 ts->tiling.row_end, t->by >> f->sb_shift,
2611 ts->tiling.row, t->frame_thread.pass);
2612 }
2613
2614 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) && c->n_fc > 1) {
2615 const int sby = (t->by - ts->tiling.row_start) >> f->sb_shift;
2616 int (*const lowest_px)[2] = ts->lowest_pixel[sby];
2617 for (int n = 0; n < 7; n++)
2618 for (int m = 0; m < 2; m++)
2619 lowest_px[n][m] = INT_MIN(-2147483647 -1);
2620 }
2621
2622 reset_context(&t->l, IS_KEY_OR_INTRA(f->frame_hdr)(!((f->frame_hdr)->frame_type & 1)), t->frame_thread.pass);
2623 if (t->frame_thread.pass == 2) {
2624 const int off_2pass = c->n_tc > 1 ? f->sb128w * f->frame_hdr->tiling.rows : 0;
2625 for (t->bx = ts->tiling.col_start,
2626 t->a = f->a + off_2pass + col_sb128_start + tile_row * f->sb128w;
2627 t->bx < ts->tiling.col_end; t->bx += sb_step)
2628 {
2629 if (atomic_load_explicit__c11_atomic_load(c->flush, memory_order_acquire))
2630 return 1;
2631 if (decode_sb(t, root_bl, dav1d_intra_edge_tree[root_bl]))
2632 return 1;
2633 if (t->bx & 16 || f->seq_hdr->sb128)
2634 t->a++;
2635 }
2636 f->bd_fn.backup_ipred_edge(t);
2637 return 0;
2638 }
2639
2640 if (f->c->n_tc > 1 && f->frame_hdr->use_ref_frame_mvs) {
2641 f->c->refmvs_dsp.load_tmvs(&f->rf, ts->tiling.row,
2642 ts->tiling.col_start >> 1, ts->tiling.col_end >> 1,
2643 t->by >> 1, (t->by + sb_step) >> 1);
2644 }
2645 memset(t->pal_sz_uv[1], 0, sizeof(*t->pal_sz_uv));
2646 const int sb128y = t->by >> 5;
2647 for (t->bx = ts->tiling.col_start, t->a = f->a + col_sb128_start + tile_row * f->sb128w,
2648 t->lf_mask = f->lf.mask + sb128y * f->sb128w + col_sb128_start;
2649 t->bx < ts->tiling.col_end; t->bx += sb_step)
2650 {
2651 if (atomic_load_explicit__c11_atomic_load(c->flush, memory_order_acquire))
2652 return 1;
2653 if (root_bl == BL_128X128) {
2654 t->cur_sb_cdef_idx_ptr = t->lf_mask->cdef_idx;
2655 t->cur_sb_cdef_idx_ptr[0] = -1;
2656 t->cur_sb_cdef_idx_ptr[1] = -1;
2657 t->cur_sb_cdef_idx_ptr[2] = -1;
2658 t->cur_sb_cdef_idx_ptr[3] = -1;
2659 } else {
2660 t->cur_sb_cdef_idx_ptr =
2661 &t->lf_mask->cdef_idx[((t->bx & 16) >> 4) +
2662 ((t->by & 16) >> 3)];
2663 t->cur_sb_cdef_idx_ptr[0] = -1;
2664 }
2665 // Restoration filter
2666 for (int p = 0; p < 3; p++) {
2667 if (!((f->lf.restore_planes >> p) & 1U))
2668 continue;
2669
2670 const int ss_ver = p && f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I420;
2671 const int ss_hor = p && f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
2672 const int unit_size_log2 = f->frame_hdr->restoration.unit_size[!!p];
2673 const int y = t->by * 4 >> ss_ver;
2674 const int h = (f->cur.p.h + ss_ver) >> ss_ver;
2675
2676 const int unit_size = 1 << unit_size_log2;
2677 const unsigned mask = unit_size - 1;
2678 if (y & mask) continue;
2679 const int half_unit = unit_size >> 1;
2680 // Round half up at frame boundaries, if there's more than one
2681 // restoration unit
2682 if (y && y + half_unit > h) continue;
2683
2684 const enum Dav1dRestorationType frame_type = f->frame_hdr->restoration.type[p];
2685
2686 if (f->frame_hdr->width[0] != f->frame_hdr->width[1]) {
2687 const int w = (f->sr_cur.p.p.w + ss_hor) >> ss_hor;
2688 const int n_units = imax(1, (w + half_unit) >> unit_size_log2);
2689
2690 const int d = f->frame_hdr->super_res.width_scale_denominator;
2691 const int rnd = unit_size * 8 - 1, shift = unit_size_log2 + 3;
2692 const int x0 = ((4 * t->bx * d >> ss_hor) + rnd) >> shift;
2693 const int x1 = ((4 * (t->bx + sb_step) * d >> ss_hor) + rnd) >> shift;
2694
2695 for (int x = x0; x < imin(x1, n_units); x++) {
2696 const int px_x = x << (unit_size_log2 + ss_hor);
2697 const int sb_idx = (t->by >> 5) * f->sr_sb128w + (px_x >> 7);
2698 const int unit_idx = ((t->by & 16) >> 3) + ((px_x & 64) >> 6);
2699 Av1RestorationUnit *const lr = &f->lf.lr_mask[sb_idx].lr[p][unit_idx];
2700
2701 read_restoration_info(t, lr, p, frame_type);
2702 }
2703 } else {
2704 const int x = 4 * t->bx >> ss_hor;
2705 if (x & mask) continue;
2706 const int w = (f->cur.p.w + ss_hor) >> ss_hor;
2707 // Round half up at frame boundaries, if there's more than one
2708 // restoration unit
2709 if (x && x + half_unit > w) continue;
2710 const int sb_idx = (t->by >> 5) * f->sr_sb128w + (t->bx >> 5);
2711 const int unit_idx = ((t->by & 16) >> 3) + ((t->bx & 16) >> 4);
2712 Av1RestorationUnit *const lr = &f->lf.lr_mask[sb_idx].lr[p][unit_idx];
2713
2714 read_restoration_info(t, lr, p, frame_type);
2715 }
2716 }
2717 if (decode_sb(t, root_bl, dav1d_intra_edge_tree[root_bl]))
2718 return 1;
2719 if (t->bx & 16 || f->seq_hdr->sb128) {
2720 t->a++;
2721 t->lf_mask++;
2722 }
2723 }
2724
2725 if (f->seq_hdr->ref_frame_mvs && f->c->n_tc > 1 && IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
2726 dav1d_refmvs_save_tmvs(&f->c->refmvs_dsp, &t->rt,
2727 ts->tiling.col_start >> 1, ts->tiling.col_end >> 1,
2728 t->by >> 1, (t->by + sb_step) >> 1);
2729 }
2730
2731 // backup pre-loopfilter pixels for intra prediction of the next sbrow
2732 if (t->frame_thread.pass != 1)
2733 f->bd_fn.backup_ipred_edge(t);
2734
2735 // backup t->a/l.tx_lpf_y/uv at tile boundaries to use them to "fix"
2736 // up the initial value in neighbour tiles when running the loopfilter
2737 int align_h = (f->bh + 31) & ~31;
2738 memcpy(&f->lf.tx_lpf_right_edge[0][align_h * tile_col + t->by],
2739 &t->l.tx_lpf_y[t->by & 16], sb_step);
2740 const int ss_ver = f->cur.p.layout == DAV1D_PIXEL_LAYOUT_I420;
2741 align_h >>= ss_ver;
2742 memcpy(&f->lf.tx_lpf_right_edge[1][align_h * tile_col + (t->by >> ss_ver)],
2743 &t->l.tx_lpf_uv[(t->by & 16) >> ss_ver], sb_step >> ss_ver);
2744
2745 // error out on symbol decoder overread
2746 if (ts->msac.cnt <= -15) return 1;
2747
2748 return c->strict_std_compliance &&
2749 (t->by >> f->sb_shift) + 1 >= f->frame_hdr->tiling.row_start_sb[tile_row + 1] &&
2750 check_trailing_bits_after_symbol_coder(&ts->msac);
2751}
2752
2753int dav1d_decode_frame_init(Dav1dFrameContext *const f) {
2754 const Dav1dContext *const c = f->c;
2755 int retval = DAV1D_ERR(ENOMEM)(-(12));
2756
2757 if (f->sbh > f->lf.start_of_tile_row_sz) {
2758 dav1d_free(f->lf.start_of_tile_row)free(f->lf.start_of_tile_row);
2759 f->lf.start_of_tile_row = dav1d_malloc(ALLOC_TILE, f->sbh * sizeof(uint8_t))malloc(f->sbh * sizeof(uint8_t));
2760 if (!f->lf.start_of_tile_row) {
2761 f->lf.start_of_tile_row_sz = 0;
2762 goto error;
2763 }
2764 f->lf.start_of_tile_row_sz = f->sbh;
2765 }
2766 int sby = 0;
2767 for (int tile_row = 0; tile_row < f->frame_hdr->tiling.rows; tile_row++) {
2768 f->lf.start_of_tile_row[sby++] = tile_row;
2769 while (sby < f->frame_hdr->tiling.row_start_sb[tile_row + 1])
2770 f->lf.start_of_tile_row[sby++] = 0;
2771 }
2772
2773 const int n_ts = f->frame_hdr->tiling.cols * f->frame_hdr->tiling.rows;
2774 if (n_ts != f->n_ts) {
2775 if (c->n_fc > 1) {
2776 dav1d_free(f->frame_thread.tile_start_off)free(f->frame_thread.tile_start_off);
2777 f->frame_thread.tile_start_off =
2778 dav1d_malloc(ALLOC_TILE, sizeof(*f->frame_thread.tile_start_off) * n_ts)malloc(sizeof(*f->frame_thread.tile_start_off) * n_ts);
2779 if (!f->frame_thread.tile_start_off) {
2780 f->n_ts = 0;
2781 goto error;
2782 }
2783 }
2784 dav1d_free_aligned(f->ts)dav1d_free_aligned_internal(f->ts);
2785 f->ts = dav1d_alloc_aligned(ALLOC_TILE, sizeof(*f->ts) * n_ts, 32)dav1d_alloc_aligned_internal(sizeof(*f->ts) * n_ts, 32);
2786 if (!f->ts) goto error;
2787 f->n_ts = n_ts;
2788 }
2789
2790 const int a_sz = f->sb128w * f->frame_hdr->tiling.rows * (1 + (c->n_fc > 1 && c->n_tc > 1));
2791 if (a_sz != f->a_sz) {
2792 dav1d_free(f->a)free(f->a);
2793 f->a = dav1d_malloc(ALLOC_TILE, sizeof(*f->a) * a_sz)malloc(sizeof(*f->a) * a_sz);
2794 if (!f->a) {
2795 f->a_sz = 0;
2796 goto error;
2797 }
2798 f->a_sz = a_sz;
2799 }
2800
2801 const int num_sb128 = f->sb128w * f->sb128h;
2802 const uint8_t *const size_mul = ss_size_mul[f->cur.p.layout];
2803 const int hbd = !!f->seq_hdr->hbd;
2804 if (c->n_fc > 1) {
2805 const unsigned sb_step4 = f->sb_step * 4;
2806 int tile_idx = 0;
2807 for (int tile_row = 0; tile_row < f->frame_hdr->tiling.rows; tile_row++) {
2808 const unsigned row_off = f->frame_hdr->tiling.row_start_sb[tile_row] *
2809 sb_step4 * f->sb128w * 128;
2810 const unsigned b_diff = (f->frame_hdr->tiling.row_start_sb[tile_row + 1] -
2811 f->frame_hdr->tiling.row_start_sb[tile_row]) * sb_step4;
2812 for (int tile_col = 0; tile_col < f->frame_hdr->tiling.cols; tile_col++) {
2813 f->frame_thread.tile_start_off[tile_idx++] = row_off + b_diff *
2814 f->frame_hdr->tiling.col_start_sb[tile_col] * sb_step4;
2815 }
2816 }
2817
2818 const int lowest_pixel_mem_sz = f->frame_hdr->tiling.cols * f->sbh;
2819 if (lowest_pixel_mem_sz != f->tile_thread.lowest_pixel_mem_sz) {
2820 dav1d_free(f->tile_thread.lowest_pixel_mem)free(f->tile_thread.lowest_pixel_mem);
2821 f->tile_thread.lowest_pixel_mem =
2822 dav1d_malloc(ALLOC_TILE, lowest_pixel_mem_sz *malloc(lowest_pixel_mem_sz * sizeof(*f->tile_thread.lowest_pixel_mem
))
2823 sizeof(*f->tile_thread.lowest_pixel_mem))malloc(lowest_pixel_mem_sz * sizeof(*f->tile_thread.lowest_pixel_mem
));
2824 if (!f->tile_thread.lowest_pixel_mem) {
2825 f->tile_thread.lowest_pixel_mem_sz = 0;
2826 goto error;
2827 }
2828 f->tile_thread.lowest_pixel_mem_sz = lowest_pixel_mem_sz;
2829 }
2830 int (*lowest_pixel_ptr)[7][2] = f->tile_thread.lowest_pixel_mem;
2831 for (int tile_row = 0, tile_row_base = 0; tile_row < f->frame_hdr->tiling.rows;
2832 tile_row++, tile_row_base += f->frame_hdr->tiling.cols)
2833 {
2834 const int tile_row_sb_h = f->frame_hdr->tiling.row_start_sb[tile_row + 1] -
2835 f->frame_hdr->tiling.row_start_sb[tile_row];
2836 for (int tile_col = 0; tile_col < f->frame_hdr->tiling.cols; tile_col++) {
2837 f->ts[tile_row_base + tile_col].lowest_pixel = lowest_pixel_ptr;
2838 lowest_pixel_ptr += tile_row_sb_h;
2839 }
2840 }
2841
2842 const int cbi_sz = num_sb128 * size_mul[0];
2843 if (cbi_sz != f->frame_thread.cbi_sz) {
2844 dav1d_free_aligned(f->frame_thread.cbi)dav1d_free_aligned_internal(f->frame_thread.cbi);
2845 f->frame_thread.cbi =
2846 dav1d_alloc_aligned(ALLOC_BLOCK, sizeof(*f->frame_thread.cbi) *dav1d_alloc_aligned_internal(sizeof(*f->frame_thread.cbi) *
cbi_sz * 32 * 32 / 4, 64)
2847 cbi_sz * 32 * 32 / 4, 64)dav1d_alloc_aligned_internal(sizeof(*f->frame_thread.cbi) *
cbi_sz * 32 * 32 / 4, 64);
2848 if (!f->frame_thread.cbi) {
2849 f->frame_thread.cbi_sz = 0;
2850 goto error;
2851 }
2852 f->frame_thread.cbi_sz = cbi_sz;
2853 }
2854
2855 const int cf_sz = (num_sb128 * size_mul[0]) << hbd;
2856 if (cf_sz != f->frame_thread.cf_sz) {
2857 dav1d_free_aligned(f->frame_thread.cf)dav1d_free_aligned_internal(f->frame_thread.cf);
2858 f->frame_thread.cf =
2859 dav1d_alloc_aligned(ALLOC_COEF, (size_t)cf_sz * 128 * 128 / 2, 64)dav1d_alloc_aligned_internal((size_t)cf_sz * 128 * 128 / 2, 64
);
2860 if (!f->frame_thread.cf) {
2861 f->frame_thread.cf_sz = 0;
2862 goto error;
2863 }
2864 memset(f->frame_thread.cf, 0, (size_t)cf_sz * 128 * 128 / 2);
2865 f->frame_thread.cf_sz = cf_sz;
2866 }
2867
2868 if (f->frame_hdr->allow_screen_content_tools) {
2869 const int pal_sz = num_sb128 << hbd;
2870 if (pal_sz != f->frame_thread.pal_sz) {
2871 dav1d_free_aligned(f->frame_thread.pal)dav1d_free_aligned_internal(f->frame_thread.pal);
2872 f->frame_thread.pal =
2873 dav1d_alloc_aligned(ALLOC_PAL, sizeof(*f->frame_thread.pal) *dav1d_alloc_aligned_internal(sizeof(*f->frame_thread.pal) *
pal_sz * 16 * 16, 64)
2874 pal_sz * 16 * 16, 64)dav1d_alloc_aligned_internal(sizeof(*f->frame_thread.pal) *
pal_sz * 16 * 16, 64);
2875 if (!f->frame_thread.pal) {
2876 f->frame_thread.pal_sz = 0;
2877 goto error;
2878 }
2879 f->frame_thread.pal_sz = pal_sz;
2880 }
2881
2882 const int pal_idx_sz = num_sb128 * size_mul[1];
2883 if (pal_idx_sz != f->frame_thread.pal_idx_sz) {
2884 dav1d_free_aligned(f->frame_thread.pal_idx)dav1d_free_aligned_internal(f->frame_thread.pal_idx);
2885 f->frame_thread.pal_idx =
2886 dav1d_alloc_aligned(ALLOC_PAL, sizeof(*f->frame_thread.pal_idx) *dav1d_alloc_aligned_internal(sizeof(*f->frame_thread.pal_idx
) * pal_idx_sz * 128 * 128 / 8, 64)
2887 pal_idx_sz * 128 * 128 / 8, 64)dav1d_alloc_aligned_internal(sizeof(*f->frame_thread.pal_idx
) * pal_idx_sz * 128 * 128 / 8, 64);
2888 if (!f->frame_thread.pal_idx) {
2889 f->frame_thread.pal_idx_sz = 0;
2890 goto error;
2891 }
2892 f->frame_thread.pal_idx_sz = pal_idx_sz;
2893 }
2894 } else if (f->frame_thread.pal) {
2895 dav1d_freep_aligned(&f->frame_thread.pal);
2896 dav1d_freep_aligned(&f->frame_thread.pal_idx);
2897 f->frame_thread.pal_sz = f->frame_thread.pal_idx_sz = 0;
2898 }
2899 }
2900
2901 // update allocation of block contexts for above
2902 ptrdiff_t y_stride = f->cur.stride[0], uv_stride = f->cur.stride[1];
2903 const int has_resize = f->frame_hdr->width[0] != f->frame_hdr->width[1];
2904 const int need_cdef_lpf_copy = c->n_tc > 1 && has_resize;
2905 if (y_stride * f->sbh * 4 != f->lf.cdef_buf_plane_sz[0] ||
2906 uv_stride * f->sbh * 8 != f->lf.cdef_buf_plane_sz[1] ||
2907 need_cdef_lpf_copy != f->lf.need_cdef_lpf_copy ||
2908 f->sbh != f->lf.cdef_buf_sbh)
2909 {
2910 dav1d_free_aligned(f->lf.cdef_line_buf)dav1d_free_aligned_internal(f->lf.cdef_line_buf);
2911 size_t alloc_sz = 64;
2912 alloc_sz += (size_t)llabs(y_stride) * 4 * f->sbh << need_cdef_lpf_copy;
2913 alloc_sz += (size_t)llabs(uv_stride) * 8 * f->sbh << need_cdef_lpf_copy;
2914 uint8_t *ptr = f->lf.cdef_line_buf = dav1d_alloc_aligned(ALLOC_CDEF, alloc_sz, 32)dav1d_alloc_aligned_internal(alloc_sz, 32);
2915 if (!ptr) {
2916 f->lf.cdef_buf_plane_sz[0] = f->lf.cdef_buf_plane_sz[1] = 0;
2917 goto error;
2918 }
2919
2920 ptr += 32;
2921 if (y_stride < 0) {
2922 f->lf.cdef_line[0][0] = ptr - y_stride * (f->sbh * 4 - 1);
2923 f->lf.cdef_line[1][0] = ptr - y_stride * (f->sbh * 4 - 3);
2924 } else {
2925 f->lf.cdef_line[0][0] = ptr + y_stride * 0;
2926 f->lf.cdef_line[1][0] = ptr + y_stride * 2;
2927 }
2928 ptr += llabs(y_stride) * f->sbh * 4;
2929 if (uv_stride < 0) {
2930 f->lf.cdef_line[0][1] = ptr - uv_stride * (f->sbh * 8 - 1);
2931 f->lf.cdef_line[0][2] = ptr - uv_stride * (f->sbh * 8 - 3);
2932 f->lf.cdef_line[1][1] = ptr - uv_stride * (f->sbh * 8 - 5);
2933 f->lf.cdef_line[1][2] = ptr - uv_stride * (f->sbh * 8 - 7);
2934 } else {
2935 f->lf.cdef_line[0][1] = ptr + uv_stride * 0;
2936 f->lf.cdef_line[0][2] = ptr + uv_stride * 2;
2937 f->lf.cdef_line[1][1] = ptr + uv_stride * 4;
2938 f->lf.cdef_line[1][2] = ptr + uv_stride * 6;
2939 }
2940
2941 if (need_cdef_lpf_copy) {
2942 ptr += llabs(uv_stride) * f->sbh * 8;
2943 if (y_stride < 0)
2944 f->lf.cdef_lpf_line[0] = ptr - y_stride * (f->sbh * 4 - 1);
2945 else
2946 f->lf.cdef_lpf_line[0] = ptr;
2947 ptr += llabs(y_stride) * f->sbh * 4;
2948 if (uv_stride < 0) {
2949 f->lf.cdef_lpf_line[1] = ptr - uv_stride * (f->sbh * 4 - 1);
2950 f->lf.cdef_lpf_line[2] = ptr - uv_stride * (f->sbh * 8 - 1);
2951 } else {
2952 f->lf.cdef_lpf_line[1] = ptr;
2953 f->lf.cdef_lpf_line[2] = ptr + uv_stride * f->sbh * 4;
2954 }
2955 }
2956
2957 f->lf.cdef_buf_plane_sz[0] = (int) y_stride * f->sbh * 4;
2958 f->lf.cdef_buf_plane_sz[1] = (int) uv_stride * f->sbh * 8;
2959 f->lf.need_cdef_lpf_copy = need_cdef_lpf_copy;
2960 f->lf.cdef_buf_sbh = f->sbh;
2961 }
2962
2963 const int sb128 = f->seq_hdr->sb128;
2964 const int num_lines = c->n_tc > 1 ? f->sbh * 4 << sb128 : 12;
2965 y_stride = f->sr_cur.p.stride[0], uv_stride = f->sr_cur.p.stride[1];
2966 if (y_stride * num_lines != f->lf.lr_buf_plane_sz[0] ||
2967 uv_stride * num_lines * 2 != f->lf.lr_buf_plane_sz[1])
2968 {
2969 dav1d_free_aligned(f->lf.lr_line_buf)dav1d_free_aligned_internal(f->lf.lr_line_buf);
2970 // lr simd may overread the input, so slightly over-allocate the lpf buffer
2971 size_t alloc_sz = 128;
2972 alloc_sz += (size_t)llabs(y_stride) * num_lines;
2973 alloc_sz += (size_t)llabs(uv_stride) * num_lines * 2;
2974 uint8_t *ptr = f->lf.lr_line_buf = dav1d_alloc_aligned(ALLOC_LR, alloc_sz, 64)dav1d_alloc_aligned_internal(alloc_sz, 64);
2975 if (!ptr) {
2976 f->lf.lr_buf_plane_sz[0] = f->lf.lr_buf_plane_sz[1] = 0;
2977 goto error;
2978 }
2979
2980 ptr += 64;
2981 if (y_stride < 0)
2982 f->lf.lr_lpf_line[0] = ptr - y_stride * (num_lines - 1);
2983 else
2984 f->lf.lr_lpf_line[0] = ptr;
2985 ptr += llabs(y_stride) * num_lines;
2986 if (uv_stride < 0) {
2987 f->lf.lr_lpf_line[1] = ptr - uv_stride * (num_lines * 1 - 1);
2988 f->lf.lr_lpf_line[2] = ptr - uv_stride * (num_lines * 2 - 1);
2989 } else {
2990 f->lf.lr_lpf_line[1] = ptr;
2991 f->lf.lr_lpf_line[2] = ptr + uv_stride * num_lines;
2992 }
2993
2994 f->lf.lr_buf_plane_sz[0] = (int) y_stride * num_lines;
2995 f->lf.lr_buf_plane_sz[1] = (int) uv_stride * num_lines * 2;
2996 }
2997
2998 // update allocation for loopfilter masks
2999 if (num_sb128 != f->lf.mask_sz) {
3000 dav1d_free(f->lf.mask)free(f->lf.mask);
3001 dav1d_free(f->lf.level)free(f->lf.level);
3002 f->lf.mask = dav1d_malloc(ALLOC_LF, sizeof(*f->lf.mask) * num_sb128)malloc(sizeof(*f->lf.mask) * num_sb128);
3003 // over-allocate by 3 bytes since some of the SIMD implementations
3004 // index this from the level type and can thus over-read by up to 3
3005 f->lf.level = dav1d_malloc(ALLOC_LF, sizeof(*f->lf.level) * num_sb128 * 32 * 32 + 3)malloc(sizeof(*f->lf.level) * num_sb128 * 32 * 32 + 3);
3006 if (!f->lf.mask || !f->lf.level) {
3007 f->lf.mask_sz = 0;
3008 goto error;
3009 }
3010 if (c->n_fc > 1) {
3011 dav1d_free(f->frame_thread.b)free(f->frame_thread.b);
3012 f->frame_thread.b = dav1d_malloc(ALLOC_BLOCK, sizeof(*f->frame_thread.b) *malloc(sizeof(*f->frame_thread.b) * num_sb128 * 32 * 32)
3013 num_sb128 * 32 * 32)malloc(sizeof(*f->frame_thread.b) * num_sb128 * 32 * 32);
3014 if (!f->frame_thread.b) {
3015 f->lf.mask_sz = 0;
3016 goto error;
3017 }
3018 }
3019 f->lf.mask_sz = num_sb128;
3020 }
3021
3022 f->sr_sb128w = (f->sr_cur.p.p.w + 127) >> 7;
3023 const int lr_mask_sz = f->sr_sb128w * f->sb128h;
3024 if (lr_mask_sz != f->lf.lr_mask_sz) {
3025 dav1d_free(f->lf.lr_mask)free(f->lf.lr_mask);
3026 f->lf.lr_mask = dav1d_malloc(ALLOC_LR, sizeof(*f->lf.lr_mask) * lr_mask_sz)malloc(sizeof(*f->lf.lr_mask) * lr_mask_sz);
3027 if (!f->lf.lr_mask) {
3028 f->lf.lr_mask_sz = 0;
3029 goto error;
3030 }
3031 f->lf.lr_mask_sz = lr_mask_sz;
3032 }
3033 f->lf.restore_planes =
3034 ((f->frame_hdr->restoration.type[0] != DAV1D_RESTORATION_NONE) << 0) +
3035 ((f->frame_hdr->restoration.type[1] != DAV1D_RESTORATION_NONE) << 1) +
3036 ((f->frame_hdr->restoration.type[2] != DAV1D_RESTORATION_NONE) << 2);
3037 if (f->frame_hdr->loopfilter.sharpness != f->lf.last_sharpness) {
3038 dav1d_calc_eih(&f->lf.lim_lut, f->frame_hdr->loopfilter.sharpness);
3039 f->lf.last_sharpness = f->frame_hdr->loopfilter.sharpness;
3040 }
3041 dav1d_calc_lf_values(f->lf.lvl, f->frame_hdr, (int8_t[4]) { 0, 0, 0, 0 });
3042 memset(f->lf.mask, 0, sizeof(*f->lf.mask) * num_sb128);
3043
3044 const int ipred_edge_sz = f->sbh * f->sb128w << hbd;
3045 if (ipred_edge_sz != f->ipred_edge_sz) {
3046 dav1d_free_aligned(f->ipred_edge[0])dav1d_free_aligned_internal(f->ipred_edge[0]);
3047 uint8_t *ptr = f->ipred_edge[0] =
3048 dav1d_alloc_aligned(ALLOC_IPRED, ipred_edge_sz * 128 * 3, 64)dav1d_alloc_aligned_internal(ipred_edge_sz * 128 * 3, 64);
3049 if (!ptr) {
3050 f->ipred_edge_sz = 0;
3051 goto error;
3052 }
3053 f->ipred_edge[1] = ptr + ipred_edge_sz * 128 * 1;
3054 f->ipred_edge[2] = ptr + ipred_edge_sz * 128 * 2;
3055 f->ipred_edge_sz = ipred_edge_sz;
3056 }
3057
3058 const int re_sz = f->sb128h * f->frame_hdr->tiling.cols;
3059 if (re_sz != f->lf.re_sz) {
3060 dav1d_free(f->lf.tx_lpf_right_edge[0])free(f->lf.tx_lpf_right_edge[0]);
3061 f->lf.tx_lpf_right_edge[0] = dav1d_malloc(ALLOC_LF, re_sz * 32 * 2)malloc(re_sz * 32 * 2);
3062 if (!f->lf.tx_lpf_right_edge[0]) {
3063 f->lf.re_sz = 0;
3064 goto error;
3065 }
3066 f->lf.tx_lpf_right_edge[1] = f->lf.tx_lpf_right_edge[0] + re_sz * 32;
3067 f->lf.re_sz = re_sz;
3068 }
3069
3070 // init ref mvs
3071 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) || f->frame_hdr->allow_intrabc) {
3072 const int ret =
3073 dav1d_refmvs_init_frame(&f->rf, f->seq_hdr, f->frame_hdr,
3074 f->refpoc, f->mvs, f->refrefpoc, f->ref_mvs,
3075 f->c->n_tc, f->c->n_fc);
3076 if (ret < 0) goto error;
3077 }
3078
3079 // setup dequant tables
3080 init_quant_tables(f->seq_hdr, f->frame_hdr, f->frame_hdr->quant.yac, f->dq);
3081 if (f->frame_hdr->quant.qm)
3082 for (int i = 0; i < N_RECT_TX_SIZES; i++) {
3083 f->qm[i][0] = dav1d_qm_tbl[f->frame_hdr->quant.qm_y][0][i];
3084 f->qm[i][1] = dav1d_qm_tbl[f->frame_hdr->quant.qm_u][1][i];
3085 f->qm[i][2] = dav1d_qm_tbl[f->frame_hdr->quant.qm_v][1][i];
3086 }
3087 else
3088 memset(f->qm, 0, sizeof(f->qm));
3089
3090 // setup jnt_comp weights
3091 if (f->frame_hdr->switchable_comp_refs) {
3092 for (int i = 0; i < 7; i++) {
3093 const unsigned ref0poc = f->refp[i].p.frame_hdr->frame_offset;
3094
3095 for (int j = i + 1; j < 7; j++) {
3096 const unsigned ref1poc = f->refp[j].p.frame_hdr->frame_offset;
3097
3098 const unsigned d1 =
3099 imin(abs(get_poc_diff(f->seq_hdr->order_hint_n_bits, ref0poc,
3100 f->cur.frame_hdr->frame_offset)), 31);
3101 const unsigned d0 =
3102 imin(abs(get_poc_diff(f->seq_hdr->order_hint_n_bits, ref1poc,
3103 f->cur.frame_hdr->frame_offset)), 31);
3104 const int order = d0 <= d1;
3105
3106 static const uint8_t quant_dist_weight[3][2] = {
3107 { 2, 3 }, { 2, 5 }, { 2, 7 }
3108 };
3109 static const uint8_t quant_dist_lookup_table[4][2] = {
3110 { 9, 7 }, { 11, 5 }, { 12, 4 }, { 13, 3 }
3111 };
3112
3113 int k;
3114 for (k = 0; k < 3; k++) {
3115 const int c0 = quant_dist_weight[k][order];
3116 const int c1 = quant_dist_weight[k][!order];
3117 const int d0_c0 = d0 * c0;
3118 const int d1_c1 = d1 * c1;
3119 if ((d0 > d1 && d0_c0 < d1_c1) || (d0 <= d1 && d0_c0 > d1_c1)) break;
3120 }
3121
3122 f->jnt_weights[i][j] = quant_dist_lookup_table[k][order];
3123 }
3124 }
3125 }
3126
3127 /* Init loopfilter pointers. Increasing NULL pointers is technically UB,
3128 * so just point the chroma pointers in 4:0:0 to the luma plane here to
3129 * avoid having additional in-loop branches in various places. We never
3130 * dereference those pointers so it doesn't really matter what they
3131 * point at, as long as the pointers are valid. */
3132 const int has_chroma = f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I400;
3133 f->lf.p[0] = f->cur.data[0];
3134 f->lf.p[1] = f->cur.data[has_chroma ? 1 : 0];
3135 f->lf.p[2] = f->cur.data[has_chroma ? 2 : 0];
3136 f->lf.sr_p[0] = f->sr_cur.p.data[0];
3137 f->lf.sr_p[1] = f->sr_cur.p.data[has_chroma ? 1 : 0];
3138 f->lf.sr_p[2] = f->sr_cur.p.data[has_chroma ? 2 : 0];
3139
3140 retval = 0;
3141error:
3142 return retval;
3143}
3144
3145int dav1d_decode_frame_init_cdf(Dav1dFrameContext *const f) {
3146 const Dav1dContext *const c = f->c;
3147 int retval = DAV1D_ERR(EINVAL)(-(22));
3148
3149 if (f->frame_hdr->refresh_context)
3150 dav1d_cdf_thread_copy(f->out_cdf.data.cdf, &f->in_cdf);
3151
3152 // parse individual tiles per tile group
3153 int tile_row = 0, tile_col = 0;
3154 f->task_thread.update_set = 0;
3155 for (int i = 0; i < f->n_tile_data; i++) {
3156 const uint8_t *data = f->tile[i].data.data;
3157 size_t size = f->tile[i].data.sz;
3158
3159 for (int j = f->tile[i].start; j <= f->tile[i].end; j++) {
3160 size_t tile_sz;
3161 if (j == f->tile[i].end) {
3162 tile_sz = size;
3163 } else {
3164 if (f->frame_hdr->tiling.n_bytes > size) goto error;
3165 tile_sz = 0;
3166 for (unsigned k = 0; k < f->frame_hdr->tiling.n_bytes; k++)
3167 tile_sz |= (unsigned)*data++ << (k * 8);
3168 tile_sz++;
3169 size -= f->frame_hdr->tiling.n_bytes;
3170 if (tile_sz > size) goto error;
3171 }
3172
3173 setup_tile(&f->ts[j], f, data, tile_sz, tile_row, tile_col++,
3174 c->n_fc > 1 ? f->frame_thread.tile_start_off[j] : 0);
3175
3176 if (tile_col == f->frame_hdr->tiling.cols) {
3177 tile_col = 0;
3178 tile_row++;
3179 }
3180 if (j == f->frame_hdr->tiling.update && f->frame_hdr->refresh_context)
3181 f->task_thread.update_set = 1;
3182 data += tile_sz;
3183 size -= tile_sz;
3184 }
3185 }
3186
3187 if (c->n_tc > 1) {
3188 const int uses_2pass = c->n_fc > 1;
3189 for (int n = 0; n < f->sb128w * f->frame_hdr->tiling.rows * (1 + uses_2pass); n++)
3190 reset_context(&f->a[n], IS_KEY_OR_INTRA(f->frame_hdr)(!((f->frame_hdr)->frame_type & 1)),
3191 uses_2pass ? 1 + (n >= f->sb128w * f->frame_hdr->tiling.rows) : 0);
3192 }
3193
3194 retval = 0;
3195error:
3196 return retval;
3197}
3198
3199int dav1d_decode_frame_main(Dav1dFrameContext *const f) {
3200 const Dav1dContext *const c = f->c;
3201 int retval = DAV1D_ERR(EINVAL)(-(22));
3202
3203 assert(f->c->n_tc == 1)((void) sizeof ((f->c->n_tc == 1) ? 1 : 0), __extension__
({ if (f->c->n_tc == 1) ; else __assert_fail ("f->c->n_tc == 1"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 3203,
__extension__ __PRETTY_FUNCTION__); }));
3204
3205 Dav1dTaskContext *const t = &c->tc[f - c->fc];
3206 t->f = f;
3207 t->frame_thread.pass = 0;
3208
3209 for (int n = 0; n < f->sb128w * f->frame_hdr->tiling.rows; n++)
3210 reset_context(&f->a[n], IS_KEY_OR_INTRA(f->frame_hdr)(!((f->frame_hdr)->frame_type & 1)), 0);
3211
3212 // no threading - we explicitly interleave tile/sbrow decoding
3213 // and post-filtering, so that the full process runs in-line
3214 for (int tile_row = 0; tile_row < f->frame_hdr->tiling.rows; tile_row++) {
3215 const int sbh_end =
3216 imin(f->frame_hdr->tiling.row_start_sb[tile_row + 1], f->sbh);
3217 for (int sby = f->frame_hdr->tiling.row_start_sb[tile_row];
3218 sby < sbh_end; sby++)
3219 {
3220 t->by = sby << (4 + f->seq_hdr->sb128);
3221 const int by_end = (t->by + f->sb_step) >> 1;
3222 if (f->frame_hdr->use_ref_frame_mvs) {
3223 f->c->refmvs_dsp.load_tmvs(&f->rf, tile_row,
3224 0, f->bw >> 1, t->by >> 1, by_end);
3225 }
3226 for (int tile_col = 0; tile_col < f->frame_hdr->tiling.cols; tile_col++) {
3227 t->ts = &f->ts[tile_row * f->frame_hdr->tiling.cols + tile_col];
3228 if (dav1d_decode_tile_sbrow(t)) goto error;
3229 }
3230 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
3231 dav1d_refmvs_save_tmvs(&f->c->refmvs_dsp, &t->rt,
3232 0, f->bw >> 1, t->by >> 1, by_end);
3233 }
3234
3235 // loopfilter + cdef + restoration
3236 f->bd_fn.filter_sbrow(f, sby);
3237 }
3238 }
3239
3240 retval = 0;
3241error:
3242 return retval;
3243}
3244
3245void dav1d_decode_frame_exit(Dav1dFrameContext *const f, int retval) {
3246 const Dav1dContext *const c = f->c;
3247
3248 if (f->sr_cur.p.data[0])
3249 atomic_init__c11_atomic_init(&f->task_thread.error, 0);
3250
3251 if (c->n_fc > 1 && retval && f->frame_thread.cf) {
3252 memset(f->frame_thread.cf, 0,
3253 (size_t)f->frame_thread.cf_sz * 128 * 128 / 2);
3254 }
3255 for (int i = 0; i < 7; i++) {
3256 if (f->refp[i].p.frame_hdr) {
3257 if (!retval && c->n_fc > 1 && c->strict_std_compliance &&
3258 atomic_load(&f->refp[i].progress[1])__c11_atomic_load(&f->refp[i].progress[1], 5) == FRAME_ERROR((2147483647 *2U +1U) - 1))
3259 {
3260 retval = DAV1D_ERR(EINVAL)(-(22));
3261 atomic_store(&f->task_thread.error, 1)__c11_atomic_store(&f->task_thread.error, 1, 5);
3262 atomic_store(&f->sr_cur.progress[1], FRAME_ERROR)__c11_atomic_store(&f->sr_cur.progress[1], ((2147483647
*2U +1U) - 1), 5);
3263 }
3264 dav1d_thread_picture_unref(&f->refp[i]);
3265 }
3266 dav1d_ref_dec(&f->ref_mvs_ref[i]);
3267 }
3268
3269 dav1d_picture_unref_internal(&f->cur);
3270 dav1d_thread_picture_unref(&f->sr_cur);
3271 dav1d_cdf_thread_unref(&f->in_cdf);
3272 if (f->frame_hdr && f->frame_hdr->refresh_context) {
3273 if (f->out_cdf.progress)
3274 atomic_store(f->out_cdf.progress, retval == 0 ? 1 : TILE_ERROR)__c11_atomic_store(f->out_cdf.progress, retval == 0 ? 1 : (
2147483647 - 1), 5);
3275 dav1d_cdf_thread_unref(&f->out_cdf);
3276 }
3277 dav1d_ref_dec(&f->cur_segmap_ref);
3278 dav1d_ref_dec(&f->prev_segmap_ref);
3279 dav1d_ref_dec(&f->mvs_ref);
3280 dav1d_ref_dec(&f->seq_hdr_ref);
3281 dav1d_ref_dec(&f->frame_hdr_ref);
3282
3283 for (int i = 0; i < f->n_tile_data; i++)
3284 dav1d_data_unref_internal(&f->tile[i].data);
3285 f->task_thread.retval = retval;
3286}
3287
3288int dav1d_decode_frame(Dav1dFrameContext *const f) {
3289 assert(f->c->n_fc == 1)((void) sizeof ((f->c->n_fc == 1) ? 1 : 0), __extension__
({ if (f->c->n_fc == 1) ; else __assert_fail ("f->c->n_fc == 1"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 3289,
__extension__ __PRETTY_FUNCTION__); }));
3290 // if n_tc > 1 (but n_fc == 1), we could run init/exit in the task
3291 // threads also. Not sure it makes a measurable difference.
3292 int res = dav1d_decode_frame_init(f);
3293 if (!res) res = dav1d_decode_frame_init_cdf(f);
3294 // wait until all threads have completed
3295 if (!res) {
3296 if (f->c->n_tc > 1) {
3297 res = dav1d_task_create_tile_sbrow(f, 0, 1);
3298 pthread_mutex_lock(&f->task_thread.ttd->lock);
3299 pthread_cond_signal(&f->task_thread.ttd->cond);
3300 if (!res) {
3301 while (!f->task_thread.done[0] ||
3302 atomic_load(&f->task_thread.task_counter)__c11_atomic_load(&f->task_thread.task_counter, 5) > 0)
3303 {
3304 pthread_cond_wait(&f->task_thread.cond,
3305 &f->task_thread.ttd->lock);
3306 }
3307 }
3308 pthread_mutex_unlock(&f->task_thread.ttd->lock);
3309 res = f->task_thread.retval;
3310 } else {
3311 res = dav1d_decode_frame_main(f);
3312 if (!res && f->frame_hdr->refresh_context && f->task_thread.update_set) {
3313 dav1d_cdf_thread_update(f->frame_hdr, f->out_cdf.data.cdf,
3314 &f->ts[f->frame_hdr->tiling.update].cdf);
3315 }
3316 }
3317 }
3318 dav1d_decode_frame_exit(f, res);
3319 res = f->task_thread.retval;
3320 f->n_tile_data = 0;
3321 return res;
3322}
3323
3324static int get_upscale_x0(const int in_w, const int out_w, const int step) {
3325 const int err = out_w * step - (in_w << 14);
3326 const int x0 = (-((out_w - in_w) << 13) + (out_w >> 1)) / out_w + 128 - (err / 2);
3327 return x0 & 0x3fff;
3328}
3329
3330int dav1d_submit_frame(Dav1dContext *const c) {
3331 Dav1dFrameContext *f;
3332 int res = -1;
3333
3334 // wait for c->out_delayed[next] and move into c->out if visible
3335 Dav1dThreadPicture *out_delayed;
3336 if (c->n_fc > 1) {
1
Assuming field 'n_fc' is <= 1
→
2
←
Taking false branch
→
3337 pthread_mutex_lock(&c->task_thread.lock);
3338 const unsigned next = c->frame_thread.next++;
3339 if (c->frame_thread.next == c->n_fc)
3340 c->frame_thread.next = 0;
3341
3342 f = &c->fc[next];
3343 while (f->n_tile_data > 0)
3344 pthread_cond_wait(&f->task_thread.cond,
3345 &c->task_thread.lock);
3346 out_delayed = &c->frame_thread.out_delayed[next];
3347 if (out_delayed->p.data[0] || atomic_load(&f->task_thread.error)__c11_atomic_load(&f->task_thread.error, 5)) {
3348 unsigned first = atomic_load(&c->task_thread.first)__c11_atomic_load(&c->task_thread.first, 5);
3349 if (first + 1U < c->n_fc)
3350 atomic_fetch_add(&c->task_thread.first, 1U)__c11_atomic_fetch_add(&c->task_thread.first, 1U, 5);
3351 else
3352 atomic_store(&c->task_thread.first, 0)__c11_atomic_store(&c->task_thread.first, 0, 5);
3353 atomic_compare_exchange_strong(&c->task_thread.reset_task_cur,__c11_atomic_compare_exchange_strong(&c->task_thread.reset_task_cur
, &first, (2147483647 *2U +1U), 5, 5)
3354 &first, UINT_MAX)__c11_atomic_compare_exchange_strong(&c->task_thread.reset_task_cur
, &first, (2147483647 *2U +1U), 5, 5);
3355 if (c->task_thread.cur && c->task_thread.cur < c->n_fc)
3356 c->task_thread.cur--;
3357 }
3358 const int error = f->task_thread.retval;
3359 if (error) {
3360 f->task_thread.retval = 0;
3361 c->cached_error = error;
3362 dav1d_data_props_copy(&c->cached_error_props, &out_delayed->p.m);
3363 dav1d_thread_picture_unref(out_delayed);
3364 } else if (out_delayed->p.data[0]) {
3365 const unsigned progress = atomic_load_explicit__c11_atomic_load(&out_delayed->progress[1],
3366 memory_order_relaxed);
3367 if ((out_delayed->visible || c->output_invisible_frames) &&
3368 progress != FRAME_ERROR((2147483647 *2U +1U) - 1))
3369 {
3370 dav1d_thread_picture_ref(&c->out, out_delayed);
3371 c->event_flags |= dav1d_picture_get_event_flags(out_delayed);
3372 }
3373 dav1d_thread_picture_unref(out_delayed);
3374 }
3375 } else {
3376 f = c->fc;
3377 }
3378
3379 f->seq_hdr = c->seq_hdr;
3380 f->seq_hdr_ref = c->seq_hdr_ref;
3381 dav1d_ref_inc(f->seq_hdr_ref);
3382 f->frame_hdr = c->frame_hdr;
3383 f->frame_hdr_ref = c->frame_hdr_ref;
3384 c->frame_hdr = NULL((void*)0);
3385 c->frame_hdr_ref = NULL((void*)0);
3386 f->dsp = &c->dsp[f->seq_hdr->hbd];
3387
3388 const int bpc = 8 + 2 * f->seq_hdr->hbd;
3389
3390 if (!f->dsp->ipred.intra_pred[DC_PRED]) {
3
←
Assuming the condition is false
→
4
←
Taking false branch
→
3391 Dav1dDSPContext *const dsp = &c->dsp[f->seq_hdr->hbd];
3392
3393 switch (bpc) {
3394#define assign_bitdepth_case(bd) \
3395 dav1d_cdef_dsp_init_##bd##bpc(&dsp->cdef); \
3396 dav1d_intra_pred_dsp_init_##bd##bpc(&dsp->ipred); \
3397 dav1d_itx_dsp_init_##bd##bpc(&dsp->itx, bpc); \
3398 dav1d_loop_filter_dsp_init_##bd##bpc(&dsp->lf); \
3399 dav1d_loop_restoration_dsp_init_##bd##bpc(&dsp->lr, bpc); \
3400 dav1d_mc_dsp_init_##bd##bpc(&dsp->mc); \
3401 dav1d_film_grain_dsp_init_##bd##bpc(&dsp->fg); \
3402 break
3403#if CONFIG_8BPC1
3404 case 8:
3405 assign_bitdepth_case(8);
3406#endif
3407#if CONFIG_16BPC1
3408 case 10:
3409 case 12:
3410 assign_bitdepth_case(16);
3411#endif
3412#undef assign_bitdepth_case
3413 default:
3414 dav1d_log(c, "Compiled without support for %d-bit decoding\n",do { } while(0)
3415 8 + 2 * f->seq_hdr->hbd)do { } while(0);
3416 res = DAV1D_ERR(ENOPROTOOPT)(-(92));
3417 goto error;
3418 }
3419 }
3420
3421#define assign_bitdepth_case(bd) \
3422 f->bd_fn.recon_b_inter = dav1d_recon_b_inter_##bd##bpc; \
3423 f->bd_fn.recon_b_intra = dav1d_recon_b_intra_##bd##bpc; \
3424 f->bd_fn.filter_sbrow = dav1d_filter_sbrow_##bd##bpc; \
3425 f->bd_fn.filter_sbrow_deblock_cols = dav1d_filter_sbrow_deblock_cols_##bd##bpc; \
3426 f->bd_fn.filter_sbrow_deblock_rows = dav1d_filter_sbrow_deblock_rows_##bd##bpc; \
3427 f->bd_fn.filter_sbrow_cdef = dav1d_filter_sbrow_cdef_##bd##bpc; \
3428 f->bd_fn.filter_sbrow_resize = dav1d_filter_sbrow_resize_##bd##bpc; \
3429 f->bd_fn.filter_sbrow_lr = dav1d_filter_sbrow_lr_##bd##bpc; \
3430 f->bd_fn.backup_ipred_edge = dav1d_backup_ipred_edge_##bd##bpc; \
3431 f->bd_fn.read_coef_blocks = dav1d_read_coef_blocks_##bd##bpc; \
3432 f->bd_fn.copy_pal_block_y = dav1d_copy_pal_block_y_##bd##bpc; \
3433 f->bd_fn.copy_pal_block_uv = dav1d_copy_pal_block_uv_##bd##bpc; \
3434 f->bd_fn.read_pal_plane = dav1d_read_pal_plane_##bd##bpc; \
3435 f->bd_fn.read_pal_uv = dav1d_read_pal_uv_##bd##bpc
3436 if (!f->seq_hdr->hbd) {
5
←
Assuming field 'hbd' is not equal to 0
→
6
←
Taking false branch
→
3437#if CONFIG_8BPC1
3438 assign_bitdepth_case(8);
3439#endif
3440 } else {
3441#if CONFIG_16BPC1
3442 assign_bitdepth_case(16);
3443#endif
3444 }
3445#undef assign_bitdepth_case
3446
3447 int ref_coded_width[7];
3448 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1)) {
7
←
Assuming the condition is false
→
8
←
Taking false branch
→
3449 if (f->frame_hdr->primary_ref_frame != DAV1D_PRIMARY_REF_NONE7) {
3450 const int pri_ref = f->frame_hdr->refidx[f->frame_hdr->primary_ref_frame];
3451 if (!c->refs[pri_ref].p.p.data[0]) {
3452 res = DAV1D_ERR(EINVAL)(-(22));
3453 goto error;
3454 }
3455 }
3456 for (int i = 0; i < 7; i++) {
3457 const int refidx = f->frame_hdr->refidx[i];
3458 if (!c->refs[refidx].p.p.data[0] ||
3459 f->frame_hdr->width[0] * 2 < c->refs[refidx].p.p.p.w ||
3460 f->frame_hdr->height * 2 < c->refs[refidx].p.p.p.h ||
3461 f->frame_hdr->width[0] > c->refs[refidx].p.p.p.w * 16 ||
3462 f->frame_hdr->height > c->refs[refidx].p.p.p.h * 16 ||
3463 f->seq_hdr->layout != c->refs[refidx].p.p.p.layout ||
3464 bpc != c->refs[refidx].p.p.p.bpc)
3465 {
3466 for (int j = 0; j < i; j++)
3467 dav1d_thread_picture_unref(&f->refp[j]);
3468 res = DAV1D_ERR(EINVAL)(-(22));
3469 goto error;
3470 }
3471 dav1d_thread_picture_ref(&f->refp[i], &c->refs[refidx].p);
3472 ref_coded_width[i] = c->refs[refidx].p.p.frame_hdr->width[0];
3473 if (f->frame_hdr->width[0] != c->refs[refidx].p.p.p.w ||
3474 f->frame_hdr->height != c->refs[refidx].p.p.p.h)
3475 {
3476#define scale_fac(ref_sz, this_sz) \
3477 ((((ref_sz) << 14) + ((this_sz) >> 1)) / (this_sz))
3478 f->svc[i][0].scale = scale_fac(c->refs[refidx].p.p.p.w,
3479 f->frame_hdr->width[0]);
3480 f->svc[i][1].scale = scale_fac(c->refs[refidx].p.p.p.h,
3481 f->frame_hdr->height);
3482 f->svc[i][0].step = (f->svc[i][0].scale + 8) >> 4;
3483 f->svc[i][1].step = (f->svc[i][1].scale + 8) >> 4;
3484 } else {
3485 f->svc[i][0].scale = f->svc[i][1].scale = 0;
3486 }
3487 f->gmv_warp_allowed[i] = f->frame_hdr->gmv[i].type > DAV1D_WM_TYPE_TRANSLATION &&
3488 !f->frame_hdr->force_integer_mv &&
3489 !dav1d_get_shear_params(&f->frame_hdr->gmv[i]) &&
3490 !f->svc[i][0].scale;
3491 }
3492 }
3493
3494 // setup entropy
3495 if (f->frame_hdr->primary_ref_frame == DAV1D_PRIMARY_REF_NONE7) {
9
←
Assuming field 'primary_ref_frame' is equal to DAV1D_PRIMARY_REF_NONE
→
10
←
Taking true branch
→
3496 dav1d_cdf_thread_init_static(&f->in_cdf, f->frame_hdr->quant.yac);
3497 } else {
3498 const int pri_ref = f->frame_hdr->refidx[f->frame_hdr->primary_ref_frame];
3499 dav1d_cdf_thread_ref(&f->in_cdf, &c->cdf[pri_ref]);
3500 }
3501 if (f->frame_hdr->refresh_context) {
11
←
Assuming field 'refresh_context' is 0
→
12
←
Taking false branch
→
3502 res = dav1d_cdf_thread_alloc(c, &f->out_cdf, c->n_fc > 1);
3503 if (res < 0) goto error;
3504 }
3505
3506 // FIXME qsort so tiles are in order (for frame threading)
3507 if (f->n_tile_data_alloc < c->n_tile_data) {
13
←
Assuming field 'n_tile_data_alloc' is >= field 'n_tile_data'
→
14
←
Taking false branch
→
3508 dav1d_free(f->tile)free(f->tile);
3509 assert(c->n_tile_data < INT_MAX / (int)sizeof(*f->tile))((void) sizeof ((c->n_tile_data < 2147483647 / (int)sizeof
(*f->tile)) ? 1 : 0), __extension__ ({ if (c->n_tile_data
< 2147483647 / (int)sizeof(*f->tile)) ; else __assert_fail
("c->n_tile_data < INT_MAX / (int)sizeof(*f->tile)"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 3509,
__extension__ __PRETTY_FUNCTION__); }));
3510 f->tile = dav1d_malloc(ALLOC_TILE, c->n_tile_data * sizeof(*f->tile))malloc(c->n_tile_data * sizeof(*f->tile));
3511 if (!f->tile) {
3512 f->n_tile_data_alloc = f->n_tile_data = 0;
3513 res = DAV1D_ERR(ENOMEM)(-(12));
3514 goto error;
3515 }
3516 f->n_tile_data_alloc = c->n_tile_data;
3517 }
3518 memcpy(f->tile, c->tile, c->n_tile_data * sizeof(*f->tile));
3519 memset(c->tile, 0, c->n_tile_data * sizeof(*c->tile));
3520 f->n_tile_data = c->n_tile_data;
3521 c->n_tile_data = 0;
3522
3523 // allocate frame
3524 res = dav1d_thread_picture_alloc(c, f, bpc);
3525 if (res < 0) goto error;
15
←
Assuming 'res' is >= 0
→
16
←
Taking false branch
→
3526
3527 if (f->frame_hdr->width[0] != f->frame_hdr->width[1]) {
17
←
Assuming the condition is false
→
18
←
Taking false branch
→
3528 res = dav1d_picture_alloc_copy(c, &f->cur, f->frame_hdr->width[0], &f->sr_cur.p);
3529 if (res < 0) goto error;
3530 } else {
3531 dav1d_picture_ref(&f->cur, &f->sr_cur.p);
3532 }
3533
3534 if (f->frame_hdr->width[0] != f->frame_hdr->width[1]) {
19
←
Taking false branch
→
3535 f->resize_step[0] = scale_fac(f->cur.p.w, f->sr_cur.p.p.w);
3536 const int ss_hor = f->cur.p.layout != DAV1D_PIXEL_LAYOUT_I444;
3537 const int in_cw = (f->cur.p.w + ss_hor) >> ss_hor;
3538 const int out_cw = (f->sr_cur.p.p.w + ss_hor) >> ss_hor;
3539 f->resize_step[1] = scale_fac(in_cw, out_cw);
3540#undef scale_fac
3541 f->resize_start[0] = get_upscale_x0(f->cur.p.w, f->sr_cur.p.p.w, f->resize_step[0]);
3542 f->resize_start[1] = get_upscale_x0(in_cw, out_cw, f->resize_step[1]);
3543 }
3544
3545 // move f->cur into output queue
3546 if (c->n_fc == 1) {
20
←
Assuming field 'n_fc' is equal to 1
→
3547 if (f->frame_hdr->show_frame || c->output_invisible_frames) {
21
←
Assuming field 'show_frame' is 0
→
22
←
Assuming field 'output_invisible_frames' is 0
→
23
←
Taking false branch
→
3548 dav1d_thread_picture_ref(&c->out, &f->sr_cur);
3549 c->event_flags |= dav1d_picture_get_event_flags(&f->sr_cur);
3550 }
3551 } else {
3552 dav1d_thread_picture_ref(out_delayed, &f->sr_cur);
3553 }
3554
3555 f->w4 = (f->frame_hdr->width[0] + 3) >> 2;
3556 f->h4 = (f->frame_hdr->height + 3) >> 2;
3557 f->bw = ((f->frame_hdr->width[0] + 7) >> 3) << 1;
3558 f->bh = ((f->frame_hdr->height + 7) >> 3) << 1;
3559 f->sb128w = (f->bw + 31) >> 5;
3560 f->sb128h = (f->bh + 31) >> 5;
3561 f->sb_shift = 4 + f->seq_hdr->sb128;
3562 f->sb_step = 16 << f->seq_hdr->sb128;
24
←
Assuming right operand of bit shift is less than 32
→
3563 f->sbh = (f->bh + f->sb_step - 1) >> f->sb_shift;
25
←
Assuming right operand of bit shift is less than 32
→
3564 f->b4_stride = (f->bw + 31) & ~31;
3565 f->bitdepth_max = (1 << f->cur.p.bpc) - 1;
26
←
Assuming right operand of bit shift is non-negative but less than 32
→
3566 atomic_init__c11_atomic_init(&f->task_thread.error, 0);
3567 const int uses_2pass = c->n_fc > 1;
3568 const int cols = f->frame_hdr->tiling.cols;
3569 const int rows = f->frame_hdr->tiling.rows;
3570 atomic_store(&f->task_thread.task_counter,__c11_atomic_store(&f->task_thread.task_counter, (cols
* rows + f->sbh) << uses_2pass, 5)
3571 (cols * rows + f->sbh) << uses_2pass)__c11_atomic_store(&f->task_thread.task_counter, (cols
* rows + f->sbh) << uses_2pass, 5);
3572
3573 // ref_mvs
3574 if (IS_INTER_OR_SWITCH(f->frame_hdr)((f->frame_hdr)->frame_type & 1) || f->frame_hdr->allow_intrabc) {
27
←
Assuming the condition is true
→
3575 f->mvs_ref = dav1d_ref_create_using_pool(c->refmvs_pool,
3576 sizeof(*f->mvs) * f->sb128h * 16 * (f->b4_stride >> 1));
3577 if (!f->mvs_ref) {
28
←
Assuming field 'mvs_ref' is non-null
→
29
←
Taking false branch
→
3578 res = DAV1D_ERR(ENOMEM)(-(12));
3579 goto error;
3580 }
3581 f->mvs = f->mvs_ref->data;
3582 if (!f->frame_hdr->allow_intrabc) {
30
←
Assuming field 'allow_intrabc' is not equal to 0
→
31
←
Taking false branch
→
3583 for (int i = 0; i < 7; i++)
3584 f->refpoc[i] = f->refp[i].p.frame_hdr->frame_offset;
3585 } else {
3586 memset(f->refpoc, 0, sizeof(f->refpoc));
3587 }
3588 if (f->frame_hdr->use_ref_frame_mvs) {
32
←
Assuming field 'use_ref_frame_mvs' is not equal to 0
→
33
←
Taking true branch
→
3589 for (int i = 0; i < 7; i++) {
34
←
'i' initialized to 0
→
35
←
Loop condition is true. Entering loop body
→
3590 const int refidx = f->frame_hdr->refidx[i];
3591 const int ref_w = ((ref_coded_width[i] + 7) >> 3) << 1;
36
←
The left operand of '+' is a garbage value
3592 const int ref_h = ((f->refp[i].p.p.h + 7) >> 3) << 1;
3593 if (c->refs[refidx].refmvs != NULL((void*)0) &&
3594 ref_w == f->bw && ref_h == f->bh)
3595 {
3596 f->ref_mvs_ref[i] = c->refs[refidx].refmvs;
3597 dav1d_ref_inc(f->ref_mvs_ref[i]);
3598 f->ref_mvs[i] = c->refs[refidx].refmvs->data;
3599 } else {
3600 f->ref_mvs[i] = NULL((void*)0);
3601 f->ref_mvs_ref[i] = NULL((void*)0);
3602 }
3603 memcpy(f->refrefpoc[i], c->refs[refidx].refpoc,
3604 sizeof(*f->refrefpoc));
3605 }
3606 } else {
3607 memset(f->ref_mvs_ref, 0, sizeof(f->ref_mvs_ref));
3608 }
3609 } else {
3610 f->mvs_ref = NULL((void*)0);
3611 memset(f->ref_mvs_ref, 0, sizeof(f->ref_mvs_ref));
3612 }
3613
3614 // segmap
3615 if (f->frame_hdr->segmentation.enabled) {
3616 // By default, the previous segmentation map is not initialised.
3617 f->prev_segmap_ref = NULL((void*)0);
3618 f->prev_segmap = NULL((void*)0);
3619
3620 // We might need a previous frame's segmentation map. This
3621 // happens if there is either no update or a temporal update.
3622 if (f->frame_hdr->segmentation.temporal || !f->frame_hdr->segmentation.update_map) {
3623 const int pri_ref = f->frame_hdr->primary_ref_frame;
3624 assert(pri_ref != DAV1D_PRIMARY_REF_NONE)((void) sizeof ((pri_ref != 7) ? 1 : 0), __extension__ ({ if (
pri_ref != 7) ; else __assert_fail ("pri_ref != DAV1D_PRIMARY_REF_NONE"
, "/root/firefox-clang/third_party/dav1d/src/decode.c", 3624,
__extension__ __PRETTY_FUNCTION__); }));
3625 const int ref_w = ((ref_coded_width[pri_ref] + 7) >> 3) << 1;
3626 const int ref_h = ((f->refp[pri_ref].p.p.h + 7) >> 3) << 1;
3627 if (ref_w == f->bw && ref_h == f->bh) {
3628 f->prev_segmap_ref = c->refs[f->frame_hdr->refidx[pri_ref]].segmap;
3629 if (f->prev_segmap_ref) {
3630 dav1d_ref_inc(f->prev_segmap_ref);
3631 f->prev_segmap = f->prev_segmap_ref->data;
3632 }
3633 }
3634 }
3635
3636 if (f->frame_hdr->segmentation.update_map) {
3637 // We're updating an existing map, but need somewhere to
3638 // put the new values. Allocate them here (the data
3639 // actually gets set elsewhere)
3640 f->cur_segmap_ref = dav1d_ref_create_using_pool(c->segmap_pool,
3641 sizeof(*f->cur_segmap) * f->b4_stride * 32 * f->sb128h);
3642 if (!f->cur_segmap_ref) {
3643 dav1d_ref_dec(&f->prev_segmap_ref);
3644 res = DAV1D_ERR(ENOMEM)(-(12));
3645 goto error;
3646 }
3647 f->cur_segmap = f->cur_segmap_ref->data;
3648 } else if (f->prev_segmap_ref) {
3649 // We're not updating an existing map, and we have a valid
3650 // reference. Use that.
3651 f->cur_segmap_ref = f->prev_segmap_ref;
3652 dav1d_ref_inc(f->cur_segmap_ref);
3653 f->cur_segmap = f->prev_segmap_ref->data;
3654 } else {
3655 // We need to make a new map. Allocate one here and zero it out.
3656 const size_t segmap_size = sizeof(*f->cur_segmap) * f->b4_stride * 32 * f->sb128h;
3657 f->cur_segmap_ref = dav1d_ref_create_using_pool(c->segmap_pool, segmap_size);
3658 if (!f->cur_segmap_ref) {
3659 res = DAV1D_ERR(ENOMEM)(-(12));
3660 goto error;
3661 }
3662 f->cur_segmap = f->cur_segmap_ref->data;
3663 memset(f->cur_segmap, 0, segmap_size);
3664 }
3665 } else {
3666 f->cur_segmap = NULL((void*)0);
3667 f->cur_segmap_ref = NULL((void*)0);
3668 f->prev_segmap_ref = NULL((void*)0);
3669 }
3670
3671 // update references etc.
3672 const unsigned refresh_frame_flags = f->frame_hdr->refresh_frame_flags;
3673 for (int i = 0; i < 8; i++) {
3674 if (refresh_frame_flags & (1 << i)) {
3675 if (c->refs[i].p.p.frame_hdr)
3676 dav1d_thread_picture_unref(&c->refs[i].p);
3677 dav1d_thread_picture_ref(&c->refs[i].p, &f->sr_cur);
3678
3679 dav1d_cdf_thread_unref(&c->cdf[i]);
3680 if (f->frame_hdr->refresh_context) {
3681 dav1d_cdf_thread_ref(&c->cdf[i], &f->out_cdf);
3682 } else {
3683 dav1d_cdf_thread_ref(&c->cdf[i], &f->in_cdf);
3684 }
3685
3686 dav1d_ref_dec(&c->refs[i].segmap);
3687 c->refs[i].segmap = f->cur_segmap_ref;
3688 if (f->cur_segmap_ref)
3689 dav1d_ref_inc(f->cur_segmap_ref);
3690 dav1d_ref_dec(&c->refs[i].refmvs);
3691 if (!f->frame_hdr->allow_intrabc) {
3692 c->refs[i].refmvs = f->mvs_ref;
3693 if (f->mvs_ref)
3694 dav1d_ref_inc(f->mvs_ref);
3695 }
3696 memcpy(c->refs[i].refpoc, f->refpoc, sizeof(f->refpoc));
3697 }
3698 }
3699
3700 if (c->n_fc == 1) {
3701 if ((res = dav1d_decode_frame(f)) < 0) {
3702 dav1d_thread_picture_unref(&c->out);
3703 for (int i = 0; i < 8; i++) {
3704 if (refresh_frame_flags & (1 << i)) {
3705 if (c->refs[i].p.p.frame_hdr)
3706 dav1d_thread_picture_unref(&c->refs[i].p);
3707 dav1d_cdf_thread_unref(&c->cdf[i]);
3708 dav1d_ref_dec(&c->refs[i].segmap);
3709 dav1d_ref_dec(&c->refs[i].refmvs);
3710 }
3711 }
3712 goto error;
3713 }
3714 } else {
3715 dav1d_task_frame_init(f);
3716 pthread_mutex_unlock(&c->task_thread.lock);
3717 }
3718
3719 return 0;
3720error:
3721 atomic_init__c11_atomic_init(&f->task_thread.error, 1);
3722 dav1d_cdf_thread_unref(&f->in_cdf);
3723 if (f->frame_hdr->refresh_context)
3724 dav1d_cdf_thread_unref(&f->out_cdf);
3725 for (int i = 0; i < 7; i++) {
3726 if (f->refp[i].p.frame_hdr)
3727 dav1d_thread_picture_unref(&f->refp[i]);
3728 dav1d_ref_dec(&f->ref_mvs_ref[i]);
3729 }
3730 if (c->n_fc == 1)
3731 dav1d_thread_picture_unref(&c->out);
3732 else
3733 dav1d_thread_picture_unref(out_delayed);
3734 dav1d_picture_unref_internal(&f->cur);
3735 dav1d_thread_picture_unref(&f->sr_cur);
3736 dav1d_ref_dec(&f->mvs_ref);
3737 dav1d_ref_dec(&f->seq_hdr_ref);
3738 dav1d_ref_dec(&f->frame_hdr_ref);
3739 dav1d_data_props_copy(&c->cached_error_props, &c->in.m);
3740
3741 for (int i = 0; i < f->n_tile_data; i++)
3742 dav1d_data_unref_internal(&f->tile[i].data);
3743 f->n_tile_data = 0;
3744
3745 if (c->n_fc > 1)
3746 pthread_mutex_unlock(&c->task_thread.lock);
3747
3748 return res;
3749}