Line | Count | Source |
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.h> |
31 | | #include <limits.h> |
32 | | #include <stdio.h> |
33 | | |
34 | | #include "dav1d/data.h" |
35 | | |
36 | | #include "common/frame.h" |
37 | | #include "common/intops.h" |
38 | | #include "common/validate.h" |
39 | | |
40 | | #include "src/decode.h" |
41 | | #include "src/getbits.h" |
42 | | #include "src/levels.h" |
43 | | #include "src/log.h" |
44 | | #include "src/obu.h" |
45 | | #include "src/ref.h" |
46 | | #include "src/thread_task.h" |
47 | | |
48 | | static int check_trailing_bits(GetBits *const gb, |
49 | | const int strict_std_compliance) |
50 | 101k | { |
51 | 101k | const int trailing_one_bit = dav1d_get_bit(gb); |
52 | | |
53 | 101k | if (gb->error) |
54 | 776 | return DAV1D_ERR(EINVAL); |
55 | | |
56 | 100k | if (!strict_std_compliance) |
57 | 100k | return 0; |
58 | | |
59 | 0 | if (!trailing_one_bit || gb->state) |
60 | 0 | return DAV1D_ERR(EINVAL); |
61 | | |
62 | 0 | ptrdiff_t size = gb->ptr_end - gb->ptr; |
63 | 0 | while (size > 0 && gb->ptr[size - 1] == 0) |
64 | 0 | size--; |
65 | |
|
66 | 0 | if (size) |
67 | 0 | return DAV1D_ERR(EINVAL); |
68 | | |
69 | 0 | return 0; |
70 | 0 | } |
71 | | |
72 | | static NOINLINE int parse_seq_hdr(Dav1dSequenceHeader *const hdr, |
73 | | GetBits *const gb, |
74 | | const int strict_std_compliance) |
75 | 85.2k | { |
76 | 85.2k | #define DEBUG_SEQ_HDR 0 |
77 | | |
78 | | #if DEBUG_SEQ_HDR |
79 | | const unsigned init_bit_pos = dav1d_get_bits_pos(gb); |
80 | | #endif |
81 | | |
82 | 85.2k | memset(hdr, 0, sizeof(*hdr)); |
83 | 85.2k | hdr->profile = dav1d_get_bits(gb, 3); |
84 | 85.2k | if (hdr->profile > 2) goto error; |
85 | | #if DEBUG_SEQ_HDR |
86 | | printf("SEQHDR: post-profile: off=%u\n", |
87 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
88 | | #endif |
89 | | |
90 | 84.9k | hdr->still_picture = dav1d_get_bit(gb); |
91 | 84.9k | hdr->reduced_still_picture_header = dav1d_get_bit(gb); |
92 | 84.9k | if (hdr->reduced_still_picture_header && !hdr->still_picture) goto error; |
93 | | #if DEBUG_SEQ_HDR |
94 | | printf("SEQHDR: post-stillpicture_flags: off=%u\n", |
95 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
96 | | #endif |
97 | | |
98 | 84.5k | if (hdr->reduced_still_picture_header) { |
99 | 53.7k | hdr->num_operating_points = 1; |
100 | 53.7k | hdr->operating_points[0].major_level = dav1d_get_bits(gb, 3); |
101 | 53.7k | hdr->operating_points[0].minor_level = dav1d_get_bits(gb, 2); |
102 | 53.7k | hdr->operating_points[0].initial_display_delay = 10; |
103 | 53.7k | } else { |
104 | 30.7k | hdr->timing_info_present = dav1d_get_bit(gb); |
105 | 30.7k | if (hdr->timing_info_present) { |
106 | 8.45k | hdr->num_units_in_tick = dav1d_get_bits(gb, 32); |
107 | 8.45k | hdr->time_scale = dav1d_get_bits(gb, 32); |
108 | 8.45k | if (strict_std_compliance && (!hdr->num_units_in_tick || !hdr->time_scale)) |
109 | 0 | goto error; |
110 | 8.45k | hdr->equal_picture_interval = dav1d_get_bit(gb); |
111 | 8.45k | if (hdr->equal_picture_interval) { |
112 | 2.55k | const unsigned num_ticks_per_picture = dav1d_get_vlc(gb); |
113 | 2.55k | if (num_ticks_per_picture == UINT32_MAX) |
114 | 22 | goto error; |
115 | 2.53k | hdr->num_ticks_per_picture = num_ticks_per_picture + 1; |
116 | 2.53k | } |
117 | | |
118 | 8.43k | hdr->decoder_model_info_present = dav1d_get_bit(gb); |
119 | 8.43k | if (hdr->decoder_model_info_present) { |
120 | 6.05k | hdr->encoder_decoder_buffer_delay_length = dav1d_get_bits(gb, 5) + 1; |
121 | 6.05k | hdr->num_units_in_decoding_tick = dav1d_get_bits(gb, 32); |
122 | 6.05k | if (strict_std_compliance && !hdr->num_units_in_decoding_tick) |
123 | 0 | goto error; |
124 | 6.05k | hdr->buffer_removal_delay_length = dav1d_get_bits(gb, 5) + 1; |
125 | 6.05k | hdr->frame_presentation_delay_length = dav1d_get_bits(gb, 5) + 1; |
126 | 6.05k | } |
127 | 8.43k | } |
128 | | #if DEBUG_SEQ_HDR |
129 | | printf("SEQHDR: post-timinginfo: off=%u\n", |
130 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
131 | | #endif |
132 | | |
133 | 30.7k | hdr->display_model_info_present = dav1d_get_bit(gb); |
134 | 30.7k | hdr->num_operating_points = dav1d_get_bits(gb, 5) + 1; |
135 | 151k | for (int i = 0; i < hdr->num_operating_points; i++) { |
136 | 120k | struct Dav1dSequenceHeaderOperatingPoint *const op = |
137 | 120k | &hdr->operating_points[i]; |
138 | 120k | op->idc = dav1d_get_bits(gb, 12); |
139 | 120k | if (op->idc && (!(op->idc & 0xff) || !(op->idc & 0xf00))) |
140 | 273 | goto error; |
141 | 120k | op->major_level = 2 + dav1d_get_bits(gb, 3); |
142 | 120k | op->minor_level = dav1d_get_bits(gb, 2); |
143 | 120k | if (op->major_level > 3) |
144 | 68.6k | op->tier = dav1d_get_bit(gb); |
145 | 120k | if (hdr->decoder_model_info_present) { |
146 | 20.0k | op->decoder_model_param_present = dav1d_get_bit(gb); |
147 | 20.0k | if (op->decoder_model_param_present) { |
148 | 3.34k | struct Dav1dSequenceHeaderOperatingParameterInfo *const opi = |
149 | 3.34k | &hdr->operating_parameter_info[i]; |
150 | 3.34k | opi->decoder_buffer_delay = |
151 | 3.34k | dav1d_get_bits(gb, hdr->encoder_decoder_buffer_delay_length); |
152 | 3.34k | opi->encoder_buffer_delay = |
153 | 3.34k | dav1d_get_bits(gb, hdr->encoder_decoder_buffer_delay_length); |
154 | 3.34k | opi->low_delay_mode = dav1d_get_bit(gb); |
155 | 3.34k | } |
156 | 20.0k | } |
157 | 120k | if (hdr->display_model_info_present) |
158 | 83.8k | op->display_model_param_present = dav1d_get_bit(gb); |
159 | 120k | op->initial_display_delay = |
160 | 120k | op->display_model_param_present ? dav1d_get_bits(gb, 4) + 1 : 10; |
161 | 120k | } |
162 | | #if DEBUG_SEQ_HDR |
163 | | printf("SEQHDR: post-operating-points: off=%u\n", |
164 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
165 | | #endif |
166 | 30.7k | } |
167 | | |
168 | 84.2k | hdr->width_n_bits = dav1d_get_bits(gb, 4) + 1; |
169 | 84.2k | hdr->height_n_bits = dav1d_get_bits(gb, 4) + 1; |
170 | 84.2k | hdr->max_width = dav1d_get_bits(gb, hdr->width_n_bits) + 1; |
171 | 84.2k | hdr->max_height = dav1d_get_bits(gb, hdr->height_n_bits) + 1; |
172 | | #if DEBUG_SEQ_HDR |
173 | | printf("SEQHDR: post-size: off=%u\n", |
174 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
175 | | #endif |
176 | 84.2k | if (!hdr->reduced_still_picture_header) { |
177 | 30.4k | hdr->frame_id_numbers_present = dav1d_get_bit(gb); |
178 | 30.4k | if (hdr->frame_id_numbers_present) { |
179 | 1.05k | hdr->delta_frame_id_n_bits = dav1d_get_bits(gb, 4) + 2; |
180 | 1.05k | hdr->frame_id_n_bits = dav1d_get_bits(gb, 3) + hdr->delta_frame_id_n_bits + 1; |
181 | 1.05k | } |
182 | 30.4k | } |
183 | | #if DEBUG_SEQ_HDR |
184 | | printf("SEQHDR: post-frame-id-numbers-present: off=%u\n", |
185 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
186 | | #endif |
187 | | |
188 | 84.2k | hdr->sb128 = dav1d_get_bit(gb); |
189 | 84.2k | hdr->filter_intra = dav1d_get_bit(gb); |
190 | 84.2k | hdr->intra_edge_filter = dav1d_get_bit(gb); |
191 | 84.2k | if (hdr->reduced_still_picture_header) { |
192 | 53.7k | hdr->screen_content_tools = DAV1D_ADAPTIVE; |
193 | 53.7k | hdr->force_integer_mv = DAV1D_ADAPTIVE; |
194 | 53.7k | } else { |
195 | 30.4k | hdr->inter_intra = dav1d_get_bit(gb); |
196 | 30.4k | hdr->masked_compound = dav1d_get_bit(gb); |
197 | 30.4k | hdr->warped_motion = dav1d_get_bit(gb); |
198 | 30.4k | hdr->dual_filter = dav1d_get_bit(gb); |
199 | 30.4k | hdr->order_hint = dav1d_get_bit(gb); |
200 | 30.4k | if (hdr->order_hint) { |
201 | 13.8k | hdr->jnt_comp = dav1d_get_bit(gb); |
202 | 13.8k | hdr->ref_frame_mvs = dav1d_get_bit(gb); |
203 | 13.8k | } |
204 | 30.4k | hdr->screen_content_tools = dav1d_get_bit(gb) ? DAV1D_ADAPTIVE : dav1d_get_bit(gb); |
205 | | #if DEBUG_SEQ_HDR |
206 | | printf("SEQHDR: post-screentools: off=%u\n", |
207 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
208 | | #endif |
209 | 30.4k | hdr->force_integer_mv = hdr->screen_content_tools ? |
210 | 18.6k | dav1d_get_bit(gb) ? DAV1D_ADAPTIVE : dav1d_get_bit(gb) : 2; |
211 | 30.4k | if (hdr->order_hint) |
212 | 13.8k | hdr->order_hint_n_bits = dav1d_get_bits(gb, 3) + 1; |
213 | 30.4k | } |
214 | 84.2k | hdr->super_res = dav1d_get_bit(gb); |
215 | 84.2k | hdr->cdef = dav1d_get_bit(gb); |
216 | 84.2k | hdr->restoration = dav1d_get_bit(gb); |
217 | | #if DEBUG_SEQ_HDR |
218 | | printf("SEQHDR: post-featurebits: off=%u\n", |
219 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
220 | | #endif |
221 | | |
222 | 84.2k | hdr->hbd = dav1d_get_bit(gb); |
223 | 84.2k | if (hdr->profile == 2 && hdr->hbd) |
224 | 5.57k | hdr->hbd += dav1d_get_bit(gb); |
225 | 84.2k | if (hdr->profile != 1) |
226 | 52.7k | hdr->monochrome = dav1d_get_bit(gb); |
227 | 84.2k | hdr->color_description_present = dav1d_get_bit(gb); |
228 | 84.2k | if (hdr->color_description_present) { |
229 | 30.0k | hdr->pri = dav1d_get_bits(gb, 8); |
230 | 30.0k | hdr->trc = dav1d_get_bits(gb, 8); |
231 | 30.0k | hdr->mtrx = dav1d_get_bits(gb, 8); |
232 | 54.1k | } else { |
233 | 54.1k | hdr->pri = DAV1D_COLOR_PRI_UNKNOWN; |
234 | 54.1k | hdr->trc = DAV1D_TRC_UNKNOWN; |
235 | 54.1k | hdr->mtrx = DAV1D_MC_UNKNOWN; |
236 | 54.1k | } |
237 | 84.2k | if (hdr->monochrome) { |
238 | 16.2k | hdr->color_range = dav1d_get_bit(gb); |
239 | 16.2k | hdr->layout = DAV1D_PIXEL_LAYOUT_I400; |
240 | 16.2k | hdr->ss_hor = hdr->ss_ver = 1; |
241 | 16.2k | hdr->chr = DAV1D_CHR_UNKNOWN; |
242 | 67.9k | } else if (hdr->pri == DAV1D_COLOR_PRI_BT709 && |
243 | 2.80k | hdr->trc == DAV1D_TRC_SRGB && |
244 | 2.33k | hdr->mtrx == DAV1D_MC_IDENTITY) |
245 | 47 | { |
246 | 47 | hdr->layout = DAV1D_PIXEL_LAYOUT_I444; |
247 | 47 | hdr->color_range = 1; |
248 | 47 | if (hdr->profile != 1 && !(hdr->profile == 2 && hdr->hbd == 2)) |
249 | 22 | goto error; |
250 | 67.8k | } else { |
251 | 67.8k | hdr->color_range = dav1d_get_bit(gb); |
252 | 67.8k | switch (hdr->profile) { |
253 | 31.5k | case 0: hdr->layout = DAV1D_PIXEL_LAYOUT_I420; |
254 | 31.5k | hdr->ss_hor = hdr->ss_ver = 1; |
255 | 31.5k | break; |
256 | 31.4k | case 1: hdr->layout = DAV1D_PIXEL_LAYOUT_I444; |
257 | 31.4k | break; |
258 | 4.86k | case 2: |
259 | 4.86k | if (hdr->hbd == 2) { |
260 | 2.60k | hdr->ss_hor = dav1d_get_bit(gb); |
261 | 2.60k | if (hdr->ss_hor) |
262 | 1.51k | hdr->ss_ver = dav1d_get_bit(gb); |
263 | 2.60k | } else |
264 | 2.25k | hdr->ss_hor = 1; |
265 | 4.86k | hdr->layout = hdr->ss_hor ? |
266 | 3.77k | hdr->ss_ver ? DAV1D_PIXEL_LAYOUT_I420 : |
267 | 3.77k | DAV1D_PIXEL_LAYOUT_I422 : |
268 | 4.86k | DAV1D_PIXEL_LAYOUT_I444; |
269 | 4.86k | break; |
270 | 67.8k | } |
271 | 67.8k | hdr->chr = (hdr->ss_hor & hdr->ss_ver) ? |
272 | 34.9k | dav1d_get_bits(gb, 2) : DAV1D_CHR_UNKNOWN; |
273 | 67.8k | } |
274 | 84.2k | if (strict_std_compliance && |
275 | 0 | hdr->mtrx == DAV1D_MC_IDENTITY && hdr->layout != DAV1D_PIXEL_LAYOUT_I444) |
276 | 0 | { |
277 | 0 | goto error; |
278 | 0 | } |
279 | 84.2k | if (!hdr->monochrome) |
280 | 67.9k | hdr->separate_uv_delta_q = dav1d_get_bit(gb); |
281 | | #if DEBUG_SEQ_HDR |
282 | | printf("SEQHDR: post-colorinfo: off=%u\n", |
283 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
284 | | #endif |
285 | | |
286 | 84.2k | hdr->film_grain_present = dav1d_get_bit(gb); |
287 | | #if DEBUG_SEQ_HDR |
288 | | printf("SEQHDR: post-filmgrain: off=%u\n", |
289 | | dav1d_get_bits_pos(gb) - init_bit_pos); |
290 | | #endif |
291 | | |
292 | | // We needn't bother flushing the OBU here: we'll check we didn't |
293 | | // overrun in the caller and will then discard gb, so there's no |
294 | | // point in setting its position properly. |
295 | | |
296 | 84.2k | return check_trailing_bits(gb, strict_std_compliance); |
297 | | |
298 | 1.07k | error: |
299 | 1.07k | return DAV1D_ERR(EINVAL); |
300 | 84.2k | } |
301 | | |
302 | | int dav1d_parse_sequence_header(Dav1dSequenceHeader *const out, |
303 | | const uint8_t *const ptr, const size_t sz) |
304 | 0 | { |
305 | 0 | validate_input_or_ret(out != NULL, DAV1D_ERR(EINVAL)); |
306 | 0 | validate_input_or_ret(ptr != NULL, DAV1D_ERR(EINVAL)); |
307 | 0 | validate_input_or_ret(sz > 0 && sz <= SIZE_MAX / 2, DAV1D_ERR(EINVAL)); |
308 | |
|
309 | 0 | GetBits gb; |
310 | 0 | dav1d_init_get_bits(&gb, ptr, sz); |
311 | 0 | int res = DAV1D_ERR(ENOENT); |
312 | |
|
313 | 0 | do { |
314 | 0 | dav1d_get_bit(&gb); // obu_forbidden_bit |
315 | 0 | const enum Dav1dObuType type = dav1d_get_bits(&gb, 4); |
316 | 0 | const int has_extension = dav1d_get_bit(&gb); |
317 | 0 | const int has_length_field = dav1d_get_bit(&gb); |
318 | 0 | dav1d_get_bits(&gb, 1 + 8 * has_extension); // ignore |
319 | |
|
320 | 0 | const uint8_t *obu_end = gb.ptr_end; |
321 | 0 | if (has_length_field) { |
322 | 0 | const size_t len = dav1d_get_uleb128(&gb); |
323 | 0 | if (len > (size_t)(obu_end - gb.ptr)) return DAV1D_ERR(EINVAL); |
324 | 0 | obu_end = gb.ptr + len; |
325 | 0 | } |
326 | | |
327 | 0 | if (type == DAV1D_OBU_SEQ_HDR) { |
328 | 0 | if ((res = parse_seq_hdr(out, &gb, 0)) < 0) return res; |
329 | 0 | if (gb.ptr > obu_end) return DAV1D_ERR(EINVAL); |
330 | 0 | dav1d_bytealign_get_bits(&gb); |
331 | 0 | } |
332 | | |
333 | 0 | if (gb.error) return DAV1D_ERR(EINVAL); |
334 | 0 | assert(gb.state == 0 && gb.bits_left == 0); |
335 | 0 | gb.ptr = obu_end; |
336 | 0 | } while (gb.ptr < gb.ptr_end); |
337 | | |
338 | 0 | return res; |
339 | 0 | } |
340 | | |
341 | | static int read_frame_size(Dav1dContext *const c, GetBits *const gb, |
342 | | const int use_ref) |
343 | 269k | { |
344 | 269k | const Dav1dSequenceHeader *const seqhdr = c->seq_hdr; |
345 | 269k | Dav1dFrameHeader *const hdr = c->frame_hdr; |
346 | | |
347 | 269k | if (use_ref) { |
348 | 249k | for (int i = 0; i < 7; i++) { |
349 | 248k | if (dav1d_get_bit(gb)) { |
350 | 104k | const Dav1dThreadPicture *const ref = |
351 | 104k | &c->refs[c->frame_hdr->refidx[i]].p; |
352 | 104k | if (!ref->p.frame_hdr) return -1; |
353 | 104k | hdr->width[1] = ref->p.frame_hdr->width[1]; |
354 | 104k | hdr->height = ref->p.frame_hdr->height; |
355 | 104k | hdr->render_width = ref->p.frame_hdr->render_width; |
356 | 104k | hdr->render_height = ref->p.frame_hdr->render_height; |
357 | 104k | hdr->super_res.enabled = seqhdr->super_res && dav1d_get_bit(gb); |
358 | 104k | if (hdr->super_res.enabled) { |
359 | 58.9k | const int d = hdr->super_res.width_scale_denominator = |
360 | 58.9k | 9 + dav1d_get_bits(gb, 3); |
361 | 58.9k | hdr->width[0] = imax((hdr->width[1] * 8 + (d >> 1)) / d, |
362 | 58.9k | imin(16, hdr->width[1])); |
363 | 58.9k | } else { |
364 | 45.3k | hdr->super_res.width_scale_denominator = 8; |
365 | 45.3k | hdr->width[0] = hdr->width[1]; |
366 | 45.3k | } |
367 | 104k | return 0; |
368 | 104k | } |
369 | 248k | } |
370 | 105k | } |
371 | | |
372 | 165k | if (hdr->frame_size_override) { |
373 | 22.4k | hdr->width[1] = dav1d_get_bits(gb, seqhdr->width_n_bits) + 1; |
374 | 22.4k | hdr->height = dav1d_get_bits(gb, seqhdr->height_n_bits) + 1; |
375 | 143k | } else { |
376 | 143k | hdr->width[1] = seqhdr->max_width; |
377 | 143k | hdr->height = seqhdr->max_height; |
378 | 143k | } |
379 | 165k | hdr->super_res.enabled = seqhdr->super_res && dav1d_get_bit(gb); |
380 | 165k | if (hdr->super_res.enabled) { |
381 | 37.4k | const int d = hdr->super_res.width_scale_denominator = 9 + dav1d_get_bits(gb, 3); |
382 | 37.4k | hdr->width[0] = imax((hdr->width[1] * 8 + (d >> 1)) / d, imin(16, hdr->width[1])); |
383 | 128k | } else { |
384 | 128k | hdr->super_res.width_scale_denominator = 8; |
385 | 128k | hdr->width[0] = hdr->width[1]; |
386 | 128k | } |
387 | 165k | hdr->have_render_size = dav1d_get_bit(gb); |
388 | 165k | if (hdr->have_render_size) { |
389 | 51.5k | hdr->render_width = dav1d_get_bits(gb, 16) + 1; |
390 | 51.5k | hdr->render_height = dav1d_get_bits(gb, 16) + 1; |
391 | 114k | } else { |
392 | 114k | hdr->render_width = hdr->width[1]; |
393 | 114k | hdr->render_height = hdr->height; |
394 | 114k | } |
395 | 165k | return 0; |
396 | 269k | } |
397 | | |
398 | 1.40M | static inline int tile_log2(const int sz, const int tgt) { |
399 | 1.40M | int k; |
400 | 1.65M | for (k = 0; (sz << k) < tgt; k++) ; |
401 | 1.40M | return k; |
402 | 1.40M | } |
403 | | |
404 | | static const Dav1dLoopfilterModeRefDeltas default_mode_ref_deltas = { |
405 | | .mode_delta = { 0, 0 }, |
406 | | .ref_delta = { 1, 0, 0, 0, -1, 0, -1, -1 }, |
407 | | }; |
408 | | |
409 | 271k | static int parse_frame_hdr(Dav1dContext *const c, GetBits *const gb) { |
410 | 271k | #define DEBUG_FRAME_HDR 0 |
411 | | |
412 | | #if DEBUG_FRAME_HDR |
413 | | const uint8_t *const init_ptr = gb->ptr; |
414 | | #endif |
415 | 271k | const Dav1dSequenceHeader *const seqhdr = c->seq_hdr; |
416 | 271k | Dav1dFrameHeader *const hdr = c->frame_hdr; |
417 | | |
418 | 271k | if (!seqhdr->reduced_still_picture_header) |
419 | 212k | hdr->show_existing_frame = dav1d_get_bit(gb); |
420 | | #if DEBUG_FRAME_HDR |
421 | | printf("HDR: post-show_existing_frame: off=%td\n", |
422 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
423 | | #endif |
424 | 271k | if (hdr->show_existing_frame) { |
425 | 936 | hdr->existing_frame_idx = dav1d_get_bits(gb, 3); |
426 | 936 | if (seqhdr->decoder_model_info_present && !seqhdr->equal_picture_interval) |
427 | 108 | hdr->frame_presentation_delay = dav1d_get_bits(gb, seqhdr->frame_presentation_delay_length); |
428 | 936 | if (seqhdr->frame_id_numbers_present) { |
429 | 58 | hdr->frame_id = dav1d_get_bits(gb, seqhdr->frame_id_n_bits); |
430 | 58 | Dav1dFrameHeader *const ref_frame_hdr = c->refs[hdr->existing_frame_idx].p.p.frame_hdr; |
431 | 58 | if (!ref_frame_hdr || ref_frame_hdr->frame_id != hdr->frame_id) goto error; |
432 | 58 | } |
433 | 887 | return 0; |
434 | 936 | } |
435 | | |
436 | 270k | if (seqhdr->reduced_still_picture_header) { |
437 | 59.0k | hdr->frame_type = DAV1D_FRAME_TYPE_KEY; |
438 | 59.0k | hdr->show_frame = 1; |
439 | 211k | } else { |
440 | 211k | hdr->frame_type = dav1d_get_bits(gb, 2); |
441 | 211k | hdr->show_frame = dav1d_get_bit(gb); |
442 | 211k | } |
443 | 270k | if (hdr->show_frame) { |
444 | 253k | if (seqhdr->decoder_model_info_present && !seqhdr->equal_picture_interval) |
445 | 29.6k | hdr->frame_presentation_delay = dav1d_get_bits(gb, seqhdr->frame_presentation_delay_length); |
446 | 253k | hdr->showable_frame = hdr->frame_type != DAV1D_FRAME_TYPE_KEY; |
447 | 253k | } else |
448 | 16.3k | hdr->showable_frame = dav1d_get_bit(gb); |
449 | 270k | hdr->error_resilient_mode = |
450 | 270k | (hdr->frame_type == DAV1D_FRAME_TYPE_KEY && hdr->show_frame) || |
451 | 182k | hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH || |
452 | 178k | seqhdr->reduced_still_picture_header || dav1d_get_bit(gb); |
453 | | #if DEBUG_FRAME_HDR |
454 | | printf("HDR: post-frametype_bits: off=%td\n", |
455 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
456 | | #endif |
457 | 270k | hdr->disable_cdf_update = dav1d_get_bit(gb); |
458 | 270k | hdr->allow_screen_content_tools = seqhdr->screen_content_tools == DAV1D_ADAPTIVE ? |
459 | 158k | dav1d_get_bit(gb) : seqhdr->screen_content_tools; |
460 | 270k | if (hdr->allow_screen_content_tools) |
461 | 133k | hdr->force_integer_mv = seqhdr->force_integer_mv == DAV1D_ADAPTIVE ? |
462 | 71.0k | dav1d_get_bit(gb) : seqhdr->force_integer_mv; |
463 | | |
464 | 270k | if (IS_KEY_OR_INTRA(hdr)) |
465 | 96.5k | hdr->force_integer_mv = 1; |
466 | | |
467 | 270k | if (seqhdr->frame_id_numbers_present) |
468 | 2.52k | hdr->frame_id = dav1d_get_bits(gb, seqhdr->frame_id_n_bits); |
469 | | |
470 | 270k | if (!seqhdr->reduced_still_picture_header) |
471 | 211k | hdr->frame_size_override = hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ? 1 : dav1d_get_bit(gb); |
472 | | #if DEBUG_FRAME_HDR |
473 | | printf("HDR: post-frame_size_override_flag: off=%td\n", |
474 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
475 | | #endif |
476 | 270k | if (seqhdr->order_hint) |
477 | 109k | hdr->frame_offset = dav1d_get_bits(gb, seqhdr->order_hint_n_bits); |
478 | 270k | hdr->primary_ref_frame = !hdr->error_resilient_mode && IS_INTER_OR_SWITCH(hdr) ? |
479 | 164k | dav1d_get_bits(gb, 3) : DAV1D_PRIMARY_REF_NONE; |
480 | | |
481 | 270k | if (seqhdr->decoder_model_info_present) { |
482 | 39.1k | hdr->buffer_removal_time_present = dav1d_get_bit(gb); |
483 | 39.1k | if (hdr->buffer_removal_time_present) { |
484 | 194k | for (int i = 0; i < c->seq_hdr->num_operating_points; i++) { |
485 | 169k | const struct Dav1dSequenceHeaderOperatingPoint *const seqop = &seqhdr->operating_points[i]; |
486 | 169k | struct Dav1dFrameHeaderOperatingPoint *const op = &hdr->operating_points[i]; |
487 | 169k | if (seqop->decoder_model_param_present) { |
488 | 8.21k | int in_temporal_layer = (seqop->idc >> hdr->temporal_id) & 1; |
489 | 8.21k | int in_spatial_layer = (seqop->idc >> (hdr->spatial_id + 8)) & 1; |
490 | 8.21k | if (!seqop->idc || (in_temporal_layer && in_spatial_layer)) |
491 | 1.30k | op->buffer_removal_time = dav1d_get_bits(gb, seqhdr->buffer_removal_delay_length); |
492 | 8.21k | } |
493 | 169k | } |
494 | 24.8k | } |
495 | 39.1k | } |
496 | | |
497 | 270k | if (IS_KEY_OR_INTRA(hdr)) { |
498 | 96.5k | hdr->refresh_frame_flags = (hdr->frame_type == DAV1D_FRAME_TYPE_KEY && |
499 | 94.6k | hdr->show_frame) ? 0xff : dav1d_get_bits(gb, 8); |
500 | 96.5k | if (hdr->refresh_frame_flags != 0xff && hdr->error_resilient_mode && seqhdr->order_hint) |
501 | 3.28k | for (int i = 0; i < 8; i++) |
502 | 2.92k | dav1d_get_bits(gb, seqhdr->order_hint_n_bits); |
503 | 96.5k | if (c->strict_std_compliance && |
504 | 0 | hdr->frame_type == DAV1D_FRAME_TYPE_INTRA && hdr->refresh_frame_flags == 0xff) |
505 | 0 | { |
506 | 0 | goto error; |
507 | 0 | } |
508 | 96.5k | if (read_frame_size(c, gb, 0) < 0) goto error; |
509 | 96.5k | if (hdr->allow_screen_content_tools && !hdr->super_res.enabled) |
510 | 25.1k | hdr->allow_intrabc = dav1d_get_bit(gb); |
511 | 173k | } else { |
512 | 173k | hdr->refresh_frame_flags = hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ? 0xff : |
513 | 173k | dav1d_get_bits(gb, 8); |
514 | 173k | if (hdr->error_resilient_mode && seqhdr->order_hint) |
515 | 19.8k | for (int i = 0; i < 8; i++) |
516 | 17.6k | dav1d_get_bits(gb, seqhdr->order_hint_n_bits); |
517 | 173k | if (seqhdr->order_hint) { |
518 | 92.0k | hdr->frame_ref_short_signaling = dav1d_get_bit(gb); |
519 | 92.0k | if (hdr->frame_ref_short_signaling) { |
520 | 51.1k | hdr->refidx[0] = dav1d_get_bits(gb, 3); |
521 | 51.1k | hdr->refidx[1] = hdr->refidx[2] = -1; |
522 | 51.1k | hdr->refidx[3] = dav1d_get_bits(gb, 3); |
523 | | |
524 | | /* +1 allows for unconditional stores, as unused |
525 | | * values can be dumped into frame_offset[-1]. */ |
526 | 51.1k | int frame_offset_mem[8+1]; |
527 | 51.1k | int *const frame_offset = &frame_offset_mem[1]; |
528 | 51.1k | int earliest_ref = -1; |
529 | 460k | for (int i = 0, earliest_offset = INT_MAX; i < 8; i++) { |
530 | 409k | const Dav1dFrameHeader *const refhdr = c->refs[i].p.p.frame_hdr; |
531 | 409k | if (!refhdr) goto error; |
532 | 409k | const int diff = get_poc_diff(seqhdr->order_hint_n_bits, |
533 | 409k | refhdr->frame_offset, |
534 | 409k | hdr->frame_offset); |
535 | 409k | frame_offset[i] = diff; |
536 | 409k | if (diff < earliest_offset) { |
537 | 80.7k | earliest_offset = diff; |
538 | 80.7k | earliest_ref = i; |
539 | 80.7k | } |
540 | 409k | } |
541 | 51.1k | frame_offset[hdr->refidx[0]] = INT_MIN; // = reference frame is used |
542 | 51.1k | frame_offset[hdr->refidx[3]] = INT_MIN; |
543 | 51.1k | assert(earliest_ref >= 0); |
544 | | |
545 | 51.1k | int refidx = -1; |
546 | 460k | for (int i = 0, latest_offset = 0; i < 8; i++) { |
547 | 409k | const int hint = frame_offset[i]; |
548 | 409k | if (hint >= latest_offset) { |
549 | 164k | latest_offset = hint; |
550 | 164k | refidx = i; |
551 | 164k | } |
552 | 409k | } |
553 | 51.1k | frame_offset[refidx] = INT_MIN; |
554 | 51.1k | hdr->refidx[6] = refidx; |
555 | | |
556 | 153k | for (int i = 4; i < 6; i++) { |
557 | | /* Unsigned compares to handle negative values. */ |
558 | 102k | unsigned earliest_offset = UINT8_MAX; |
559 | 102k | refidx = -1; |
560 | 920k | for (int j = 0; j < 8; j++) { |
561 | 818k | const unsigned hint = frame_offset[j]; |
562 | 818k | if (hint < earliest_offset) { |
563 | 121k | earliest_offset = hint; |
564 | 121k | refidx = j; |
565 | 121k | } |
566 | 818k | } |
567 | 102k | frame_offset[refidx] = INT_MIN; |
568 | 102k | hdr->refidx[i] = refidx; |
569 | 102k | } |
570 | | |
571 | 357k | for (int i = 1; i < 7; i++) { |
572 | 306k | refidx = hdr->refidx[i]; |
573 | 306k | if (refidx < 0) { |
574 | 116k | unsigned latest_offset = ~UINT8_MAX; |
575 | 1.05M | for (int j = 0; j < 8; j++) { |
576 | 935k | const unsigned hint = frame_offset[j]; |
577 | 935k | if (hint >= latest_offset) { |
578 | 201k | latest_offset = hint; |
579 | 201k | refidx = j; |
580 | 201k | } |
581 | 935k | } |
582 | 116k | frame_offset[refidx] = INT_MIN; |
583 | 116k | hdr->refidx[i] = refidx >= 0 ? refidx : earliest_ref; |
584 | 116k | } |
585 | 306k | } |
586 | 51.1k | } |
587 | 92.0k | } |
588 | 1.38M | for (int i = 0; i < 7; i++) { |
589 | 1.21M | if (!hdr->frame_ref_short_signaling) |
590 | 856k | hdr->refidx[i] = dav1d_get_bits(gb, 3); |
591 | 1.21M | if (seqhdr->frame_id_numbers_present) { |
592 | 287 | const unsigned delta_ref_frame_id = dav1d_get_bits(gb, seqhdr->delta_frame_id_n_bits) + 1; |
593 | 287 | const unsigned ref_frame_id = (hdr->frame_id + (1 << seqhdr->frame_id_n_bits) - delta_ref_frame_id) & ((1 << seqhdr->frame_id_n_bits) - 1); |
594 | 287 | Dav1dFrameHeader *const ref_frame_hdr = c->refs[hdr->refidx[i]].p.p.frame_hdr; |
595 | 287 | if (!ref_frame_hdr || ref_frame_hdr->frame_id != ref_frame_id) goto error; |
596 | 287 | } |
597 | 1.21M | } |
598 | 173k | const int use_ref = !hdr->error_resilient_mode && |
599 | 164k | hdr->frame_size_override; |
600 | 173k | if (read_frame_size(c, gb, use_ref) < 0) goto error; |
601 | 173k | if (!hdr->force_integer_mv) |
602 | 122k | hdr->hp = dav1d_get_bit(gb); |
603 | 173k | hdr->subpel_filter_mode = dav1d_get_bit(gb) ? DAV1D_FILTER_SWITCHABLE : |
604 | 173k | dav1d_get_bits(gb, 2); |
605 | 173k | hdr->switchable_motion_mode = dav1d_get_bit(gb); |
606 | 173k | if (!hdr->error_resilient_mode && seqhdr->ref_frame_mvs && |
607 | 44.7k | seqhdr->order_hint && IS_INTER_OR_SWITCH(hdr)) |
608 | 44.7k | { |
609 | 44.7k | hdr->use_ref_frame_mvs = dav1d_get_bit(gb); |
610 | 44.7k | } |
611 | 173k | } |
612 | | #if DEBUG_FRAME_HDR |
613 | | printf("HDR: post-frametype-specific-bits: off=%td\n", |
614 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
615 | | #endif |
616 | | |
617 | 269k | if (!seqhdr->reduced_still_picture_header && !hdr->disable_cdf_update) |
618 | 168k | hdr->refresh_context = !dav1d_get_bit(gb); |
619 | | #if DEBUG_FRAME_HDR |
620 | | printf("HDR: post-refresh_context: off=%td\n", |
621 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
622 | | #endif |
623 | | |
624 | | // tile data |
625 | 269k | hdr->tiling.uniform = dav1d_get_bit(gb); |
626 | 269k | const int sbsz_min1 = (64 << seqhdr->sb128) - 1; |
627 | 269k | const int sbsz_log2 = 6 + seqhdr->sb128; |
628 | 269k | const int sbw = (hdr->width[0] + sbsz_min1) >> sbsz_log2; |
629 | 269k | const int sbh = (hdr->height + sbsz_min1) >> sbsz_log2; |
630 | 269k | const int max_tile_width_sb = 4096 >> sbsz_log2; |
631 | 269k | const int max_tile_area_sb = 4096 * 2304 >> (2 * sbsz_log2); |
632 | 269k | hdr->tiling.min_log2_cols = tile_log2(max_tile_width_sb, sbw); |
633 | 269k | hdr->tiling.max_log2_cols = tile_log2(1, imin(sbw, DAV1D_MAX_TILE_COLS)); |
634 | 269k | hdr->tiling.max_log2_rows = tile_log2(1, imin(sbh, DAV1D_MAX_TILE_ROWS)); |
635 | 269k | const int min_log2_tiles = imax(tile_log2(max_tile_area_sb, sbw * sbh), |
636 | 269k | hdr->tiling.min_log2_cols); |
637 | 269k | if (hdr->tiling.uniform) { |
638 | 106k | for (hdr->tiling.log2_cols = hdr->tiling.min_log2_cols; |
639 | 113k | hdr->tiling.log2_cols < hdr->tiling.max_log2_cols && dav1d_get_bit(gb); |
640 | 106k | hdr->tiling.log2_cols++) ; |
641 | 106k | const int tile_w = 1 + ((sbw - 1) >> hdr->tiling.log2_cols); |
642 | 106k | hdr->tiling.cols = 0; |
643 | 234k | for (int sbx = 0; sbx < sbw; sbx += tile_w, hdr->tiling.cols++) |
644 | 127k | hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx; |
645 | 106k | hdr->tiling.min_log2_rows = |
646 | 106k | imax(min_log2_tiles - hdr->tiling.log2_cols, 0); |
647 | | |
648 | 106k | for (hdr->tiling.log2_rows = hdr->tiling.min_log2_rows; |
649 | 112k | hdr->tiling.log2_rows < hdr->tiling.max_log2_rows && dav1d_get_bit(gb); |
650 | 106k | hdr->tiling.log2_rows++) ; |
651 | 106k | const int tile_h = 1 + ((sbh - 1) >> hdr->tiling.log2_rows); |
652 | 106k | hdr->tiling.rows = 0; |
653 | 227k | for (int sby = 0; sby < sbh; sby += tile_h, hdr->tiling.rows++) |
654 | 120k | hdr->tiling.row_start_sb[hdr->tiling.rows] = sby; |
655 | 162k | } else { |
656 | 162k | hdr->tiling.cols = 0; |
657 | 162k | int widest_tile = 0, max_tile_area_sb = sbw * sbh; |
658 | 345k | for (int sbx = 0; sbx < sbw && hdr->tiling.cols < DAV1D_MAX_TILE_COLS; hdr->tiling.cols++) { |
659 | 182k | const int tile_width_sb = imin(sbw - sbx, max_tile_width_sb); |
660 | 182k | const int tile_w = (tile_width_sb > 1) ? 1 + dav1d_get_uniform(gb, tile_width_sb) : 1; |
661 | 182k | hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx; |
662 | 182k | sbx += tile_w; |
663 | 182k | widest_tile = imax(widest_tile, tile_w); |
664 | 182k | } |
665 | 162k | hdr->tiling.log2_cols = tile_log2(1, hdr->tiling.cols); |
666 | 162k | if (min_log2_tiles) max_tile_area_sb >>= min_log2_tiles + 1; |
667 | 162k | const int max_tile_height_sb = imax(max_tile_area_sb / widest_tile, 1); |
668 | | |
669 | 162k | hdr->tiling.rows = 0; |
670 | 347k | for (int sby = 0; sby < sbh && hdr->tiling.rows < DAV1D_MAX_TILE_ROWS; hdr->tiling.rows++) { |
671 | 184k | const int tile_height_sb = imin(sbh - sby, max_tile_height_sb); |
672 | 184k | const int tile_h = (tile_height_sb > 1) ? 1 + dav1d_get_uniform(gb, tile_height_sb) : 1; |
673 | 184k | hdr->tiling.row_start_sb[hdr->tiling.rows] = sby; |
674 | 184k | sby += tile_h; |
675 | 184k | } |
676 | 162k | hdr->tiling.log2_rows = tile_log2(1, hdr->tiling.rows); |
677 | 162k | } |
678 | 269k | hdr->tiling.col_start_sb[hdr->tiling.cols] = sbw; |
679 | 269k | hdr->tiling.row_start_sb[hdr->tiling.rows] = sbh; |
680 | 269k | if (hdr->tiling.log2_cols || hdr->tiling.log2_rows) { |
681 | 13.9k | hdr->tiling.update = dav1d_get_bits(gb, hdr->tiling.log2_cols + hdr->tiling.log2_rows); |
682 | 13.9k | if (hdr->tiling.update >= hdr->tiling.cols * hdr->tiling.rows) |
683 | 86 | goto error; |
684 | 13.8k | hdr->tiling.n_bytes = dav1d_get_bits(gb, 2) + 1; |
685 | 13.8k | } |
686 | | #if DEBUG_FRAME_HDR |
687 | | printf("HDR: post-tiling: off=%td\n", |
688 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
689 | | #endif |
690 | | |
691 | | // quant data |
692 | 269k | hdr->quant.yac = dav1d_get_bits(gb, 8); |
693 | 269k | if (dav1d_get_bit(gb)) |
694 | 163k | hdr->quant.ydc_delta = dav1d_get_sbits(gb, 7); |
695 | 269k | if (!seqhdr->monochrome) { |
696 | | // If the sequence header says that delta_q might be different |
697 | | // for U, V, we must check whether it actually is for this |
698 | | // frame. |
699 | 204k | const int diff_uv_delta = seqhdr->separate_uv_delta_q ? dav1d_get_bit(gb) : 0; |
700 | 204k | if (dav1d_get_bit(gb)) |
701 | 121k | hdr->quant.udc_delta = dav1d_get_sbits(gb, 7); |
702 | 204k | if (dav1d_get_bit(gb)) |
703 | 121k | hdr->quant.uac_delta = dav1d_get_sbits(gb, 7); |
704 | 204k | if (diff_uv_delta) { |
705 | 58.6k | if (dav1d_get_bit(gb)) |
706 | 33.1k | hdr->quant.vdc_delta = dav1d_get_sbits(gb, 7); |
707 | 58.6k | if (dav1d_get_bit(gb)) |
708 | 52.1k | hdr->quant.vac_delta = dav1d_get_sbits(gb, 7); |
709 | 145k | } else { |
710 | 145k | hdr->quant.vdc_delta = hdr->quant.udc_delta; |
711 | 145k | hdr->quant.vac_delta = hdr->quant.uac_delta; |
712 | 145k | } |
713 | 204k | } |
714 | | #if DEBUG_FRAME_HDR |
715 | | printf("HDR: post-quant: off=%td\n", |
716 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
717 | | #endif |
718 | 269k | hdr->quant.qm = dav1d_get_bit(gb); |
719 | 269k | if (hdr->quant.qm) { |
720 | 193k | hdr->quant.qm_y = dav1d_get_bits(gb, 4); |
721 | 193k | hdr->quant.qm_u = dav1d_get_bits(gb, 4); |
722 | 193k | hdr->quant.qm_v = seqhdr->separate_uv_delta_q ? dav1d_get_bits(gb, 4) : |
723 | 193k | hdr->quant.qm_u; |
724 | 193k | } |
725 | | #if DEBUG_FRAME_HDR |
726 | | printf("HDR: post-qm: off=%td\n", |
727 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
728 | | #endif |
729 | | |
730 | | // segmentation data |
731 | 269k | hdr->segmentation.enabled = dav1d_get_bit(gb); |
732 | 269k | if (hdr->segmentation.enabled) { |
733 | 97.6k | if (hdr->primary_ref_frame == DAV1D_PRIMARY_REF_NONE) { |
734 | 28.0k | hdr->segmentation.update_map = 1; |
735 | 28.0k | hdr->segmentation.update_data = 1; |
736 | 69.5k | } else { |
737 | 69.5k | hdr->segmentation.update_map = dav1d_get_bit(gb); |
738 | 69.5k | if (hdr->segmentation.update_map) |
739 | 9.38k | hdr->segmentation.temporal = dav1d_get_bit(gb); |
740 | 69.5k | hdr->segmentation.update_data = dav1d_get_bit(gb); |
741 | 69.5k | } |
742 | | |
743 | 97.6k | if (hdr->segmentation.update_data) { |
744 | 29.7k | hdr->segmentation.seg_data.last_active_segid = -1; |
745 | 267k | for (int i = 0; i < DAV1D_MAX_SEGMENTS; i++) { |
746 | 238k | Dav1dSegmentationData *const seg = |
747 | 238k | &hdr->segmentation.seg_data.d[i]; |
748 | 238k | if (dav1d_get_bit(gb)) { |
749 | 66.2k | seg->delta_q = dav1d_get_sbits(gb, 9); |
750 | 66.2k | hdr->segmentation.seg_data.last_active_segid = i; |
751 | 66.2k | } |
752 | 238k | if (dav1d_get_bit(gb)) { |
753 | 58.7k | seg->delta_lf_y_v = dav1d_get_sbits(gb, 7); |
754 | 58.7k | hdr->segmentation.seg_data.last_active_segid = i; |
755 | 58.7k | } |
756 | 238k | if (dav1d_get_bit(gb)) { |
757 | 90.2k | seg->delta_lf_y_h = dav1d_get_sbits(gb, 7); |
758 | 90.2k | hdr->segmentation.seg_data.last_active_segid = i; |
759 | 90.2k | } |
760 | 238k | if (dav1d_get_bit(gb)) { |
761 | 90.2k | seg->delta_lf_u = dav1d_get_sbits(gb, 7); |
762 | 90.2k | hdr->segmentation.seg_data.last_active_segid = i; |
763 | 90.2k | } |
764 | 238k | if (dav1d_get_bit(gb)) { |
765 | 89.1k | seg->delta_lf_v = dav1d_get_sbits(gb, 7); |
766 | 89.1k | hdr->segmentation.seg_data.last_active_segid = i; |
767 | 89.1k | } |
768 | 238k | if (dav1d_get_bit(gb)) { |
769 | 89.9k | seg->ref = dav1d_get_bits(gb, 3); |
770 | 89.9k | hdr->segmentation.seg_data.last_active_segid = i; |
771 | 89.9k | hdr->segmentation.seg_data.preskip = 1; |
772 | 148k | } else { |
773 | 148k | seg->ref = -1; |
774 | 148k | } |
775 | 238k | if ((seg->skip = dav1d_get_bit(gb))) { |
776 | 94.2k | hdr->segmentation.seg_data.last_active_segid = i; |
777 | 94.2k | hdr->segmentation.seg_data.preskip = 1; |
778 | 94.2k | } |
779 | 238k | if ((seg->globalmv = dav1d_get_bit(gb))) { |
780 | 80.8k | hdr->segmentation.seg_data.last_active_segid = i; |
781 | 80.8k | hdr->segmentation.seg_data.preskip = 1; |
782 | 80.8k | } |
783 | 238k | } |
784 | 67.8k | } else { |
785 | | // segmentation.update_data was false so we should copy |
786 | | // segmentation data from the reference frame. |
787 | 67.8k | assert(hdr->primary_ref_frame != DAV1D_PRIMARY_REF_NONE); |
788 | 67.8k | const int pri_ref = hdr->refidx[hdr->primary_ref_frame]; |
789 | 67.8k | if (!c->refs[pri_ref].p.p.frame_hdr) goto error; |
790 | 67.8k | hdr->segmentation.seg_data = |
791 | 67.8k | c->refs[pri_ref].p.p.frame_hdr->segmentation.seg_data; |
792 | 67.8k | } |
793 | 172k | } else { |
794 | 1.54M | for (int i = 0; i < DAV1D_MAX_SEGMENTS; i++) |
795 | 1.37M | hdr->segmentation.seg_data.d[i].ref = -1; |
796 | 172k | } |
797 | | #if DEBUG_FRAME_HDR |
798 | | printf("HDR: post-segmentation: off=%td\n", |
799 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
800 | | #endif |
801 | | |
802 | | // delta q |
803 | 269k | if (hdr->quant.yac) { |
804 | 261k | hdr->delta.q.present = dav1d_get_bit(gb); |
805 | 261k | if (hdr->delta.q.present) { |
806 | 101k | hdr->delta.q.res_log2 = dav1d_get_bits(gb, 2); |
807 | 101k | if (!hdr->allow_intrabc) { |
808 | 97.1k | hdr->delta.lf.present = dav1d_get_bit(gb); |
809 | 97.1k | if (hdr->delta.lf.present) { |
810 | 13.4k | hdr->delta.lf.res_log2 = dav1d_get_bits(gb, 2); |
811 | 13.4k | hdr->delta.lf.multi = dav1d_get_bit(gb); |
812 | 13.4k | } |
813 | 97.1k | } |
814 | 101k | } |
815 | 261k | } |
816 | | #if DEBUG_FRAME_HDR |
817 | | printf("HDR: post-delta_q_lf_flags: off=%td\n", |
818 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
819 | | #endif |
820 | | |
821 | | // derive lossless flags |
822 | 269k | const int delta_lossless = !hdr->quant.ydc_delta && !hdr->quant.udc_delta && |
823 | 86.9k | !hdr->quant.uac_delta && !hdr->quant.vdc_delta && !hdr->quant.vac_delta; |
824 | 269k | hdr->all_lossless = 1; |
825 | 2.42M | for (int i = 0; i < DAV1D_MAX_SEGMENTS; i++) { |
826 | 2.15M | hdr->segmentation.qidx[i] = hdr->segmentation.enabled ? |
827 | 780k | iclip_u8(hdr->quant.yac + hdr->segmentation.seg_data.d[i].delta_q) : |
828 | 2.15M | hdr->quant.yac; |
829 | 2.15M | hdr->segmentation.lossless[i] = |
830 | 2.15M | !hdr->segmentation.qidx[i] && delta_lossless; |
831 | 2.15M | hdr->all_lossless &= hdr->segmentation.lossless[i]; |
832 | 2.15M | } |
833 | | |
834 | | // loopfilter |
835 | 269k | if (hdr->all_lossless || hdr->allow_intrabc) { |
836 | 22.1k | hdr->loopfilter.mode_ref_delta_enabled = 1; |
837 | 22.1k | hdr->loopfilter.mode_ref_delta_update = 1; |
838 | 22.1k | hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas; |
839 | 247k | } else { |
840 | 247k | hdr->loopfilter.level_y[0] = dav1d_get_bits(gb, 6); |
841 | 247k | hdr->loopfilter.level_y[1] = dav1d_get_bits(gb, 6); |
842 | 247k | if (!seqhdr->monochrome && |
843 | 187k | (hdr->loopfilter.level_y[0] || hdr->loopfilter.level_y[1])) |
844 | 171k | { |
845 | 171k | hdr->loopfilter.level_u = dav1d_get_bits(gb, 6); |
846 | 171k | hdr->loopfilter.level_v = dav1d_get_bits(gb, 6); |
847 | 171k | } |
848 | 247k | hdr->loopfilter.sharpness = dav1d_get_bits(gb, 3); |
849 | | |
850 | 247k | if (hdr->primary_ref_frame == DAV1D_PRIMARY_REF_NONE) { |
851 | 87.0k | hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas; |
852 | 160k | } else { |
853 | 160k | const int ref = hdr->refidx[hdr->primary_ref_frame]; |
854 | 160k | if (!c->refs[ref].p.p.frame_hdr) goto error; |
855 | 160k | hdr->loopfilter.mode_ref_deltas = |
856 | 160k | c->refs[ref].p.p.frame_hdr->loopfilter.mode_ref_deltas; |
857 | 160k | } |
858 | 247k | hdr->loopfilter.mode_ref_delta_enabled = dav1d_get_bit(gb); |
859 | 247k | if (hdr->loopfilter.mode_ref_delta_enabled) { |
860 | 36.0k | hdr->loopfilter.mode_ref_delta_update = dav1d_get_bit(gb); |
861 | 36.0k | if (hdr->loopfilter.mode_ref_delta_update) { |
862 | 161k | for (int i = 0; i < 8; i++) |
863 | 143k | if (dav1d_get_bit(gb)) |
864 | 78.0k | hdr->loopfilter.mode_ref_deltas.ref_delta[i] = |
865 | 78.0k | dav1d_get_sbits(gb, 7); |
866 | 53.8k | for (int i = 0; i < 2; i++) |
867 | 35.8k | if (dav1d_get_bit(gb)) |
868 | 18.9k | hdr->loopfilter.mode_ref_deltas.mode_delta[i] = |
869 | 18.9k | dav1d_get_sbits(gb, 7); |
870 | 17.9k | } |
871 | 36.0k | } |
872 | 247k | } |
873 | | #if DEBUG_FRAME_HDR |
874 | | printf("HDR: post-lpf: off=%td\n", |
875 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
876 | | #endif |
877 | | |
878 | | // cdef |
879 | 269k | if (!hdr->all_lossless && seqhdr->cdef && !hdr->allow_intrabc) { |
880 | 115k | hdr->cdef.damping = dav1d_get_bits(gb, 2) + 3; |
881 | 115k | hdr->cdef.n_bits = dav1d_get_bits(gb, 2); |
882 | 318k | for (int i = 0; i < (1 << hdr->cdef.n_bits); i++) { |
883 | 203k | hdr->cdef.y_strength[i] = dav1d_get_bits(gb, 6); |
884 | 203k | if (!seqhdr->monochrome) |
885 | 127k | hdr->cdef.uv_strength[i] = dav1d_get_bits(gb, 6); |
886 | 203k | } |
887 | 115k | } |
888 | | #if DEBUG_FRAME_HDR |
889 | | printf("HDR: post-cdef: off=%td\n", |
890 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
891 | | #endif |
892 | | |
893 | | // restoration |
894 | 269k | if ((!hdr->all_lossless || hdr->super_res.enabled) && |
895 | 264k | seqhdr->restoration && !hdr->allow_intrabc) |
896 | 156k | { |
897 | 156k | hdr->restoration.type[0] = dav1d_get_bits(gb, 2); |
898 | 156k | if (!seqhdr->monochrome) { |
899 | 116k | hdr->restoration.type[1] = dav1d_get_bits(gb, 2); |
900 | 116k | hdr->restoration.type[2] = dav1d_get_bits(gb, 2); |
901 | 116k | } |
902 | | |
903 | 156k | if (hdr->restoration.type[0] || hdr->restoration.type[1] || |
904 | 28.7k | hdr->restoration.type[2]) |
905 | 133k | { |
906 | | // Log2 of the restoration unit size. |
907 | 133k | hdr->restoration.unit_size[0] = 6 + seqhdr->sb128; |
908 | 133k | if (dav1d_get_bit(gb)) { |
909 | 51.5k | hdr->restoration.unit_size[0]++; |
910 | 51.5k | if (!seqhdr->sb128) |
911 | 34.6k | hdr->restoration.unit_size[0] += dav1d_get_bit(gb); |
912 | 51.5k | } |
913 | 133k | hdr->restoration.unit_size[1] = hdr->restoration.unit_size[0]; |
914 | 133k | if ((hdr->restoration.type[1] || hdr->restoration.type[2]) && |
915 | 105k | seqhdr->ss_hor == 1 && seqhdr->ss_ver == 1) |
916 | 61.8k | { |
917 | 61.8k | hdr->restoration.unit_size[1] -= dav1d_get_bit(gb); |
918 | 61.8k | } |
919 | 133k | } else { |
920 | 23.0k | hdr->restoration.unit_size[0] = 8; |
921 | 23.0k | } |
922 | 156k | } |
923 | | #if DEBUG_FRAME_HDR |
924 | | printf("HDR: post-restoration: off=%td\n", |
925 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
926 | | #endif |
927 | | |
928 | 269k | if (!hdr->all_lossless) |
929 | 263k | hdr->txfm_mode = dav1d_get_bit(gb) ? DAV1D_TX_SWITCHABLE : DAV1D_TX_LARGEST; |
930 | | #if DEBUG_FRAME_HDR |
931 | | printf("HDR: post-txfmmode: off=%td\n", |
932 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
933 | | #endif |
934 | 269k | if (IS_INTER_OR_SWITCH(hdr)) |
935 | 173k | hdr->switchable_comp_refs = dav1d_get_bit(gb); |
936 | | #if DEBUG_FRAME_HDR |
937 | | printf("HDR: post-refmode: off=%td\n", |
938 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
939 | | #endif |
940 | 269k | if (hdr->switchable_comp_refs && IS_INTER_OR_SWITCH(hdr) && seqhdr->order_hint) { |
941 | 77.0k | const int poc = hdr->frame_offset; |
942 | 77.0k | int off_before = -1, off_after = -1; |
943 | 77.0k | int off_before_idx, off_after_idx; |
944 | 616k | for (int i = 0; i < 7; i++) { |
945 | 539k | if (!c->refs[hdr->refidx[i]].p.p.frame_hdr) goto error; |
946 | 539k | const int refpoc = c->refs[hdr->refidx[i]].p.p.frame_hdr->frame_offset; |
947 | | |
948 | 539k | const int diff = get_poc_diff(seqhdr->order_hint_n_bits, refpoc, poc); |
949 | 539k | if (diff > 0) { |
950 | 66.4k | if (off_after < 0 || get_poc_diff(seqhdr->order_hint_n_bits, |
951 | 42.0k | off_after, refpoc) > 0) |
952 | 25.5k | { |
953 | 25.5k | off_after = refpoc; |
954 | 25.5k | off_after_idx = i; |
955 | 25.5k | } |
956 | 472k | } else if (diff < 0 && (off_before < 0 || |
957 | 101k | get_poc_diff(seqhdr->order_hint_n_bits, |
958 | 101k | refpoc, off_before) > 0)) |
959 | 42.1k | { |
960 | 42.1k | off_before = refpoc; |
961 | 42.1k | off_before_idx = i; |
962 | 42.1k | } |
963 | 539k | } |
964 | | |
965 | 77.0k | if ((off_before | off_after) >= 0) { |
966 | 7.55k | hdr->skip_mode_refs[0] = imin(off_before_idx, off_after_idx); |
967 | 7.55k | hdr->skip_mode_refs[1] = imax(off_before_idx, off_after_idx); |
968 | 7.55k | hdr->skip_mode_allowed = 1; |
969 | 69.4k | } else if (off_before >= 0) { |
970 | 32.6k | int off_before2 = -1; |
971 | 32.6k | int off_before2_idx; |
972 | 261k | for (int i = 0; i < 7; i++) { |
973 | 228k | if (!c->refs[hdr->refidx[i]].p.p.frame_hdr) goto error; |
974 | 228k | const int refpoc = c->refs[hdr->refidx[i]].p.p.frame_hdr->frame_offset; |
975 | 228k | if (get_poc_diff(seqhdr->order_hint_n_bits, |
976 | 228k | refpoc, off_before) < 0) { |
977 | 23.0k | if (off_before2 < 0 || get_poc_diff(seqhdr->order_hint_n_bits, |
978 | 16.0k | refpoc, off_before2) > 0) |
979 | 7.41k | { |
980 | 7.41k | off_before2 = refpoc; |
981 | 7.41k | off_before2_idx = i; |
982 | 7.41k | } |
983 | 23.0k | } |
984 | 228k | } |
985 | | |
986 | 32.6k | if (off_before2 >= 0) { |
987 | 6.99k | hdr->skip_mode_refs[0] = imin(off_before_idx, off_before2_idx); |
988 | 6.99k | hdr->skip_mode_refs[1] = imax(off_before_idx, off_before2_idx); |
989 | 6.99k | hdr->skip_mode_allowed = 1; |
990 | 6.99k | } |
991 | 32.6k | } |
992 | 77.0k | } |
993 | 269k | if (hdr->skip_mode_allowed) |
994 | 14.5k | hdr->skip_mode_enabled = dav1d_get_bit(gb); |
995 | | #if DEBUG_FRAME_HDR |
996 | | printf("HDR: post-extskip: off=%td\n", |
997 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
998 | | #endif |
999 | 269k | if (!hdr->error_resilient_mode && IS_INTER_OR_SWITCH(hdr) && seqhdr->warped_motion) |
1000 | 94.5k | hdr->warp_motion = dav1d_get_bit(gb); |
1001 | | #if DEBUG_FRAME_HDR |
1002 | | printf("HDR: post-warpmotionbit: off=%td\n", |
1003 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
1004 | | #endif |
1005 | 269k | hdr->reduced_txtp_set = dav1d_get_bit(gb); |
1006 | | #if DEBUG_FRAME_HDR |
1007 | | printf("HDR: post-reducedtxtpset: off=%td\n", |
1008 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
1009 | | #endif |
1010 | | |
1011 | 2.15M | for (int i = 0; i < 7; i++) |
1012 | 1.88M | hdr->gmv[i] = dav1d_default_wm_params; |
1013 | | |
1014 | 269k | if (IS_INTER_OR_SWITCH(hdr)) { |
1015 | 1.38M | for (int i = 0; i < 7; i++) { |
1016 | 1.21M | hdr->gmv[i].type = !dav1d_get_bit(gb) ? DAV1D_WM_TYPE_IDENTITY : |
1017 | 1.21M | dav1d_get_bit(gb) ? DAV1D_WM_TYPE_ROT_ZOOM : |
1018 | 450k | dav1d_get_bit(gb) ? DAV1D_WM_TYPE_TRANSLATION : |
1019 | 117k | DAV1D_WM_TYPE_AFFINE; |
1020 | | |
1021 | 1.21M | if (hdr->gmv[i].type == DAV1D_WM_TYPE_IDENTITY) continue; |
1022 | | |
1023 | 450k | const Dav1dWarpedMotionParams *ref_gmv; |
1024 | 450k | if (hdr->primary_ref_frame == DAV1D_PRIMARY_REF_NONE) { |
1025 | 23.8k | ref_gmv = &dav1d_default_wm_params; |
1026 | 426k | } else { |
1027 | 426k | const int pri_ref = hdr->refidx[hdr->primary_ref_frame]; |
1028 | 426k | if (!c->refs[pri_ref].p.p.frame_hdr) goto error; |
1029 | 426k | ref_gmv = &c->refs[pri_ref].p.p.frame_hdr->gmv[i]; |
1030 | 426k | } |
1031 | 450k | int32_t *const mat = hdr->gmv[i].matrix; |
1032 | 450k | const int32_t *const ref_mat = ref_gmv->matrix; |
1033 | 450k | int bits, shift; |
1034 | | |
1035 | 450k | if (hdr->gmv[i].type >= DAV1D_WM_TYPE_ROT_ZOOM) { |
1036 | 438k | mat[2] = (1 << 16) + 2 * |
1037 | 438k | dav1d_get_bits_subexp(gb, (ref_mat[2] - (1 << 16)) >> 1, 12); |
1038 | 438k | mat[3] = 2 * dav1d_get_bits_subexp(gb, ref_mat[3] >> 1, 12); |
1039 | | |
1040 | 438k | bits = 12; |
1041 | 438k | shift = 10; |
1042 | 438k | } else { |
1043 | 11.6k | bits = 9 - !hdr->hp; |
1044 | 11.6k | shift = 13 + !hdr->hp; |
1045 | 11.6k | } |
1046 | | |
1047 | 450k | if (hdr->gmv[i].type == DAV1D_WM_TYPE_AFFINE) { |
1048 | 105k | mat[4] = 2 * dav1d_get_bits_subexp(gb, ref_mat[4] >> 1, 12); |
1049 | 105k | mat[5] = (1 << 16) + 2 * |
1050 | 105k | dav1d_get_bits_subexp(gb, (ref_mat[5] - (1 << 16)) >> 1, 12); |
1051 | 344k | } else { |
1052 | 344k | mat[4] = -mat[3]; |
1053 | 344k | mat[5] = mat[2]; |
1054 | 344k | } |
1055 | | |
1056 | 450k | mat[0] = dav1d_get_bits_subexp(gb, ref_mat[0] >> shift, bits) * (1 << shift); |
1057 | 450k | mat[1] = dav1d_get_bits_subexp(gb, ref_mat[1] >> shift, bits) * (1 << shift); |
1058 | 450k | } |
1059 | 173k | } |
1060 | | #if DEBUG_FRAME_HDR |
1061 | | printf("HDR: post-gmv: off=%td\n", |
1062 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
1063 | | #endif |
1064 | | |
1065 | 269k | if (seqhdr->film_grain_present && (hdr->show_frame || hdr->showable_frame)) { |
1066 | 65.3k | hdr->film_grain.present = dav1d_get_bit(gb); |
1067 | 65.3k | if (hdr->film_grain.present) { |
1068 | 8.27k | const unsigned seed = dav1d_get_bits(gb, 16); |
1069 | 8.27k | hdr->film_grain.update = hdr->frame_type != DAV1D_FRAME_TYPE_INTER || dav1d_get_bit(gb); |
1070 | 8.27k | if (!hdr->film_grain.update) { |
1071 | 1.01k | const int refidx = dav1d_get_bits(gb, 3); |
1072 | 1.01k | int i; |
1073 | 3.62k | for (i = 0; i < 7; i++) |
1074 | 3.58k | if (hdr->refidx[i] == refidx) |
1075 | 979 | break; |
1076 | 1.01k | if (i == 7 || !c->refs[refidx].p.p.frame_hdr) goto error; |
1077 | 961 | hdr->film_grain.data = c->refs[refidx].p.p.frame_hdr->film_grain.data; |
1078 | 961 | hdr->film_grain.data.seed = seed; |
1079 | 7.25k | } else { |
1080 | 7.25k | Dav1dFilmGrainData *const fgd = &hdr->film_grain.data; |
1081 | 7.25k | fgd->seed = seed; |
1082 | | |
1083 | 7.25k | fgd->num_y_points = dav1d_get_bits(gb, 4); |
1084 | 7.25k | if (fgd->num_y_points > 14) goto error; |
1085 | 12.3k | for (int i = 0; i < fgd->num_y_points; i++) { |
1086 | 5.32k | fgd->y_points[i][0] = dav1d_get_bits(gb, 8); |
1087 | 5.32k | if (i && fgd->y_points[i - 1][0] >= fgd->y_points[i][0]) |
1088 | 145 | goto error; |
1089 | 5.17k | fgd->y_points[i][1] = dav1d_get_bits(gb, 8); |
1090 | 5.17k | } |
1091 | | |
1092 | 7.07k | if (!seqhdr->monochrome) |
1093 | 5.72k | fgd->chroma_scaling_from_luma = dav1d_get_bit(gb); |
1094 | 7.07k | if (seqhdr->monochrome || fgd->chroma_scaling_from_luma || |
1095 | 2.69k | (seqhdr->ss_ver == 1 && seqhdr->ss_hor == 1 && !fgd->num_y_points)) |
1096 | 5.06k | { |
1097 | 5.06k | fgd->num_uv_points[0] = fgd->num_uv_points[1] = 0; |
1098 | 5.90k | } else for (int pl = 0; pl < 2; pl++) { |
1099 | 3.97k | fgd->num_uv_points[pl] = dav1d_get_bits(gb, 4); |
1100 | 3.97k | if (fgd->num_uv_points[pl] > 10) goto error; |
1101 | 6.63k | for (int i = 0; i < fgd->num_uv_points[pl]; i++) { |
1102 | 2.74k | fgd->uv_points[pl][i][0] = dav1d_get_bits(gb, 8); |
1103 | 2.74k | if (i && fgd->uv_points[pl][i - 1][0] >= fgd->uv_points[pl][i][0]) |
1104 | 51 | goto error; |
1105 | 2.68k | fgd->uv_points[pl][i][1] = dav1d_get_bits(gb, 8); |
1106 | 2.68k | } |
1107 | 3.95k | } |
1108 | | |
1109 | 7.00k | if (seqhdr->ss_hor == 1 && seqhdr->ss_ver == 1 && |
1110 | 3.72k | !!fgd->num_uv_points[0] != !!fgd->num_uv_points[1]) |
1111 | 10 | { |
1112 | 10 | goto error; |
1113 | 10 | } |
1114 | | |
1115 | 6.99k | fgd->scaling_shift = dav1d_get_bits(gb, 2) + 8; |
1116 | 6.99k | fgd->ar_coeff_lag = dav1d_get_bits(gb, 2); |
1117 | 6.99k | const int num_y_pos = 2 * fgd->ar_coeff_lag * (fgd->ar_coeff_lag + 1); |
1118 | 6.99k | if (fgd->num_y_points) |
1119 | 30.3k | for (int i = 0; i < num_y_pos; i++) |
1120 | 26.7k | fgd->ar_coeffs_y[i] = dav1d_get_bits(gb, 8) - 128; |
1121 | 20.9k | for (int pl = 0; pl < 2; pl++) |
1122 | 13.9k | if (fgd->num_uv_points[pl] || fgd->chroma_scaling_from_luma) { |
1123 | 7.84k | const int num_uv_pos = num_y_pos + !!fgd->num_y_points; |
1124 | 64.8k | for (int i = 0; i < num_uv_pos; i++) |
1125 | 56.9k | fgd->ar_coeffs_uv[pl][i] = dav1d_get_bits(gb, 8) - 128; |
1126 | 7.84k | if (!fgd->num_y_points) |
1127 | 3.25k | fgd->ar_coeffs_uv[pl][num_uv_pos] = 0; |
1128 | 7.84k | } |
1129 | 6.99k | fgd->ar_coeff_shift = dav1d_get_bits(gb, 2) + 6; |
1130 | 6.99k | fgd->grain_scale_shift = dav1d_get_bits(gb, 2); |
1131 | 20.9k | for (int pl = 0; pl < 2; pl++) |
1132 | 13.9k | if (fgd->num_uv_points[pl]) { |
1133 | 1.78k | fgd->uv_mult[pl] = dav1d_get_bits(gb, 8) - 128; |
1134 | 1.78k | fgd->uv_luma_mult[pl] = dav1d_get_bits(gb, 8) - 128; |
1135 | 1.78k | fgd->uv_offset[pl] = dav1d_get_bits(gb, 9) - 256; |
1136 | 1.78k | } |
1137 | 6.99k | fgd->overlap_flag = dav1d_get_bit(gb); |
1138 | 6.99k | fgd->clip_to_restricted_range = dav1d_get_bit(gb); |
1139 | 6.99k | } |
1140 | 8.27k | } |
1141 | 65.3k | } |
1142 | | #if DEBUG_FRAME_HDR |
1143 | | printf("HDR: post-filmgrain: off=%td\n", |
1144 | | (gb->ptr - init_ptr) * 8 - gb->bits_left); |
1145 | | #endif |
1146 | | |
1147 | 269k | return 0; |
1148 | | |
1149 | 869 | error: |
1150 | 869 | dav1d_log(c, "Error parsing frame header\n"); |
1151 | 869 | return DAV1D_ERR(EINVAL); |
1152 | 269k | } |
1153 | | |
1154 | 255k | static void parse_tile_hdr(Dav1dContext *const c, GetBits *const gb) { |
1155 | 255k | const int n_tiles = c->frame_hdr->tiling.cols * c->frame_hdr->tiling.rows; |
1156 | 255k | const int have_tile_pos = n_tiles > 1 ? dav1d_get_bit(gb) : 0; |
1157 | | |
1158 | 255k | if (have_tile_pos) { |
1159 | 342 | const int n_bits = c->frame_hdr->tiling.log2_cols + |
1160 | 342 | c->frame_hdr->tiling.log2_rows; |
1161 | 342 | c->tile[c->n_tile_data].start = dav1d_get_bits(gb, n_bits); |
1162 | 342 | c->tile[c->n_tile_data].end = dav1d_get_bits(gb, n_bits); |
1163 | 255k | } else { |
1164 | 255k | c->tile[c->n_tile_data].start = 0; |
1165 | 255k | c->tile[c->n_tile_data].end = n_tiles - 1; |
1166 | 255k | } |
1167 | 255k | } |
1168 | | |
1169 | 399k | ptrdiff_t dav1d_parse_obus(Dav1dContext *const c, Dav1dData *const in) { |
1170 | 399k | GetBits gb; |
1171 | 399k | int res; |
1172 | | |
1173 | 399k | dav1d_init_get_bits(&gb, in->data, in->sz); |
1174 | | |
1175 | | // obu header |
1176 | 399k | const int obu_forbidden_bit = dav1d_get_bit(&gb); |
1177 | 399k | if (c->strict_std_compliance && obu_forbidden_bit) goto error; |
1178 | 399k | const enum Dav1dObuType type = dav1d_get_bits(&gb, 4); |
1179 | 399k | const int has_extension = dav1d_get_bit(&gb); |
1180 | 399k | const int has_length_field = dav1d_get_bit(&gb); |
1181 | 399k | dav1d_get_bit(&gb); // reserved |
1182 | | |
1183 | 399k | int temporal_id = 0, spatial_id = 0; |
1184 | 399k | if (has_extension) { |
1185 | 83.9k | temporal_id = dav1d_get_bits(&gb, 3); |
1186 | 83.9k | spatial_id = dav1d_get_bits(&gb, 2); |
1187 | 83.9k | dav1d_get_bits(&gb, 3); // reserved |
1188 | 83.9k | } |
1189 | | |
1190 | 399k | if (has_length_field) { |
1191 | 323k | const size_t len = dav1d_get_uleb128(&gb); |
1192 | 323k | if (len > (size_t)(gb.ptr_end - gb.ptr)) goto error; |
1193 | 321k | gb.ptr_end = gb.ptr + len; |
1194 | 321k | } |
1195 | 396k | if (gb.error) goto error; |
1196 | | |
1197 | | // We must have read a whole number of bytes at this point (1 byte |
1198 | | // for the header and whole bytes at a time when reading the |
1199 | | // leb128 length field). |
1200 | 396k | assert(gb.bits_left == 0); |
1201 | | |
1202 | | // skip obu not belonging to the selected temporal/spatial layer |
1203 | 396k | if (type != DAV1D_OBU_SEQ_HDR && type != DAV1D_OBU_TD && |
1204 | 294k | has_extension && c->operating_point_idc != 0) |
1205 | 6.04k | { |
1206 | 6.04k | const int in_temporal_layer = (c->operating_point_idc >> temporal_id) & 1; |
1207 | 6.04k | const int in_spatial_layer = (c->operating_point_idc >> (spatial_id + 8)) & 1; |
1208 | 6.04k | if (!in_temporal_layer || !in_spatial_layer) |
1209 | 3.91k | return gb.ptr_end - gb.ptr_start; |
1210 | 6.04k | } |
1211 | | |
1212 | 392k | switch (type) { |
1213 | 85.2k | case DAV1D_OBU_SEQ_HDR: { |
1214 | 85.2k | Dav1dRef *ref = dav1d_ref_create_using_pool(c->seq_hdr_pool, |
1215 | 85.2k | sizeof(Dav1dSequenceHeader)); |
1216 | 85.2k | if (!ref) return DAV1D_ERR(ENOMEM); |
1217 | 85.2k | Dav1dSequenceHeader *seq_hdr = ref->data; |
1218 | 85.2k | if ((res = parse_seq_hdr(seq_hdr, &gb, c->strict_std_compliance)) < 0) { |
1219 | 1.49k | dav1d_log(c, "Error parsing sequence header\n"); |
1220 | 1.49k | dav1d_ref_dec(&ref); |
1221 | 1.49k | goto error; |
1222 | 1.49k | } |
1223 | | |
1224 | 83.7k | const int op_idx = |
1225 | 83.7k | c->operating_point < seq_hdr->num_operating_points ? c->operating_point : 0; |
1226 | 83.7k | c->operating_point_idc = seq_hdr->operating_points[op_idx].idc; |
1227 | 83.7k | const unsigned spatial_mask = c->operating_point_idc >> 8; |
1228 | 83.7k | c->max_spatial_id = spatial_mask ? ulog2(spatial_mask) : 0; |
1229 | | |
1230 | | // If we have read a sequence header which is different from |
1231 | | // the old one, this is a new video sequence and can't use any |
1232 | | // previous state. Free that state. |
1233 | | |
1234 | 83.7k | if (!c->seq_hdr) { |
1235 | 79.1k | c->frame_hdr = NULL; |
1236 | 79.1k | c->frame_flags |= PICTURE_FLAG_NEW_SEQUENCE; |
1237 | | // see 7.5, operating_parameter_info is allowed to change in |
1238 | | // sequence headers of a single sequence |
1239 | 79.1k | } else if (memcmp(seq_hdr, c->seq_hdr, offsetof(Dav1dSequenceHeader, operating_parameter_info))) { |
1240 | 4.22k | c->frame_hdr = NULL; |
1241 | 4.22k | c->mastering_display = NULL; |
1242 | 4.22k | c->content_light = NULL; |
1243 | 4.22k | dav1d_ref_dec(&c->mastering_display_ref); |
1244 | 4.22k | dav1d_ref_dec(&c->content_light_ref); |
1245 | 38.0k | for (int i = 0; i < 8; i++) { |
1246 | 33.8k | if (c->refs[i].p.p.frame_hdr) |
1247 | 3.96k | dav1d_thread_picture_unref(&c->refs[i].p); |
1248 | 33.8k | dav1d_ref_dec(&c->refs[i].segmap); |
1249 | 33.8k | dav1d_ref_dec(&c->refs[i].refmvs); |
1250 | 33.8k | dav1d_cdf_thread_unref(&c->cdf[i]); |
1251 | 33.8k | } |
1252 | 4.22k | c->frame_flags |= PICTURE_FLAG_NEW_SEQUENCE; |
1253 | | // If operating_parameter_info changed, signal it |
1254 | 4.22k | } else if (memcmp(seq_hdr->operating_parameter_info, c->seq_hdr->operating_parameter_info, |
1255 | 426 | sizeof(seq_hdr->operating_parameter_info))) |
1256 | 31 | { |
1257 | 31 | c->frame_flags |= PICTURE_FLAG_NEW_OP_PARAMS_INFO; |
1258 | 31 | } |
1259 | 83.7k | dav1d_ref_dec(&c->seq_hdr_ref); |
1260 | 83.7k | c->seq_hdr_ref = ref; |
1261 | 83.7k | c->seq_hdr = seq_hdr; |
1262 | 83.7k | break; |
1263 | 85.2k | } |
1264 | 1.26k | case DAV1D_OBU_REDUNDANT_FRAME_HDR: |
1265 | 1.26k | if (c->frame_hdr) break; |
1266 | | // fall-through |
1267 | 254k | case DAV1D_OBU_FRAME: |
1268 | 271k | case DAV1D_OBU_FRAME_HDR: |
1269 | 271k | if (!c->seq_hdr) goto error; |
1270 | 271k | if (!c->frame_hdr_ref) { |
1271 | 258k | c->frame_hdr_ref = dav1d_ref_create_using_pool(c->frame_hdr_pool, |
1272 | 258k | sizeof(Dav1dFrameHeader)); |
1273 | 258k | if (!c->frame_hdr_ref) return DAV1D_ERR(ENOMEM); |
1274 | 258k | } |
1275 | | #ifndef NDEBUG |
1276 | | // ensure that the reference is writable |
1277 | | assert(dav1d_ref_is_writable(c->frame_hdr_ref)); |
1278 | | #endif |
1279 | 271k | c->frame_hdr = c->frame_hdr_ref->data; |
1280 | 271k | memset(c->frame_hdr, 0, sizeof(*c->frame_hdr)); |
1281 | 271k | c->frame_hdr->temporal_id = temporal_id; |
1282 | 271k | c->frame_hdr->spatial_id = spatial_id; |
1283 | 271k | if ((res = parse_frame_hdr(c, &gb)) < 0) { |
1284 | 869 | c->frame_hdr = NULL; |
1285 | 869 | goto error; |
1286 | 869 | } |
1287 | 270k | for (int n = 0; n < c->n_tile_data; n++) |
1288 | 66 | dav1d_data_unref_internal(&c->tile[n].data); |
1289 | 270k | c->n_tile_data = 0; |
1290 | 270k | c->n_tiles = 0; |
1291 | 270k | if (type != DAV1D_OBU_FRAME) { |
1292 | | // This is actually a frame header OBU so read the |
1293 | | // trailing bit and check for overrun. |
1294 | 17.1k | if (check_trailing_bits(&gb, c->strict_std_compliance) < 0) { |
1295 | 338 | c->frame_hdr = NULL; |
1296 | 338 | goto error; |
1297 | 338 | } |
1298 | 17.1k | } |
1299 | | |
1300 | 269k | if (c->frame_size_limit && (int64_t)c->frame_hdr->width[1] * |
1301 | 269k | c->frame_hdr->height > c->frame_size_limit) |
1302 | 259 | { |
1303 | 259 | dav1d_log(c, "Frame size %dx%d exceeds limit %u\n", c->frame_hdr->width[1], |
1304 | 259 | c->frame_hdr->height, c->frame_size_limit); |
1305 | 259 | c->frame_hdr = NULL; |
1306 | 259 | return DAV1D_ERR(ERANGE); |
1307 | 259 | } |
1308 | | |
1309 | 269k | if (type != DAV1D_OBU_FRAME) |
1310 | 16.7k | break; |
1311 | | // OBU_FRAMEs shouldn't be signaled with show_existing_frame |
1312 | 252k | if (c->frame_hdr->show_existing_frame) { |
1313 | 160 | c->frame_hdr = NULL; |
1314 | 160 | goto error; |
1315 | 160 | } |
1316 | | |
1317 | | // This is the frame header at the start of a frame OBU. |
1318 | | // There's no trailing bit at the end to skip, but we do need |
1319 | | // to align to the next byte. |
1320 | 252k | dav1d_bytealign_get_bits(&gb); |
1321 | | // fall-through |
1322 | 255k | case DAV1D_OBU_TILE_GRP: { |
1323 | 255k | if (!c->frame_hdr) goto error; |
1324 | 255k | if (c->n_tile_data_alloc < c->n_tile_data + 1) { |
1325 | 77.1k | if ((c->n_tile_data + 1) > INT_MAX / (int)sizeof(*c->tile)) goto error; |
1326 | 77.1k | struct Dav1dTileGroup *tile = dav1d_realloc(ALLOC_TILE, c->tile, |
1327 | 77.1k | (c->n_tile_data + 1) * sizeof(*c->tile)); |
1328 | 77.1k | if (!tile) goto error; |
1329 | 77.1k | c->tile = tile; |
1330 | 77.1k | memset(c->tile + c->n_tile_data, 0, sizeof(*c->tile)); |
1331 | 77.1k | c->n_tile_data_alloc = c->n_tile_data + 1; |
1332 | 77.1k | } |
1333 | 255k | parse_tile_hdr(c, &gb); |
1334 | | // Align to the next byte boundary and check for overrun. |
1335 | 255k | dav1d_bytealign_get_bits(&gb); |
1336 | 255k | if (gb.error) goto error; |
1337 | | |
1338 | 253k | dav1d_data_ref(&c->tile[c->n_tile_data].data, in); |
1339 | 253k | c->tile[c->n_tile_data].data.data = gb.ptr; |
1340 | 253k | c->tile[c->n_tile_data].data.sz = (size_t)(gb.ptr_end - gb.ptr); |
1341 | | // ensure tile groups are in order and sane, see 6.10.1 |
1342 | 253k | if (c->tile[c->n_tile_data].start > c->tile[c->n_tile_data].end || |
1343 | 253k | c->tile[c->n_tile_data].start != c->n_tiles) |
1344 | 83 | { |
1345 | 179 | for (int i = 0; i <= c->n_tile_data; i++) |
1346 | 96 | dav1d_data_unref_internal(&c->tile[i].data); |
1347 | 83 | c->n_tile_data = 0; |
1348 | 83 | c->n_tiles = 0; |
1349 | 83 | goto error; |
1350 | 83 | } |
1351 | 253k | c->n_tiles += 1 + c->tile[c->n_tile_data].end - |
1352 | 253k | c->tile[c->n_tile_data].start; |
1353 | 253k | c->n_tile_data++; |
1354 | 253k | break; |
1355 | 253k | } |
1356 | 1.46k | case DAV1D_OBU_METADATA: { |
1357 | 1.46k | #define DEBUG_OBU_METADATA 0 |
1358 | | #if DEBUG_OBU_METADATA |
1359 | | const uint8_t *const init_ptr = gb.ptr; |
1360 | | #endif |
1361 | | // obu metadta type field |
1362 | 1.46k | const enum ObuMetaType meta_type = dav1d_get_uleb128(&gb); |
1363 | 1.46k | if (gb.error) goto error; |
1364 | | |
1365 | 1.43k | switch (meta_type) { |
1366 | 148 | case OBU_META_HDR_CLL: { |
1367 | 148 | Dav1dRef *ref = dav1d_ref_create(ALLOC_OBU_META, |
1368 | 148 | sizeof(Dav1dContentLightLevel)); |
1369 | 148 | if (!ref) return DAV1D_ERR(ENOMEM); |
1370 | 148 | Dav1dContentLightLevel *const content_light = ref->data; |
1371 | | |
1372 | 148 | content_light->max_content_light_level = dav1d_get_bits(&gb, 16); |
1373 | | #if DEBUG_OBU_METADATA |
1374 | | printf("CLLOBU: max-content-light-level: %d [off=%td]\n", |
1375 | | content_light->max_content_light_level, |
1376 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1377 | | #endif |
1378 | 148 | content_light->max_frame_average_light_level = dav1d_get_bits(&gb, 16); |
1379 | | #if DEBUG_OBU_METADATA |
1380 | | printf("CLLOBU: max-frame-average-light-level: %d [off=%td]\n", |
1381 | | content_light->max_frame_average_light_level, |
1382 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1383 | | #endif |
1384 | | |
1385 | 148 | if (check_trailing_bits(&gb, c->strict_std_compliance) < 0) { |
1386 | 9 | dav1d_ref_dec(&ref); |
1387 | 9 | goto error; |
1388 | 9 | } |
1389 | | |
1390 | 139 | dav1d_ref_dec(&c->content_light_ref); |
1391 | 139 | c->content_light = content_light; |
1392 | 139 | c->content_light_ref = ref; |
1393 | 139 | break; |
1394 | 148 | } |
1395 | 125 | case OBU_META_HDR_MDCV: { |
1396 | 125 | Dav1dRef *ref = dav1d_ref_create(ALLOC_OBU_META, |
1397 | 125 | sizeof(Dav1dMasteringDisplay)); |
1398 | 125 | if (!ref) return DAV1D_ERR(ENOMEM); |
1399 | 125 | Dav1dMasteringDisplay *const mastering_display = ref->data; |
1400 | | |
1401 | 500 | for (int i = 0; i < 3; i++) { |
1402 | 375 | mastering_display->primaries[i][0] = dav1d_get_bits(&gb, 16); |
1403 | 375 | mastering_display->primaries[i][1] = dav1d_get_bits(&gb, 16); |
1404 | | #if DEBUG_OBU_METADATA |
1405 | | printf("MDCVOBU: primaries[%d]: (%d, %d) [off=%td]\n", i, |
1406 | | mastering_display->primaries[i][0], |
1407 | | mastering_display->primaries[i][1], |
1408 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1409 | | #endif |
1410 | 375 | } |
1411 | 125 | mastering_display->white_point[0] = dav1d_get_bits(&gb, 16); |
1412 | | #if DEBUG_OBU_METADATA |
1413 | | printf("MDCVOBU: white-point-x: %d [off=%td]\n", |
1414 | | mastering_display->white_point[0], |
1415 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1416 | | #endif |
1417 | 125 | mastering_display->white_point[1] = dav1d_get_bits(&gb, 16); |
1418 | | #if DEBUG_OBU_METADATA |
1419 | | printf("MDCVOBU: white-point-y: %d [off=%td]\n", |
1420 | | mastering_display->white_point[1], |
1421 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1422 | | #endif |
1423 | 125 | mastering_display->max_luminance = dav1d_get_bits(&gb, 32); |
1424 | | #if DEBUG_OBU_METADATA |
1425 | | printf("MDCVOBU: max-luminance: %d [off=%td]\n", |
1426 | | mastering_display->max_luminance, |
1427 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1428 | | #endif |
1429 | 125 | mastering_display->min_luminance = dav1d_get_bits(&gb, 32); |
1430 | | #if DEBUG_OBU_METADATA |
1431 | | printf("MDCVOBU: min-luminance: %d [off=%td]\n", |
1432 | | mastering_display->min_luminance, |
1433 | | (gb.ptr - init_ptr) * 8 - gb.bits_left); |
1434 | | #endif |
1435 | 125 | if (check_trailing_bits(&gb, c->strict_std_compliance) < 0) { |
1436 | 9 | dav1d_ref_dec(&ref); |
1437 | 9 | goto error; |
1438 | 9 | } |
1439 | | |
1440 | 116 | dav1d_ref_dec(&c->mastering_display_ref); |
1441 | 116 | c->mastering_display = mastering_display; |
1442 | 116 | c->mastering_display_ref = ref; |
1443 | 116 | break; |
1444 | 125 | } |
1445 | 127 | case OBU_META_ITUT_T35: { |
1446 | 127 | ptrdiff_t payload_size = gb.ptr_end - gb.ptr; |
1447 | | // Don't take into account all the trailing bits for payload_size |
1448 | 1.57k | while (payload_size > 0 && !gb.ptr[payload_size - 1]) |
1449 | 1.44k | payload_size--; // trailing_zero_bit x 8 |
1450 | 127 | payload_size--; // trailing_one_bit + trailing_zero_bit x 7 |
1451 | | |
1452 | 127 | int country_code_extension_byte = 0; |
1453 | 127 | const int country_code = dav1d_get_bits(&gb, 8); |
1454 | 127 | payload_size--; |
1455 | 127 | if (country_code == 0xFF) { |
1456 | 33 | country_code_extension_byte = dav1d_get_bits(&gb, 8); |
1457 | 33 | payload_size--; |
1458 | 33 | } |
1459 | | |
1460 | 127 | if (payload_size <= 0 || gb.ptr[payload_size] != 0x80) { |
1461 | 104 | dav1d_log(c, "Malformed ITU-T T.35 metadata message format\n"); |
1462 | 104 | break; |
1463 | 104 | } |
1464 | | |
1465 | 23 | if ((c->n_itut_t35 + 1) > INT_MAX / (int)sizeof(*c->itut_t35)) goto error; |
1466 | 23 | struct Dav1dITUTT35 *itut_t35 = dav1d_realloc(ALLOC_OBU_META, c->itut_t35, |
1467 | 23 | (c->n_itut_t35 + 1) * sizeof(*c->itut_t35)); |
1468 | 23 | if (!itut_t35) goto error; |
1469 | 23 | c->itut_t35 = itut_t35; |
1470 | 23 | memset(c->itut_t35 + c->n_itut_t35, 0, sizeof(*c->itut_t35)); |
1471 | | |
1472 | 23 | struct itut_t35_ctx_context *itut_t35_ctx; |
1473 | 23 | if (!c->n_itut_t35) { |
1474 | 23 | assert(!c->itut_t35_ref); |
1475 | 23 | itut_t35_ctx = dav1d_malloc(ALLOC_OBU_META, sizeof(struct itut_t35_ctx_context)); |
1476 | 23 | if (!itut_t35_ctx) goto error; |
1477 | 23 | c->itut_t35_ref = dav1d_ref_init(&itut_t35_ctx->ref, c->itut_t35, |
1478 | 23 | dav1d_picture_free_itut_t35, itut_t35_ctx, 0); |
1479 | 23 | } else { |
1480 | 0 | assert(c->itut_t35_ref && atomic_load(&c->itut_t35_ref->ref_cnt) == 1); |
1481 | 0 | itut_t35_ctx = c->itut_t35_ref->user_data; |
1482 | 0 | c->itut_t35_ref->const_data = (uint8_t *)c->itut_t35; |
1483 | 0 | } |
1484 | 23 | itut_t35_ctx->itut_t35 = c->itut_t35; |
1485 | 23 | itut_t35_ctx->n_itut_t35 = c->n_itut_t35 + 1; |
1486 | | |
1487 | 23 | Dav1dITUTT35 *const itut_t35_metadata = &c->itut_t35[c->n_itut_t35]; |
1488 | 23 | itut_t35_metadata->payload = dav1d_malloc(ALLOC_OBU_META, payload_size); |
1489 | 23 | if (!itut_t35_metadata->payload) goto error; |
1490 | | |
1491 | 23 | itut_t35_metadata->country_code = country_code; |
1492 | 23 | itut_t35_metadata->country_code_extension_byte = country_code_extension_byte; |
1493 | 23 | itut_t35_metadata->payload_size = payload_size; |
1494 | | |
1495 | | // We know that we've read a whole number of bytes and that the |
1496 | | // payload is within the OBU boundaries, so just use memcpy() |
1497 | 23 | assert(gb.bits_left == 0); |
1498 | 23 | memcpy(itut_t35_metadata->payload, gb.ptr, payload_size); |
1499 | | |
1500 | 23 | c->n_itut_t35++; |
1501 | 23 | break; |
1502 | 23 | } |
1503 | 90 | case OBU_META_SCALABILITY: |
1504 | 116 | case OBU_META_TIMECODE: |
1505 | | // ignore metadata OBUs we don't care about |
1506 | 116 | break; |
1507 | 917 | default: |
1508 | | // print a warning but don't fail for unknown types |
1509 | 917 | if (meta_type > 31) // Types 6 to 31 are "Unregistered user private", so ignore them. |
1510 | 784 | dav1d_log(c, "Unknown Metadata OBU type %d\n", meta_type); |
1511 | 917 | break; |
1512 | 1.43k | } |
1513 | | |
1514 | 1.41k | break; |
1515 | 1.43k | } |
1516 | 17.1k | case DAV1D_OBU_TD: |
1517 | 17.1k | c->frame_flags |= PICTURE_FLAG_NEW_TEMPORAL_UNIT; |
1518 | 17.1k | break; |
1519 | 3.18k | case DAV1D_OBU_PADDING: |
1520 | | // ignore OBUs we don't care about |
1521 | 3.18k | break; |
1522 | 10.3k | default: |
1523 | | // print a warning but don't fail for unknown types |
1524 | 10.3k | dav1d_log(c, "Unknown OBU type %d of size %td\n", type, gb.ptr_end - gb.ptr); |
1525 | 10.3k | break; |
1526 | 392k | } |
1527 | | |
1528 | 386k | if (c->seq_hdr && c->frame_hdr) { |
1529 | 272k | if (c->frame_hdr->show_existing_frame) { |
1530 | 726 | if (!c->refs[c->frame_hdr->existing_frame_idx].p.p.frame_hdr) goto error; |
1531 | 699 | switch (c->refs[c->frame_hdr->existing_frame_idx].p.p.frame_hdr->frame_type) { |
1532 | 186 | case DAV1D_FRAME_TYPE_INTER: |
1533 | 282 | case DAV1D_FRAME_TYPE_SWITCH: |
1534 | 282 | if (c->decode_frame_type > DAV1D_DECODEFRAMETYPE_REFERENCE) |
1535 | 0 | goto skip; |
1536 | 282 | break; |
1537 | 282 | case DAV1D_FRAME_TYPE_INTRA: |
1538 | 77 | if (c->decode_frame_type > DAV1D_DECODEFRAMETYPE_INTRA) |
1539 | 0 | goto skip; |
1540 | | // fall-through |
1541 | 417 | default: |
1542 | 417 | break; |
1543 | 699 | } |
1544 | 699 | if (!c->refs[c->frame_hdr->existing_frame_idx].p.p.data[0]) goto error; |
1545 | 699 | if (c->strict_std_compliance && |
1546 | 0 | !c->refs[c->frame_hdr->existing_frame_idx].p.showable) |
1547 | 0 | { |
1548 | 0 | goto error; |
1549 | 0 | } |
1550 | 699 | if (c->n_fc == 1) { |
1551 | 0 | dav1d_thread_picture_ref(&c->out, |
1552 | 0 | &c->refs[c->frame_hdr->existing_frame_idx].p); |
1553 | 0 | dav1d_picture_copy_props(&c->out.p, |
1554 | 0 | c->content_light, c->content_light_ref, |
1555 | 0 | c->mastering_display, c->mastering_display_ref, |
1556 | 0 | c->itut_t35, c->itut_t35_ref, c->n_itut_t35, |
1557 | 0 | &in->m); |
1558 | | // Must be removed from the context after being attached to the frame |
1559 | 0 | dav1d_ref_dec(&c->itut_t35_ref); |
1560 | 0 | c->itut_t35 = NULL; |
1561 | 0 | c->n_itut_t35 = 0; |
1562 | 0 | c->event_flags |= dav1d_picture_get_event_flags(&c->refs[c->frame_hdr->existing_frame_idx].p); |
1563 | 699 | } else { |
1564 | 699 | pthread_mutex_lock(&c->task_thread.lock); |
1565 | | // need to append this to the frame output queue |
1566 | 699 | const unsigned next = c->frame_thread.next++; |
1567 | 699 | if (c->frame_thread.next == c->n_fc) |
1568 | 88 | c->frame_thread.next = 0; |
1569 | | |
1570 | 699 | Dav1dFrameContext *const f = &c->fc[next]; |
1571 | 784 | while (f->n_tile_data > 0) |
1572 | 85 | pthread_cond_wait(&f->task_thread.cond, |
1573 | 85 | &f->task_thread.ttd->lock); |
1574 | 699 | Dav1dThreadPicture *const out_delayed = |
1575 | 699 | &c->frame_thread.out_delayed[next]; |
1576 | 699 | if (out_delayed->p.data[0] || atomic_load(&f->task_thread.error)) { |
1577 | 284 | unsigned first = atomic_load(&c->task_thread.first); |
1578 | 284 | if (first + 1U < c->n_fc) |
1579 | 284 | atomic_fetch_add(&c->task_thread.first, 1U); |
1580 | 52 | else |
1581 | 284 | atomic_store(&c->task_thread.first, 0); |
1582 | 284 | atomic_compare_exchange_strong(&c->task_thread.reset_task_cur, |
1583 | 284 | &first, UINT_MAX); |
1584 | 284 | if (c->task_thread.cur && c->task_thread.cur < c->n_fc) |
1585 | 41 | c->task_thread.cur--; |
1586 | 284 | } |
1587 | 699 | const int error = f->task_thread.retval; |
1588 | 699 | if (error) { |
1589 | 0 | c->cached_error = error; |
1590 | 0 | f->task_thread.retval = 0; |
1591 | 0 | dav1d_data_props_copy(&c->cached_error_props, &out_delayed->p.m); |
1592 | 0 | dav1d_thread_picture_unref(out_delayed); |
1593 | 699 | } else if (out_delayed->p.data[0]) { |
1594 | 284 | const unsigned progress = atomic_load_explicit(&out_delayed->progress[1], |
1595 | 284 | memory_order_relaxed); |
1596 | 284 | if ((out_delayed->visible || c->output_invisible_frames) && |
1597 | 278 | progress != FRAME_ERROR) |
1598 | 278 | { |
1599 | 278 | dav1d_thread_picture_ref(&c->out, out_delayed); |
1600 | 278 | c->event_flags |= dav1d_picture_get_event_flags(out_delayed); |
1601 | 278 | } |
1602 | 284 | dav1d_thread_picture_unref(out_delayed); |
1603 | 284 | } |
1604 | 699 | dav1d_thread_picture_ref(out_delayed, |
1605 | 699 | &c->refs[c->frame_hdr->existing_frame_idx].p); |
1606 | 699 | out_delayed->visible = 1; |
1607 | 699 | dav1d_picture_copy_props(&out_delayed->p, |
1608 | 699 | c->content_light, c->content_light_ref, |
1609 | 699 | c->mastering_display, c->mastering_display_ref, |
1610 | 699 | c->itut_t35, c->itut_t35_ref, c->n_itut_t35, |
1611 | 699 | &in->m); |
1612 | | // Must be removed from the context after being attached to the frame |
1613 | 699 | dav1d_ref_dec(&c->itut_t35_ref); |
1614 | 699 | c->itut_t35 = NULL; |
1615 | 699 | c->n_itut_t35 = 0; |
1616 | | |
1617 | 699 | pthread_mutex_unlock(&c->task_thread.lock); |
1618 | 699 | } |
1619 | 699 | if (c->refs[c->frame_hdr->existing_frame_idx].p.p.frame_hdr->frame_type == DAV1D_FRAME_TYPE_KEY) { |
1620 | 340 | const int r = c->frame_hdr->existing_frame_idx; |
1621 | 340 | c->refs[r].p.showable = 0; |
1622 | 3.06k | for (int i = 0; i < 8; i++) { |
1623 | 2.72k | if (i == r) continue; |
1624 | | |
1625 | 2.38k | if (c->refs[i].p.p.frame_hdr) |
1626 | 2.23k | dav1d_thread_picture_unref(&c->refs[i].p); |
1627 | 2.38k | dav1d_thread_picture_ref(&c->refs[i].p, &c->refs[r].p); |
1628 | | |
1629 | 2.38k | dav1d_cdf_thread_unref(&c->cdf[i]); |
1630 | 2.38k | dav1d_cdf_thread_ref(&c->cdf[i], &c->cdf[r]); |
1631 | | |
1632 | 2.38k | dav1d_ref_dec(&c->refs[i].segmap); |
1633 | 2.38k | c->refs[i].segmap = c->refs[r].segmap; |
1634 | 2.38k | if (c->refs[r].segmap) |
1635 | 637 | dav1d_ref_inc(c->refs[r].segmap); |
1636 | 2.38k | dav1d_ref_dec(&c->refs[i].refmvs); |
1637 | 2.38k | } |
1638 | 340 | } |
1639 | 699 | c->frame_hdr = NULL; |
1640 | 271k | } else if (c->n_tiles == c->frame_hdr->tiling.cols * c->frame_hdr->tiling.rows) { |
1641 | 253k | switch (c->frame_hdr->frame_type) { |
1642 | 165k | case DAV1D_FRAME_TYPE_INTER: |
1643 | 170k | case DAV1D_FRAME_TYPE_SWITCH: |
1644 | 170k | if (c->decode_frame_type > DAV1D_DECODEFRAMETYPE_REFERENCE || |
1645 | 170k | (c->decode_frame_type == DAV1D_DECODEFRAMETYPE_REFERENCE && |
1646 | 0 | !c->frame_hdr->refresh_frame_flags)) |
1647 | 0 | goto skip; |
1648 | 170k | break; |
1649 | 170k | case DAV1D_FRAME_TYPE_INTRA: |
1650 | 1.79k | if (c->decode_frame_type > DAV1D_DECODEFRAMETYPE_INTRA || |
1651 | 1.79k | (c->decode_frame_type == DAV1D_DECODEFRAMETYPE_REFERENCE && |
1652 | 0 | !c->frame_hdr->refresh_frame_flags)) |
1653 | 0 | goto skip; |
1654 | | // fall-through |
1655 | 83.0k | default: |
1656 | 83.0k | break; |
1657 | 253k | } |
1658 | 253k | if (!c->n_tile_data) |
1659 | 0 | goto error; |
1660 | 253k | if ((res = dav1d_submit_frame(c)) < 0) |
1661 | 453 | return res; |
1662 | 252k | assert(!c->n_tile_data); |
1663 | 252k | c->frame_hdr = NULL; |
1664 | 252k | c->n_tiles = 0; |
1665 | 252k | } |
1666 | 272k | } |
1667 | | |
1668 | 386k | return gb.ptr_end - gb.ptr_start; |
1669 | | |
1670 | 0 | skip: |
1671 | | // update refs with only the headers in case we skip the frame |
1672 | 0 | for (int i = 0; i < 8; i++) { |
1673 | 0 | if (c->frame_hdr->refresh_frame_flags & (1 << i)) { |
1674 | 0 | dav1d_thread_picture_unref(&c->refs[i].p); |
1675 | 0 | c->refs[i].p.p.frame_hdr = c->frame_hdr; |
1676 | 0 | c->refs[i].p.p.seq_hdr = c->seq_hdr; |
1677 | 0 | c->refs[i].p.p.frame_hdr_ref = c->frame_hdr_ref; |
1678 | 0 | c->refs[i].p.p.seq_hdr_ref = c->seq_hdr_ref; |
1679 | 0 | dav1d_ref_inc(c->frame_hdr_ref); |
1680 | 0 | dav1d_ref_inc(c->seq_hdr_ref); |
1681 | 0 | } |
1682 | 0 | } |
1683 | |
|
1684 | 0 | dav1d_ref_dec(&c->frame_hdr_ref); |
1685 | 0 | c->frame_hdr = NULL; |
1686 | 0 | c->n_tiles = 0; |
1687 | |
|
1688 | 0 | return gb.ptr_end - gb.ptr_start; |
1689 | | |
1690 | 8.15k | error: |
1691 | 8.15k | dav1d_data_props_copy(&c->cached_error_props, &in->m); |
1692 | 8.15k | dav1d_log(c, gb.error ? "Overrun in OBU bit buffer\n" : |
1693 | 8.15k | "Error parsing OBU data\n"); |
1694 | 8.15k | return DAV1D_ERR(EINVAL); |
1695 | 386k | } |