GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* Copyright (C) 2007 Marco Gerards <marco@gnu.org> |
||
3 |
* Copyright (C) 2009 David Conrad |
||
4 |
* Copyright (C) 2011 Jordi Ortiz |
||
5 |
* |
||
6 |
* This file is part of FFmpeg. |
||
7 |
* |
||
8 |
* FFmpeg is free software; you can redistribute it and/or |
||
9 |
* modify it under the terms of the GNU Lesser General Public |
||
10 |
* License as published by the Free Software Foundation; either |
||
11 |
* version 2.1 of the License, or (at your option) any later version. |
||
12 |
* |
||
13 |
* FFmpeg is distributed in the hope that it will be useful, |
||
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
16 |
* Lesser General Public License for more details. |
||
17 |
* |
||
18 |
* You should have received a copy of the GNU Lesser General Public |
||
19 |
* License along with FFmpeg; if not, write to the Free Software |
||
20 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
21 |
*/ |
||
22 |
|||
23 |
/** |
||
24 |
* @file |
||
25 |
* Dirac Decoder |
||
26 |
* @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com> |
||
27 |
*/ |
||
28 |
|||
29 |
#include "libavutil/mem_internal.h" |
||
30 |
#include "libavutil/pixdesc.h" |
||
31 |
#include "libavutil/thread.h" |
||
32 |
#include "avcodec.h" |
||
33 |
#include "get_bits.h" |
||
34 |
#include "bytestream.h" |
||
35 |
#include "internal.h" |
||
36 |
#include "golomb.h" |
||
37 |
#include "dirac_arith.h" |
||
38 |
#include "dirac_vlc.h" |
||
39 |
#include "mpeg12data.h" |
||
40 |
#include "libavcodec/mpegvideo.h" |
||
41 |
#include "mpegvideoencdsp.h" |
||
42 |
#include "dirac_dwt.h" |
||
43 |
#include "dirac.h" |
||
44 |
#include "diractab.h" |
||
45 |
#include "diracdsp.h" |
||
46 |
#include "videodsp.h" |
||
47 |
|||
48 |
/** |
||
49 |
* The spec limits this to 3 for frame coding, but in practice can be as high as 6 |
||
50 |
*/ |
||
51 |
#define MAX_REFERENCE_FRAMES 8 |
||
52 |
#define MAX_DELAY 5 /* limit for main profile for frame coding (TODO: field coding) */ |
||
53 |
#define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1) |
||
54 |
#define MAX_QUANT 255 /* max quant for VC-2 */ |
||
55 |
#define MAX_BLOCKSIZE 32 /* maximum xblen/yblen we support */ |
||
56 |
|||
57 |
/** |
||
58 |
* DiracBlock->ref flags, if set then the block does MC from the given ref |
||
59 |
*/ |
||
60 |
#define DIRAC_REF_MASK_REF1 1 |
||
61 |
#define DIRAC_REF_MASK_REF2 2 |
||
62 |
#define DIRAC_REF_MASK_GLOBAL 4 |
||
63 |
|||
64 |
/** |
||
65 |
* Value of Picture.reference when Picture is not a reference picture, but |
||
66 |
* is held for delayed output. |
||
67 |
*/ |
||
68 |
#define DELAYED_PIC_REF 4 |
||
69 |
|||
70 |
#define CALC_PADDING(size, depth) \ |
||
71 |
(((size + (1 << depth) - 1) >> depth) << depth) |
||
72 |
|||
73 |
#define DIVRNDUP(a, b) (((a) + (b) - 1) / (b)) |
||
74 |
|||
75 |
typedef struct { |
||
76 |
AVFrame *avframe; |
||
77 |
int interpolated[3]; /* 1 if hpel[] is valid */ |
||
78 |
uint8_t *hpel[3][4]; |
||
79 |
uint8_t *hpel_base[3][4]; |
||
80 |
int reference; |
||
81 |
} DiracFrame; |
||
82 |
|||
83 |
typedef struct { |
||
84 |
union { |
||
85 |
int16_t mv[2][2]; |
||
86 |
int16_t dc[3]; |
||
87 |
} u; /* anonymous unions aren't in C99 :( */ |
||
88 |
uint8_t ref; |
||
89 |
} DiracBlock; |
||
90 |
|||
91 |
typedef struct SubBand { |
||
92 |
int level; |
||
93 |
int orientation; |
||
94 |
int stride; /* in bytes */ |
||
95 |
int width; |
||
96 |
int height; |
||
97 |
int pshift; |
||
98 |
int quant; |
||
99 |
uint8_t *ibuf; |
||
100 |
struct SubBand *parent; |
||
101 |
|||
102 |
/* for low delay */ |
||
103 |
unsigned length; |
||
104 |
const uint8_t *coeff_data; |
||
105 |
} SubBand; |
||
106 |
|||
107 |
typedef struct Plane { |
||
108 |
DWTPlane idwt; |
||
109 |
|||
110 |
int width; |
||
111 |
int height; |
||
112 |
ptrdiff_t stride; |
||
113 |
|||
114 |
/* block length */ |
||
115 |
uint8_t xblen; |
||
116 |
uint8_t yblen; |
||
117 |
/* block separation (block n+1 starts after this many pixels in block n) */ |
||
118 |
uint8_t xbsep; |
||
119 |
uint8_t ybsep; |
||
120 |
/* amount of overspill on each edge (half of the overlap between blocks) */ |
||
121 |
uint8_t xoffset; |
||
122 |
uint8_t yoffset; |
||
123 |
|||
124 |
SubBand band[MAX_DWT_LEVELS][4]; |
||
125 |
} Plane; |
||
126 |
|||
127 |
/* Used by Low Delay and High Quality profiles */ |
||
128 |
typedef struct DiracSlice { |
||
129 |
GetBitContext gb; |
||
130 |
int slice_x; |
||
131 |
int slice_y; |
||
132 |
int bytes; |
||
133 |
} DiracSlice; |
||
134 |
|||
135 |
typedef struct DiracContext { |
||
136 |
AVCodecContext *avctx; |
||
137 |
MpegvideoEncDSPContext mpvencdsp; |
||
138 |
VideoDSPContext vdsp; |
||
139 |
DiracDSPContext diracdsp; |
||
140 |
DiracVersionInfo version; |
||
141 |
GetBitContext gb; |
||
142 |
AVDiracSeqHeader seq; |
||
143 |
int seen_sequence_header; |
||
144 |
int64_t frame_number; /* number of the next frame to display */ |
||
145 |
Plane plane[3]; |
||
146 |
int chroma_x_shift; |
||
147 |
int chroma_y_shift; |
||
148 |
|||
149 |
int bit_depth; /* bit depth */ |
||
150 |
int pshift; /* pixel shift = bit_depth > 8 */ |
||
151 |
|||
152 |
int zero_res; /* zero residue flag */ |
||
153 |
int is_arith; /* whether coeffs use arith or golomb coding */ |
||
154 |
int core_syntax; /* use core syntax only */ |
||
155 |
int low_delay; /* use the low delay syntax */ |
||
156 |
int hq_picture; /* high quality picture, enables low_delay */ |
||
157 |
int ld_picture; /* use low delay picture, turns on low_delay */ |
||
158 |
int dc_prediction; /* has dc prediction */ |
||
159 |
int globalmc_flag; /* use global motion compensation */ |
||
160 |
int num_refs; /* number of reference pictures */ |
||
161 |
|||
162 |
/* wavelet decoding */ |
||
163 |
unsigned wavelet_depth; /* depth of the IDWT */ |
||
164 |
unsigned wavelet_idx; |
||
165 |
|||
166 |
/** |
||
167 |
* schroedinger older than 1.0.8 doesn't store |
||
168 |
* quant delta if only one codebook exists in a band |
||
169 |
*/ |
||
170 |
unsigned old_delta_quant; |
||
171 |
unsigned codeblock_mode; |
||
172 |
|||
173 |
unsigned num_x; /* number of horizontal slices */ |
||
174 |
unsigned num_y; /* number of vertical slices */ |
||
175 |
|||
176 |
uint8_t *thread_buf; /* Per-thread buffer for coefficient storage */ |
||
177 |
int threads_num_buf; /* Current # of buffers allocated */ |
||
178 |
int thread_buf_size; /* Each thread has a buffer this size */ |
||
179 |
|||
180 |
DiracSlice *slice_params_buf; |
||
181 |
int slice_params_num_buf; |
||
182 |
|||
183 |
struct { |
||
184 |
unsigned width; |
||
185 |
unsigned height; |
||
186 |
} codeblock[MAX_DWT_LEVELS+1]; |
||
187 |
|||
188 |
struct { |
||
189 |
AVRational bytes; /* average bytes per slice */ |
||
190 |
uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */ |
||
191 |
} lowdelay; |
||
192 |
|||
193 |
struct { |
||
194 |
unsigned prefix_bytes; |
||
195 |
uint64_t size_scaler; |
||
196 |
} highquality; |
||
197 |
|||
198 |
struct { |
||
199 |
int pan_tilt[2]; /* pan/tilt vector */ |
||
200 |
int zrs[2][2]; /* zoom/rotate/shear matrix */ |
||
201 |
int perspective[2]; /* perspective vector */ |
||
202 |
unsigned zrs_exp; |
||
203 |
unsigned perspective_exp; |
||
204 |
} globalmc[2]; |
||
205 |
|||
206 |
/* motion compensation */ |
||
207 |
uint8_t mv_precision; /* [DIRAC_STD] REFS_WT_PRECISION */ |
||
208 |
int16_t weight[2]; /* [DIRAC_STD] REF1_WT and REF2_WT */ |
||
209 |
unsigned weight_log2denom; /* [DIRAC_STD] REFS_WT_PRECISION */ |
||
210 |
|||
211 |
int blwidth; /* number of blocks (horizontally) */ |
||
212 |
int blheight; /* number of blocks (vertically) */ |
||
213 |
int sbwidth; /* number of superblocks (horizontally) */ |
||
214 |
int sbheight; /* number of superblocks (vertically) */ |
||
215 |
|||
216 |
uint8_t *sbsplit; |
||
217 |
DiracBlock *blmotion; |
||
218 |
|||
219 |
uint8_t *edge_emu_buffer[4]; |
||
220 |
uint8_t *edge_emu_buffer_base; |
||
221 |
|||
222 |
uint16_t *mctmp; /* buffer holding the MC data multiplied by OBMC weights */ |
||
223 |
uint8_t *mcscratch; |
||
224 |
int buffer_stride; |
||
225 |
|||
226 |
DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE]; |
||
227 |
|||
228 |
void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h); |
||
229 |
void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h); |
||
230 |
void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen); |
||
231 |
dirac_weight_func weight_func; |
||
232 |
dirac_biweight_func biweight_func; |
||
233 |
|||
234 |
DiracFrame *current_picture; |
||
235 |
DiracFrame *ref_pics[2]; |
||
236 |
|||
237 |
DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1]; |
||
238 |
DiracFrame *delay_frames[MAX_DELAY+1]; |
||
239 |
DiracFrame all_frames[MAX_FRAMES]; |
||
240 |
} DiracContext; |
||
241 |
|||
242 |
enum dirac_subband { |
||
243 |
subband_ll = 0, |
||
244 |
subband_hl = 1, |
||
245 |
subband_lh = 2, |
||
246 |
subband_hh = 3, |
||
247 |
subband_nb, |
||
248 |
}; |
||
249 |
|||
250 |
/* magic number division by 3 from schroedinger */ |
||
251 |
55371 |
static inline int divide3(int x) |
|
252 |
{ |
||
253 |
55371 |
return (int)((x+1U)*21845 + 10922) >> 16; |
|
254 |
} |
||
255 |
|||
256 |
14 |
static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum) |
|
257 |
{ |
||
258 |
14 |
DiracFrame *remove_pic = NULL; |
|
259 |
14 |
int i, remove_idx = -1; |
|
260 |
|||
261 |
✓✓ | 39 |
for (i = 0; framelist[i]; i++) |
262 |
✓✓ | 25 |
if (framelist[i]->avframe->display_picture_number == picnum) { |
263 |
13 |
remove_pic = framelist[i]; |
|
264 |
13 |
remove_idx = i; |
|
265 |
} |
||
266 |
|||
267 |
✓✓ | 14 |
if (remove_pic) |
268 |
✓✓ | 32 |
for (i = remove_idx; framelist[i]; i++) |
269 |
19 |
framelist[i] = framelist[i+1]; |
|
270 |
|||
271 |
14 |
return remove_pic; |
|
272 |
} |
||
273 |
|||
274 |
18 |
static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame) |
|
275 |
{ |
||
276 |
int i; |
||
277 |
✓✗ | 33 |
for (i = 0; i < maxframes; i++) |
278 |
✓✓ | 33 |
if (!framelist[i]) { |
279 |
18 |
framelist[i] = frame; |
|
280 |
18 |
return 0; |
|
281 |
} |
||
282 |
return -1; |
||
283 |
} |
||
284 |
|||
285 |
70 |
static int alloc_sequence_buffers(DiracContext *s) |
|
286 |
{ |
||
287 |
70 |
int sbwidth = DIVRNDUP(s->seq.width, 4); |
|
288 |
70 |
int sbheight = DIVRNDUP(s->seq.height, 4); |
|
289 |
int i, w, h, top_padding; |
||
290 |
|||
291 |
/* todo: think more about this / use or set Plane here */ |
||
292 |
✓✓ | 280 |
for (i = 0; i < 3; i++) { |
293 |
✓✓ | 210 |
int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0); |
294 |
✓✓ | 210 |
int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0); |
295 |
✓✓ | 210 |
w = s->seq.width >> (i ? s->chroma_x_shift : 0); |
296 |
✓✓ | 210 |
h = s->seq.height >> (i ? s->chroma_y_shift : 0); |
297 |
|||
298 |
/* we allocate the max we support here since num decompositions can |
||
299 |
* change from frame to frame. Stride is aligned to 16 for SIMD, and |
||
300 |
* 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding |
||
301 |
* MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that |
||
302 |
* on each side */ |
||
303 |
✗✓ | 210 |
top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2); |
304 |
210 |
w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */ |
|
305 |
210 |
h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2; |
|
306 |
|||
307 |
210 |
s->plane[i].idwt.buf_base = av_mallocz_array((w+max_xblen), h * (2 << s->pshift)); |
|
308 |
210 |
s->plane[i].idwt.tmp = av_malloc_array((w+16), 2 << s->pshift); |
|
309 |
210 |
s->plane[i].idwt.buf = s->plane[i].idwt.buf_base + (top_padding*w)*(2 << s->pshift); |
|
310 |
✓✗✗✓ |
210 |
if (!s->plane[i].idwt.buf_base || !s->plane[i].idwt.tmp) |
311 |
return AVERROR(ENOMEM); |
||
312 |
} |
||
313 |
|||
314 |
/* fixme: allocate using real stride here */ |
||
315 |
70 |
s->sbsplit = av_malloc_array(sbwidth, sbheight); |
|
316 |
70 |
s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion)); |
|
317 |
|||
318 |
✓✗✗✓ |
70 |
if (!s->sbsplit || !s->blmotion) |
319 |
return AVERROR(ENOMEM); |
||
320 |
70 |
return 0; |
|
321 |
} |
||
322 |
|||
323 |
260 |
static int alloc_buffers(DiracContext *s, int stride) |
|
324 |
{ |
||
325 |
260 |
int w = s->seq.width; |
|
326 |
260 |
int h = s->seq.height; |
|
327 |
|||
328 |
✗✓ | 260 |
av_assert0(stride >= w); |
329 |
260 |
stride += 64; |
|
330 |
|||
331 |
✓✓ | 260 |
if (s->buffer_stride >= stride) |
332 |
190 |
return 0; |
|
333 |
70 |
s->buffer_stride = 0; |
|
334 |
|||
335 |
70 |
av_freep(&s->edge_emu_buffer_base); |
|
336 |
70 |
memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer)); |
|
337 |
70 |
av_freep(&s->mctmp); |
|
338 |
70 |
av_freep(&s->mcscratch); |
|
339 |
|||
340 |
70 |
s->edge_emu_buffer_base = av_malloc_array(stride, MAX_BLOCKSIZE); |
|
341 |
|||
342 |
70 |
s->mctmp = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp)); |
|
343 |
70 |
s->mcscratch = av_malloc_array(stride, MAX_BLOCKSIZE); |
|
344 |
|||
345 |
✓✗✓✗ ✗✓ |
70 |
if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch) |
346 |
return AVERROR(ENOMEM); |
||
347 |
|||
348 |
70 |
s->buffer_stride = stride; |
|
349 |
70 |
return 0; |
|
350 |
} |
||
351 |
|||
352 |
70 |
static void free_sequence_buffers(DiracContext *s) |
|
353 |
{ |
||
354 |
int i, j, k; |
||
355 |
|||
356 |
✓✓ | 1050 |
for (i = 0; i < MAX_FRAMES; i++) { |
357 |
✓✓ | 980 |
if (s->all_frames[i].avframe->data[0]) { |
358 |
38 |
av_frame_unref(s->all_frames[i].avframe); |
|
359 |
38 |
memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated)); |
|
360 |
} |
||
361 |
|||
362 |
✓✓ | 3920 |
for (j = 0; j < 3; j++) |
363 |
✓✓ | 11760 |
for (k = 1; k < 4; k++) |
364 |
8820 |
av_freep(&s->all_frames[i].hpel_base[j][k]); |
|
365 |
} |
||
366 |
|||
367 |
70 |
memset(s->ref_frames, 0, sizeof(s->ref_frames)); |
|
368 |
70 |
memset(s->delay_frames, 0, sizeof(s->delay_frames)); |
|
369 |
|||
370 |
✓✓ | 280 |
for (i = 0; i < 3; i++) { |
371 |
210 |
av_freep(&s->plane[i].idwt.buf_base); |
|
372 |
210 |
av_freep(&s->plane[i].idwt.tmp); |
|
373 |
} |
||
374 |
|||
375 |
70 |
s->buffer_stride = 0; |
|
376 |
70 |
av_freep(&s->sbsplit); |
|
377 |
70 |
av_freep(&s->blmotion); |
|
378 |
70 |
av_freep(&s->edge_emu_buffer_base); |
|
379 |
|||
380 |
70 |
av_freep(&s->mctmp); |
|
381 |
70 |
av_freep(&s->mcscratch); |
|
382 |
70 |
} |
|
383 |
|||
384 |
static AVOnce dirac_arith_init = AV_ONCE_INIT; |
||
385 |
|||
386 |
70 |
static av_cold int dirac_decode_init(AVCodecContext *avctx) |
|
387 |
{ |
||
388 |
70 |
DiracContext *s = avctx->priv_data; |
|
389 |
int i, ret; |
||
390 |
|||
391 |
70 |
s->avctx = avctx; |
|
392 |
70 |
s->frame_number = -1; |
|
393 |
|||
394 |
70 |
s->thread_buf = NULL; |
|
395 |
70 |
s->threads_num_buf = -1; |
|
396 |
70 |
s->thread_buf_size = -1; |
|
397 |
|||
398 |
70 |
ff_diracdsp_init(&s->diracdsp); |
|
399 |
70 |
ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx); |
|
400 |
70 |
ff_videodsp_init(&s->vdsp, 8); |
|
401 |
|||
402 |
✓✓ | 1050 |
for (i = 0; i < MAX_FRAMES; i++) { |
403 |
980 |
s->all_frames[i].avframe = av_frame_alloc(); |
|
404 |
✗✓ | 980 |
if (!s->all_frames[i].avframe) { |
405 |
while (i > 0) |
||
406 |
av_frame_free(&s->all_frames[--i].avframe); |
||
407 |
return AVERROR(ENOMEM); |
||
408 |
} |
||
409 |
} |
||
410 |
70 |
ret = ff_thread_once(&dirac_arith_init, ff_dirac_init_arith_tables); |
|
411 |
✗✓ | 70 |
if (ret != 0) |
412 |
return AVERROR_UNKNOWN; |
||
413 |
|||
414 |
70 |
return 0; |
|
415 |
} |
||
416 |
|||
417 |
70 |
static void dirac_decode_flush(AVCodecContext *avctx) |
|
418 |
{ |
||
419 |
70 |
DiracContext *s = avctx->priv_data; |
|
420 |
70 |
free_sequence_buffers(s); |
|
421 |
70 |
s->seen_sequence_header = 0; |
|
422 |
70 |
s->frame_number = -1; |
|
423 |
70 |
} |
|
424 |
|||
425 |
70 |
static av_cold int dirac_decode_end(AVCodecContext *avctx) |
|
426 |
{ |
||
427 |
70 |
DiracContext *s = avctx->priv_data; |
|
428 |
int i; |
||
429 |
|||
430 |
70 |
dirac_decode_flush(avctx); |
|
431 |
✓✓ | 1050 |
for (i = 0; i < MAX_FRAMES; i++) |
432 |
980 |
av_frame_free(&s->all_frames[i].avframe); |
|
433 |
|||
434 |
70 |
av_freep(&s->thread_buf); |
|
435 |
70 |
av_freep(&s->slice_params_buf); |
|
436 |
|||
437 |
70 |
return 0; |
|
438 |
} |
||
439 |
|||
440 |
1949239 |
static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset) |
|
441 |
{ |
||
442 |
1949239 |
int coeff = dirac_get_se_golomb(gb); |
|
443 |
✓✓ | 1949239 |
const unsigned sign = FFSIGN(coeff); |
444 |
✓✓ | 1949239 |
if (coeff) |
445 |
336797 |
coeff = sign*((sign * coeff * qfactor + qoffset) >> 2); |
|
446 |
1949239 |
return coeff; |
|
447 |
} |
||
448 |
|||
449 |
#define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0)) |
||
450 |
|||
451 |
#define UNPACK_ARITH(n, type) \ |
||
452 |
static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \ |
||
453 |
SubBand *b, type *buf, int x, int y) \ |
||
454 |
{ \ |
||
455 |
int sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \ |
||
456 |
unsigned coeff; \ |
||
457 |
const int mstride = -(b->stride >> (1+b->pshift)); \ |
||
458 |
if (b->parent) { \ |
||
459 |
const type *pbuf = (type *)b->parent->ibuf; \ |
||
460 |
const int stride = b->parent->stride >> (1+b->parent->pshift); \ |
||
461 |
pred_ctx += !!pbuf[stride * (y>>1) + (x>>1)] << 1; \ |
||
462 |
} \ |
||
463 |
if (b->orientation == subband_hl) \ |
||
464 |
sign_pred = buf[mstride]; \ |
||
465 |
if (x) { \ |
||
466 |
pred_ctx += !(buf[-1] | buf[mstride] | buf[-1 + mstride]); \ |
||
467 |
if (b->orientation == subband_lh) \ |
||
468 |
sign_pred = buf[-1]; \ |
||
469 |
} else { \ |
||
470 |
pred_ctx += !buf[mstride]; \ |
||
471 |
} \ |
||
472 |
coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA); \ |
||
473 |
if (coeff) { \ |
||
474 |
coeff = (coeff * qfactor + qoffset) >> 2; \ |
||
475 |
sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred)); \ |
||
476 |
coeff = (coeff ^ -sign) + sign; \ |
||
477 |
} \ |
||
478 |
*buf = coeff; \ |
||
479 |
} \ |
||
480 |
|||
481 |
✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓ |
337100 |
UNPACK_ARITH(8, int16_t) |
482 |
UNPACK_ARITH(10, int32_t) |
||
483 |
|||
484 |
/** |
||
485 |
* Decode the coeffs in the rectangle defined by left, right, top, bottom |
||
486 |
* [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock() |
||
487 |
*/ |
||
488 |
82699 |
static inline int codeblock(DiracContext *s, SubBand *b, |
|
489 |
GetBitContext *gb, DiracArith *c, |
||
490 |
int left, int right, int top, int bottom, |
||
491 |
int blockcnt_one, int is_arith) |
||
492 |
{ |
||
493 |
int x, y, zero_block; |
||
494 |
int qoffset, qfactor; |
||
495 |
uint8_t *buf; |
||
496 |
|||
497 |
/* check for any coded coefficients in this codeblock */ |
||
498 |
✓✓ | 82699 |
if (!blockcnt_one) { |
499 |
✓✗ | 82635 |
if (is_arith) |
500 |
82635 |
zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK); |
|
501 |
else |
||
502 |
zero_block = get_bits1(gb); |
||
503 |
|||
504 |
✓✓ | 82635 |
if (zero_block) |
505 |
77258 |
return 0; |
|
506 |
} |
||
507 |
|||
508 |
✗✓✗✗ ✗✗ |
5441 |
if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) { |
509 |
int quant; |
||
510 |
if (is_arith) |
||
511 |
quant = dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA); |
||
512 |
else |
||
513 |
quant = dirac_get_se_golomb(gb); |
||
514 |
if (quant > INT_MAX - b->quant || b->quant + quant < 0) { |
||
515 |
av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n"); |
||
516 |
return AVERROR_INVALIDDATA; |
||
517 |
} |
||
518 |
b->quant += quant; |
||
519 |
} |
||
520 |
|||
521 |
✗✓ | 5441 |
if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) { |
522 |
av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant); |
||
523 |
b->quant = 0; |
||
524 |
return AVERROR_INVALIDDATA; |
||
525 |
} |
||
526 |
|||
527 |
5441 |
qfactor = ff_dirac_qscale_tab[b->quant]; |
|
528 |
/* TODO: context pointer? */ |
||
529 |
✓✓ | 5441 |
if (!s->num_refs) |
530 |
1700 |
qoffset = ff_dirac_qoffset_intra_tab[b->quant] + 2; |
|
531 |
else |
||
532 |
3741 |
qoffset = ff_dirac_qoffset_inter_tab[b->quant] + 2; |
|
533 |
|||
534 |
5441 |
buf = b->ibuf + top * b->stride; |
|
535 |
✓✗ | 5441 |
if (is_arith) { |
536 |
✓✓ | 46055 |
for (y = top; y < bottom; y++) { |
537 |
✗✓ | 40614 |
if (c->error) |
538 |
return c->error; |
||
539 |
✓✓ | 377714 |
for (x = left; x < right; x++) { |
540 |
✗✓ | 337100 |
if (b->pshift) { |
541 |
coeff_unpack_arith_10(c, qfactor, qoffset, b, (int32_t*)(buf)+x, x, y); |
||
542 |
} else { |
||
543 |
337100 |
coeff_unpack_arith_8(c, qfactor, qoffset, b, (int16_t*)(buf)+x, x, y); |
|
544 |
} |
||
545 |
} |
||
546 |
40614 |
buf += b->stride; |
|
547 |
} |
||
548 |
} else { |
||
549 |
for (y = top; y < bottom; y++) { |
||
550 |
if (get_bits_left(gb) < 1) |
||
551 |
return AVERROR_INVALIDDATA; |
||
552 |
for (x = left; x < right; x++) { |
||
553 |
int val = coeff_unpack_golomb(gb, qfactor, qoffset); |
||
554 |
if (b->pshift) { |
||
555 |
AV_WN32(&buf[4*x], val); |
||
556 |
} else { |
||
557 |
AV_WN16(&buf[2*x], val); |
||
558 |
} |
||
559 |
} |
||
560 |
buf += b->stride; |
||
561 |
} |
||
562 |
} |
||
563 |
5441 |
return 0; |
|
564 |
} |
||
565 |
|||
566 |
/** |
||
567 |
* Dirac Specification -> |
||
568 |
* 13.3 intra_dc_prediction(band) |
||
569 |
*/ |
||
570 |
#define INTRA_DC_PRED(n, type) \ |
||
571 |
static inline void intra_dc_prediction_##n(SubBand *b) \ |
||
572 |
{ \ |
||
573 |
type *buf = (type*)b->ibuf; \ |
||
574 |
int x, y; \ |
||
575 |
\ |
||
576 |
for (x = 1; x < b->width; x++) \ |
||
577 |
buf[x] += buf[x-1]; \ |
||
578 |
buf += (b->stride >> (1+b->pshift)); \ |
||
579 |
\ |
||
580 |
for (y = 1; y < b->height; y++) { \ |
||
581 |
buf[0] += buf[-(b->stride >> (1+b->pshift))]; \ |
||
582 |
\ |
||
583 |
for (x = 1; x < b->width; x++) { \ |
||
584 |
int pred = buf[x - 1] + buf[x - (b->stride >> (1+b->pshift))] + buf[x - (b->stride >> (1+b->pshift))-1]; \ |
||
585 |
buf[x] += divide3(pred); \ |
||
586 |
} \ |
||
587 |
buf += (b->stride >> (1+b->pshift)); \ |
||
588 |
} \ |
||
589 |
} \ |
||
590 |
|||
591 |
✓✓✓✓ ✓✓ |
59400 |
INTRA_DC_PRED(8, int16_t) |
592 |
INTRA_DC_PRED(10, uint32_t) |
||
593 |
|||
594 |
/** |
||
595 |
* Dirac Specification -> |
||
596 |
* 13.4.2 Non-skipped subbands. subband_coeffs() |
||
597 |
*/ |
||
598 |
930 |
static av_always_inline int decode_subband_internal(DiracContext *s, SubBand *b, int is_arith) |
|
599 |
{ |
||
600 |
int cb_x, cb_y, left, right, top, bottom; |
||
601 |
DiracArith c; |
||
602 |
GetBitContext gb; |
||
603 |
930 |
int cb_width = s->codeblock[b->level + (b->orientation != subband_ll)].width; |
|
604 |
930 |
int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height; |
|
605 |
930 |
int blockcnt_one = (cb_width + cb_height) == 2; |
|
606 |
int ret; |
||
607 |
|||
608 |
✓✓ | 930 |
if (!b->length) |
609 |
263 |
return 0; |
|
610 |
|||
611 |
667 |
init_get_bits8(&gb, b->coeff_data, b->length); |
|
612 |
|||
613 |
✓✗ | 667 |
if (is_arith) |
614 |
667 |
ff_dirac_init_arith_decoder(&c, &gb, b->length); |
|
615 |
|||
616 |
667 |
top = 0; |
|
617 |
✓✓ | 5972 |
for (cb_y = 0; cb_y < cb_height; cb_y++) { |
618 |
5305 |
bottom = (b->height * (cb_y+1LL)) / cb_height; |
|
619 |
5305 |
left = 0; |
|
620 |
✓✓ | 88004 |
for (cb_x = 0; cb_x < cb_width; cb_x++) { |
621 |
82699 |
right = (b->width * (cb_x+1LL)) / cb_width; |
|
622 |
82699 |
ret = codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith); |
|
623 |
✗✓ | 82699 |
if (ret < 0) |
624 |
return ret; |
||
625 |
82699 |
left = right; |
|
626 |
} |
||
627 |
5305 |
top = bottom; |
|
628 |
} |
||
629 |
|||
630 |
✓✓✓✓ |
667 |
if (b->orientation == subband_ll && s->num_refs == 0) { |
631 |
✗✓ | 6 |
if (s->pshift) { |
632 |
intra_dc_prediction_10(b); |
||
633 |
} else { |
||
634 |
6 |
intra_dc_prediction_8(b); |
|
635 |
} |
||
636 |
} |
||
637 |
667 |
return 0; |
|
638 |
} |
||
639 |
|||
640 |
930 |
static int decode_subband_arith(AVCodecContext *avctx, void *b) |
|
641 |
{ |
||
642 |
930 |
DiracContext *s = avctx->priv_data; |
|
643 |
930 |
return decode_subband_internal(s, b, 1); |
|
644 |
} |
||
645 |
|||
646 |
static int decode_subband_golomb(AVCodecContext *avctx, void *arg) |
||
647 |
{ |
||
648 |
DiracContext *s = avctx->priv_data; |
||
649 |
SubBand **b = arg; |
||
650 |
return decode_subband_internal(s, *b, 0); |
||
651 |
} |
||
652 |
|||
653 |
/** |
||
654 |
* Dirac Specification -> |
||
655 |
* [DIRAC_STD] 13.4.1 core_transform_data() |
||
656 |
*/ |
||
657 |
93 |
static int decode_component(DiracContext *s, int comp) |
|
658 |
{ |
||
659 |
93 |
AVCodecContext *avctx = s->avctx; |
|
660 |
SubBand *bands[3*MAX_DWT_LEVELS+1]; |
||
661 |
enum dirac_subband orientation; |
||
662 |
93 |
int level, num_bands = 0; |
|
663 |
int ret[3*MAX_DWT_LEVELS+1]; |
||
664 |
int i; |
||
665 |
93 |
int damaged_count = 0; |
|
666 |
|||
667 |
/* Unpack all subbands at all levels. */ |
||
668 |
✓✓ | 372 |
for (level = 0; level < s->wavelet_depth; level++) { |
669 |
✓✓ | 1209 |
for (orientation = !!level; orientation < 4; orientation++) { |
670 |
930 |
SubBand *b = &s->plane[comp].band[level][orientation]; |
|
671 |
930 |
bands[num_bands++] = b; |
|
672 |
|||
673 |
930 |
align_get_bits(&s->gb); |
|
674 |
/* [DIRAC_STD] 13.4.2 subband() */ |
||
675 |
930 |
b->length = get_interleaved_ue_golomb(&s->gb); |
|
676 |
✓✓ | 930 |
if (b->length) { |
677 |
667 |
b->quant = get_interleaved_ue_golomb(&s->gb); |
|
678 |
✗✓ | 667 |
if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) { |
679 |
av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant); |
||
680 |
b->quant = 0; |
||
681 |
return AVERROR_INVALIDDATA; |
||
682 |
} |
||
683 |
667 |
align_get_bits(&s->gb); |
|
684 |
667 |
b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8; |
|
685 |
✓✗✗✓ |
667 |
if (b->length > FFMAX(get_bits_left(&s->gb)/8, 0)) { |
686 |
b->length = FFMAX(get_bits_left(&s->gb)/8, 0); |
||
687 |
damaged_count ++; |
||
688 |
} |
||
689 |
667 |
skip_bits_long(&s->gb, b->length*8); |
|
690 |
} |
||
691 |
} |
||
692 |
/* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */ |
||
693 |
✓✗ | 279 |
if (s->is_arith) |
694 |
✓✓ | 279 |
avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level], |
695 |
✓✓ | 279 |
ret + 3*level + !!level, 4-!!level, sizeof(SubBand)); |
696 |
} |
||
697 |
/* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */ |
||
698 |
✗✓ | 93 |
if (!s->is_arith) |
699 |
avctx->execute(avctx, decode_subband_golomb, bands, ret, num_bands, sizeof(SubBand*)); |
||
700 |
|||
701 |
✓✓ | 1023 |
for (i = 0; i < s->wavelet_depth * 3 + 1; i++) { |
702 |
✗✓ | 930 |
if (ret[i] < 0) |
703 |
damaged_count++; |
||
704 |
} |
||
705 |
✗✓ | 93 |
if (damaged_count > (s->wavelet_depth * 3 + 1) /2) |
706 |
return AVERROR_INVALIDDATA; |
||
707 |
|||
708 |
93 |
return 0; |
|
709 |
} |
||
710 |
|||
711 |
#define PARSE_VALUES(type, x, gb, ebits, buf1, buf2) \ |
||
712 |
type *buf = (type *)buf1; \ |
||
713 |
buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \ |
||
714 |
if (get_bits_count(gb) >= ebits) \ |
||
715 |
return; \ |
||
716 |
if (buf2) { \ |
||
717 |
buf = (type *)buf2; \ |
||
718 |
buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \ |
||
719 |
if (get_bits_count(gb) >= ebits) \ |
||
720 |
return; \ |
||
721 |
} \ |
||
722 |
|||
723 |
186000 |
static void decode_subband(DiracContext *s, GetBitContext *gb, int quant, |
|
724 |
int slice_x, int slice_y, int bits_end, |
||
725 |
SubBand *b1, SubBand *b2) |
||
726 |
{ |
||
727 |
186000 |
int left = b1->width * slice_x / s->num_x; |
|
728 |
186000 |
int right = b1->width *(slice_x+1) / s->num_x; |
|
729 |
186000 |
int top = b1->height * slice_y / s->num_y; |
|
730 |
186000 |
int bottom = b1->height *(slice_y+1) / s->num_y; |
|
731 |
|||
732 |
int qfactor, qoffset; |
||
733 |
|||
734 |
186000 |
uint8_t *buf1 = b1->ibuf + top * b1->stride; |
|
735 |
✓✓ | 186000 |
uint8_t *buf2 = b2 ? b2->ibuf + top * b2->stride: NULL; |
736 |
int x, y; |
||
737 |
|||
738 |
✗✓ | 186000 |
if (quant > (DIRAC_MAX_QUANT_INDEX - 1)) { |
739 |
av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", quant); |
||
740 |
return; |
||
741 |
} |
||
742 |
186000 |
qfactor = ff_dirac_qscale_tab[quant]; |
|
743 |
186000 |
qoffset = ff_dirac_qoffset_intra_tab[quant] + 2; |
|
744 |
/* we have to constantly check for overread since the spec explicitly |
||
745 |
requires this, with the meaning that all remaining coeffs are set to 0 */ |
||
746 |
✓✓ | 186000 |
if (get_bits_count(gb) >= bits_end) |
747 |
38746 |
return; |
|
748 |
|||
749 |
✗✓ | 147254 |
if (s->pshift) { |
750 |
for (y = top; y < bottom; y++) { |
||
751 |
for (x = left; x < right; x++) { |
||
752 |
PARSE_VALUES(int32_t, x, gb, bits_end, buf1, buf2); |
||
753 |
} |
||
754 |
buf1 += b1->stride; |
||
755 |
if (buf2) |
||
756 |
buf2 += b2->stride; |
||
757 |
} |
||
758 |
} |
||
759 |
else { |
||
760 |
✓✓ | 518899 |
for (y = top; y < bottom; y++) { |
761 |
✓✓ | 1836007 |
for (x = left; x < right; x++) { |
762 |
✓✓✓✓ ✓✓ |
1464362 |
PARSE_VALUES(int16_t, x, gb, bits_end, buf1, buf2); |
763 |
} |
||
764 |
371645 |
buf1 += b1->stride; |
|
765 |
✓✓ | 371645 |
if (buf2) |
766 |
173605 |
buf2 += b2->stride; |
|
767 |
} |
||
768 |
} |
||
769 |
} |
||
770 |
|||
771 |
/** |
||
772 |
* Dirac Specification -> |
||
773 |
* 13.5.2 Slices. slice(sx,sy) |
||
774 |
*/ |
||
775 |
9300 |
static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg) |
|
776 |
{ |
||
777 |
9300 |
DiracContext *s = avctx->priv_data; |
|
778 |
9300 |
DiracSlice *slice = arg; |
|
779 |
9300 |
GetBitContext *gb = &slice->gb; |
|
780 |
enum dirac_subband orientation; |
||
781 |
int level, quant, chroma_bits, chroma_end; |
||
782 |
|||
783 |
9300 |
int quant_base = get_bits(gb, 7); /*[DIRAC_STD] qindex */ |
|
784 |
9300 |
int length_bits = av_log2(8 * slice->bytes)+1; |
|
785 |
9300 |
int luma_bits = get_bits_long(gb, length_bits); |
|
786 |
✗✓ | 9300 |
int luma_end = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb)); |
787 |
|||
788 |
/* [DIRAC_STD] 13.5.5.2 luma_slice_band */ |
||
789 |
✓✓ | 37200 |
for (level = 0; level < s->wavelet_depth; level++) |
790 |
✓✓ | 120900 |
for (orientation = !!level; orientation < 4; orientation++) { |
791 |
93000 |
quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0); |
|
792 |
93000 |
decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end, |
|
793 |
&s->plane[0].band[level][orientation], NULL); |
||
794 |
} |
||
795 |
|||
796 |
/* consume any unused bits from luma */ |
||
797 |
9300 |
skip_bits_long(gb, get_bits_count(gb) - luma_end); |
|
798 |
|||
799 |
9300 |
chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits; |
|
800 |
✗✓ | 9300 |
chroma_end = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb)); |
801 |
/* [DIRAC_STD] 13.5.5.3 chroma_slice_band */ |
||
802 |
✓✓ | 37200 |
for (level = 0; level < s->wavelet_depth; level++) |
803 |
✓✓ | 120900 |
for (orientation = !!level; orientation < 4; orientation++) { |
804 |
93000 |
quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0); |
|
805 |
93000 |
decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end, |
|
806 |
&s->plane[1].band[level][orientation], |
||
807 |
&s->plane[2].band[level][orientation]); |
||
808 |
} |
||
809 |
|||
810 |
9300 |
return 0; |
|
811 |
} |
||
812 |
|||
813 |
typedef struct SliceCoeffs { |
||
814 |
int left; |
||
815 |
int top; |
||
816 |
int tot_h; |
||
817 |
int tot_v; |
||
818 |
int tot; |
||
819 |
} SliceCoeffs; |
||
820 |
|||
821 |
117841 |
static int subband_coeffs(DiracContext *s, int x, int y, int p, |
|
822 |
SliceCoeffs c[MAX_DWT_LEVELS]) |
||
823 |
{ |
||
824 |
117841 |
int level, coef = 0; |
|
825 |
✓✓ | 589174 |
for (level = 0; level < s->wavelet_depth; level++) { |
826 |
471333 |
SliceCoeffs *o = &c[level]; |
|
827 |
471333 |
SubBand *b = &s->plane[p].band[level][3]; /* orientation doens't matter */ |
|
828 |
471333 |
o->top = b->height * y / s->num_y; |
|
829 |
471333 |
o->left = b->width * x / s->num_x; |
|
830 |
471333 |
o->tot_h = ((b->width * (x + 1)) / s->num_x) - o->left; |
|
831 |
471333 |
o->tot_v = ((b->height * (y + 1)) / s->num_y) - o->top; |
|
832 |
471333 |
o->tot = o->tot_h*o->tot_v; |
|
833 |
✓✓ | 471333 |
coef += o->tot * (4 - !!level); |
834 |
} |
||
835 |
117841 |
return coef; |
|
836 |
} |
||
837 |
|||
838 |
/** |
||
839 |
* VC-2 Specification -> |
||
840 |
* 13.5.3 hq_slice(sx,sy) |
||
841 |
*/ |
||
842 |
39204 |
static int decode_hq_slice(DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf) |
|
843 |
{ |
||
844 |
int i, level, orientation, quant_idx; |
||
845 |
int qfactor[MAX_DWT_LEVELS][4], qoffset[MAX_DWT_LEVELS][4]; |
||
846 |
39204 |
GetBitContext *gb = &slice->gb; |
|
847 |
SliceCoeffs coeffs_num[MAX_DWT_LEVELS]; |
||
848 |
|||
849 |
39204 |
skip_bits_long(gb, 8*s->highquality.prefix_bytes); |
|
850 |
39204 |
quant_idx = get_bits(gb, 8); |
|
851 |
|||
852 |
✗✓ | 39204 |
if (quant_idx > DIRAC_MAX_QUANT_INDEX - 1) { |
853 |
av_log(s->avctx, AV_LOG_ERROR, "Invalid quantization index - %i\n", quant_idx); |
||
854 |
return AVERROR_INVALIDDATA; |
||
855 |
} |
||
856 |
|||
857 |
/* Slice quantization (slice_quantizers() in the specs) */ |
||
858 |
✓✓ | 196020 |
for (level = 0; level < s->wavelet_depth; level++) { |
859 |
✓✓ | 666468 |
for (orientation = !!level; orientation < 4; orientation++) { |
860 |
509652 |
const int quant = FFMAX(quant_idx - s->lowdelay.quant[level][orientation], 0); |
|
861 |
509652 |
qfactor[level][orientation] = ff_dirac_qscale_tab[quant]; |
|
862 |
509652 |
qoffset[level][orientation] = ff_dirac_qoffset_intra_tab[quant] + 2; |
|
863 |
} |
||
864 |
} |
||
865 |
|||
866 |
/* Luma + 2 Chroma planes */ |
||
867 |
✓✓ | 156816 |
for (i = 0; i < 3; i++) { |
868 |
117612 |
int coef_num, coef_par, off = 0; |
|
869 |
117612 |
int64_t length = s->highquality.size_scaler*get_bits(gb, 8); |
|
870 |
117612 |
int64_t bits_end = get_bits_count(gb) + 8*length; |
|
871 |
117612 |
const uint8_t *addr = align_get_bits(gb); |
|
872 |
|||
873 |
✗✓ | 117612 |
if (length*8 > get_bits_left(gb)) { |
874 |
av_log(s->avctx, AV_LOG_ERROR, "end too far away\n"); |
||
875 |
return AVERROR_INVALIDDATA; |
||
876 |
} |
||
877 |
|||
878 |
117612 |
coef_num = subband_coeffs(s, slice->slice_x, slice->slice_y, i, coeffs_num); |
|
879 |
|||
880 |
✓✓ | 117612 |
if (s->pshift) |
881 |
85536 |
coef_par = ff_dirac_golomb_read_32bit(addr, length, |
|
882 |
tmp_buf, coef_num); |
||
883 |
else |
||
884 |
32076 |
coef_par = ff_dirac_golomb_read_16bit(addr, length, |
|
885 |
tmp_buf, coef_num); |
||
886 |
|||
887 |
✗✓ | 117612 |
if (coef_num > coef_par) { |
888 |
const int start_b = coef_par * (1 << (s->pshift + 1)); |
||
889 |
const int end_b = coef_num * (1 << (s->pshift + 1)); |
||
890 |
memset(&tmp_buf[start_b], 0, end_b - start_b); |
||
891 |
} |
||
892 |
|||
893 |
✓✓ | 588060 |
for (level = 0; level < s->wavelet_depth; level++) { |
894 |
470448 |
const SliceCoeffs *c = &coeffs_num[level]; |
|
895 |
✓✓ | 1999404 |
for (orientation = !!level; orientation < 4; orientation++) { |
896 |
1528956 |
const SubBand *b1 = &s->plane[i].band[level][orientation]; |
|
897 |
1528956 |
uint8_t *buf = b1->ibuf + c->top * b1->stride + (c->left << (s->pshift + 1)); |
|
898 |
|||
899 |
/* Change to c->tot_h <= 4 for AVX2 dequantization */ |
||
900 |
✓✓ | 1528956 |
const int qfunc = s->pshift + 2*(c->tot_h <= 2); |
901 |
1528956 |
s->diracdsp.dequant_subband[qfunc](&tmp_buf[off], buf, b1->stride, |
|
902 |
qfactor[level][orientation], |
||
903 |
qoffset[level][orientation], |
||
904 |
c->tot_v, c->tot_h); |
||
905 |
|||
906 |
1528956 |
off += c->tot << (s->pshift + 1); |
|
907 |
} |
||
908 |
} |
||
909 |
|||
910 |
117612 |
skip_bits_long(gb, bits_end - get_bits_count(gb)); |
|
911 |
} |
||
912 |
|||
913 |
39204 |
return 0; |
|
914 |
} |
||
915 |
|||
916 |
3564 |
static int decode_hq_slice_row(AVCodecContext *avctx, void *arg, int jobnr, int threadnr) |
|
917 |
{ |
||
918 |
int i; |
||
919 |
3564 |
DiracContext *s = avctx->priv_data; |
|
920 |
3564 |
DiracSlice *slices = ((DiracSlice *)arg) + s->num_x*jobnr; |
|
921 |
3564 |
uint8_t *thread_buf = &s->thread_buf[s->thread_buf_size*threadnr]; |
|
922 |
✓✓ | 42768 |
for (i = 0; i < s->num_x; i++) |
923 |
39204 |
decode_hq_slice(s, &slices[i], thread_buf); |
|
924 |
3564 |
return 0; |
|
925 |
} |
||
926 |
|||
927 |
/** |
||
928 |
* Dirac Specification -> |
||
929 |
* 13.5.1 low_delay_transform_data() |
||
930 |
*/ |
||
931 |
229 |
static int decode_lowdelay(DiracContext *s) |
|
932 |
{ |
||
933 |
229 |
AVCodecContext *avctx = s->avctx; |
|
934 |
int slice_x, slice_y, bufsize; |
||
935 |
229 |
int64_t coef_buf_size, bytes = 0; |
|
936 |
const uint8_t *buf; |
||
937 |
DiracSlice *slices; |
||
938 |
SliceCoeffs tmp[MAX_DWT_LEVELS]; |
||
939 |
229 |
int slice_num = 0; |
|
940 |
|||
941 |
✓✓ | 229 |
if (s->slice_params_num_buf != (s->num_x * s->num_y)) { |
942 |
68 |
s->slice_params_buf = av_realloc_f(s->slice_params_buf, s->num_x * s->num_y, sizeof(DiracSlice)); |
|
943 |
✗✓ | 68 |
if (!s->slice_params_buf) { |
944 |
av_log(s->avctx, AV_LOG_ERROR, "slice params buffer allocation failure\n"); |
||
945 |
s->slice_params_num_buf = 0; |
||
946 |
return AVERROR(ENOMEM); |
||
947 |
} |
||
948 |
68 |
s->slice_params_num_buf = s->num_x * s->num_y; |
|
949 |
} |
||
950 |
229 |
slices = s->slice_params_buf; |
|
951 |
|||
952 |
/* 8 becacuse that's how much the golomb reader could overread junk data |
||
953 |
* from another plane/slice at most, and 512 because SIMD */ |
||
954 |
229 |
coef_buf_size = subband_coeffs(s, s->num_x - 1, s->num_y - 1, 0, tmp) + 8; |
|
955 |
229 |
coef_buf_size = (coef_buf_size << (1 + s->pshift)) + 512; |
|
956 |
|||
957 |
✓✓ | 229 |
if (s->threads_num_buf != avctx->thread_count || |
958 |
✗✓ | 161 |
s->thread_buf_size != coef_buf_size) { |
959 |
68 |
s->threads_num_buf = avctx->thread_count; |
|
960 |
68 |
s->thread_buf_size = coef_buf_size; |
|
961 |
68 |
s->thread_buf = av_realloc_f(s->thread_buf, avctx->thread_count, s->thread_buf_size); |
|
962 |
✗✓ | 68 |
if (!s->thread_buf) { |
963 |
av_log(s->avctx, AV_LOG_ERROR, "thread buffer allocation failure\n"); |
||
964 |
return AVERROR(ENOMEM); |
||
965 |
} |
||
966 |
} |
||
967 |
|||
968 |
229 |
align_get_bits(&s->gb); |
|
969 |
/*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */ |
||
970 |
229 |
buf = s->gb.buffer + get_bits_count(&s->gb)/8; |
|
971 |
229 |
bufsize = get_bits_left(&s->gb); |
|
972 |
|||
973 |
✓✓ | 229 |
if (s->hq_picture) { |
974 |
int i; |
||
975 |
|||
976 |
✓✓✓✗ |
3762 |
for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) { |
977 |
✓✓✓✓ |
42768 |
for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) { |
978 |
39204 |
bytes = s->highquality.prefix_bytes + 1; |
|
979 |
✓✓ | 156816 |
for (i = 0; i < 3; i++) { |
980 |
✓✗ | 117612 |
if (bytes <= bufsize/8) |
981 |
117612 |
bytes += buf[bytes] * s->highquality.size_scaler + 1; |
|
982 |
} |
||
983 |
✓✗✗✓ |
39204 |
if (bytes >= INT_MAX || bytes*8 > bufsize) { |
984 |
av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n"); |
||
985 |
return AVERROR_INVALIDDATA; |
||
986 |
} |
||
987 |
|||
988 |
39204 |
slices[slice_num].bytes = bytes; |
|
989 |
39204 |
slices[slice_num].slice_x = slice_x; |
|
990 |
39204 |
slices[slice_num].slice_y = slice_y; |
|
991 |
39204 |
init_get_bits(&slices[slice_num].gb, buf, bufsize); |
|
992 |
39204 |
slice_num++; |
|
993 |
|||
994 |
39204 |
buf += bytes; |
|
995 |
✓✗ | 39204 |
if (bufsize/8 >= bytes) |
996 |
39204 |
bufsize -= bytes*8; |
|
997 |
else |
||
998 |
bufsize = 0; |
||
999 |
} |
||
1000 |
} |
||
1001 |
|||
1002 |
✗✓ | 198 |
if (s->num_x*s->num_y != slice_num) { |
1003 |
av_log(s->avctx, AV_LOG_ERROR, "too few slices\n"); |
||
1004 |
return AVERROR_INVALIDDATA; |
||
1005 |
} |
||
1006 |
|||
1007 |
198 |
avctx->execute2(avctx, decode_hq_slice_row, slices, NULL, s->num_y); |
|
1008 |
} else { |
||
1009 |
✓✓✓✗ |
496 |
for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) { |
1010 |
✓✓✓✓ |
9765 |
for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) { |
1011 |
9300 |
bytes = (slice_num+1) * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den |
|
1012 |
9300 |
- slice_num * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den; |
|
1013 |
✓✗✗✓ |
9300 |
if (bytes >= INT_MAX || bytes*8 > bufsize) { |
1014 |
av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n"); |
||
1015 |
return AVERROR_INVALIDDATA; |
||
1016 |
} |
||
1017 |
9300 |
slices[slice_num].bytes = bytes; |
|
1018 |
9300 |
slices[slice_num].slice_x = slice_x; |
|
1019 |
9300 |
slices[slice_num].slice_y = slice_y; |
|
1020 |
9300 |
init_get_bits(&slices[slice_num].gb, buf, bufsize); |
|
1021 |
9300 |
slice_num++; |
|
1022 |
|||
1023 |
9300 |
buf += bytes; |
|
1024 |
✓✗ | 9300 |
if (bufsize/8 >= bytes) |
1025 |
9300 |
bufsize -= bytes*8; |
|
1026 |
else |
||
1027 |
bufsize = 0; |
||
1028 |
} |
||
1029 |
} |
||
1030 |
31 |
avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num, |
|
1031 |
sizeof(DiracSlice)); /* [DIRAC_STD] 13.5.2 Slices */ |
||
1032 |
} |
||
1033 |
|||
1034 |
✓✓ | 229 |
if (s->dc_prediction) { |
1035 |
✗✓ | 31 |
if (s->pshift) { |
1036 |
intra_dc_prediction_10(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */ |
||
1037 |
intra_dc_prediction_10(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */ |
||
1038 |
intra_dc_prediction_10(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */ |
||
1039 |
} else { |
||
1040 |
31 |
intra_dc_prediction_8(&s->plane[0].band[0][0]); |
|
1041 |
31 |
intra_dc_prediction_8(&s->plane[1].band[0][0]); |
|
1042 |
31 |
intra_dc_prediction_8(&s->plane[2].band[0][0]); |
|
1043 |
} |
||
1044 |
} |
||
1045 |
|||
1046 |
229 |
return 0; |
|
1047 |
} |
||
1048 |
|||
1049 |
260 |
static void init_planes(DiracContext *s) |
|
1050 |
{ |
||
1051 |
int i, w, h, level, orientation; |
||
1052 |
|||
1053 |
✓✓ | 1040 |
for (i = 0; i < 3; i++) { |
1054 |
780 |
Plane *p = &s->plane[i]; |
|
1055 |
|||
1056 |
✓✓ | 780 |
p->width = s->seq.width >> (i ? s->chroma_x_shift : 0); |
1057 |
✓✓ | 780 |
p->height = s->seq.height >> (i ? s->chroma_y_shift : 0); |
1058 |
780 |
p->idwt.width = w = CALC_PADDING(p->width , s->wavelet_depth); |
|
1059 |
780 |
p->idwt.height = h = CALC_PADDING(p->height, s->wavelet_depth); |
|
1060 |
780 |
p->idwt.stride = FFALIGN(p->idwt.width, 8) << (1 + s->pshift); |
|
1061 |
|||
1062 |
✓✓ | 3714 |
for (level = s->wavelet_depth-1; level >= 0; level--) { |
1063 |
2934 |
w = w>>1; |
|
1064 |
2934 |
h = h>>1; |
|
1065 |
✓✓ | 12516 |
for (orientation = !!level; orientation < 4; orientation++) { |
1066 |
9582 |
SubBand *b = &p->band[level][orientation]; |
|
1067 |
|||
1068 |
9582 |
b->pshift = s->pshift; |
|
1069 |
9582 |
b->ibuf = p->idwt.buf; |
|
1070 |
9582 |
b->level = level; |
|
1071 |
9582 |
b->stride = p->idwt.stride << (s->wavelet_depth - level); |
|
1072 |
9582 |
b->width = w; |
|
1073 |
9582 |
b->height = h; |
|
1074 |
9582 |
b->orientation = orientation; |
|
1075 |
|||
1076 |
✓✓ | 9582 |
if (orientation & 1) |
1077 |
5868 |
b->ibuf += w << (1+b->pshift); |
|
1078 |
✓✓ | 9582 |
if (orientation > 1) |
1079 |
5868 |
b->ibuf += (b->stride>>1); |
|
1080 |
|||
1081 |
✓✓ | 9582 |
if (level) |
1082 |
6462 |
b->parent = &p->band[level-1][orientation]; |
|
1083 |
} |
||
1084 |
} |
||
1085 |
|||
1086 |
✓✓ | 780 |
if (i > 0) { |
1087 |
520 |
p->xblen = s->plane[0].xblen >> s->chroma_x_shift; |
|
1088 |
520 |
p->yblen = s->plane[0].yblen >> s->chroma_y_shift; |
|
1089 |
520 |
p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift; |
|
1090 |
520 |
p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift; |
|
1091 |
} |
||
1092 |
|||
1093 |
780 |
p->xoffset = (p->xblen - p->xbsep)/2; |
|
1094 |
780 |
p->yoffset = (p->yblen - p->ybsep)/2; |
|
1095 |
} |
||
1096 |
260 |
} |
|
1097 |
|||
1098 |
/** |
||
1099 |
* Unpack the motion compensation parameters |
||
1100 |
* Dirac Specification -> |
||
1101 |
* 11.2 Picture prediction data. picture_prediction() |
||
1102 |
*/ |
||
1103 |
29 |
static int dirac_unpack_prediction_parameters(DiracContext *s) |
|
1104 |
{ |
||
1105 |
static const uint8_t default_blen[] = { 4, 12, 16, 24 }; |
||
1106 |
|||
1107 |
29 |
GetBitContext *gb = &s->gb; |
|
1108 |
unsigned idx, ref; |
||
1109 |
|||
1110 |
29 |
align_get_bits(gb); |
|
1111 |
/* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */ |
||
1112 |
/* Luma and Chroma are equal. 11.2.3 */ |
||
1113 |
29 |
idx = get_interleaved_ue_golomb(gb); /* [DIRAC_STD] index */ |
|
1114 |
|||
1115 |
✗✓ | 29 |
if (idx > 4) { |
1116 |
av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n"); |
||
1117 |
return AVERROR_INVALIDDATA; |
||
1118 |
} |
||
1119 |
|||
1120 |
✓✗ | 29 |
if (idx == 0) { |
1121 |
29 |
s->plane[0].xblen = get_interleaved_ue_golomb(gb); |
|
1122 |
29 |
s->plane[0].yblen = get_interleaved_ue_golomb(gb); |
|
1123 |
29 |
s->plane[0].xbsep = get_interleaved_ue_golomb(gb); |
|
1124 |
29 |
s->plane[0].ybsep = get_interleaved_ue_golomb(gb); |
|
1125 |
} else { |
||
1126 |
/*[DIRAC_STD] preset_block_params(index). Table 11.1 */ |
||
1127 |
s->plane[0].xblen = default_blen[idx-1]; |
||
1128 |
s->plane[0].yblen = default_blen[idx-1]; |
||
1129 |
s->plane[0].xbsep = 4 * idx; |
||
1130 |
s->plane[0].ybsep = 4 * idx; |
||
1131 |
} |
||
1132 |
/*[DIRAC_STD] 11.2.4 motion_data_dimensions() |
||
1133 |
Calculated in function dirac_unpack_block_motion_data */ |
||
1134 |
|||
1135 |
✓✗ | 29 |
if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 || |
1136 |
✓✗ | 29 |
s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 || |
1137 |
✓✗✗✓ |
29 |
!s->plane[0].xblen || !s->plane[0].yblen) { |
1138 |
av_log(s->avctx, AV_LOG_ERROR, |
||
1139 |
"invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n", |
||
1140 |
s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift); |
||
1141 |
return AVERROR_INVALIDDATA; |
||
1142 |
} |
||
1143 |
✓✗✓✗ ✓✗✗✓ |
29 |
if (!s->plane[0].xbsep || !s->plane[0].ybsep || s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) { |
1144 |
av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n"); |
||
1145 |
return AVERROR_INVALIDDATA; |
||
1146 |
} |
||
1147 |
✓✗✗✓ |
29 |
if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) { |
1148 |
av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n"); |
||
1149 |
return AVERROR_INVALIDDATA; |
||
1150 |
} |
||
1151 |
✗✓ | 29 |
if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) { |
1152 |
av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n"); |
||
1153 |
return AVERROR_PATCHWELCOME; |
||
1154 |
} |
||
1155 |
|||
1156 |
/*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision() |
||
1157 |
Read motion vector precision */ |
||
1158 |
29 |
s->mv_precision = get_interleaved_ue_golomb(gb); |
|
1159 |
✗✓ | 29 |
if (s->mv_precision > 3) { |
1160 |
av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n"); |
||
1161 |
return AVERROR_INVALIDDATA; |
||
1162 |
} |
||
1163 |
|||
1164 |
/*[DIRAC_STD] 11.2.6 Global motion. global_motion() |
||
1165 |
Read the global motion compensation parameters */ |
||
1166 |
29 |
s->globalmc_flag = get_bits1(gb); |
|
1167 |
✗✓ | 29 |
if (s->globalmc_flag) { |
1168 |
memset(s->globalmc, 0, sizeof(s->globalmc)); |
||
1169 |
/* [DIRAC_STD] pan_tilt(gparams) */ |
||
1170 |
for (ref = 0; ref < s->num_refs; ref++) { |
||
1171 |
if (get_bits1(gb)) { |
||
1172 |
s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb); |
||
1173 |
s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb); |
||
1174 |
} |
||
1175 |
/* [DIRAC_STD] zoom_rotate_shear(gparams) |
||
1176 |
zoom/rotation/shear parameters */ |
||
1177 |
if (get_bits1(gb)) { |
||
1178 |
s->globalmc[ref].zrs_exp = get_interleaved_ue_golomb(gb); |
||
1179 |
s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb); |
||
1180 |
s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb); |
||
1181 |
s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb); |
||
1182 |
s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb); |
||
1183 |
} else { |
||
1184 |
s->globalmc[ref].zrs[0][0] = 1; |
||
1185 |
s->globalmc[ref].zrs[1][1] = 1; |
||
1186 |
} |
||
1187 |
/* [DIRAC_STD] perspective(gparams) */ |
||
1188 |
if (get_bits1(gb)) { |
||
1189 |
s->globalmc[ref].perspective_exp = get_interleaved_ue_golomb(gb); |
||
1190 |
s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb); |
||
1191 |
s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb); |
||
1192 |
} |
||
1193 |
if (s->globalmc[ref].perspective_exp + (uint64_t)s->globalmc[ref].zrs_exp > 30) { |
||
1194 |
return AVERROR_INVALIDDATA; |
||
1195 |
} |
||
1196 |
|||
1197 |
} |
||
1198 |
} |
||
1199 |
|||
1200 |
/*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode() |
||
1201 |
Picture prediction mode, not currently used. */ |
||
1202 |
✗✓ | 29 |
if (get_interleaved_ue_golomb(gb)) { |
1203 |
av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n"); |
||
1204 |
return AVERROR_INVALIDDATA; |
||
1205 |
} |
||
1206 |
|||
1207 |
/* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights() |
||
1208 |
just data read, weight calculation will be done later on. */ |
||
1209 |
29 |
s->weight_log2denom = 1; |
|
1210 |
29 |
s->weight[0] = 1; |
|
1211 |
29 |
s->weight[1] = 1; |
|
1212 |
|||
1213 |
✗✓ | 29 |
if (get_bits1(gb)) { |
1214 |
s->weight_log2denom = get_interleaved_ue_golomb(gb); |
||
1215 |
if (s->weight_log2denom < 1 || s->weight_log2denom > 8) { |
||
1216 |
av_log(s->avctx, AV_LOG_ERROR, "weight_log2denom unsupported or invalid\n"); |
||
1217 |
s->weight_log2denom = 1; |
||
1218 |
return AVERROR_INVALIDDATA; |
||
1219 |
} |
||
1220 |
s->weight[0] = dirac_get_se_golomb(gb); |
||
1221 |
if (s->num_refs == 2) |
||
1222 |
s->weight[1] = dirac_get_se_golomb(gb); |
||
1223 |
} |
||
1224 |
29 |
return 0; |
|
1225 |
} |
||
1226 |
|||
1227 |
/** |
||
1228 |
* Dirac Specification -> |
||
1229 |
* 11.3 Wavelet transform data. wavelet_transform() |
||
1230 |
*/ |
||
1231 |
260 |
static int dirac_unpack_idwt_params(DiracContext *s) |
|
1232 |
{ |
||
1233 |
260 |
GetBitContext *gb = &s->gb; |
|
1234 |
int i, level; |
||
1235 |
unsigned tmp; |
||
1236 |
|||
1237 |
#define CHECKEDREAD(dst, cond, errmsg) \ |
||
1238 |
tmp = get_interleaved_ue_golomb(gb); \ |
||
1239 |
if (cond) { \ |
||
1240 |
av_log(s->avctx, AV_LOG_ERROR, errmsg); \ |
||
1241 |
return AVERROR_INVALIDDATA; \ |
||
1242 |
}\ |
||
1243 |
dst = tmp; |
||
1244 |
|||
1245 |
260 |
align_get_bits(gb); |
|
1246 |
|||
1247 |
✓✓ | 260 |
s->zero_res = s->num_refs ? get_bits1(gb) : 0; |
1248 |
✗✓ | 260 |
if (s->zero_res) |
1249 |
return 0; |
||
1250 |
|||
1251 |
/*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */ |
||
1252 |
✗✓ | 260 |
CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n") |
1253 |
|||
1254 |
✓✗✗✓ |
260 |
CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n") |
1255 |
|||
1256 |
✓✓ | 260 |
if (!s->low_delay) { |
1257 |
/* Codeblock parameters (core syntax only) */ |
||
1258 |
✓✗ | 31 |
if (get_bits1(gb)) { |
1259 |
✓✓ | 155 |
for (i = 0; i <= s->wavelet_depth; i++) { |
1260 |
✓✗✗✓ |
124 |
CHECKEDREAD(s->codeblock[i].width , tmp < 1 || tmp > (s->avctx->width >>s->wavelet_depth-i), "codeblock width invalid\n") |
1261 |
✓✗✗✓ |
124 |
CHECKEDREAD(s->codeblock[i].height, tmp < 1 || tmp > (s->avctx->height>>s->wavelet_depth-i), "codeblock height invalid\n") |
1262 |
} |
||
1263 |
|||
1264 |
✗✓ | 31 |
CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n") |
1265 |
} |
||
1266 |
else { |
||
1267 |
for (i = 0; i <= s->wavelet_depth; i++) |
||
1268 |
s->codeblock[i].width = s->codeblock[i].height = 1; |
||
1269 |
} |
||
1270 |
} |
||
1271 |
else { |
||
1272 |
229 |
s->num_x = get_interleaved_ue_golomb(gb); |
|
1273 |
229 |
s->num_y = get_interleaved_ue_golomb(gb); |
|
1274 |
✓✗✓✗ |
229 |
if (s->num_x * s->num_y == 0 || s->num_x * (uint64_t)s->num_y > INT_MAX || |
1275 |
✓✗ | 229 |
s->num_x * (uint64_t)s->avctx->width > INT_MAX || |
1276 |
✓✗ | 229 |
s->num_y * (uint64_t)s->avctx->height > INT_MAX || |
1277 |
✓✗ | 229 |
s->num_x > s->avctx->width || |
1278 |
✗✓ | 229 |
s->num_y > s->avctx->height |
1279 |
) { |
||
1280 |
av_log(s->avctx,AV_LOG_ERROR,"Invalid numx/y\n"); |
||
1281 |
s->num_x = s->num_y = 0; |
||
1282 |
return AVERROR_INVALIDDATA; |
||
1283 |
} |
||
1284 |
✓✓ | 229 |
if (s->ld_picture) { |
1285 |
31 |
s->lowdelay.bytes.num = get_interleaved_ue_golomb(gb); |
|
1286 |
31 |
s->lowdelay.bytes.den = get_interleaved_ue_golomb(gb); |
|
1287 |
✗✓ | 31 |
if (s->lowdelay.bytes.den <= 0) { |
1288 |
av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n"); |
||
1289 |
return AVERROR_INVALIDDATA; |
||
1290 |
} |
||
1291 |
✓✗ | 198 |
} else if (s->hq_picture) { |
1292 |
198 |
s->highquality.prefix_bytes = get_interleaved_ue_golomb(gb); |
|
1293 |
198 |
s->highquality.size_scaler = get_interleaved_ue_golomb(gb); |
|
1294 |
✗✓ | 198 |
if (s->highquality.prefix_bytes >= INT_MAX / 8) { |
1295 |
av_log(s->avctx,AV_LOG_ERROR,"too many prefix bytes\n"); |
||
1296 |
return AVERROR_INVALIDDATA; |
||
1297 |
} |
||
1298 |
} |
||
1299 |
|||
1300 |
/* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */ |
||
1301 |
✗✓ | 229 |
if (get_bits1(gb)) { |
1302 |
av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n"); |
||
1303 |
/* custom quantization matrix */ |
||
1304 |
for (level = 0; level < s->wavelet_depth; level++) { |
||
1305 |
for (i = !!level; i < 4; i++) { |
||
1306 |
s->lowdelay.quant[level][i] = get_interleaved_ue_golomb(gb); |
||
1307 |
} |
||
1308 |
} |
||
1309 |
} else { |
||
1310 |
✗✓ | 229 |
if (s->wavelet_depth > 4) { |
1311 |
av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth); |
||
1312 |
return AVERROR_INVALIDDATA; |
||
1313 |
} |
||
1314 |
/* default quantization matrix */ |
||
1315 |
✓✓ | 1114 |
for (level = 0; level < s->wavelet_depth; level++) |
1316 |
✓✓ | 4425 |
for (i = 0; i < 4; i++) { |
1317 |
3540 |
s->lowdelay.quant[level][i] = ff_dirac_default_qmat[s->wavelet_idx][level][i]; |
|
1318 |
/* haar with no shift differs for different depths */ |
||
1319 |
✗✓ | 3540 |
if (s->wavelet_idx == 3) |
1320 |
s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level); |
||
1321 |
} |
||
1322 |
} |
||
1323 |
} |
||
1324 |
260 |
return 0; |
|
1325 |
} |
||
1326 |
|||
1327 |
2320 |
static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y) |
|
1328 |
{ |
||
1329 |
static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 }; |
||
1330 |
|||
1331 |
✓✓ | 2320 |
if (!(x|y)) |
1332 |
29 |
return 0; |
|
1333 |
✓✓ | 2291 |
else if (!y) |
1334 |
261 |
return sbsplit[-1]; |
|
1335 |
✓✓ | 2030 |
else if (!x) |
1336 |
203 |
return sbsplit[-stride]; |
|
1337 |
|||
1338 |
1827 |
return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]]; |
|
1339 |
} |
||
1340 |
|||
1341 |
8493 |
static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask) |
|
1342 |
{ |
||
1343 |
int pred; |
||
1344 |
|||
1345 |
✓✓ | 8493 |
if (!(x|y)) |
1346 |
57 |
return 0; |
|
1347 |
✓✓ | 8436 |
else if (!y) |
1348 |
545 |
return block[-1].ref & refmask; |
|
1349 |
✓✓ | 7891 |
else if (!x) |
1350 |
399 |
return block[-stride].ref & refmask; |
|
1351 |
|||
1352 |
/* return the majority */ |
||
1353 |
7492 |
pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask); |
|
1354 |
7492 |
return (pred >> 1) & refmask; |
|
1355 |
} |
||
1356 |
|||
1357 |
754 |
static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y) |
|
1358 |
{ |
||
1359 |
754 |
int i, n = 0; |
|
1360 |
|||
1361 |
754 |
memset(block->u.dc, 0, sizeof(block->u.dc)); |
|
1362 |
|||
1363 |
✓✗✓✓ |
754 |
if (x && !(block[-1].ref & 3)) { |
1364 |
✓✓ | 1752 |
for (i = 0; i < 3; i++) |
1365 |
1314 |
block->u.dc[i] += block[-1].u.dc[i]; |
|
1366 |
438 |
n++; |
|
1367 |
} |
||
1368 |
|||
1369 |
✓✗✓✓ |
754 |
if (y && !(block[-stride].ref & 3)) { |
1370 |
✓✓ | 1616 |
for (i = 0; i < 3; i++) |
1371 |
1212 |
block->u.dc[i] += block[-stride].u.dc[i]; |
|
1372 |
404 |
n++; |
|
1373 |
} |
||
1374 |
|||
1375 |
✓✗✓✗ ✓✓ |
754 |
if (x && y && !(block[-1-stride].ref & 3)) { |
1376 |
✓✓ | 1372 |
for (i = 0; i < 3; i++) |
1377 |
1029 |
block->u.dc[i] += block[-1-stride].u.dc[i]; |
|
1378 |
343 |
n++; |
|
1379 |
} |
||
1380 |
|||
1381 |
✓✓ | 754 |
if (n == 2) { |
1382 |
✓✓ | 880 |
for (i = 0; i < 3; i++) |
1383 |
660 |
block->u.dc[i] = (block->u.dc[i]+1)>>1; |
|
1384 |
✓✓ | 534 |
} else if (n == 3) { |
1385 |
✓✓ | 656 |
for (i = 0; i < 3; i++) |
1386 |
492 |
block->u.dc[i] = divide3(block->u.dc[i]); |
|
1387 |
} |
||
1388 |
754 |
} |
|
1389 |
|||
1390 |
5951 |
static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref) |
|
1391 |
{ |
||
1392 |
int16_t *pred[3]; |
||
1393 |
5951 |
int refmask = ref+1; |
|
1394 |
5951 |
int mask = refmask | DIRAC_REF_MASK_GLOBAL; /* exclude gmc blocks */ |
|
1395 |
5951 |
int n = 0; |
|
1396 |
|||
1397 |
✓✓✓✓ |
5951 |
if (x && (block[-1].ref & mask) == refmask) |
1398 |
4890 |
pred[n++] = block[-1].u.mv[ref]; |
|
1399 |
|||
1400 |
✓✓✓✓ |
5951 |
if (y && (block[-stride].ref & mask) == refmask) |
1401 |
4719 |
pred[n++] = block[-stride].u.mv[ref]; |
|
1402 |
|||
1403 |
✓✓✓✓ ✓✓ |
5951 |
if (x && y && (block[-stride-1].ref & mask) == refmask) |
1404 |
4313 |
pred[n++] = block[-stride-1].u.mv[ref]; |
|
1405 |
|||
1406 |
✓✓✓✓ ✗ |
5951 |
switch (n) { |
1407 |
304 |
case 0: |
|
1408 |
304 |
block->u.mv[ref][0] = 0; |
|
1409 |
304 |
block->u.mv[ref][1] = 0; |
|
1410 |
304 |
break; |
|
1411 |
1266 |
case 1: |
|
1412 |
1266 |
block->u.mv[ref][0] = pred[0][0]; |
|
1413 |
1266 |
block->u.mv[ref][1] = pred[0][1]; |
|
1414 |
1266 |
break; |
|
1415 |
487 |
case 2: |
|
1416 |
487 |
block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1; |
|
1417 |
487 |
block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1; |
|
1418 |
487 |
break; |
|
1419 |
3894 |
case 3: |
|
1420 |
3894 |
block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]); |
|
1421 |
3894 |
block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]); |
|
1422 |
3894 |
break; |
|
1423 |
} |
||
1424 |
5951 |
} |
|
1425 |
|||
1426 |
static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref) |
||
1427 |
{ |
||
1428 |
int ez = s->globalmc[ref].zrs_exp; |
||
1429 |
int ep = s->globalmc[ref].perspective_exp; |
||
1430 |
int (*A)[2] = s->globalmc[ref].zrs; |
||
1431 |
int *b = s->globalmc[ref].pan_tilt; |
||
1432 |
int *c = s->globalmc[ref].perspective; |
||
1433 |
|||
1434 |
int64_t m = (1<<ep) - (c[0]*(int64_t)x + c[1]*(int64_t)y); |
||
1435 |
int64_t mx = m * (int64_t)((A[0][0] * (int64_t)x + A[0][1]*(int64_t)y) + (1LL<<ez) * b[0]); |
||
1436 |
int64_t my = m * (int64_t)((A[1][0] * (int64_t)x + A[1][1]*(int64_t)y) + (1LL<<ez) * b[1]); |
||
1437 |
|||
1438 |
block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep); |
||
1439 |
block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep); |
||
1440 |
} |
||
1441 |
|||
1442 |
4348 |
static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block, |
|
1443 |
int stride, int x, int y) |
||
1444 |
{ |
||
1445 |
int i; |
||
1446 |
|||
1447 |
4348 |
block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1); |
|
1448 |
4348 |
block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1); |
|
1449 |
|||
1450 |
✓✓ | 4348 |
if (s->num_refs == 2) { |
1451 |
4145 |
block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2); |
|
1452 |
4145 |
block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1; |
|
1453 |
} |
||
1454 |
|||
1455 |
✓✓ | 4348 |
if (!block->ref) { |
1456 |
754 |
pred_block_dc(block, stride, x, y); |
|
1457 |
✓✓ | 3016 |
for (i = 0; i < 3; i++) |
1458 |
2262 |
block->u.dc[i] += (unsigned)dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA); |
|
1459 |
754 |
return; |
|
1460 |
} |
||
1461 |
|||
1462 |
✗✓ | 3594 |
if (s->globalmc_flag) { |
1463 |
block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL); |
||
1464 |
block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2; |
||
1465 |
} |
||
1466 |
|||
1467 |
✓✓ | 10636 |
for (i = 0; i < s->num_refs; i++) |
1468 |
✓✓ | 7042 |
if (block->ref & (i+1)) { |
1469 |
✗✓ | 5951 |
if (block->ref & DIRAC_REF_MASK_GLOBAL) { |
1470 |
global_mv(s, block, x, y, i); |
||
1471 |
} else { |
||
1472 |
5951 |
pred_mv(block, stride, x, y, i); |
|
1473 |
5951 |
block->u.mv[i][0] += (unsigned)dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA); |
|
1474 |
5951 |
block->u.mv[i][1] += (unsigned)dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA); |
|
1475 |
} |
||
1476 |
} |
||
1477 |
} |
||
1478 |
|||
1479 |
/** |
||
1480 |
* Copies the current block to the other blocks covered by the current superblock split mode |
||
1481 |
*/ |
||
1482 |
4348 |
static void propagate_block_data(DiracBlock *block, int stride, int size) |
|
1483 |
{ |
||
1484 |
int x, y; |
||
1485 |
4348 |
DiracBlock *dst = block; |
|
1486 |
|||
1487 |
✓✓ | 11112 |
for (x = 1; x < size; x++) |
1488 |
6764 |
dst[x] = *block; |
|
1489 |
|||
1490 |
✓✓ | 11112 |
for (y = 1; y < size; y++) { |
1491 |
6764 |
dst += stride; |
|
1492 |
✓✓ | 32772 |
for (x = 0; x < size; x++) |
1493 |
26008 |
dst[x] = *block; |
|
1494 |
} |
||
1495 |
4348 |
} |
|
1496 |
|||
1497 |
/** |
||
1498 |
* Dirac Specification -> |
||
1499 |
* 12. Block motion data syntax |
||
1500 |
*/ |
||
1501 |
29 |
static int dirac_unpack_block_motion_data(DiracContext *s) |
|
1502 |
{ |
||
1503 |
29 |
GetBitContext *gb = &s->gb; |
|
1504 |
29 |
uint8_t *sbsplit = s->sbsplit; |
|
1505 |
int i, x, y, q, p; |
||
1506 |
DiracArith arith[8]; |
||
1507 |
|||
1508 |
29 |
align_get_bits(gb); |
|
1509 |
|||
1510 |
/* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */ |
||
1511 |
29 |
s->sbwidth = DIVRNDUP(s->seq.width, 4*s->plane[0].xbsep); |
|
1512 |
29 |
s->sbheight = DIVRNDUP(s->seq.height, 4*s->plane[0].ybsep); |
|
1513 |
29 |
s->blwidth = 4 * s->sbwidth; |
|
1514 |
29 |
s->blheight = 4 * s->sbheight; |
|
1515 |
|||
1516 |
/* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes() |
||
1517 |
decode superblock split modes */ |
||
1518 |
29 |
ff_dirac_init_arith_decoder(arith, gb, get_interleaved_ue_golomb(gb)); /* get_interleaved_ue_golomb(gb) is the length */ |
|
1519 |
✓✓ | 261 |
for (y = 0; y < s->sbheight; y++) { |
1520 |
✓✓ | 2552 |
for (x = 0; x < s->sbwidth; x++) { |
1521 |
2320 |
unsigned int split = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA); |
|
1522 |
✗✓ | 2320 |
if (split > 2) |
1523 |
return AVERROR_INVALIDDATA; |
||
1524 |
2320 |
sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3; |
|
1525 |
} |
||
1526 |
232 |
sbsplit += s->sbwidth; |
|
1527 |
} |
||
1528 |
|||
1529 |
/* setup arith decoding */ |
||
1530 |
29 |
ff_dirac_init_arith_decoder(arith, gb, get_interleaved_ue_golomb(gb)); |
|
1531 |
✓✓ | 86 |
for (i = 0; i < s->num_refs; i++) { |
1532 |
57 |
ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, get_interleaved_ue_golomb(gb)); |
|
1533 |
57 |
ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, get_interleaved_ue_golomb(gb)); |
|
1534 |
} |
||
1535 |
✓✓ | 116 |
for (i = 0; i < 3; i++) |
1536 |
87 |
ff_dirac_init_arith_decoder(arith+1+i, gb, get_interleaved_ue_golomb(gb)); |
|
1537 |
|||
1538 |
✓✓ | 261 |
for (y = 0; y < s->sbheight; y++) |
1539 |
✓✓ | 2552 |
for (x = 0; x < s->sbwidth; x++) { |
1540 |
2320 |
int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x]; |
|
1541 |
2320 |
int step = 4 >> s->sbsplit[y * s->sbwidth + x]; |
|
1542 |
|||
1543 |
✓✓ | 5098 |
for (q = 0; q < blkcnt; q++) |
1544 |
✓✓ | 7126 |
for (p = 0; p < blkcnt; p++) { |
1545 |
4348 |
int bx = 4 * x + p*step; |
|
1546 |
4348 |
int by = 4 * y + q*step; |
|
1547 |
4348 |
DiracBlock *block = &s->blmotion[by*s->blwidth + bx]; |
|
1548 |
4348 |
decode_block_params(s, arith, block, s->blwidth, bx, by); |
|
1549 |
4348 |
propagate_block_data(block, s->blwidth, step); |
|
1550 |
} |
||
1551 |
} |
||
1552 |
|||
1553 |
✓✓ | 259 |
for (i = 0; i < 4 + 2*s->num_refs; i++) { |
1554 |
✗✓ | 230 |
if (arith[i].error) |
1555 |
return arith[i].error; |
||
1556 |
} |
||
1557 |
|||
1558 |
29 |
return 0; |
|
1559 |
} |
||
1560 |
|||
1561 |
72384 |
static int weight(int i, int blen, int offset) |
|
1562 |
{ |
||
1563 |
#define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \ |
||
1564 |
(1 + (6*(i) + offset - 1) / (2*offset - 1)) |
||
1565 |
|||
1566 |
✓✓ | 72384 |
if (i < 2*offset) |
1567 |
✗✓✗✗ |
36192 |
return ROLLOFF(i); |
1568 |
✓✗ | 36192 |
else if (i > blen-1 - 2*offset) |
1569 |
✗✓✗✗ |
36192 |
return ROLLOFF(blen-1 - i); |
1570 |
return 8; |
||
1571 |
} |
||
1572 |
|||
1573 |
8352 |
static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride, |
|
1574 |
int left, int right, int wy) |
||
1575 |
{ |
||
1576 |
int x; |
||
1577 |
✓✓✓✓ |
25056 |
for (x = 0; left && x < p->xblen >> 1; x++) |
1578 |
16704 |
obmc_weight[x] = wy*8; |
|
1579 |
✓✓ | 75168 |
for (; x < p->xblen >> right; x++) |
1580 |
66816 |
obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset); |
|
1581 |
✓✓ | 25056 |
for (; x < p->xblen; x++) |
1582 |
16704 |
obmc_weight[x] = wy*8; |
|
1583 |
✓✓ | 175392 |
for (; x < stride; x++) |
1584 |
167040 |
obmc_weight[x] = 0; |
|
1585 |
8352 |
} |
|
1586 |
|||
1587 |
783 |
static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride, |
|
1588 |
int left, int right, int top, int bottom) |
||
1589 |
{ |
||
1590 |
int y; |
||
1591 |
✓✓✓✓ |
2175 |
for (y = 0; top && y < p->yblen >> 1; y++) { |
1592 |
1392 |
init_obmc_weight_row(p, obmc_weight, stride, left, right, 8); |
|
1593 |
1392 |
obmc_weight += stride; |
|
1594 |
} |
||
1595 |
✓✓ | 6351 |
for (; y < p->yblen >> bottom; y++) { |
1596 |
5568 |
int wy = weight(y, p->yblen, p->yoffset); |
|
1597 |
5568 |
init_obmc_weight_row(p, obmc_weight, stride, left, right, wy); |
|
1598 |
5568 |
obmc_weight += stride; |
|
1599 |
} |
||
1600 |
✓✓ | 2175 |
for (; y < p->yblen; y++) { |
1601 |
1392 |
init_obmc_weight_row(p, obmc_weight, stride, left, right, 8); |
|
1602 |
1392 |
obmc_weight += stride; |
|
1603 |
} |
||
1604 |
783 |
} |
|
1605 |
|||
1606 |
2784 |
static void init_obmc_weights(DiracContext *s, Plane *p, int by) |
|
1607 |
{ |
||
1608 |
2784 |
int top = !by; |
|
1609 |
2784 |
int bottom = by == s->blheight-1; |
|
1610 |
|||
1611 |
/* don't bother re-initing for rows 2 to blheight-2, the weights don't change */ |
||
1612 |
✓✓✓✓ ✓✓ |
2784 |
if (top || bottom || by == 1) { |
1613 |
261 |
init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom); |
|
1614 |
261 |
init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom); |
|
1615 |
261 |
init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom); |
|
1616 |
} |
||
1617 |
2784 |
} |
|
1618 |
|||
1619 |
static const uint8_t epel_weights[4][4][4] = { |
||
1620 |
{{ 16, 0, 0, 0 }, |
||
1621 |
{ 12, 4, 0, 0 }, |
||
1622 |
{ 8, 8, 0, 0 }, |
||
1623 |
{ 4, 12, 0, 0 }}, |
||
1624 |
{{ 12, 0, 4, 0 }, |
||
1625 |
{ 9, 3, 3, 1 }, |
||
1626 |
{ 6, 6, 2, 2 }, |
||
1627 |
{ 3, 9, 1, 3 }}, |
||
1628 |
{{ 8, 0, 8, 0 }, |
||
1629 |
{ 6, 2, 6, 2 }, |
||
1630 |
{ 4, 4, 4, 4 }, |
||
1631 |
{ 2, 6, 2, 6 }}, |
||
1632 |
{{ 4, 0, 12, 0 }, |
||
1633 |
{ 3, 1, 9, 3 }, |
||
1634 |
{ 2, 2, 6, 6 }, |
||
1635 |
{ 1, 3, 3, 9 }} |
||
1636 |
}; |
||
1637 |
|||
1638 |
/** |
||
1639 |
* For block x,y, determine which of the hpel planes to do bilinear |
||
1640 |
* interpolation from and set src[] to the location in each hpel plane |
||
1641 |
* to MC from. |
||
1642 |
* |
||
1643 |
* @return the index of the put_dirac_pixels_tab function to use |
||
1644 |
* 0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel |
||
1645 |
*/ |
||
1646 |
199452 |
static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5], |
|
1647 |
int x, int y, int ref, int plane) |
||
1648 |
{ |
||
1649 |
199452 |
Plane *p = &s->plane[plane]; |
|
1650 |
199452 |
uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane]; |
|
1651 |
199452 |
int motion_x = block->u.mv[ref][0]; |
|
1652 |
199452 |
int motion_y = block->u.mv[ref][1]; |
|
1653 |
199452 |
int mx, my, i, epel, nplanes = 0; |
|
1654 |
|||
1655 |
✓✓ | 199452 |
if (plane) { |
1656 |
132968 |
motion_x >>= s->chroma_x_shift; |
|
1657 |
132968 |
motion_y >>= s->chroma_y_shift; |
|
1658 |
} |
||
1659 |
|||
1660 |
199452 |
mx = motion_x & ~(-1U << s->mv_precision); |
|
1661 |
199452 |
my = motion_y & ~(-1U << s->mv_precision); |
|
1662 |
199452 |
motion_x >>= s->mv_precision; |
|
1663 |
199452 |
motion_y >>= s->mv_precision; |
|
1664 |
/* normalize subpel coordinates to epel */ |
||
1665 |
/* TODO: template this function? */ |
||
1666 |
199452 |
mx <<= 3 - s->mv_precision; |
|
1667 |
199452 |
my <<= 3 - s->mv_precision; |
|
1668 |
|||
1669 |
199452 |
x += motion_x; |
|
1670 |
199452 |
y += motion_y; |
|
1671 |
199452 |
epel = (mx|my)&1; |
|
1672 |
|||
1673 |
/* hpel position */ |
||
1674 |
✓✗ | 199452 |
if (!((mx|my)&3)) { |
1675 |
199452 |
nplanes = 1; |
|
1676 |
199452 |
src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x; |
|
1677 |
} else { |
||
1678 |
/* qpel or epel */ |
||
1679 |
nplanes = 4; |
||
1680 |
for (i = 0; i < 4; i++) |
||
1681 |
src[i] = ref_hpel[i] + y*p->stride + x; |
||
1682 |
|||
1683 |
/* if we're interpolating in the right/bottom halves, adjust the planes as needed |
||
1684 |
we increment x/y because the edge changes for half of the pixels */ |
||
1685 |
if (mx > 4) { |
||
1686 |
src[0] += 1; |
||
1687 |
src[2] += 1; |
||
1688 |
x++; |
||
1689 |
} |
||
1690 |
if (my > 4) { |
||
1691 |
src[0] += p->stride; |
||
1692 |
src[1] += p->stride; |
||
1693 |
y++; |
||
1694 |
} |
||
1695 |
|||
1696 |
/* hpel planes are: |
||
1697 |
[0]: F [1]: H |
||
1698 |
[2]: V [3]: C */ |
||
1699 |
if (!epel) { |
||
1700 |
/* check if we really only need 2 planes since either mx or my is |
||
1701 |
a hpel position. (epel weights of 0 handle this there) */ |
||
1702 |
if (!(mx&3)) { |
||
1703 |
/* mx == 0: average [0] and [2] |
||
1704 |
mx == 4: average [1] and [3] */ |
||
1705 |
src[!mx] = src[2 + !!mx]; |
||
1706 |
nplanes = 2; |
||
1707 |
} else if (!(my&3)) { |
||
1708 |
src[0] = src[(my>>1) ]; |
||
1709 |
src[1] = src[(my>>1)+1]; |
||
1710 |
nplanes = 2; |
||
1711 |
} |
||
1712 |
} else { |
||
1713 |
/* adjust the ordering if needed so the weights work */ |
||
1714 |
if (mx > 4) { |
||
1715 |
FFSWAP(const uint8_t *, src[0], src[1]); |
||
1716 |
FFSWAP(const uint8_t *, src[2], src[3]); |
||
1717 |
} |
||
1718 |
if (my > 4) { |
||
1719 |
FFSWAP(const uint8_t *, src[0], src[2]); |
||
1720 |
FFSWAP(const uint8_t *, src[1], src[3]); |
||
1721 |
} |
||
1722 |
src[4] = epel_weights[my&3][mx&3]; |
||
1723 |
} |
||
1724 |
} |
||
1725 |
|||
1726 |
/* fixme: v/h _edge_pos */ |
||
1727 |
✓✓ | 199452 |
if (x + p->xblen > p->width +EDGE_WIDTH/2 || |
1728 |
✓✓✓✓ |
199293 |
y + p->yblen > p->height+EDGE_WIDTH/2 || |
1729 |
✓✓ | 191702 |
x < 0 || y < 0) { |
1730 |
✓✓ | 27830 |
for (i = 0; i < nplanes; i++) { |
1731 |
13915 |
s->vdsp.emulated_edge_mc(s->edge_emu_buffer[i], src[i], |
|
1732 |
p->stride, p->stride, |
||
1733 |
13915 |
p->xblen, p->yblen, x, y, |
|
1734 |
13915 |
p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2); |
|
1735 |
13915 |
src[i] = s->edge_emu_buffer[i]; |
|
1736 |
} |
||
1737 |
} |
||
1738 |
199452 |
return (nplanes>>1) + epel; |
|
1739 |
} |
||
1740 |
|||
1741 |
2262 |
static void add_dc(uint16_t *dst, int dc, int stride, |
|
1742 |
uint8_t *obmc_weight, int xblen, int yblen) |
||
1743 |
{ |
||
1744 |
int x, y; |
||
1745 |
2262 |
dc += 128; |
|
1746 |
|||
1747 |
✓✓ | 26390 |
for (y = 0; y < yblen; y++) { |
1748 |
✓✓ | 168896 |
for (x = 0; x < xblen; x += 2) { |
1749 |
144768 |
dst[x ] += dc * obmc_weight[x ]; |
|
1750 |
144768 |
dst[x+1] += dc * obmc_weight[x+1]; |
|
1751 |
} |
||
1752 |
24128 |
dst += stride; |
|
1753 |
24128 |
obmc_weight += MAX_BLOCKSIZE; |
|
1754 |
} |
||
1755 |
2262 |
} |
|
1756 |
|||
1757 |
107880 |
static void block_mc(DiracContext *s, DiracBlock *block, |
|
1758 |
uint16_t *mctmp, uint8_t *obmc_weight, |
||
1759 |
int plane, int dstx, int dsty) |
||
1760 |
{ |
||
1761 |
107880 |
Plane *p = &s->plane[plane]; |
|
1762 |
const uint8_t *src[5]; |
||
1763 |
int idx; |
||
1764 |
|||
1765 |
✓✓✓✗ |
107880 |
switch (block->ref&3) { |
1766 |
2262 |
case 0: /* DC */ |
|
1767 |
2262 |
add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen); |
|
1768 |
2262 |
return; |
|
1769 |
11784 |
case 1: |
|
1770 |
case 2: |
||
1771 |
11784 |
idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane); |
|
1772 |
11784 |
s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen); |
|
1773 |
✗✓ | 11784 |
if (s->weight_func) |
1774 |
s->weight_func(s->mcscratch, p->stride, s->weight_log2denom, |
||
1775 |
s->weight[0] + s->weight[1], p->yblen); |
||
1776 |
11784 |
break; |
|
1777 |
93834 |
case 3: |
|
1778 |
93834 |
idx = mc_subpel(s, block, src, dstx, dsty, 0, plane); |
|
1779 |
93834 |
s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen); |
|
1780 |
93834 |
idx = mc_subpel(s, block, src, dstx, dsty, 1, plane); |
|
1781 |
✗✓ | 93834 |
if (s->biweight_func) { |
1782 |
/* fixme: +32 is a quick hack */ |
||
1783 |
s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen); |
||
1784 |
s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom, |
||
1785 |
s->weight[0], s->weight[1], p->yblen); |
||
1786 |
} else |
||
1787 |
93834 |
s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen); |
|
1788 |
93834 |
break; |
|
1789 |
} |
||
1790 |
105618 |
s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen); |
|
1791 |
} |
||
1792 |
|||
1793 |
2697 |
static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty) |
|
1794 |
{ |
||
1795 |
2697 |
Plane *p = &s->plane[plane]; |
|
1796 |
2697 |
int x, dstx = p->xbsep - p->xoffset; |
|
1797 |
|||
1798 |
2697 |
block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty); |
|
1799 |
2697 |
mctmp += p->xbsep; |
|
1800 |
|||
1801 |
✓✓ | 105183 |
for (x = 1; x < s->blwidth-1; x++) { |
1802 |
102486 |
block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty); |
|
1803 |
102486 |
dstx += p->xbsep; |
|
1804 |
102486 |
mctmp += p->xbsep; |
|
1805 |
} |
||
1806 |
2697 |
block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty); |
|
1807 |
2697 |
} |
|
1808 |
|||
1809 |
87 |
static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen) |
|
1810 |
{ |
||
1811 |
87 |
int idx = 0; |
|
1812 |
✓✓ | 87 |
if (xblen > 8) |
1813 |
29 |
idx = 1; |
|
1814 |
✗✓ | 87 |
if (xblen > 16) |
1815 |
idx = 2; |
||
1816 |
|||
1817 |
87 |
memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab)); |
|
1818 |
87 |
memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab)); |
|
1819 |
87 |
s->add_obmc = s->diracdsp.add_dirac_obmc[idx]; |
|
1820 |
✓✗✓✗ ✗✓ |
87 |
if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) { |
1821 |
s->weight_func = s->diracdsp.weight_dirac_pixels_tab[idx]; |
||
1822 |
s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx]; |
||
1823 |
} else { |
||
1824 |
87 |
s->weight_func = NULL; |
|
1825 |
87 |
s->biweight_func = NULL; |
|
1826 |
} |
||
1827 |
87 |
} |
|
1828 |
|||
1829 |
171 |
static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height) |
|
1830 |
{ |
||
1831 |
/* chroma allocates an edge of 8 when subsampled |
||
1832 |
which for 4:2:2 means an h edge of 16 and v edge of 8 |
||
1833 |
just use 8 for everything for the moment */ |
||
1834 |
171 |
int i, edge = EDGE_WIDTH/2; |
|
1835 |
|||
1836 |
171 |
ref->hpel[plane][0] = ref->avframe->data[plane]; |
|
1837 |
171 |
s->mpvencdsp.draw_edges(ref->hpel[plane][0], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM); /* EDGE_TOP | EDGE_BOTTOM values just copied to make it build, this needs to be ensured */ |
|
1838 |
|||
1839 |
/* no need for hpel if we only have fpel vectors */ |
||
1840 |
✓✗ | 171 |
if (!s->mv_precision) |
1841 |
171 |
return 0; |
|
1842 |
|||
1843 |
for (i = 1; i < 4; i++) { |
||
1844 |
if (!ref->hpel_base[plane][i]) |
||
1845 |
ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32); |
||
1846 |
if (!ref->hpel_base[plane][i]) { |
||
1847 |
return AVERROR(ENOMEM); |
||
1848 |
} |
||
1849 |
/* we need to be 16-byte aligned even for chroma */ |
||
1850 |
ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16; |
||
1851 |
} |
||
1852 |
|||
1853 |
if (!ref->interpolated[plane]) { |
||
1854 |
s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2], |
||
1855 |
ref->hpel[plane][3], ref->hpel[plane][0], |
||
1856 |
ref->avframe->linesize[plane], width, height); |
||
1857 |
s->mpvencdsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM); |
||
1858 |
s->mpvencdsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM); |
||
1859 |
s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM); |
||
1860 |
} |
||
1861 |
ref->interpolated[plane] = 1; |
||
1862 |
|||
1863 |
return 0; |
||
1864 |
} |
||
1865 |
|||
1866 |
/** |
||
1867 |
* Dirac Specification -> |
||
1868 |
* 13.0 Transform data syntax. transform_data() |
||
1869 |
*/ |
||
1870 |
260 |
static int dirac_decode_frame_internal(DiracContext *s) |
|
1871 |
{ |
||
1872 |
DWTContext d; |
||
1873 |
int y, i, comp, dsty; |
||
1874 |
int ret; |
||
1875 |
|||
1876 |
✓✓ | 260 |
if (s->low_delay) { |
1877 |
/* [DIRAC_STD] 13.5.1 low_delay_transform_data() */ |
||
1878 |
✓✓ | 229 |
if (!s->hq_picture) { |
1879 |
✓✓ | 124 |
for (comp = 0; comp < 3; comp++) { |
1880 |
93 |
Plane *p = &s->plane[comp]; |
|
1881 |
93 |
memset(p->idwt.buf, 0, p->idwt.stride * p->idwt.height); |
|
1882 |
} |
||
1883 |
} |
||
1884 |
✓✗ | 229 |
if (!s->zero_res) { |
1885 |
✗✓ | 229 |
if ((ret = decode_lowdelay(s)) < 0) |
1886 |
return ret; |
||
1887 |
} |
||
1888 |
} |
||
1889 |
|||
1890 |
✓✓ | 1040 |
for (comp = 0; comp < 3; comp++) { |
1891 |
780 |
Plane *p = &s->plane[comp]; |
|
1892 |
780 |
uint8_t *frame = s->current_picture->avframe->data[comp]; |
|
1893 |
|||
1894 |
/* FIXME: small resolutions */ |
||
1895 |
✓✓ | 3900 |
for (i = 0; i < 4; i++) |
1896 |
3120 |
s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16); |
|
1897 |
|||
1898 |
✓✗✓✓ |
780 |
if (!s->zero_res && !s->low_delay) |
1899 |
{ |
||
1900 |
93 |
memset(p->idwt.buf, 0, p->idwt.stride * p->idwt.height); |
|
1901 |
93 |
ret = decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */ |
|
1902 |
✗✓ | 93 |
if (ret < 0) |
1903 |
return ret; |
||
1904 |
} |
||
1905 |
780 |
ret = ff_spatial_idwt_init(&d, &p->idwt, s->wavelet_idx+2, |
|
1906 |
780 |
s->wavelet_depth, s->bit_depth); |
|
1907 |
✗✓ | 780 |
if (ret < 0) |
1908 |
return ret; |
||
1909 |
|||
1910 |
✓✓ | 780 |
if (!s->num_refs) { /* intra */ |
1911 |
✓✓ | 11436 |
for (y = 0; y < p->height; y += 16) { |
1912 |
10743 |
int idx = (s->bit_depth - 8) >> 1; |
|
1913 |
10743 |
ff_spatial_idwt_slice2(&d, y+16); /* decode */ |
|
1914 |
10743 |
s->diracdsp.put_signed_rect_clamped[idx](frame + y*p->stride, |
|
1915 |
10743 |
p->stride, |
|
1916 |
10743 |
p->idwt.buf + y*p->idwt.stride, |
|
1917 |
p->idwt.stride, p->width, 16); |
||
1918 |
} |
||
1919 |
} else { /* inter */ |
||
1920 |
87 |
int rowheight = p->ybsep*p->stride; |
|
1921 |
|||
1922 |
87 |
select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen); |
|
1923 |
|||
1924 |
✓✓ | 258 |
for (i = 0; i < s->num_refs; i++) { |
1925 |
171 |
int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height); |
|
1926 |
✗✓ | 171 |
if (ret < 0) |
1927 |
return ret; |
||
1928 |
} |
||
1929 |
|||
1930 |
87 |
memset(s->mctmp, 0, 4*p->yoffset*p->stride); |
|
1931 |
|||
1932 |
87 |
dsty = -p->yoffset; |
|
1933 |
✓✗ | 2784 |
for (y = 0; y < s->blheight; y++) { |
1934 |
2784 |
int h = 0, |
|
1935 |
2784 |
start = FFMAX(dsty, 0); |
|
1936 |
2784 |
uint16_t *mctmp = s->mctmp + y*rowheight; |
|
1937 |
2784 |
DiracBlock *blocks = s->blmotion + y*s->blwidth; |
|
1938 |
|||
1939 |
2784 |
init_obmc_weights(s, p, y); |
|
1940 |
|||
1941 |
✓✓✓✓ |
2784 |
if (y == s->blheight-1 || start+p->ybsep > p->height) |
1942 |
174 |
h = p->height - start; |
|
1943 |
else |
||
1944 |
2610 |
h = p->ybsep - (start - dsty); |
|
1945 |
✓✓ | 2784 |
if (h < 0) |
1946 |
87 |
break; |
|
1947 |
|||
1948 |
2697 |
memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight); |
|
1949 |
2697 |
mc_row(s, blocks, mctmp, comp, dsty); |
|
1950 |
|||
1951 |
2697 |
mctmp += (start - dsty)*p->stride + p->xoffset; |
|
1952 |
2697 |
ff_spatial_idwt_slice2(&d, start + h); /* decode */ |
|
1953 |
/* NOTE: add_rect_clamped hasn't been templated hence the shifts. |
||
1954 |
* idwt.stride is passed as pixels, not in bytes as in the rest of the decoder */ |
||
1955 |
2697 |
s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride, |
|
1956 |
2697 |
(int16_t*)(p->idwt.buf) + start*(p->idwt.stride >> 1), (p->idwt.stride >> 1), p->width, h); |
|
1957 |
|||
1958 |
2697 |
dsty += p->ybsep; |
|
1959 |
} |
||
1960 |
} |
||
1961 |
} |
||
1962 |
|||
1963 |
|||
1964 |
260 |
return 0; |
|
1965 |
} |
||
1966 |
|||
1967 |
260 |
static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags) |
|
1968 |
{ |
||
1969 |
int ret, i; |
||
1970 |
int chroma_x_shift, chroma_y_shift; |
||
1971 |
260 |
ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift, |
|
1972 |
&chroma_y_shift); |
||
1973 |
✗✓ | 260 |
if (ret < 0) |
1974 |
return ret; |
||
1975 |
|||
1976 |
260 |
f->width = avctx->width + 2 * EDGE_WIDTH; |
|
1977 |
260 |
f->height = avctx->height + 2 * EDGE_WIDTH + 2; |
|
1978 |
260 |
ret = ff_get_buffer(avctx, f, flags); |
|
1979 |
✗✓ | 260 |
if (ret < 0) |
1980 |
return ret; |
||
1981 |
|||
1982 |
✓✓ | 1040 |
for (i = 0; f->data[i]; i++) { |
1983 |
✓✓✓✗ |
780 |
int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) * |
1984 |
780 |
f->linesize[i] + 32; |
|
1985 |
780 |
f->data[i] += offset; |
|
1986 |
} |
||
1987 |
260 |
f->width = avctx->width; |
|
1988 |
260 |
f->height = avctx->height; |
|
1989 |
|||
1990 |
260 |
return 0; |
|
1991 |
} |
||
1992 |
|||
1993 |
/** |
||
1994 |
* Dirac Specification -> |
||
1995 |
* 11.1.1 Picture Header. picture_header() |
||
1996 |
*/ |
||
1997 |
260 |
static int dirac_decode_picture_header(DiracContext *s) |
|
1998 |
{ |
||
1999 |
unsigned retire, picnum; |
||
2000 |
int i, j, ret; |
||
2001 |
int64_t refdist, refnum; |
||
2002 |
260 |
GetBitContext *gb = &s->gb; |
|
2003 |
|||
2004 |
/* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */ |
||
2005 |
260 |
picnum = s->current_picture->avframe->display_picture_number = get_bits_long(gb, 32); |
|
2006 |
|||
2007 |
|||
2008 |
260 |
av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum); |
|
2009 |
|||
2010 |
/* if this is the first keyframe after a sequence header, start our |
||
2011 |
reordering from here */ |
||
2012 |
✓✓ | 260 |
if (s->frame_number < 0) |
2013 |
70 |
s->frame_number = picnum; |
|
2014 |
|||
2015 |
260 |
s->ref_pics[0] = s->ref_pics[1] = NULL; |
|
2016 |
✓✓ | 317 |
for (i = 0; i < s->num_refs; i++) { |
2017 |
57 |
refnum = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF; |
|
2018 |
57 |
refdist = INT64_MAX; |
|
2019 |
|||
2020 |
/* find the closest reference to the one we want */ |
||
2021 |
/* Jordi: this is needed if the referenced picture hasn't yet arrived */ |
||
2022 |
✓✗✓✓ |
184 |
for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++) |
2023 |
✓✗ | 127 |
if (s->ref_frames[j] |
2024 |
✓✗ | 127 |
&& FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) { |
2025 |
127 |
s->ref_pics[i] = s->ref_frames[j]; |
|
2026 |
127 |
refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum); |
|
2027 |
} |
||
2028 |
|||
2029 |
✓✗✗✓ |
57 |
if (!s->ref_pics[i] || refdist) |
2030 |
av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n"); |
||
2031 |
|||
2032 |
/* if there were no references at all, allocate one */ |
||
2033 |
✗✓ | 57 |
if (!s->ref_pics[i]) |
2034 |
for (j = 0; j < MAX_FRAMES; j++) |
||
2035 |
if (!s->all_frames[j].avframe->data[0]) { |
||
2036 |
s->ref_pics[i] = &s->all_frames[j]; |
||
2037 |
ret = get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF); |
||
2038 |
if (ret < 0) |
||
2039 |
return ret; |
||
2040 |
break; |
||
2041 |
} |
||
2042 |
|||
2043 |
✗✓ | 57 |
if (!s->ref_pics[i]) { |
2044 |
av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n"); |
||
2045 |
return AVERROR_INVALIDDATA; |
||
2046 |
} |
||
2047 |
|||
2048 |
} |
||
2049 |
|||
2050 |
/* retire the reference frames that are not used anymore */ |
||
2051 |
✓✓ | 260 |
if (s->current_picture->reference) { |
2052 |
10 |
retire = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF; |
|
2053 |
✓✓ | 10 |
if (retire != picnum) { |
2054 |
6 |
DiracFrame *retire_pic = remove_frame(s->ref_frames, retire); |
|
2055 |
|||
2056 |
✓✗ | 6 |
if (retire_pic) |
2057 |
6 |
retire_pic->reference &= DELAYED_PIC_REF; |
|
2058 |
else |
||
2059 |
av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n"); |
||
2060 |
} |
||
2061 |
|||
2062 |
/* if reference array is full, remove the oldest as per the spec */ |
||
2063 |
✗✓ | 10 |
while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) { |
2064 |
av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n"); |
||
2065 |
remove_frame(s->ref_frames, s->ref_frames[0]->avframe->display_picture_number)->reference &= DELAYED_PIC_REF; |
||
2066 |
} |
||
2067 |
} |
||
2068 |
|||
2069 |
✓✓ | 260 |
if (s->num_refs) { |
2070 |
29 |
ret = dirac_unpack_prediction_parameters(s); /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */ |
|
2071 |
✗✓ | 29 |
if (ret < 0) |
2072 |
return ret; |
||
2073 |
29 |
ret = dirac_unpack_block_motion_data(s); /* [DIRAC_STD] 12. Block motion data syntax */ |
|
2074 |
✗✓ | 29 |
if (ret < 0) |
2075 |
return ret; |
||
2076 |
} |
||
2077 |
260 |
ret = dirac_unpack_idwt_params(s); /* [DIRAC_STD] 11.3 Wavelet transform data */ |
|
2078 |
✗✓ | 260 |
if (ret < 0) |
2079 |
return ret; |
||
2080 |
|||
2081 |
260 |
init_planes(s); |
|
2082 |
260 |
return 0; |
|
2083 |
} |
||
2084 |
|||
2085 |
36 |
static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame) |
|
2086 |
{ |
||
2087 |
36 |
DiracFrame *out = s->delay_frames[0]; |
|
2088 |
36 |
int i, out_idx = 0; |
|
2089 |
int ret; |
||
2090 |
|||
2091 |
/* find frame with lowest picture number */ |
||
2092 |
✗✓ | 36 |
for (i = 1; s->delay_frames[i]; i++) |
2093 |
if (s->delay_frames[i]->avframe->display_picture_number < out->avframe->display_picture_number) { |
||
2094 |
out = s->delay_frames[i]; |
||
2095 |
out_idx = i; |
||
2096 |
} |
||
2097 |
|||
2098 |
✓✓ | 37 |
for (i = out_idx; s->delay_frames[i]; i++) |
2099 |
1 |
s->delay_frames[i] = s->delay_frames[i+1]; |
|
2100 |
|||
2101 |
✓✓ | 36 |
if (out) { |
2102 |
1 |
out->reference ^= DELAYED_PIC_REF; |
|
2103 |
✗✓ | 1 |
if((ret = av_frame_ref(picture, out->avframe)) < 0) |
2104 |
return ret; |
||
2105 |
1 |
*got_frame = 1; |
|
2106 |
} |
||
2107 |
|||
2108 |
36 |
return 0; |
|
2109 |
} |
||
2110 |
|||
2111 |
/** |
||
2112 |
* Dirac Specification -> |
||
2113 |
* 9.6 Parse Info Header Syntax. parse_info() |
||
2114 |
* 4 byte start code + byte parse code + 4 byte size + 4 byte previous size |
||
2115 |
*/ |
||
2116 |
#define DATA_UNIT_HEADER_SIZE 13 |
||
2117 |
|||
2118 |
/* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 |
||
2119 |
inside the function parse_sequence() */ |
||
2120 |
757 |
static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size) |
|
2121 |
{ |
||
2122 |
757 |
DiracContext *s = avctx->priv_data; |
|
2123 |
757 |
DiracFrame *pic = NULL; |
|
2124 |
AVDiracSeqHeader *dsh; |
||
2125 |
int ret, i; |
||
2126 |
uint8_t parse_code; |
||
2127 |
unsigned tmp; |
||
2128 |
|||
2129 |
✗✓ | 757 |
if (size < DATA_UNIT_HEADER_SIZE) |
2130 |
return AVERROR_INVALIDDATA; |
||
2131 |
|||
2132 |
757 |
parse_code = buf[4]; |
|
2133 |
|||
2134 |
757 |
init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE)); |
|
2135 |
|||
2136 |
✓✓ | 757 |
if (parse_code == DIRAC_PCODE_SEQ_HEADER) { |
2137 |
✓✓ | 231 |
if (s->seen_sequence_header) |
2138 |
161 |
return 0; |
|
2139 |
|||
2140 |
/* [DIRAC_STD] 10. Sequence header */ |
||
2141 |
70 |
ret = av_dirac_parse_sequence_header(&dsh, buf + DATA_UNIT_HEADER_SIZE, size - DATA_UNIT_HEADER_SIZE, avctx); |
|
2142 |
✗✓ | 70 |
if (ret < 0) { |
2143 |
av_log(avctx, AV_LOG_ERROR, "error parsing sequence header"); |
||
2144 |
return ret; |
||
2145 |
} |
||
2146 |
|||
2147 |
✗✓ | 70 |
if (CALC_PADDING((int64_t)dsh->width, MAX_DWT_LEVELS) * CALC_PADDING((int64_t)dsh->height, MAX_DWT_LEVELS) * 5LL > avctx->max_pixels) |
2148 |
ret = AVERROR(ERANGE); |
||
2149 |
✓✗ | 70 |
if (ret >= 0) |
2150 |
70 |
ret = ff_set_dimensions(avctx, dsh->width, dsh->height); |
|
2151 |
✗✓ | 70 |
if (ret < 0) { |
2152 |
av_freep(&dsh); |
||
2153 |
return ret; |
||
2154 |
} |
||
2155 |
|||
2156 |
70 |
ff_set_sar(avctx, dsh->sample_aspect_ratio); |
|
2157 |
70 |
avctx->pix_fmt = dsh->pix_fmt; |
|
2158 |
70 |
avctx->color_range = dsh->color_range; |
|
2159 |
70 |
avctx->color_trc = dsh->color_trc; |
|
2160 |
70 |
avctx->color_primaries = dsh->color_primaries; |
|
2161 |
70 |
avctx->colorspace = dsh->colorspace; |
|
2162 |
70 |
avctx->profile = dsh->profile; |
|
2163 |
70 |
avctx->level = dsh->level; |
|
2164 |
70 |
avctx->framerate = dsh->framerate; |
|
2165 |
70 |
s->bit_depth = dsh->bit_depth; |
|
2166 |
70 |
s->version.major = dsh->version.major; |
|
2167 |
70 |
s->version.minor = dsh->version.minor; |
|
2168 |
70 |
s->seq = *dsh; |
|
2169 |
70 |
av_freep(&dsh); |
|
2170 |
|||
2171 |
70 |
s->pshift = s->bit_depth > 8; |
|
2172 |
|||
2173 |
70 |
ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, |
|
2174 |
&s->chroma_x_shift, |
||
2175 |
&s->chroma_y_shift); |
||
2176 |
✗✓ | 70 |
if (ret < 0) |
2177 |
return ret; |
||
2178 |
|||
2179 |
70 |
ret = alloc_sequence_buffers(s); |
|
2180 |
✗✓ | 70 |
if (ret < 0) |
2181 |
return ret; |
||
2182 |
|||
2183 |
70 |
s->seen_sequence_header = 1; |
|
2184 |
✗✓ | 526 |
} else if (parse_code == DIRAC_PCODE_END_SEQ) { /* [DIRAC_STD] End of Sequence */ |
2185 |
free_sequence_buffers(s); |
||
2186 |
s->seen_sequence_header = 0; |
||
2187 |
✓✓ | 526 |
} else if (parse_code == DIRAC_PCODE_AUX) { |
2188 |
✓✓ | 266 |
if (buf[13] == 1) { /* encoder implementation/version */ |
2189 |
int ver[3]; |
||
2190 |
/* versions older than 1.0.8 don't store quant delta for |
||
2191 |
subbands with only one codeblock */ |
||
2192 |
✓✗ | 4 |
if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3) |
2193 |
✓✗✓✗ ✗✓ |
4 |
if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7) |
2194 |
s->old_delta_quant = 1; |
||
2195 |
} |
||
2196 |
✓✗ | 260 |
} else if (parse_code & 0x8) { /* picture data unit */ |
2197 |
✗✓ | 260 |
if (!s->seen_sequence_header) { |
2198 |
av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n"); |
||
2199 |
return AVERROR_INVALIDDATA; |
||
2200 |
} |
||
2201 |
|||
2202 |
/* find an unused frame */ |
||
2203 |
✓✓ | 3900 |
for (i = 0; i < MAX_FRAMES; i++) |
2204 |
✓✓ | 3640 |
if (s->all_frames[i].avframe->data[0] == NULL) |
2205 |
3559 |
pic = &s->all_frames[i]; |
|
2206 |
✗✓ | 260 |
if (!pic) { |
2207 |
av_log(avctx, AV_LOG_ERROR, "framelist full\n"); |
||
2208 |
return AVERROR_INVALIDDATA; |
||
2209 |
} |
||
2210 |
|||
2211 |
260 |
av_frame_unref(pic->avframe); |
|
2212 |
|||
2213 |
/* [DIRAC_STD] Defined in 9.6.1 ... */ |
||
2214 |
260 |
tmp = parse_code & 0x03; /* [DIRAC_STD] num_refs() */ |
|
2215 |
✗✓ | 260 |
if (tmp > 2) { |
2216 |
av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n"); |
||
2217 |
return AVERROR_INVALIDDATA; |
||
2218 |
} |
||
2219 |
260 |
s->num_refs = tmp; |
|
2220 |
260 |
s->is_arith = (parse_code & 0x48) == 0x08; /* [DIRAC_STD] using_ac() */ |
|
2221 |
260 |
s->low_delay = (parse_code & 0x88) == 0x88; /* [DIRAC_STD] is_low_delay() */ |
|
2222 |
260 |
s->core_syntax = (parse_code & 0x88) == 0x08; /* [DIRAC_STD] is_core_syntax() */ |
|
2223 |
260 |
s->ld_picture = (parse_code & 0xF8) == 0xC8; /* [DIRAC_STD] is_ld_picture() */ |
|
2224 |
260 |
s->hq_picture = (parse_code & 0xF8) == 0xE8; /* [DIRAC_STD] is_hq_picture() */ |
|
2225 |
260 |
s->dc_prediction = (parse_code & 0x28) == 0x08; /* [DIRAC_STD] using_dc_prediction() */ |
|
2226 |
260 |
pic->reference = (parse_code & 0x0C) == 0x0C; /* [DIRAC_STD] is_reference() */ |
|
2227 |
260 |
pic->avframe->key_frame = s->num_refs == 0; /* [DIRAC_STD] is_intra() */ |
|
2228 |
260 |
pic->avframe->pict_type = s->num_refs + 1; /* Definition of AVPictureType in avutil.h */ |
|
2229 |
|||
2230 |
/* VC-2 Low Delay has a different parse code than the Dirac Low Delay */ |
||
2231 |
✓✓✓✓ |
260 |
if (s->version.minor == 2 && parse_code == 0x88) |
2232 |
31 |
s->ld_picture = 1; |
|
2233 |
|||
2234 |
✓✓✓✓ ✗✓ |
260 |
if (s->low_delay && !(s->ld_picture || s->hq_picture) ) { |
2235 |
av_log(avctx, AV_LOG_ERROR, "Invalid low delay flag\n"); |
||
2236 |
return AVERROR_INVALIDDATA; |
||
2237 |
} |
||
2238 |
|||
2239 |
✗✓ | 260 |
if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0) |
2240 |
return ret; |
||
2241 |
260 |
s->current_picture = pic; |
|
2242 |
260 |
s->plane[0].stride = pic->avframe->linesize[0]; |
|
2243 |
260 |
s->plane[1].stride = pic->avframe->linesize[1]; |
|
2244 |
260 |
s->plane[2].stride = pic->avframe->linesize[2]; |
|
2245 |
|||
2246 |
✗✓ | 260 |
if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0) |
2247 |
return AVERROR(ENOMEM); |
||
2248 |
|||
2249 |
/* [DIRAC_STD] 11.1 Picture parse. picture_parse() */ |
||
2250 |
260 |
ret = dirac_decode_picture_header(s); |
|
2251 |
✗✓ | 260 |
if (ret < 0) |
2252 |
return ret; |
||
2253 |
|||
2254 |
/* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */ |
||
2255 |
260 |
ret = dirac_decode_frame_internal(s); |
|
2256 |
✗✓ | 260 |
if (ret < 0) |
2257 |
return ret; |
||
2258 |
} |
||
2259 |
596 |
return 0; |
|
2260 |
} |
||
2261 |
|||
2262 |
298 |
static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt) |
|
2263 |
{ |
||
2264 |
298 |
DiracContext *s = avctx->priv_data; |
|
2265 |
298 |
AVFrame *picture = data; |
|
2266 |
298 |
uint8_t *buf = pkt->data; |
|
2267 |
298 |
int buf_size = pkt->size; |
|
2268 |
298 |
int i, buf_idx = 0; |
|
2269 |
int ret; |
||
2270 |
unsigned data_unit_size; |
||
2271 |
|||
2272 |
/* release unused frames */ |
||
2273 |
✓✓ | 4470 |
for (i = 0; i < MAX_FRAMES; i++) |
2274 |
✓✓✓✓ |
4172 |
if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].reference) { |
2275 |
222 |
av_frame_unref(s->all_frames[i].avframe); |
|
2276 |
222 |
memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated)); |
|
2277 |
} |
||
2278 |
|||
2279 |
298 |
s->current_picture = NULL; |
|
2280 |
298 |
*got_frame = 0; |
|
2281 |
|||
2282 |
/* end of stream, so flush delayed pics */ |
||
2283 |
✓✓ | 298 |
if (buf_size == 0) |
2284 |
36 |
return get_delayed_pic(s, (AVFrame *)data, got_frame); |
|
2285 |
|||
2286 |
for (;;) { |
||
2287 |
/*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6 |
||
2288 |
[DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646 |
||
2289 |
BBCD start code search */ |
||
2290 |
✓✓ | 1019 |
for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) { |
2291 |
✓✗✓✗ |
757 |
if (buf[buf_idx ] == 'B' && buf[buf_idx+1] == 'B' && |
2292 |
✓✗✓✗ |
757 |
buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D') |
2293 |
757 |
break; |
|
2294 |
} |
||
2295 |
/* BBCD found or end of data */ |
||
2296 |
✓✓ | 1019 |
if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size) |
2297 |
262 |
break; |
|
2298 |
|||
2299 |
757 |
data_unit_size = AV_RB32(buf+buf_idx+5); |
|
2300 |
✓✗✗✓ |
757 |
if (data_unit_size > buf_size - buf_idx || !data_unit_size) { |
2301 |
if(data_unit_size > buf_size - buf_idx) |
||
2302 |
av_log(s->avctx, AV_LOG_ERROR, |
||
2303 |
"Data unit with size %d is larger than input buffer, discarding\n", |
||
2304 |
data_unit_size); |
||
2305 |
buf_idx += 4; |
||
2306 |
continue; |
||
2307 |
} |
||
2308 |
/* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */ |
||
2309 |
757 |
ret = dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size); |
|
2310 |
✗✓ | 757 |
if (ret < 0) |
2311 |
{ |
||
2312 |
av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n"); |
||
2313 |
return ret; |
||
2314 |
} |
||
2315 |
757 |
buf_idx += data_unit_size; |
|
2316 |
} |
||
2317 |
|||
2318 |
✓✓ | 262 |
if (!s->current_picture) |
2319 |
2 |
return buf_size; |
|
2320 |
|||
2321 |
✓✓ | 260 |
if (s->current_picture->avframe->display_picture_number > s->frame_number) { |
2322 |
8 |
DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number); |
|
2323 |
|||
2324 |
8 |
s->current_picture->reference |= DELAYED_PIC_REF; |
|
2325 |
|||
2326 |
✗✓ | 8 |
if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) { |
2327 |
int min_num = s->delay_frames[0]->avframe->display_picture_number; |
||
2328 |
/* Too many delayed frames, so we display the frame with the lowest pts */ |
||
2329 |
av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n"); |
||
2330 |
|||
2331 |
for (i = 1; s->delay_frames[i]; i++) |
||
2332 |
if (s->delay_frames[i]->avframe->display_picture_number < min_num) |
||
2333 |
min_num = s->delay_frames[i]->avframe->display_picture_number; |
||
2334 |
|||
2335 |
delayed_frame = remove_frame(s->delay_frames, min_num); |
||
2336 |
add_frame(s->delay_frames, MAX_DELAY, s->current_picture); |
||
2337 |
} |
||
2338 |
|||
2339 |
✓✓ | 8 |
if (delayed_frame) { |
2340 |
7 |
delayed_frame->reference ^= DELAYED_PIC_REF; |
|
2341 |
✗✓ | 7 |
if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0) |
2342 |
return ret; |
||
2343 |
7 |
*got_frame = 1; |
|
2344 |
} |
||
2345 |
✓✗ | 252 |
} else if (s->current_picture->avframe->display_picture_number == s->frame_number) { |
2346 |
/* The right frame at the right time :-) */ |
||
2347 |
✗✓ | 252 |
if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0) |
2348 |
return ret; |
||
2349 |
252 |
*got_frame = 1; |
|
2350 |
} |
||
2351 |
|||
2352 |
✓✓ | 260 |
if (*got_frame) |
2353 |
259 |
s->frame_number = picture->display_picture_number + 1LL; |
|
2354 |
|||
2355 |
260 |
return buf_idx; |
|
2356 |
} |
||
2357 |
|||
2358 |
AVCodec ff_dirac_decoder = { |
||
2359 |
.name = "dirac", |
||
2360 |
.long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"), |
||
2361 |
.type = AVMEDIA_TYPE_VIDEO, |
||
2362 |
.id = AV_CODEC_ID_DIRAC, |
||
2363 |
.priv_data_size = sizeof(DiracContext), |
||
2364 |
.init = dirac_decode_init, |
||
2365 |
.close = dirac_decode_end, |
||
2366 |
.decode = dirac_decode_frame, |
||
2367 |
.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DR1, |
||
2368 |
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, |
||
2369 |
.flush = dirac_decode_flush, |
||
2370 |
}; |
Generated by: GCOVR (Version 4.2) |