GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at> |
||
3 |
* |
||
4 |
* This file is part of FFmpeg. |
||
5 |
* |
||
6 |
* FFmpeg is free software; you can redistribute it and/or |
||
7 |
* modify it under the terms of the GNU Lesser General Public |
||
8 |
* License as published by the Free Software Foundation; either |
||
9 |
* version 2.1 of the License, or (at your option) any later version. |
||
10 |
* |
||
11 |
* FFmpeg is distributed in the hope that it will be useful, |
||
12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
14 |
* Lesser General Public License for more details. |
||
15 |
* |
||
16 |
* You should have received a copy of the GNU Lesser General Public |
||
17 |
* License along with FFmpeg; if not, write to the Free Software |
||
18 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
19 |
*/ |
||
20 |
|||
21 |
#include "libavutil/intmath.h" |
||
22 |
#include "libavutil/log.h" |
||
23 |
#include "libavutil/opt.h" |
||
24 |
#include "avcodec.h" |
||
25 |
#include "snow_dwt.h" |
||
26 |
#include "internal.h" |
||
27 |
#include "snow.h" |
||
28 |
|||
29 |
#include "rangecoder.h" |
||
30 |
#include "mathops.h" |
||
31 |
|||
32 |
#include "mpegvideo.h" |
||
33 |
#include "h263.h" |
||
34 |
|||
35 |
21699 |
static av_always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, IDWTELEM * old_buffer, int plane_index, int add, int mb_y){ |
|
36 |
21699 |
Plane *p= &s->plane[plane_index]; |
|
37 |
21699 |
const int mb_w= s->b_width << s->block_max_depth; |
|
38 |
21699 |
const int mb_h= s->b_height << s->block_max_depth; |
|
39 |
int x, y, mb_x; |
||
40 |
21699 |
int block_size = MB_SIZE >> s->block_max_depth; |
|
41 |
✓✓ | 21699 |
int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size; |
42 |
✓✓ | 21699 |
int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size; |
43 |
✓✓ | 21699 |
const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth]; |
44 |
✓✓ | 21699 |
int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size; |
45 |
21699 |
int ref_stride= s->current_picture->linesize[plane_index]; |
|
46 |
21699 |
uint8_t *dst8= s->current_picture->data[plane_index]; |
|
47 |
21699 |
int w= p->width; |
|
48 |
21699 |
int h= p->height; |
|
49 |
|||
50 |
✓✓✗✓ |
21699 |
if(s->keyframe || (s->avctx->debug&512)){ |
51 |
✓✓ | 2664 |
if(mb_y==mb_h) |
52 |
168 |
return; |
|
53 |
|||
54 |
✓✗ | 2496 |
if(add){ |
55 |
✓✓ | 18176 |
for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){ |
56 |
// DWTELEM * line = slice_buffer_get_line(sb, y); |
||
57 |
15680 |
IDWTELEM * line = sb->line[y]; |
|
58 |
✓✓ | 3359552 |
for(x=0; x<w; x++){ |
59 |
// int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1)); |
||
60 |
3343872 |
int v= line[x] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1)); |
|
61 |
3343872 |
v >>= FRAC_BITS; |
|
62 |
✓✓ | 3343872 |
if(v&(~255)) v= ~(v>>31); |
63 |
3343872 |
dst8[x + y*ref_stride]= v; |
|
64 |
} |
||
65 |
} |
||
66 |
}else{ |
||
67 |
for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){ |
||
68 |
// DWTELEM * line = slice_buffer_get_line(sb, y); |
||
69 |
IDWTELEM * line = sb->line[y]; |
||
70 |
for(x=0; x<w; x++){ |
||
71 |
line[x] -= 128 << FRAC_BITS; |
||
72 |
// buf[x + y*w]-= 128<<FRAC_BITS; |
||
73 |
} |
||
74 |
} |
||
75 |
} |
||
76 |
|||
77 |
2496 |
return; |
|
78 |
} |
||
79 |
|||
80 |
✓✓ | 729810 |
for(mb_x=0; mb_x<=mb_w; mb_x++){ |
81 |
710775 |
add_yblock(s, 1, sb, old_buffer, dst8, obmc, |
|
82 |
710775 |
block_w*mb_x - block_w/2, |
|
83 |
710775 |
block_h*mb_y - block_h/2, |
|
84 |
block_w, block_h, |
||
85 |
w, h, |
||
86 |
w, ref_stride, obmc_stride, |
||
87 |
mb_x - 1, mb_y - 1, |
||
88 |
add, 0, plane_index); |
||
89 |
} |
||
90 |
|||
91 |
✗✓✗✗ ✗✗ |
19035 |
if(s->avmv && mb_y < mb_h && plane_index == 0) |
92 |
for(mb_x=0; mb_x<mb_w; mb_x++){ |
||
93 |
AVMotionVector *avmv = s->avmv + s->avmv_index; |
||
94 |
const int b_width = s->b_width << s->block_max_depth; |
||
95 |
const int b_stride= b_width; |
||
96 |
BlockNode *bn= &s->block[mb_x + mb_y*b_stride]; |
||
97 |
|||
98 |
if (bn->type) |
||
99 |
continue; |
||
100 |
|||
101 |
s->avmv_index++; |
||
102 |
|||
103 |
avmv->w = block_w; |
||
104 |
avmv->h = block_h; |
||
105 |
avmv->dst_x = block_w*mb_x - block_w/2; |
||
106 |
avmv->dst_y = block_h*mb_y - block_h/2; |
||
107 |
avmv->motion_scale = 8; |
||
108 |
avmv->motion_x = bn->mx * s->mv_scale; |
||
109 |
avmv->motion_y = bn->my * s->mv_scale; |
||
110 |
avmv->src_x = avmv->dst_x + avmv->motion_x / 8; |
||
111 |
avmv->src_y = avmv->dst_y + avmv->motion_y / 8; |
||
112 |
avmv->source= -1 - bn->ref; |
||
113 |
avmv->flags = 0; |
||
114 |
} |
||
115 |
} |
||
116 |
|||
117 |
157912 |
static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){ |
|
118 |
157912 |
const int w= b->width; |
|
119 |
int y; |
||
120 |
157912 |
const int qlog= av_clip(s->qlog + (int64_t)b->qlog, 0, QROOT*16); |
|
121 |
157912 |
int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT); |
|
122 |
157912 |
int qadd= (s->qbias*qmul)>>QBIAS_SHIFT; |
|
123 |
157912 |
int new_index = 0; |
|
124 |
|||
125 |
✓✓✓✓ |
157912 |
if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){ |
126 |
130726 |
qadd= 0; |
|
127 |
130726 |
qmul= 1<<QEXPSHIFT; |
|
128 |
} |
||
129 |
|||
130 |
/* If we are on the second or later slice, restore our index. */ |
||
131 |
✓✓ | 157912 |
if (start_y != 0) |
132 |
135784 |
new_index = save_state[0]; |
|
133 |
|||
134 |
|||
135 |
✓✓ | 533912 |
for(y=start_y; y<h; y++){ |
136 |
376000 |
int x = 0; |
|
137 |
int v; |
||
138 |
✓✓ | 376000 |
IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset; |
139 |
376000 |
memset(line, 0, b->width*sizeof(IDWTELEM)); |
|
140 |
376000 |
v = b->x_coeff[new_index].coeff; |
|
141 |
376000 |
x = b->x_coeff[new_index++].x; |
|
142 |
✓✓ | 16873440 |
while(x < w){ |
143 |
16497440 |
register int t= (int)( (v>>1)*(unsigned)qmul + qadd)>>QEXPSHIFT; |
|
144 |
16497440 |
register int u= -(v&1); |
|
145 |
16497440 |
line[x] = (t^u) - u; |
|
146 |
|||
147 |
16497440 |
v = b->x_coeff[new_index].coeff; |
|
148 |
16497440 |
x = b->x_coeff[new_index++].x; |
|
149 |
} |
||
150 |
} |
||
151 |
|||
152 |
/* Save our variables for the next slice. */ |
||
153 |
157912 |
save_state[0] = new_index; |
|
154 |
|||
155 |
157912 |
return; |
|
156 |
} |
||
157 |
|||
158 |
250860 |
static int decode_q_branch(SnowContext *s, int level, int x, int y){ |
|
159 |
250860 |
const int w= s->b_width << s->block_max_depth; |
|
160 |
250860 |
const int rem_depth= s->block_max_depth - level; |
|
161 |
250860 |
const int index= (x + y*w) << rem_depth; |
|
162 |
250860 |
int trx= (x+1)<<rem_depth; |
|
163 |
✓✓ | 250860 |
const BlockNode *left = x ? &s->block[index-1] : &null_block; |
164 |
✓✓ | 250860 |
const BlockNode *top = y ? &s->block[index-w] : &null_block; |
165 |
✓✓✓✓ |
250860 |
const BlockNode *tl = y && x ? &s->block[index-w-1] : left; |
166 |
✓✓✓✓ ✓✓✓✓ |
250860 |
const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt |
167 |
250860 |
int s_context= 2*left->level + 2*top->level + tl->level + tr->level; |
|
168 |
int res; |
||
169 |
|||
170 |
✓✓ | 250860 |
if(s->keyframe){ |
171 |
8708 |
set_blocks(s, level, x, y, null_block.color[0], null_block.color[1], null_block.color[2], null_block.mx, null_block.my, null_block.ref, BLOCK_INTRA); |
|
172 |
8708 |
return 0; |
|
173 |
} |
||
174 |
|||
175 |
✓✓✓✓ |
439291 |
if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){ |
176 |
int type, mx, my; |
||
177 |
197139 |
int l = left->color[0]; |
|
178 |
197139 |
int cb= left->color[1]; |
|
179 |
197139 |
int cr= left->color[2]; |
|
180 |
197139 |
unsigned ref = 0; |
|
181 |
197139 |
int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref); |
|
182 |
197139 |
int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx)); |
|
183 |
197139 |
int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my)); |
|
184 |
|||
185 |
197139 |
type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0; |
|
186 |
✓✓ | 197139 |
if(type){ |
187 |
int ld, cbd, crd; |
||
188 |
44 |
pred_mv(s, &mx, &my, 0, left, top, tr); |
|
189 |
44 |
ld = get_symbol(&s->c, &s->block_state[32], 1); |
|
190 |
✓✗✗✓ |
44 |
if (ld < -255 || ld > 255) { |
191 |
return AVERROR_INVALIDDATA; |
||
192 |
} |
||
193 |
44 |
l += ld; |
|
194 |
✓✗ | 44 |
if (s->nb_planes > 2) { |
195 |
44 |
cbd = get_symbol(&s->c, &s->block_state[64], 1); |
|
196 |
44 |
crd = get_symbol(&s->c, &s->block_state[96], 1); |
|
197 |
✓✗✓✗ ✓✗✗✓ |
44 |
if (cbd < -255 || cbd > 255 || crd < -255 || crd > 255) { |
198 |
return AVERROR_INVALIDDATA; |
||
199 |
} |
||
200 |
44 |
cb += cbd; |
|
201 |
44 |
cr += crd; |
|
202 |
} |
||
203 |
}else{ |
||
204 |
✗✓ | 197095 |
if(s->ref_frames > 1) |
205 |
ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0); |
||
206 |
✗✓ | 197095 |
if (ref >= s->ref_frames) { |
207 |
av_log(s->avctx, AV_LOG_ERROR, "Invalid ref\n"); |
||
208 |
return AVERROR_INVALIDDATA; |
||
209 |
} |
||
210 |
197095 |
pred_mv(s, &mx, &my, ref, left, top, tr); |
|
211 |
✗✓ | 197095 |
mx+= (unsigned)get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1); |
212 |
✗✓ | 197095 |
my+= (unsigned)get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1); |
213 |
} |
||
214 |
197139 |
set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type); |
|
215 |
}else{ |
||
216 |
✓✗✓✗ |
90026 |
if ((res = decode_q_branch(s, level+1, 2*x+0, 2*y+0)) < 0 || |
217 |
✓✗ | 90026 |
(res = decode_q_branch(s, level+1, 2*x+1, 2*y+0)) < 0 || |
218 |
✗✓ | 90026 |
(res = decode_q_branch(s, level+1, 2*x+0, 2*y+1)) < 0 || |
219 |
45013 |
(res = decode_q_branch(s, level+1, 2*x+1, 2*y+1)) < 0) |
|
220 |
return res; |
||
221 |
} |
||
222 |
242152 |
return 0; |
|
223 |
} |
||
224 |
|||
225 |
1537 |
static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int start_y, int end_y){ |
|
226 |
1537 |
const int w= b->width; |
|
227 |
1537 |
const int qlog= av_clip(s->qlog + (int64_t)b->qlog, 0, QROOT*16); |
|
228 |
1537 |
const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT); |
|
229 |
1537 |
const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT; |
|
230 |
int x,y; |
||
231 |
|||
232 |
✓✓ | 1537 |
if(s->qlog == LOSSLESS_QLOG) return; |
233 |
|||
234 |
✓✓ | 2149 |
for(y=start_y; y<end_y; y++){ |
235 |
// DWTELEM * line = slice_buffer_get_line_from_address(sb, src + (y * stride)); |
||
236 |
✓✗ | 1228 |
IDWTELEM * line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset; |
237 |
✓✓ | 4912 |
for(x=0; x<w; x++){ |
238 |
3684 |
int i= line[x]; |
|
239 |
✓✓ | 3684 |
if(i<0){ |
240 |
1591 |
line[x]= -((-i*(unsigned)qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias |
|
241 |
✓✓ | 2093 |
}else if(i>0){ |
242 |
974 |
line[x]= (( i*(unsigned)qmul + qadd)>>(QEXPSHIFT)); |
|
243 |
} |
||
244 |
} |
||
245 |
} |
||
246 |
} |
||
247 |
|||
248 |
1537 |
static void correlate_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median, int start_y, int end_y){ |
|
249 |
1537 |
const int w= b->width; |
|
250 |
int x,y; |
||
251 |
|||
252 |
1537 |
IDWTELEM * line=0; // silence silly "could be used without having been initialized" warning |
|
253 |
IDWTELEM * prev; |
||
254 |
|||
255 |
✓✓ | 1537 |
if (start_y != 0) |
256 |
✓✗ | 154 |
line = slice_buffer_get_line(sb, ((start_y - 1) * b->stride_line) + b->buf_y_offset) + b->buf_x_offset; |
257 |
|||
258 |
✓✓ | 5691 |
for(y=start_y; y<end_y; y++){ |
259 |
4154 |
prev = line; |
|
260 |
// line = slice_buffer_get_line_from_address(sb, src + (y * stride)); |
||
261 |
✓✗ | 4154 |
line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset; |
262 |
✓✓ | 32324 |
for(x=0; x<w; x++){ |
263 |
✓✓ | 28170 |
if(x){ |
264 |
✗✓ | 24016 |
if(use_median){ |
265 |
if(y && x+1<w) line[x] += mid_pred(line[x - 1], prev[x], prev[x + 1]); |
||
266 |
else line[x] += line[x - 1]; |
||
267 |
}else{ |
||
268 |
✓✓ | 24016 |
if(y) line[x] += mid_pred(line[x - 1], prev[x], line[x - 1] + prev[x] - prev[x - 1]); |
269 |
4615 |
else line[x] += line[x - 1]; |
|
270 |
} |
||
271 |
}else{ |
||
272 |
✓✓ | 4154 |
if(y) line[x] += prev[x]; |
273 |
} |
||
274 |
} |
||
275 |
} |
||
276 |
1537 |
} |
|
277 |
|||
278 |
56 |
static void decode_qlogs(SnowContext *s){ |
|
279 |
int plane_index, level, orientation; |
||
280 |
|||
281 |
✓✓ | 224 |
for(plane_index=0; plane_index < s->nb_planes; plane_index++){ |
282 |
✓✓ | 1008 |
for(level=0; level<s->spatial_decomposition_count; level++){ |
283 |
✓✓ | 3528 |
for(orientation=level ? 1:0; orientation<4; orientation++){ |
284 |
int q; |
||
285 |
✓✓ | 2688 |
if (plane_index==2) q= s->plane[1].band[level][orientation].qlog; |
286 |
✓✓ | 1792 |
else if(orientation==2) q= s->plane[plane_index].band[level][1].qlog; |
287 |
1232 |
else q= get_symbol(&s->c, s->header_state, 1); |
|
288 |
2688 |
s->plane[plane_index].band[level][orientation].qlog= q; |
|
289 |
} |
||
290 |
} |
||
291 |
} |
||
292 |
56 |
} |
|
293 |
|||
294 |
#define GET_S(dst, check) \ |
||
295 |
tmp= get_symbol(&s->c, s->header_state, 0);\ |
||
296 |
if(!(check)){\ |
||
297 |
av_log(s->avctx, AV_LOG_ERROR, "Error " #dst " is %d\n", tmp);\ |
||
298 |
return AVERROR_INVALIDDATA;\ |
||
299 |
}\ |
||
300 |
dst= tmp; |
||
301 |
|||
302 |
461 |
static int decode_header(SnowContext *s){ |
|
303 |
int plane_index, tmp; |
||
304 |
uint8_t kstate[32]; |
||
305 |
|||
306 |
461 |
memset(kstate, MID_STATE, sizeof(kstate)); |
|
307 |
|||
308 |
461 |
s->keyframe= get_rac(&s->c, kstate); |
|
309 |
✓✓✗✓ |
461 |
if(s->keyframe || s->always_reset){ |
310 |
56 |
ff_snow_reset_contexts(s); |
|
311 |
56 |
s->spatial_decomposition_type= |
|
312 |
56 |
s->qlog= |
|
313 |
56 |
s->qbias= |
|
314 |
56 |
s->mv_scale= |
|
315 |
56 |
s->block_max_depth= 0; |
|
316 |
} |
||
317 |
✓✓ | 461 |
if(s->keyframe){ |
318 |
✗✓ | 56 |
GET_S(s->version, tmp <= 0U) |
319 |
56 |
s->always_reset= get_rac(&s->c, s->header_state); |
|
320 |
56 |
s->temporal_decomposition_type= get_symbol(&s->c, s->header_state, 0); |
|
321 |
56 |
s->temporal_decomposition_count= get_symbol(&s->c, s->header_state, 0); |
|
322 |
✓✗✗✓ |
56 |
GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS) |
323 |
56 |
s->colorspace_type= get_symbol(&s->c, s->header_state, 0); |
|
324 |
✗✓ | 56 |
if (s->colorspace_type == 1) { |
325 |
s->avctx->pix_fmt= AV_PIX_FMT_GRAY8; |
||
326 |
s->nb_planes = 1; |
||
327 |
✓✗ | 56 |
} else if(s->colorspace_type == 0) { |
328 |
56 |
s->chroma_h_shift= get_symbol(&s->c, s->header_state, 0); |
|
329 |
56 |
s->chroma_v_shift= get_symbol(&s->c, s->header_state, 0); |
|
330 |
|||
331 |
✓✗✓✗ |
56 |
if(s->chroma_h_shift == 1 && s->chroma_v_shift==1){ |
332 |
56 |
s->avctx->pix_fmt= AV_PIX_FMT_YUV420P; |
|
333 |
}else if(s->chroma_h_shift == 0 && s->chroma_v_shift==0){ |
||
334 |
s->avctx->pix_fmt= AV_PIX_FMT_YUV444P; |
||
335 |
}else if(s->chroma_h_shift == 2 && s->chroma_v_shift==2){ |
||
336 |
s->avctx->pix_fmt= AV_PIX_FMT_YUV410P; |
||
337 |
} else { |
||
338 |
av_log(s, AV_LOG_ERROR, "unsupported color subsample mode %d %d\n", s->chroma_h_shift, s->chroma_v_shift); |
||
339 |
s->chroma_h_shift = s->chroma_v_shift = 1; |
||
340 |
s->avctx->pix_fmt= AV_PIX_FMT_YUV420P; |
||
341 |
return AVERROR_INVALIDDATA; |
||
342 |
} |
||
343 |
56 |
s->nb_planes = 3; |
|
344 |
} else { |
||
345 |
av_log(s, AV_LOG_ERROR, "unsupported color space\n"); |
||
346 |
s->chroma_h_shift = s->chroma_v_shift = 1; |
||
347 |
s->avctx->pix_fmt= AV_PIX_FMT_YUV420P; |
||
348 |
return AVERROR_INVALIDDATA; |
||
349 |
} |
||
350 |
|||
351 |
|||
352 |
56 |
s->spatial_scalability= get_rac(&s->c, s->header_state); |
|
353 |
// s->rate_scalability= get_rac(&s->c, s->header_state); |
||
354 |
✗✓ | 56 |
GET_S(s->max_ref_frames, tmp < (unsigned)MAX_REF_FRAMES) |
355 |
56 |
s->max_ref_frames++; |
|
356 |
|||
357 |
56 |
decode_qlogs(s); |
|
358 |
} |
||
359 |
|||
360 |
✓✓ | 461 |
if(!s->keyframe){ |
361 |
✓✓ | 405 |
if(get_rac(&s->c, s->header_state)){ |
362 |
✓✓ | 135 |
for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){ |
363 |
90 |
int htaps, i, sum=0; |
|
364 |
90 |
Plane *p= &s->plane[plane_index]; |
|
365 |
90 |
p->diag_mc= get_rac(&s->c, s->header_state); |
|
366 |
90 |
htaps= get_symbol(&s->c, s->header_state, 0); |
|
367 |
✗✓ | 90 |
if((unsigned)htaps >= HTAPS_MAX/2 - 1) |
368 |
return AVERROR_INVALIDDATA; |
||
369 |
90 |
htaps = htaps*2 + 2; |
|
370 |
90 |
p->htaps= htaps; |
|
371 |
✓✓ | 360 |
for(i= htaps/2; i; i--){ |
372 |
270 |
unsigned hcoeff = get_symbol(&s->c, s->header_state, 0); |
|
373 |
✗✓ | 270 |
if (hcoeff > 127) |
374 |
return AVERROR_INVALIDDATA; |
||
375 |
270 |
p->hcoeff[i]= hcoeff * (1-2*(i&1)); |
|
376 |
270 |
sum += p->hcoeff[i]; |
|
377 |
} |
||
378 |
90 |
p->hcoeff[0]= 32-sum; |
|
379 |
} |
||
380 |
45 |
s->plane[2].diag_mc= s->plane[1].diag_mc; |
|
381 |
45 |
s->plane[2].htaps = s->plane[1].htaps; |
|
382 |
45 |
memcpy(s->plane[2].hcoeff, s->plane[1].hcoeff, sizeof(s->plane[1].hcoeff)); |
|
383 |
} |
||
384 |
✗✓ | 405 |
if(get_rac(&s->c, s->header_state)){ |
385 |
GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS) |
||
386 |
decode_qlogs(s); |
||
387 |
} |
||
388 |
} |
||
389 |
|||
390 |
461 |
s->spatial_decomposition_type+= (unsigned)get_symbol(&s->c, s->header_state, 1); |
|
391 |
✗✓ | 461 |
if(s->spatial_decomposition_type > 1U){ |
392 |
av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported\n", s->spatial_decomposition_type); |
||
393 |
return AVERROR_INVALIDDATA; |
||
394 |
} |
||
395 |
461 |
if(FFMIN(s->avctx-> width>>s->chroma_h_shift, |
|
396 |
✗✓ | 461 |
s->avctx->height>>s->chroma_v_shift) >> (s->spatial_decomposition_count-1) <= 1){ |
397 |
av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_count %d too large for size\n", s->spatial_decomposition_count); |
||
398 |
return AVERROR_INVALIDDATA; |
||
399 |
} |
||
400 |
✗✓ | 461 |
if (s->avctx->width > 65536-4) { |
401 |
av_log(s->avctx, AV_LOG_ERROR, "Width %d is too large\n", s->avctx->width); |
||
402 |
return AVERROR_INVALIDDATA; |
||
403 |
} |
||
404 |
|||
405 |
|||
406 |
461 |
s->qlog += (unsigned)get_symbol(&s->c, s->header_state, 1); |
|
407 |
461 |
s->mv_scale += (unsigned)get_symbol(&s->c, s->header_state, 1); |
|
408 |
461 |
s->qbias += (unsigned)get_symbol(&s->c, s->header_state, 1); |
|
409 |
461 |
s->block_max_depth+= (unsigned)get_symbol(&s->c, s->header_state, 1); |
|
410 |
✓✗✓✗ ✗✓ |
461 |
if(s->block_max_depth > 1 || s->block_max_depth < 0 || s->mv_scale > 256U){ |
411 |
av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large\n", s->block_max_depth); |
||
412 |
s->block_max_depth= 0; |
||
413 |
s->mv_scale = 0; |
||
414 |
return AVERROR_INVALIDDATA; |
||
415 |
} |
||
416 |
✗✓ | 461 |
if (FFABS(s->qbias) > 127) { |
417 |
av_log(s->avctx, AV_LOG_ERROR, "qbias %d is too large\n", s->qbias); |
||
418 |
s->qbias = 0; |
||
419 |
return AVERROR_INVALIDDATA; |
||
420 |
} |
||
421 |
|||
422 |
461 |
return 0; |
|
423 |
} |
||
424 |
|||
425 |
461 |
static int decode_blocks(SnowContext *s){ |
|
426 |
int x, y; |
||
427 |
461 |
int w= s->b_width; |
|
428 |
461 |
int h= s->b_height; |
|
429 |
int res; |
||
430 |
|||
431 |
✓✓ | 4461 |
for(y=0; y<h; y++){ |
432 |
✓✓ | 74808 |
for(x=0; x<w; x++){ |
433 |
✗✓ | 70808 |
if (s->c.bytestream >= s->c.bytestream_end) |
434 |
return AVERROR_INVALIDDATA; |
||
435 |
✗✓ | 70808 |
if ((res = decode_q_branch(s, 0, x, y)) < 0) |
436 |
return res; |
||
437 |
} |
||
438 |
} |
||
439 |
461 |
return 0; |
|
440 |
} |
||
441 |
|||
442 |
461 |
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, |
|
443 |
AVPacket *avpkt) |
||
444 |
{ |
||
445 |
461 |
const uint8_t *buf = avpkt->data; |
|
446 |
461 |
int buf_size = avpkt->size; |
|
447 |
461 |
SnowContext *s = avctx->priv_data; |
|
448 |
461 |
RangeCoder * const c= &s->c; |
|
449 |
int bytes_read; |
||
450 |
461 |
AVFrame *picture = data; |
|
451 |
int level, orientation, plane_index; |
||
452 |
int res; |
||
453 |
|||
454 |
461 |
ff_init_range_decoder(c, buf, buf_size); |
|
455 |
461 |
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8); |
|
456 |
|||
457 |
461 |
s->current_picture->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P |
|
458 |
✗✓ | 461 |
if ((res = decode_header(s)) < 0) |
459 |
return res; |
||
460 |
✗✓ | 461 |
if ((res=ff_snow_common_init_after_header(avctx)) < 0) |
461 |
return res; |
||
462 |
|||
463 |
// realloc slice buffer for the case that spatial_decomposition_count changed |
||
464 |
461 |
ff_slice_buffer_destroy(&s->sb); |
|
465 |
✗✓ | 461 |
if ((res = ff_slice_buffer_init(&s->sb, s->plane[0].height, |
466 |
461 |
(MB_SIZE >> s->block_max_depth) + |
|
467 |
461 |
s->spatial_decomposition_count * 11 + 1, |
|
468 |
s->plane[0].width, |
||
469 |
s->spatial_idwt_buffer)) < 0) |
||
470 |
return res; |
||
471 |
|||
472 |
✓✓ | 1844 |
for(plane_index=0; plane_index < s->nb_planes; plane_index++){ |
473 |
1383 |
Plane *p= &s->plane[plane_index]; |
|
474 |
✓✗✓✗ |
2706 |
p->fast_mc= p->diag_mc && p->htaps==6 && p->hcoeff[0]==40 |
475 |
✓✗ | 1323 |
&& p->hcoeff[1]==-10 |
476 |
✓✓✓✗ |
2706 |
&& p->hcoeff[2]==2; |
477 |
} |
||
478 |
|||
479 |
461 |
ff_snow_alloc_blocks(s); |
|
480 |
|||
481 |
✗✓ | 461 |
if((res = ff_snow_frame_start(s)) < 0) |
482 |
return res; |
||
483 |
|||
484 |
✓✓ | 461 |
s->current_picture->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; |
485 |
|||
486 |
//keyframe flag duplication mess FIXME |
||
487 |
✗✓ | 461 |
if(avctx->debug&FF_DEBUG_PICT_INFO) |
488 |
av_log(avctx, AV_LOG_ERROR, |
||
489 |
"keyframe:%d qlog:%d qbias: %d mvscale: %d " |
||
490 |
"decomposition_type:%d decomposition_count:%d\n", |
||
491 |
s->keyframe, s->qlog, s->qbias, s->mv_scale, |
||
492 |
s->spatial_decomposition_type, |
||
493 |
s->spatial_decomposition_count |
||
494 |
); |
||
495 |
|||
496 |
✗✓ | 461 |
av_assert0(!s->avmv); |
497 |
✗✓ | 461 |
if (s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS) { |
498 |
s->avmv = av_malloc_array(s->b_width * s->b_height, sizeof(AVMotionVector) << (s->block_max_depth*2)); |
||
499 |
} |
||
500 |
461 |
s->avmv_index = 0; |
|
501 |
|||
502 |
✗✓ | 461 |
if ((res = decode_blocks(s)) < 0) |
503 |
return res; |
||
504 |
|||
505 |
✓✓ | 1844 |
for(plane_index=0; plane_index < s->nb_planes; plane_index++){ |
506 |
1383 |
Plane *p= &s->plane[plane_index]; |
|
507 |
1383 |
int w= p->width; |
|
508 |
1383 |
int h= p->height; |
|
509 |
int x, y; |
||
510 |
int decode_state[MAX_DECOMPOSITIONS][4][1]; /* Stored state info for unpack_coeffs. 1 variable per instance. */ |
||
511 |
|||
512 |
✗✓ | 1383 |
if(s->avctx->debug&2048){ |
513 |
memset(s->spatial_dwt_buffer, 0, sizeof(DWTELEM)*w*h); |
||
514 |
predict_plane(s, s->spatial_idwt_buffer, plane_index, 1); |
||
515 |
|||
516 |
for(y=0; y<h; y++){ |
||
517 |
for(x=0; x<w; x++){ |
||
518 |
int v= s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x]; |
||
519 |
s->mconly_picture->data[plane_index][y*s->mconly_picture->linesize[plane_index] + x]= v; |
||
520 |
} |
||
521 |
} |
||
522 |
} |
||
523 |
|||
524 |
✓✓ | 8298 |
for(level=0; level<s->spatial_decomposition_count; level++){ |
525 |
✓✓ | 29043 |
for(orientation=level ? 1 : 0; orientation<4; orientation++){ |
526 |
22128 |
SubBand *b= &p->band[level][orientation]; |
|
527 |
22128 |
unpack_coeffs(s, b, b->parent, orientation); |
|
528 |
} |
||
529 |
} |
||
530 |
|||
531 |
{ |
||
532 |
1383 |
const int mb_h= s->b_height << s->block_max_depth; |
|
533 |
1383 |
const int block_size = MB_SIZE >> s->block_max_depth; |
|
534 |
✓✓ | 1383 |
const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size; |
535 |
int mb_y; |
||
536 |
DWTCompose cs[MAX_DECOMPOSITIONS]; |
||
537 |
1383 |
int yd=0, yq=0; |
|
538 |
int y; |
||
539 |
int end_y; |
||
540 |
|||
541 |
1383 |
ff_spatial_idwt_buffered_init(cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count); |
|
542 |
✓✓ | 23082 |
for(mb_y=0; mb_y<=mb_h; mb_y++){ |
543 |
|||
544 |
21699 |
int slice_starty = block_h*mb_y; |
|
545 |
21699 |
int slice_h = block_h*(mb_y+1); |
|
546 |
|||
547 |
✓✓✓✗ |
21699 |
if (!(s->keyframe || s->avctx->debug&512)){ |
548 |
19035 |
slice_starty = FFMAX(0, slice_starty - (block_h >> 1)); |
|
549 |
19035 |
slice_h -= (block_h >> 1); |
|
550 |
} |
||
551 |
|||
552 |
✓✓ | 130194 |
for(level=0; level<s->spatial_decomposition_count; level++){ |
553 |
✓✓ | 455679 |
for(orientation=level ? 1 : 0; orientation<4; orientation++){ |
554 |
347184 |
SubBand *b= &p->band[level][orientation]; |
|
555 |
int start_y; |
||
556 |
int end_y; |
||
557 |
347184 |
int our_mb_start = mb_y; |
|
558 |
347184 |
int our_mb_end = (mb_y + 1); |
|
559 |
347184 |
const int extra= 3; |
|
560 |
✓✓ | 347184 |
start_y = (mb_y ? ((block_h * our_mb_start) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra: 0); |
561 |
347184 |
end_y = (((block_h * our_mb_end) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra); |
|
562 |
✓✓✓✗ |
347184 |
if (!(s->keyframe || s->avctx->debug&512)){ |
563 |
304560 |
start_y = FFMAX(0, start_y - (block_h >> (1+s->spatial_decomposition_count - level))); |
|
564 |
304560 |
end_y = FFMAX(0, end_y - (block_h >> (1+s->spatial_decomposition_count - level))); |
|
565 |
} |
||
566 |
347184 |
start_y = FFMIN(b->height, start_y); |
|
567 |
347184 |
end_y = FFMIN(b->height, end_y); |
|
568 |
|||
569 |
✓✓ | 347184 |
if (start_y != end_y){ |
570 |
✓✓ | 157912 |
if (orientation == 0){ |
571 |
1537 |
SubBand * correlate_band = &p->band[0][0]; |
|
572 |
1537 |
int correlate_end_y = FFMIN(b->height, end_y + 1); |
|
573 |
✓✓ | 1537 |
int correlate_start_y = FFMIN(b->height, (start_y ? start_y + 1 : 0)); |
574 |
1537 |
decode_subband_slice_buffered(s, correlate_band, &s->sb, correlate_start_y, correlate_end_y, decode_state[0][0]); |
|
575 |
1537 |
correlate_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, 1, 0, correlate_start_y, correlate_end_y); |
|
576 |
1537 |
dequantize_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, start_y, end_y); |
|
577 |
} |
||
578 |
else |
||
579 |
156375 |
decode_subband_slice_buffered(s, b, &s->sb, start_y, end_y, decode_state[level][orientation]); |
|
580 |
} |
||
581 |
} |
||
582 |
} |
||
583 |
|||
584 |
✓✓ | 55556 |
for(; yd<slice_h; yd+=4){ |
585 |
33857 |
ff_spatial_idwt_buffered_slice(&s->dwt, cs, &s->sb, s->temp_idwt_buffer, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count, yd); |
|
586 |
} |
||
587 |
|||
588 |
✓✓ | 21699 |
if(s->qlog == LOSSLESS_QLOG){ |
589 |
✓✓✓✓ |
105798 |
for(; yq<slice_h && yq<h; yq++){ |
590 |
✓✗ | 88704 |
IDWTELEM * line = slice_buffer_get_line(&s->sb, yq); |
591 |
✓✓ | 23506560 |
for(x=0; x<w; x++){ |
592 |
23417856 |
line[x] *= 1<<FRAC_BITS; |
|
593 |
} |
||
594 |
} |
||
595 |
} |
||
596 |
|||
597 |
21699 |
predict_slice_buffered(s, &s->sb, s->spatial_idwt_buffer, plane_index, 1, mb_y); |
|
598 |
|||
599 |
21699 |
y = FFMIN(p->height, slice_starty); |
|
600 |
21699 |
end_y = FFMIN(p->height, slice_h); |
|
601 |
✓✓ | 149699 |
while(y < end_y) |
602 |
128000 |
ff_slice_buffer_release(&s->sb, y++); |
|
603 |
} |
||
604 |
|||
605 |
1383 |
ff_slice_buffer_flush(&s->sb); |
|
606 |
} |
||
607 |
|||
608 |
} |
||
609 |
|||
610 |
461 |
emms_c(); |
|
611 |
|||
612 |
461 |
ff_snow_release_buffer(avctx); |
|
613 |
|||
614 |
✓✗ | 461 |
if(!(s->avctx->debug&2048)) |
615 |
461 |
res = av_frame_ref(picture, s->current_picture); |
|
616 |
else |
||
617 |
res = av_frame_ref(picture, s->mconly_picture); |
||
618 |
✓✗✗✓ |
461 |
if (res >= 0 && s->avmv_index) { |
619 |
AVFrameSideData *sd; |
||
620 |
|||
621 |
sd = av_frame_new_side_data(picture, AV_FRAME_DATA_MOTION_VECTORS, s->avmv_index * sizeof(AVMotionVector)); |
||
622 |
if (!sd) |
||
623 |
return AVERROR(ENOMEM); |
||
624 |
memcpy(sd->data, s->avmv, s->avmv_index * sizeof(AVMotionVector)); |
||
625 |
} |
||
626 |
|||
627 |
461 |
av_freep(&s->avmv); |
|
628 |
|||
629 |
✗✓ | 461 |
if (res < 0) |
630 |
return res; |
||
631 |
|||
632 |
461 |
*got_frame = 1; |
|
633 |
|||
634 |
461 |
bytes_read= c->bytestream - c->bytestream_start; |
|
635 |
✗✓ | 461 |
if(bytes_read ==0) av_log(s->avctx, AV_LOG_ERROR, "error at end of frame\n"); //FIXME |
636 |
|||
637 |
461 |
return bytes_read; |
|
638 |
} |
||
639 |
|||
640 |
20 |
static av_cold int decode_end(AVCodecContext *avctx) |
|
641 |
{ |
||
642 |
20 |
SnowContext *s = avctx->priv_data; |
|
643 |
|||
644 |
20 |
ff_slice_buffer_destroy(&s->sb); |
|
645 |
|||
646 |
20 |
ff_snow_common_end(s); |
|
647 |
|||
648 |
20 |
return 0; |
|
649 |
} |
||
650 |
|||
651 |
AVCodec ff_snow_decoder = { |
||
652 |
.name = "snow", |
||
653 |
.long_name = NULL_IF_CONFIG_SMALL("Snow"), |
||
654 |
.type = AVMEDIA_TYPE_VIDEO, |
||
655 |
.id = AV_CODEC_ID_SNOW, |
||
656 |
.priv_data_size = sizeof(SnowContext), |
||
657 |
.init = ff_snow_common_init, |
||
658 |
.close = decode_end, |
||
659 |
.decode = decode_frame, |
||
660 |
.capabilities = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/, |
||
661 |
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
||
662 |
FF_CODEC_CAP_INIT_CLEANUP, |
||
663 |
}; |
Generated by: GCOVR (Version 4.2) |