1 |
|
|
/* |
2 |
|
|
* Error resilience / concealment |
3 |
|
|
* |
4 |
|
|
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
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 |
|
|
* Error resilience / concealment. |
26 |
|
|
*/ |
27 |
|
|
|
28 |
|
|
#include <limits.h> |
29 |
|
|
|
30 |
|
|
#include "libavutil/internal.h" |
31 |
|
|
#include "avcodec.h" |
32 |
|
|
#include "error_resilience.h" |
33 |
|
|
#include "me_cmp.h" |
34 |
|
|
#include "mpegutils.h" |
35 |
|
|
#include "mpegvideo.h" |
36 |
|
|
#include "rectangle.h" |
37 |
|
|
#include "thread.h" |
38 |
|
|
#include "version.h" |
39 |
|
|
|
40 |
|
|
/** |
41 |
|
|
* @param stride the number of MVs to get to the next row |
42 |
|
|
* @param mv_step the number of MVs per row or column in a macroblock |
43 |
|
|
*/ |
44 |
|
210 |
static void set_mv_strides(ERContext *s, ptrdiff_t *mv_step, ptrdiff_t *stride) |
45 |
|
|
{ |
46 |
✓✓ |
210 |
if (s->avctx->codec_id == AV_CODEC_ID_H264) { |
47 |
✗✓ |
7 |
av_assert0(s->quarter_sample); |
48 |
|
7 |
*mv_step = 4; |
49 |
|
7 |
*stride = s->mb_width * 4; |
50 |
|
|
} else { |
51 |
|
203 |
*mv_step = 2; |
52 |
|
203 |
*stride = s->b8_stride; |
53 |
|
|
} |
54 |
|
210 |
} |
55 |
|
|
|
56 |
|
|
/** |
57 |
|
|
* Replace the current MB with a flat dc-only version. |
58 |
|
|
*/ |
59 |
|
255 |
static void put_dc(ERContext *s, uint8_t *dest_y, uint8_t *dest_cb, |
60 |
|
|
uint8_t *dest_cr, int mb_x, int mb_y) |
61 |
|
|
{ |
62 |
|
255 |
int *linesize = s->cur_pic.f->linesize; |
63 |
|
|
int dc, dcu, dcv, y, i; |
64 |
✓✓ |
1275 |
for (i = 0; i < 4; i++) { |
65 |
|
1020 |
dc = s->dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->b8_stride]; |
66 |
✓✓ |
1020 |
if (dc < 0) |
67 |
|
17 |
dc = 0; |
68 |
✓✓ |
1003 |
else if (dc > 2040) |
69 |
|
8 |
dc = 2040; |
70 |
✓✓ |
9180 |
for (y = 0; y < 8; y++) { |
71 |
|
|
int x; |
72 |
✓✓ |
73440 |
for (x = 0; x < 8; x++) |
73 |
|
65280 |
dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * linesize[0]] = dc / 8; |
74 |
|
|
} |
75 |
|
|
} |
76 |
|
255 |
dcu = s->dc_val[1][mb_x + mb_y * s->mb_stride]; |
77 |
|
255 |
dcv = s->dc_val[2][mb_x + mb_y * s->mb_stride]; |
78 |
✗✓ |
255 |
if (dcu < 0) |
79 |
|
|
dcu = 0; |
80 |
✗✓ |
255 |
else if (dcu > 2040) |
81 |
|
|
dcu = 2040; |
82 |
✗✓ |
255 |
if (dcv < 0) |
83 |
|
|
dcv = 0; |
84 |
✗✓ |
255 |
else if (dcv > 2040) |
85 |
|
|
dcv = 2040; |
86 |
|
|
|
87 |
✓✗ |
255 |
if (dest_cr) |
88 |
✓✓ |
2295 |
for (y = 0; y < 8; y++) { |
89 |
|
|
int x; |
90 |
✓✓ |
18360 |
for (x = 0; x < 8; x++) { |
91 |
|
16320 |
dest_cb[x + y * linesize[1]] = dcu / 8; |
92 |
|
16320 |
dest_cr[x + y * linesize[2]] = dcv / 8; |
93 |
|
|
} |
94 |
|
|
} |
95 |
|
255 |
} |
96 |
|
|
|
97 |
|
30 |
static void filter181(int16_t *data, int width, int height, ptrdiff_t stride) |
98 |
|
|
{ |
99 |
|
|
int x, y; |
100 |
|
|
|
101 |
|
|
/* horizontal filter */ |
102 |
✓✓ |
1044 |
for (y = 1; y < height - 1; y++) { |
103 |
|
1014 |
int prev_dc = data[0 + y * stride]; |
104 |
|
|
|
105 |
✓✓ |
43490 |
for (x = 1; x < width - 1; x++) { |
106 |
|
|
int dc; |
107 |
|
42476 |
dc = -prev_dc + |
108 |
|
42476 |
data[x + y * stride] * 8 - |
109 |
|
42476 |
data[x + 1 + y * stride]; |
110 |
|
42476 |
dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16; |
111 |
|
42476 |
prev_dc = data[x + y * stride]; |
112 |
|
42476 |
data[x + y * stride] = dc; |
113 |
|
|
} |
114 |
|
|
} |
115 |
|
|
|
116 |
|
|
/* vertical filter */ |
117 |
✓✓ |
1286 |
for (x = 1; x < width - 1; x++) { |
118 |
|
1256 |
int prev_dc = data[x]; |
119 |
|
|
|
120 |
✓✓ |
43732 |
for (y = 1; y < height - 1; y++) { |
121 |
|
|
int dc; |
122 |
|
|
|
123 |
|
42476 |
dc = -prev_dc + |
124 |
|
42476 |
data[x + y * stride] * 8 - |
125 |
|
42476 |
data[x + (y + 1) * stride]; |
126 |
|
42476 |
dc = (av_clip(dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16; |
127 |
|
42476 |
prev_dc = data[x + y * stride]; |
128 |
|
42476 |
data[x + y * stride] = dc; |
129 |
|
|
} |
130 |
|
|
} |
131 |
|
30 |
} |
132 |
|
|
|
133 |
|
|
/** |
134 |
|
|
* guess the dc of blocks which do not have an undamaged dc |
135 |
|
|
* @param w width in 8 pixel blocks |
136 |
|
|
* @param h height in 8 pixel blocks |
137 |
|
|
*/ |
138 |
|
90 |
static void guess_dc(ERContext *s, int16_t *dc, int w, |
139 |
|
|
int h, ptrdiff_t stride, int is_luma) |
140 |
|
|
{ |
141 |
|
|
int b_x, b_y; |
142 |
|
90 |
int16_t (*col )[4] = av_malloc_array(stride, h*sizeof( int16_t)*4); |
143 |
|
90 |
uint32_t (*dist)[4] = av_malloc_array(stride, h*sizeof(uint32_t)*4); |
144 |
|
|
|
145 |
✓✗✗✓
|
90 |
if(!col || !dist) { |
146 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "guess_dc() is out of memory\n"); |
147 |
|
|
goto fail; |
148 |
|
|
} |
149 |
|
|
|
150 |
✓✓ |
2238 |
for(b_y=0; b_y<h; b_y++){ |
151 |
|
2148 |
int color= 1024; |
152 |
|
2148 |
int distance= -1; |
153 |
✓✓ |
72852 |
for(b_x=0; b_x<w; b_x++){ |
154 |
|
70704 |
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
155 |
|
70704 |
int error_j= s->error_status_table[mb_index_j]; |
156 |
|
70704 |
int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]); |
157 |
✓✓✓✓
|
70704 |
if(intra_j==0 || !(error_j&ER_DC_ERROR)){ |
158 |
|
69174 |
color= dc[b_x + b_y*stride]; |
159 |
|
69174 |
distance= b_x; |
160 |
|
|
} |
161 |
|
70704 |
col [b_x + b_y*stride][1]= color; |
162 |
✓✓ |
70704 |
dist[b_x + b_y*stride][1]= distance >= 0 ? b_x-distance : 9999; |
163 |
|
|
} |
164 |
|
2148 |
color= 1024; |
165 |
|
2148 |
distance= -1; |
166 |
✓✓ |
72852 |
for(b_x=w-1; b_x>=0; b_x--){ |
167 |
|
70704 |
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
168 |
|
70704 |
int error_j= s->error_status_table[mb_index_j]; |
169 |
|
70704 |
int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]); |
170 |
✓✓✓✓
|
70704 |
if(intra_j==0 || !(error_j&ER_DC_ERROR)){ |
171 |
|
69174 |
color= dc[b_x + b_y*stride]; |
172 |
|
69174 |
distance= b_x; |
173 |
|
|
} |
174 |
|
70704 |
col [b_x + b_y*stride][0]= color; |
175 |
✓✓ |
70704 |
dist[b_x + b_y*stride][0]= distance >= 0 ? distance-b_x : 9999; |
176 |
|
|
} |
177 |
|
|
} |
178 |
✓✓ |
2722 |
for(b_x=0; b_x<w; b_x++){ |
179 |
|
2632 |
int color= 1024; |
180 |
|
2632 |
int distance= -1; |
181 |
✓✓ |
73336 |
for(b_y=0; b_y<h; b_y++){ |
182 |
|
70704 |
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
183 |
|
70704 |
int error_j= s->error_status_table[mb_index_j]; |
184 |
|
70704 |
int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]); |
185 |
✓✓✓✓
|
70704 |
if(intra_j==0 || !(error_j&ER_DC_ERROR)){ |
186 |
|
69174 |
color= dc[b_x + b_y*stride]; |
187 |
|
69174 |
distance= b_y; |
188 |
|
|
} |
189 |
|
70704 |
col [b_x + b_y*stride][3]= color; |
190 |
✓✗ |
70704 |
dist[b_x + b_y*stride][3]= distance >= 0 ? b_y-distance : 9999; |
191 |
|
|
} |
192 |
|
2632 |
color= 1024; |
193 |
|
2632 |
distance= -1; |
194 |
✓✓ |
73336 |
for(b_y=h-1; b_y>=0; b_y--){ |
195 |
|
70704 |
int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
196 |
|
70704 |
int error_j= s->error_status_table[mb_index_j]; |
197 |
|
70704 |
int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]); |
198 |
✓✓✓✓
|
70704 |
if(intra_j==0 || !(error_j&ER_DC_ERROR)){ |
199 |
|
69174 |
color= dc[b_x + b_y*stride]; |
200 |
|
69174 |
distance= b_y; |
201 |
|
|
} |
202 |
|
70704 |
col [b_x + b_y*stride][2]= color; |
203 |
✓✓ |
70704 |
dist[b_x + b_y*stride][2]= distance >= 0 ? distance-b_y : 9999; |
204 |
|
|
} |
205 |
|
|
} |
206 |
|
|
|
207 |
✓✓ |
2238 |
for (b_y = 0; b_y < h; b_y++) { |
208 |
✓✓ |
72852 |
for (b_x = 0; b_x < w; b_x++) { |
209 |
|
|
int mb_index, error, j; |
210 |
|
|
int64_t guess, weight_sum; |
211 |
|
70704 |
mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride; |
212 |
|
70704 |
error = s->error_status_table[mb_index]; |
213 |
|
|
|
214 |
✓✓ |
70704 |
if (IS_INTER(s->cur_pic.mb_type[mb_index])) |
215 |
|
45774 |
continue; // inter |
216 |
✓✓ |
24930 |
if (!(error & ER_DC_ERROR)) |
217 |
|
23400 |
continue; // dc-ok |
218 |
|
|
|
219 |
|
1530 |
weight_sum = 0; |
220 |
|
1530 |
guess = 0; |
221 |
✓✓ |
7650 |
for (j = 0; j < 4; j++) { |
222 |
|
6120 |
int64_t weight = 256 * 256 * 256 * 16 / FFMAX(dist[b_x + b_y*stride][j], 1); |
223 |
|
6120 |
guess += weight*(int64_t)col[b_x + b_y*stride][j]; |
224 |
|
6120 |
weight_sum += weight; |
225 |
|
|
} |
226 |
|
1530 |
guess = (guess + weight_sum / 2) / weight_sum; |
227 |
|
1530 |
dc[b_x + b_y * stride] = guess; |
228 |
|
|
} |
229 |
|
|
} |
230 |
|
|
|
231 |
|
90 |
fail: |
232 |
|
90 |
av_freep(&col); |
233 |
|
90 |
av_freep(&dist); |
234 |
|
90 |
} |
235 |
|
|
|
236 |
|
|
/** |
237 |
|
|
* simple horizontal deblocking filter used for error resilience |
238 |
|
|
* @param w width in 8 pixel blocks |
239 |
|
|
* @param h height in 8 pixel blocks |
240 |
|
|
*/ |
241 |
|
90 |
static void h_block_filter(ERContext *s, uint8_t *dst, int w, |
242 |
|
|
int h, ptrdiff_t stride, int is_luma) |
243 |
|
|
{ |
244 |
|
|
int b_x, b_y; |
245 |
|
|
ptrdiff_t mvx_stride, mvy_stride; |
246 |
|
90 |
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; |
247 |
|
90 |
set_mv_strides(s, &mvx_stride, &mvy_stride); |
248 |
|
90 |
mvx_stride >>= is_luma; |
249 |
|
90 |
mvy_stride *= mvx_stride; |
250 |
|
|
|
251 |
✓✓ |
2238 |
for (b_y = 0; b_y < h; b_y++) { |
252 |
✓✓ |
70704 |
for (b_x = 0; b_x < w - 1; b_x++) { |
253 |
|
|
int y; |
254 |
|
68556 |
int left_status = s->error_status_table[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]; |
255 |
|
68556 |
int right_status = s->error_status_table[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]; |
256 |
|
68556 |
int left_intra = IS_INTRA(s->cur_pic.mb_type[( b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]); |
257 |
|
68556 |
int right_intra = IS_INTRA(s->cur_pic.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) * s->mb_stride]); |
258 |
|
68556 |
int left_damage = left_status & ER_MB_ERROR; |
259 |
|
68556 |
int right_damage = right_status & ER_MB_ERROR; |
260 |
|
68556 |
int offset = b_x * 8 + b_y * stride * 8; |
261 |
|
68556 |
int16_t *left_mv = s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * b_x]; |
262 |
|
68556 |
int16_t *right_mv = s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)]; |
263 |
✓✓✓✓
|
68556 |
if (!(left_damage || right_damage)) |
264 |
|
49350 |
continue; // both undamaged |
265 |
✓✓✓✓
|
19206 |
if ((!left_intra) && (!right_intra) && |
266 |
|
17664 |
FFABS(left_mv[0] - right_mv[0]) + |
267 |
✓✓ |
17664 |
FFABS(left_mv[1] + right_mv[1]) < 2) |
268 |
|
2456 |
continue; |
269 |
|
|
|
270 |
✓✓ |
150750 |
for (y = 0; y < 8; y++) { |
271 |
|
|
int a, b, c, d; |
272 |
|
|
|
273 |
|
134000 |
a = dst[offset + 7 + y * stride] - dst[offset + 6 + y * stride]; |
274 |
|
134000 |
b = dst[offset + 8 + y * stride] - dst[offset + 7 + y * stride]; |
275 |
|
134000 |
c = dst[offset + 9 + y * stride] - dst[offset + 8 + y * stride]; |
276 |
|
|
|
277 |
|
134000 |
d = FFABS(b) - ((FFABS(a) + FFABS(c) + 1) >> 1); |
278 |
|
134000 |
d = FFMAX(d, 0); |
279 |
✓✓ |
134000 |
if (b < 0) |
280 |
|
48880 |
d = -d; |
281 |
|
|
|
282 |
✓✓ |
134000 |
if (d == 0) |
283 |
|
83771 |
continue; |
284 |
|
|
|
285 |
✓✓✓✓
|
50229 |
if (!(left_damage && right_damage)) |
286 |
|
841 |
d = d * 16 / 9; |
287 |
|
|
|
288 |
✓✓ |
50229 |
if (left_damage) { |
289 |
|
49860 |
dst[offset + 7 + y * stride] = cm[dst[offset + 7 + y * stride] + ((d * 7) >> 4)]; |
290 |
|
49860 |
dst[offset + 6 + y * stride] = cm[dst[offset + 6 + y * stride] + ((d * 5) >> 4)]; |
291 |
|
49860 |
dst[offset + 5 + y * stride] = cm[dst[offset + 5 + y * stride] + ((d * 3) >> 4)]; |
292 |
|
49860 |
dst[offset + 4 + y * stride] = cm[dst[offset + 4 + y * stride] + ((d * 1) >> 4)]; |
293 |
|
|
} |
294 |
✓✓ |
50229 |
if (right_damage) { |
295 |
|
49757 |
dst[offset + 8 + y * stride] = cm[dst[offset + 8 + y * stride] - ((d * 7) >> 4)]; |
296 |
|
49757 |
dst[offset + 9 + y * stride] = cm[dst[offset + 9 + y * stride] - ((d * 5) >> 4)]; |
297 |
|
49757 |
dst[offset + 10+ y * stride] = cm[dst[offset + 10 + y * stride] - ((d * 3) >> 4)]; |
298 |
|
49757 |
dst[offset + 11+ y * stride] = cm[dst[offset + 11 + y * stride] - ((d * 1) >> 4)]; |
299 |
|
|
} |
300 |
|
|
} |
301 |
|
|
} |
302 |
|
|
} |
303 |
|
90 |
} |
304 |
|
|
|
305 |
|
|
/** |
306 |
|
|
* simple vertical deblocking filter used for error resilience |
307 |
|
|
* @param w width in 8 pixel blocks |
308 |
|
|
* @param h height in 8 pixel blocks |
309 |
|
|
*/ |
310 |
|
90 |
static void v_block_filter(ERContext *s, uint8_t *dst, int w, int h, |
311 |
|
|
ptrdiff_t stride, int is_luma) |
312 |
|
|
{ |
313 |
|
|
int b_x, b_y; |
314 |
|
|
ptrdiff_t mvx_stride, mvy_stride; |
315 |
|
90 |
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; |
316 |
|
90 |
set_mv_strides(s, &mvx_stride, &mvy_stride); |
317 |
|
90 |
mvx_stride >>= is_luma; |
318 |
|
90 |
mvy_stride *= mvx_stride; |
319 |
|
|
|
320 |
✓✓ |
2148 |
for (b_y = 0; b_y < h - 1; b_y++) { |
321 |
✓✓ |
70130 |
for (b_x = 0; b_x < w; b_x++) { |
322 |
|
|
int x; |
323 |
|
68072 |
int top_status = s->error_status_table[(b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride]; |
324 |
|
68072 |
int bottom_status = s->error_status_table[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]; |
325 |
|
68072 |
int top_intra = IS_INTRA(s->cur_pic.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) * s->mb_stride]); |
326 |
|
68072 |
int bottom_intra = IS_INTRA(s->cur_pic.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) * s->mb_stride]); |
327 |
|
68072 |
int top_damage = top_status & ER_MB_ERROR; |
328 |
|
68072 |
int bottom_damage = bottom_status & ER_MB_ERROR; |
329 |
|
68072 |
int offset = b_x * 8 + b_y * stride * 8; |
330 |
|
|
|
331 |
|
68072 |
int16_t *top_mv = s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * b_x]; |
332 |
|
68072 |
int16_t *bottom_mv = s->cur_pic.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x]; |
333 |
|
|
|
334 |
✓✓✓✓
|
68072 |
if (!(top_damage || bottom_damage)) |
335 |
|
45970 |
continue; // both undamaged |
336 |
|
|
|
337 |
✓✓✓✓
|
22102 |
if ((!top_intra) && (!bottom_intra) && |
338 |
|
18868 |
FFABS(top_mv[0] - bottom_mv[0]) + |
339 |
✓✓ |
18868 |
FFABS(top_mv[1] + bottom_mv[1]) < 2) |
340 |
|
2528 |
continue; |
341 |
|
|
|
342 |
✓✓ |
176166 |
for (x = 0; x < 8; x++) { |
343 |
|
|
int a, b, c, d; |
344 |
|
|
|
345 |
|
156592 |
a = dst[offset + x + 7 * stride] - dst[offset + x + 6 * stride]; |
346 |
|
156592 |
b = dst[offset + x + 8 * stride] - dst[offset + x + 7 * stride]; |
347 |
|
156592 |
c = dst[offset + x + 9 * stride] - dst[offset + x + 8 * stride]; |
348 |
|
|
|
349 |
|
156592 |
d = FFABS(b) - ((FFABS(a) + FFABS(c) + 1) >> 1); |
350 |
|
156592 |
d = FFMAX(d, 0); |
351 |
✓✓ |
156592 |
if (b < 0) |
352 |
|
61844 |
d = -d; |
353 |
|
|
|
354 |
✓✓ |
156592 |
if (d == 0) |
355 |
|
92946 |
continue; |
356 |
|
|
|
357 |
✓✓✓✓
|
63646 |
if (!(top_damage && bottom_damage)) |
358 |
|
18705 |
d = d * 16 / 9; |
359 |
|
|
|
360 |
✓✓ |
63646 |
if (top_damage) { |
361 |
|
54076 |
dst[offset + x + 7 * stride] = cm[dst[offset + x + 7 * stride] + ((d * 7) >> 4)]; |
362 |
|
54076 |
dst[offset + x + 6 * stride] = cm[dst[offset + x + 6 * stride] + ((d * 5) >> 4)]; |
363 |
|
54076 |
dst[offset + x + 5 * stride] = cm[dst[offset + x + 5 * stride] + ((d * 3) >> 4)]; |
364 |
|
54076 |
dst[offset + x + 4 * stride] = cm[dst[offset + x + 4 * stride] + ((d * 1) >> 4)]; |
365 |
|
|
} |
366 |
✓✓ |
63646 |
if (bottom_damage) { |
367 |
|
54511 |
dst[offset + x + 8 * stride] = cm[dst[offset + x + 8 * stride] - ((d * 7) >> 4)]; |
368 |
|
54511 |
dst[offset + x + 9 * stride] = cm[dst[offset + x + 9 * stride] - ((d * 5) >> 4)]; |
369 |
|
54511 |
dst[offset + x + 10 * stride] = cm[dst[offset + x + 10 * stride] - ((d * 3) >> 4)]; |
370 |
|
54511 |
dst[offset + x + 11 * stride] = cm[dst[offset + x + 11 * stride] - ((d * 1) >> 4)]; |
371 |
|
|
} |
372 |
|
|
} |
373 |
|
|
} |
374 |
|
|
} |
375 |
|
90 |
} |
376 |
|
|
|
377 |
|
|
#define MV_FROZEN 8 |
378 |
|
|
#define MV_CHANGED 4 |
379 |
|
|
#define MV_UNCHANGED 2 |
380 |
|
|
#define MV_LISTED 1 |
381 |
|
44746 |
static av_always_inline void add_blocklist(int (*blocklist)[2], int *blocklist_length, uint8_t *fixed, int mb_x, int mb_y, int mb_xy) |
382 |
|
|
{ |
383 |
✓✓ |
44746 |
if (fixed[mb_xy]) |
384 |
|
41720 |
return; |
385 |
|
3026 |
fixed[mb_xy] = MV_LISTED; |
386 |
|
3026 |
blocklist[ *blocklist_length ][0] = mb_x; |
387 |
|
3026 |
blocklist[(*blocklist_length)++][1] = mb_y; |
388 |
|
|
} |
389 |
|
|
|
390 |
|
30 |
static void guess_mv(ERContext *s) |
391 |
|
|
{ |
392 |
|
|
int (*blocklist)[2], (*next_blocklist)[2]; |
393 |
|
|
uint8_t *fixed; |
394 |
|
30 |
const ptrdiff_t mb_stride = s->mb_stride; |
395 |
|
30 |
const int mb_width = s->mb_width; |
396 |
|
30 |
int mb_height = s->mb_height; |
397 |
|
|
int i, depth, num_avail; |
398 |
|
|
int mb_x, mb_y; |
399 |
|
|
ptrdiff_t mot_step, mot_stride; |
400 |
|
|
int blocklist_length, next_blocklist_length; |
401 |
|
|
|
402 |
✓✓✓✗
|
30 |
if (s->last_pic.f && s->last_pic.f->data[0]) |
403 |
|
26 |
mb_height = FFMIN(mb_height, (s->last_pic.f->height+15)>>4); |
404 |
✓✓✓✗
|
30 |
if (s->next_pic.f && s->next_pic.f->data[0]) |
405 |
|
29 |
mb_height = FFMIN(mb_height, (s->next_pic.f->height+15)>>4); |
406 |
|
|
|
407 |
|
30 |
blocklist = (int (*)[2])s->er_temp_buffer; |
408 |
|
30 |
next_blocklist = blocklist + s->mb_stride * s->mb_height; |
409 |
|
30 |
fixed = (uint8_t *)(next_blocklist + s->mb_stride * s->mb_height); |
410 |
|
|
|
411 |
|
30 |
set_mv_strides(s, &mot_step, &mot_stride); |
412 |
|
|
|
413 |
|
30 |
num_avail = 0; |
414 |
✓✓ |
30 |
if (s->last_pic.motion_val[0]) |
415 |
|
26 |
ff_thread_await_progress(s->last_pic.tf, mb_height-1, 0); |
416 |
✓✓ |
11814 |
for (i = 0; i < mb_width * mb_height; i++) { |
417 |
|
11784 |
const int mb_xy = s->mb_index2xy[i]; |
418 |
|
11784 |
int f = 0; |
419 |
|
11784 |
int error = s->error_status_table[mb_xy]; |
420 |
|
|
|
421 |
✓✓ |
11784 |
if (IS_INTRA(s->cur_pic.mb_type[mb_xy])) |
422 |
|
4155 |
f = MV_FROZEN; // intra // FIXME check |
423 |
✓✓ |
11784 |
if (!(error & ER_MV_ERROR)) |
424 |
|
8503 |
f = MV_FROZEN; // inter with undamaged MV |
425 |
|
|
|
426 |
|
11784 |
fixed[mb_xy] = f; |
427 |
✓✓ |
11784 |
if (f == MV_FROZEN) |
428 |
|
8758 |
num_avail++; |
429 |
✓✗✓✗
|
3026 |
else if(s->last_pic.f->data[0] && s->last_pic.motion_val[0]){ |
430 |
|
3026 |
const int mb_y= mb_xy / s->mb_stride; |
431 |
|
3026 |
const int mb_x= mb_xy % s->mb_stride; |
432 |
|
3026 |
const int mot_index= (mb_x + mb_y*mot_stride) * mot_step; |
433 |
|
3026 |
s->cur_pic.motion_val[0][mot_index][0]= s->last_pic.motion_val[0][mot_index][0]; |
434 |
|
3026 |
s->cur_pic.motion_val[0][mot_index][1]= s->last_pic.motion_val[0][mot_index][1]; |
435 |
|
3026 |
s->cur_pic.ref_index[0][4*mb_xy] = s->last_pic.ref_index[0][4*mb_xy]; |
436 |
|
|
} |
437 |
|
|
} |
438 |
|
|
|
439 |
✓✗ |
30 |
if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) || |
440 |
✗✓ |
30 |
num_avail <= FFMAX(mb_width, mb_height) / 2) { |
441 |
|
|
for (mb_y = 0; mb_y < mb_height; mb_y++) { |
442 |
|
|
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
443 |
|
|
const int mb_xy = mb_x + mb_y * s->mb_stride; |
444 |
|
|
int mv_dir = (s->last_pic.f && s->last_pic.f->data[0]) ? MV_DIR_FORWARD : MV_DIR_BACKWARD; |
445 |
|
|
|
446 |
|
|
if (IS_INTRA(s->cur_pic.mb_type[mb_xy])) |
447 |
|
|
continue; |
448 |
|
|
if (!(s->error_status_table[mb_xy] & ER_MV_ERROR)) |
449 |
|
|
continue; |
450 |
|
|
|
451 |
|
|
s->mv[0][0][0] = 0; |
452 |
|
|
s->mv[0][0][1] = 0; |
453 |
|
|
s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv, |
454 |
|
|
mb_x, mb_y, 0, 0); |
455 |
|
|
} |
456 |
|
|
} |
457 |
|
|
return; |
458 |
|
|
} |
459 |
|
|
|
460 |
|
30 |
blocklist_length = 0; |
461 |
✓✓ |
567 |
for (mb_y = 0; mb_y < mb_height; mb_y++) { |
462 |
✓✓ |
12321 |
for (mb_x = 0; mb_x < mb_width; mb_x++) { |
463 |
|
11784 |
const int mb_xy = mb_x + mb_y * mb_stride; |
464 |
✓✓ |
11784 |
if (fixed[mb_xy] == MV_FROZEN) { |
465 |
✓✓ |
8758 |
if (mb_x) add_blocklist(blocklist, &blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1); |
466 |
✓✓ |
8758 |
if (mb_y) add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride); |
467 |
✓✓ |
8758 |
if (mb_x+1 < mb_width) add_blocklist(blocklist, &blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1); |
468 |
✓✓ |
8758 |
if (mb_y+1 < mb_height) add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride); |
469 |
|
|
} |
470 |
|
|
} |
471 |
|
|
} |
472 |
|
|
|
473 |
|
30 |
for (depth = 0; ; depth++) { |
474 |
|
|
int changed, pass, none_left; |
475 |
|
|
int blocklist_index; |
476 |
|
|
|
477 |
|
118 |
none_left = 1; |
478 |
|
118 |
changed = 1; |
479 |
✓✓✓✓ ✓✓ |
739 |
for (pass = 0; (changed || pass < 2) && pass < 10; pass++) { |
480 |
|
621 |
int score_sum = 0; |
481 |
|
|
|
482 |
|
621 |
changed = 0; |
483 |
✓✓ |
21383 |
for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) { |
484 |
|
20762 |
const int mb_x = blocklist[blocklist_index][0]; |
485 |
|
20762 |
const int mb_y = blocklist[blocklist_index][1]; |
486 |
|
20762 |
const int mb_xy = mb_x + mb_y * mb_stride; |
487 |
|
|
int mv_predictor[8][2]; |
488 |
|
|
int ref[8]; |
489 |
|
|
int pred_count; |
490 |
|
|
int j; |
491 |
|
|
int best_score; |
492 |
|
|
int best_pred; |
493 |
|
|
int mot_index; |
494 |
|
|
int prev_x, prev_y, prev_ref; |
495 |
|
|
|
496 |
✓✓ |
20762 |
if ((mb_x ^ mb_y ^ pass) & 1) |
497 |
|
12859 |
continue; |
498 |
|
|
av_assert2(fixed[mb_xy] != MV_FROZEN); |
499 |
|
|
|
500 |
|
|
|
501 |
|
|
av_assert1(!IS_INTRA(s->cur_pic.mb_type[mb_xy])); |
502 |
|
|
av_assert1(s->last_pic.f && s->last_pic.f->data[0]); |
503 |
|
|
|
504 |
|
10375 |
j = 0; |
505 |
✓✓ |
10375 |
if (mb_x > 0) |
506 |
|
9916 |
j |= fixed[mb_xy - 1]; |
507 |
✓✓ |
10375 |
if (mb_x + 1 < mb_width) |
508 |
|
9913 |
j |= fixed[mb_xy + 1]; |
509 |
✓✗ |
10375 |
if (mb_y > 0) |
510 |
|
10375 |
j |= fixed[mb_xy - mb_stride]; |
511 |
✓✓ |
10375 |
if (mb_y + 1 < mb_height) |
512 |
|
10292 |
j |= fixed[mb_xy + mb_stride]; |
513 |
|
|
|
514 |
|
|
av_assert2(j & MV_FROZEN); |
515 |
|
|
|
516 |
✓✓✓✓
|
10375 |
if (!(j & MV_CHANGED) && pass > 1) |
517 |
|
2472 |
continue; |
518 |
|
|
|
519 |
|
7903 |
none_left = 0; |
520 |
|
7903 |
pred_count = 0; |
521 |
|
7903 |
mot_index = (mb_x + mb_y * mot_stride) * mot_step; |
522 |
|
|
|
523 |
✓✓✓✓
|
7903 |
if (mb_x > 0 && fixed[mb_xy - 1] > 1) { |
524 |
|
6124 |
mv_predictor[pred_count][0] = |
525 |
|
6124 |
s->cur_pic.motion_val[0][mot_index - mot_step][0]; |
526 |
|
6124 |
mv_predictor[pred_count][1] = |
527 |
|
6124 |
s->cur_pic.motion_val[0][mot_index - mot_step][1]; |
528 |
|
6124 |
ref[pred_count] = |
529 |
|
6124 |
s->cur_pic.ref_index[0][4 * (mb_xy - 1)]; |
530 |
|
6124 |
pred_count++; |
531 |
|
|
} |
532 |
✓✓✓✓
|
7903 |
if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) { |
533 |
|
6137 |
mv_predictor[pred_count][0] = |
534 |
|
6137 |
s->cur_pic.motion_val[0][mot_index + mot_step][0]; |
535 |
|
6137 |
mv_predictor[pred_count][1] = |
536 |
|
6137 |
s->cur_pic.motion_val[0][mot_index + mot_step][1]; |
537 |
|
6137 |
ref[pred_count] = |
538 |
|
6137 |
s->cur_pic.ref_index[0][4 * (mb_xy + 1)]; |
539 |
|
6137 |
pred_count++; |
540 |
|
|
} |
541 |
✓✗✓✓
|
7903 |
if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) { |
542 |
|
5118 |
mv_predictor[pred_count][0] = |
543 |
|
5118 |
s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][0]; |
544 |
|
5118 |
mv_predictor[pred_count][1] = |
545 |
|
5118 |
s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][1]; |
546 |
|
5118 |
ref[pred_count] = |
547 |
|
5118 |
s->cur_pic.ref_index[0][4 * (mb_xy - s->mb_stride)]; |
548 |
|
5118 |
pred_count++; |
549 |
|
|
} |
550 |
✓✓✓✓
|
7903 |
if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride] > 1) { |
551 |
|
4796 |
mv_predictor[pred_count][0] = |
552 |
|
4796 |
s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][0]; |
553 |
|
4796 |
mv_predictor[pred_count][1] = |
554 |
|
4796 |
s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][1]; |
555 |
|
4796 |
ref[pred_count] = |
556 |
|
4796 |
s->cur_pic.ref_index[0][4 * (mb_xy + s->mb_stride)]; |
557 |
|
4796 |
pred_count++; |
558 |
|
|
} |
559 |
✗✓ |
7903 |
if (pred_count == 0) |
560 |
|
|
continue; |
561 |
|
|
|
562 |
✓✓ |
7903 |
if (pred_count > 1) { |
563 |
|
6589 |
int sum_x = 0, sum_y = 0, sum_r = 0; |
564 |
|
|
int max_x, max_y, min_x, min_y, max_r, min_r; |
565 |
|
|
|
566 |
✓✓ |
27450 |
for (j = 0; j < pred_count; j++) { |
567 |
|
20861 |
sum_x += mv_predictor[j][0]; |
568 |
|
20861 |
sum_y += mv_predictor[j][1]; |
569 |
|
20861 |
sum_r += ref[j]; |
570 |
✓✓✗✓
|
20861 |
if (j && ref[j] != ref[j - 1]) |
571 |
|
|
goto skip_mean_and_median; |
572 |
|
|
} |
573 |
|
|
|
574 |
|
|
/* mean */ |
575 |
|
6589 |
mv_predictor[pred_count][0] = sum_x / j; |
576 |
|
6589 |
mv_predictor[pred_count][1] = sum_y / j; |
577 |
|
6589 |
ref[pred_count] = sum_r / j; |
578 |
|
|
|
579 |
|
|
/* median */ |
580 |
✓✓ |
6589 |
if (pred_count >= 3) { |
581 |
|
6014 |
min_y = min_x = min_r = 99999; |
582 |
|
6014 |
max_y = max_x = max_r = -99999; |
583 |
|
|
} else { |
584 |
|
575 |
min_x = min_y = max_x = max_y = min_r = max_r = 0; |
585 |
|
|
} |
586 |
✓✓ |
27450 |
for (j = 0; j < pred_count; j++) { |
587 |
|
20861 |
max_x = FFMAX(max_x, mv_predictor[j][0]); |
588 |
|
20861 |
max_y = FFMAX(max_y, mv_predictor[j][1]); |
589 |
|
20861 |
max_r = FFMAX(max_r, ref[j]); |
590 |
|
20861 |
min_x = FFMIN(min_x, mv_predictor[j][0]); |
591 |
|
20861 |
min_y = FFMIN(min_y, mv_predictor[j][1]); |
592 |
|
20861 |
min_r = FFMIN(min_r, ref[j]); |
593 |
|
|
} |
594 |
|
6589 |
mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x; |
595 |
|
6589 |
mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y; |
596 |
|
6589 |
ref[pred_count + 1] = sum_r - max_r - min_r; |
597 |
|
|
|
598 |
✓✓ |
6589 |
if (pred_count == 4) { |
599 |
|
1669 |
mv_predictor[pred_count + 1][0] /= 2; |
600 |
|
1669 |
mv_predictor[pred_count + 1][1] /= 2; |
601 |
|
1669 |
ref[pred_count + 1] /= 2; |
602 |
|
|
} |
603 |
|
6589 |
pred_count += 2; |
604 |
|
|
} |
605 |
|
|
|
606 |
|
1314 |
skip_mean_and_median: |
607 |
|
|
/* zero MV */ |
608 |
|
7903 |
mv_predictor[pred_count][0] = |
609 |
|
7903 |
mv_predictor[pred_count][1] = |
610 |
|
7903 |
ref[pred_count] = 0; |
611 |
|
7903 |
pred_count++; |
612 |
|
|
|
613 |
|
7903 |
prev_x = s->cur_pic.motion_val[0][mot_index][0]; |
614 |
|
7903 |
prev_y = s->cur_pic.motion_val[0][mot_index][1]; |
615 |
|
7903 |
prev_ref = s->cur_pic.ref_index[0][4 * mb_xy]; |
616 |
|
|
|
617 |
|
|
/* last MV */ |
618 |
|
7903 |
mv_predictor[pred_count][0] = prev_x; |
619 |
|
7903 |
mv_predictor[pred_count][1] = prev_y; |
620 |
|
7903 |
ref[pred_count] = prev_ref; |
621 |
|
7903 |
pred_count++; |
622 |
|
|
|
623 |
|
7903 |
best_pred = 0; |
624 |
|
7903 |
best_score = 256 * 256 * 256 * 64; |
625 |
✓✓ |
59062 |
for (j = 0; j < pred_count; j++) { |
626 |
|
51159 |
int *linesize = s->cur_pic.f->linesize; |
627 |
|
51159 |
int score = 0; |
628 |
|
51159 |
uint8_t *src = s->cur_pic.f->data[0] + |
629 |
|
51159 |
mb_x * 16 + mb_y * 16 * linesize[0]; |
630 |
|
|
|
631 |
|
51159 |
s->cur_pic.motion_val[0][mot_index][0] = |
632 |
|
51159 |
s->mv[0][0][0] = mv_predictor[j][0]; |
633 |
|
51159 |
s->cur_pic.motion_val[0][mot_index][1] = |
634 |
|
51159 |
s->mv[0][0][1] = mv_predictor[j][1]; |
635 |
|
|
|
636 |
|
|
// predictor intra or otherwise not available |
637 |
✗✓ |
51159 |
if (ref[j] < 0) |
638 |
|
|
continue; |
639 |
|
|
|
640 |
|
51159 |
s->decode_mb(s->opaque, ref[j], MV_DIR_FORWARD, |
641 |
|
|
MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0); |
642 |
|
|
|
643 |
✓✓✓✓
|
51159 |
if (mb_x > 0 && fixed[mb_xy - 1] > 1) { |
644 |
|
|
int k; |
645 |
✓✓ |
753508 |
for (k = 0; k < 16; k++) |
646 |
|
709184 |
score += FFABS(src[k * linesize[0] - 1] - |
647 |
|
|
src[k * linesize[0]]); |
648 |
|
|
} |
649 |
✓✓✓✓
|
51159 |
if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) { |
650 |
|
|
int k; |
651 |
✓✓ |
754222 |
for (k = 0; k < 16; k++) |
652 |
|
709856 |
score += FFABS(src[k * linesize[0] + 15] - |
653 |
|
|
src[k * linesize[0] + 16]); |
654 |
|
|
} |
655 |
✓✗✓✓
|
51159 |
if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) { |
656 |
|
|
int k; |
657 |
✓✓ |
584477 |
for (k = 0; k < 16; k++) |
658 |
|
550096 |
score += FFABS(src[k - linesize[0]] - src[k]); |
659 |
|
|
} |
660 |
✓✓✓✓
|
51159 |
if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] > 1) { |
661 |
|
|
int k; |
662 |
✓✓ |
551208 |
for (k = 0; k < 16; k++) |
663 |
|
518784 |
score += FFABS(src[k + linesize[0] * 15] - |
664 |
|
|
src[k + linesize[0] * 16]); |
665 |
|
|
} |
666 |
|
|
|
667 |
✓✓ |
51159 |
if (score <= best_score) { // <= will favor the last MV |
668 |
|
26196 |
best_score = score; |
669 |
|
26196 |
best_pred = j; |
670 |
|
|
} |
671 |
|
|
} |
672 |
|
7903 |
score_sum += best_score; |
673 |
|
7903 |
s->mv[0][0][0] = mv_predictor[best_pred][0]; |
674 |
|
7903 |
s->mv[0][0][1] = mv_predictor[best_pred][1]; |
675 |
|
|
|
676 |
✓✓ |
23709 |
for (i = 0; i < mot_step; i++) |
677 |
✓✓ |
47418 |
for (j = 0; j < mot_step; j++) { |
678 |
|
31612 |
s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0]; |
679 |
|
31612 |
s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1]; |
680 |
|
|
} |
681 |
|
|
|
682 |
|
7903 |
s->decode_mb(s->opaque, ref[best_pred], MV_DIR_FORWARD, |
683 |
|
|
MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0); |
684 |
|
|
|
685 |
|
|
|
686 |
✓✓✓✓
|
7903 |
if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) { |
687 |
|
3425 |
fixed[mb_xy] = MV_CHANGED; |
688 |
|
3425 |
changed++; |
689 |
|
|
} else |
690 |
|
4478 |
fixed[mb_xy] = MV_UNCHANGED; |
691 |
|
|
} |
692 |
|
|
} |
693 |
|
|
|
694 |
✓✓ |
118 |
if (none_left) |
695 |
|
30 |
return; |
696 |
|
|
|
697 |
|
88 |
next_blocklist_length = 0; |
698 |
|
|
|
699 |
✓✓ |
3114 |
for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) { |
700 |
|
3026 |
const int mb_x = blocklist[blocklist_index][0]; |
701 |
|
3026 |
const int mb_y = blocklist[blocklist_index][1]; |
702 |
|
3026 |
const int mb_xy = mb_x + mb_y * mb_stride; |
703 |
|
|
|
704 |
✓✗ |
3026 |
if (fixed[mb_xy] & (MV_CHANGED|MV_UNCHANGED|MV_FROZEN)) { |
705 |
|
3026 |
fixed[mb_xy] = MV_FROZEN; |
706 |
✓✓ |
3026 |
if (mb_x > 0) |
707 |
|
2890 |
add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1); |
708 |
✓✗ |
3026 |
if (mb_y > 0) |
709 |
|
3026 |
add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride); |
710 |
✓✓ |
3026 |
if (mb_x + 1 < mb_width) |
711 |
|
2891 |
add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1); |
712 |
✓✓ |
3026 |
if (mb_y + 1 < mb_height) |
713 |
|
2992 |
add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride); |
714 |
|
|
} |
715 |
|
|
} |
716 |
✗✓ |
88 |
av_assert0(next_blocklist_length <= mb_height * mb_width); |
717 |
|
88 |
FFSWAP(int , blocklist_length, next_blocklist_length); |
718 |
|
88 |
FFSWAP(void*, blocklist, next_blocklist); |
719 |
|
|
} |
720 |
|
|
} |
721 |
|
|
|
722 |
|
30 |
static int is_intra_more_likely(ERContext *s) |
723 |
|
|
{ |
724 |
|
|
int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y; |
725 |
|
|
|
726 |
✓✓✗✓
|
30 |
if (!s->last_pic.f || !s->last_pic.f->data[0]) |
727 |
|
4 |
return 1; // no previous frame available -> use spatial prediction |
728 |
|
|
|
729 |
✗✓ |
26 |
if (s->avctx->error_concealment & FF_EC_FAVOR_INTER) |
730 |
|
|
return 0; |
731 |
|
|
|
732 |
|
26 |
undamaged_count = 0; |
733 |
✓✓ |
10322 |
for (i = 0; i < s->mb_num; i++) { |
734 |
|
10296 |
const int mb_xy = s->mb_index2xy[i]; |
735 |
|
10296 |
const int error = s->error_status_table[mb_xy]; |
736 |
✓✓✗✓
|
10296 |
if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR))) |
737 |
|
7270 |
undamaged_count++; |
738 |
|
|
} |
739 |
|
|
|
740 |
✗✓ |
26 |
if (undamaged_count < 5) |
741 |
|
|
return 0; // almost all MBs damaged -> use temporal prediction |
742 |
|
|
|
743 |
|
|
// prevent dsp.sad() check, that requires access to the image |
744 |
|
|
if (CONFIG_XVMC && |
745 |
|
|
s->avctx->hwaccel && s->avctx->hwaccel->decode_mb && |
746 |
|
|
s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) |
747 |
|
|
return 1; |
748 |
|
|
|
749 |
✓✗ |
26 |
skip_amount = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs |
750 |
|
26 |
is_intra_likely = 0; |
751 |
|
|
|
752 |
|
26 |
j = 0; |
753 |
✓✓ |
468 |
for (mb_y = 0; mb_y < s->mb_height - 1; mb_y++) { |
754 |
✓✓ |
10166 |
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
755 |
|
|
int error; |
756 |
|
9724 |
const int mb_xy = mb_x + mb_y * s->mb_stride; |
757 |
|
|
|
758 |
|
9724 |
error = s->error_status_table[mb_xy]; |
759 |
✓✓✓✗
|
9724 |
if ((error & ER_DC_ERROR) && (error & ER_MV_ERROR)) |
760 |
|
2992 |
continue; // skip damaged |
761 |
|
|
|
762 |
|
6732 |
j++; |
763 |
|
|
// skip a few to speed things up |
764 |
✓✓ |
6732 |
if ((j % skip_amount) != 0) |
765 |
|
5384 |
continue; |
766 |
|
|
|
767 |
✓✓ |
1348 |
if (s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I) { |
768 |
|
355 |
int *linesize = s->cur_pic.f->linesize; |
769 |
|
355 |
uint8_t *mb_ptr = s->cur_pic.f->data[0] + |
770 |
|
355 |
mb_x * 16 + mb_y * 16 * linesize[0]; |
771 |
|
355 |
uint8_t *last_mb_ptr = s->last_pic.f->data[0] + |
772 |
|
355 |
mb_x * 16 + mb_y * 16 * linesize[0]; |
773 |
|
|
|
774 |
✓✗ |
355 |
if (s->avctx->codec_id == AV_CODEC_ID_H264) { |
775 |
|
|
// FIXME |
776 |
|
|
} else { |
777 |
|
355 |
ff_thread_await_progress(s->last_pic.tf, mb_y, 0); |
778 |
|
|
} |
779 |
|
710 |
is_intra_likely += s->mecc.sad[0](NULL, last_mb_ptr, mb_ptr, |
780 |
|
355 |
linesize[0], 16); |
781 |
|
|
// FIXME need await_progress() here |
782 |
|
355 |
is_intra_likely -= s->mecc.sad[0](NULL, last_mb_ptr, |
783 |
|
355 |
last_mb_ptr + linesize[0] * 16, |
784 |
|
355 |
linesize[0], 16); |
785 |
|
|
} else { |
786 |
✓✓ |
993 |
if (IS_INTRA(s->cur_pic.mb_type[mb_xy])) |
787 |
|
58 |
is_intra_likely++; |
788 |
|
|
else |
789 |
|
935 |
is_intra_likely--; |
790 |
|
|
} |
791 |
|
|
} |
792 |
|
|
} |
793 |
|
|
// av_log(NULL, AV_LOG_ERROR, "is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type); |
794 |
|
26 |
return is_intra_likely > 0; |
795 |
|
|
} |
796 |
|
|
|
797 |
|
33790 |
void ff_er_frame_start(ERContext *s) |
798 |
|
|
{ |
799 |
✗✓ |
33790 |
if (!s->avctx->error_concealment) |
800 |
|
|
return; |
801 |
|
|
|
802 |
✓✓ |
33790 |
if (!s->mecc_inited) { |
803 |
|
735 |
ff_me_cmp_init(&s->mecc, s->avctx); |
804 |
|
735 |
s->mecc_inited = 1; |
805 |
|
|
} |
806 |
|
|
|
807 |
|
33790 |
memset(s->error_status_table, ER_MB_ERROR | VP_START | ER_MB_END, |
808 |
|
33790 |
s->mb_stride * s->mb_height * sizeof(uint8_t)); |
809 |
|
33790 |
atomic_init(&s->error_count, 3 * s->mb_num); |
810 |
|
33790 |
s->error_occurred = 0; |
811 |
|
|
} |
812 |
|
|
|
813 |
|
115617 |
static int er_supported(ERContext *s) |
814 |
|
|
{ |
815 |
✗✓✗✗
|
115617 |
if(s->avctx->hwaccel && s->avctx->hwaccel->decode_slice || |
816 |
✓✓ |
115617 |
!s->cur_pic.f || |
817 |
✓✓ |
105179 |
s->cur_pic.field_picture |
818 |
|
|
) |
819 |
|
27146 |
return 0; |
820 |
|
88471 |
return 1; |
821 |
|
|
} |
822 |
|
|
|
823 |
|
|
/** |
824 |
|
|
* Add a slice. |
825 |
|
|
* @param endx x component of the last macroblock, can be -1 |
826 |
|
|
* for the last of the previous line |
827 |
|
|
* @param status the status at the end (ER_MV_END, ER_AC_ERROR, ...), it is |
828 |
|
|
* assumed that no earlier end or error of the same type occurred |
829 |
|
|
*/ |
830 |
|
162411 |
void ff_er_add_slice(ERContext *s, int startx, int starty, |
831 |
|
|
int endx, int endy, int status) |
832 |
|
|
{ |
833 |
|
162411 |
const int start_i = av_clip(startx + starty * s->mb_width, 0, s->mb_num - 1); |
834 |
|
162411 |
const int end_i = av_clip(endx + endy * s->mb_width, 0, s->mb_num); |
835 |
|
162411 |
const int start_xy = s->mb_index2xy[start_i]; |
836 |
|
162411 |
const int end_xy = s->mb_index2xy[end_i]; |
837 |
|
162411 |
int mask = -1; |
838 |
|
|
|
839 |
✗✓✗✗
|
162411 |
if (s->avctx->hwaccel && s->avctx->hwaccel->decode_slice) |
840 |
|
|
return; |
841 |
|
|
|
842 |
✓✗✗✓
|
162411 |
if (start_i > end_i || start_xy > end_xy) { |
843 |
|
|
av_log(s->avctx, AV_LOG_ERROR, |
844 |
|
|
"internal error, slice end before start\n"); |
845 |
|
|
return; |
846 |
|
|
} |
847 |
|
|
|
848 |
✗✓ |
162411 |
if (!s->avctx->error_concealment) |
849 |
|
|
return; |
850 |
|
|
|
851 |
|
162411 |
mask &= ~VP_START; |
852 |
✓✓ |
162411 |
if (status & (ER_AC_ERROR | ER_AC_END)) { |
853 |
|
159454 |
mask &= ~(ER_AC_ERROR | ER_AC_END); |
854 |
|
159454 |
atomic_fetch_add(&s->error_count, start_i - end_i - 1); |
855 |
|
|
} |
856 |
✓✓ |
162411 |
if (status & (ER_DC_ERROR | ER_DC_END)) { |
857 |
|
159454 |
mask &= ~(ER_DC_ERROR | ER_DC_END); |
858 |
|
159454 |
atomic_fetch_add(&s->error_count, start_i - end_i - 1); |
859 |
|
|
} |
860 |
✓✓ |
162411 |
if (status & (ER_MV_ERROR | ER_MV_END)) { |
861 |
|
159454 |
mask &= ~(ER_MV_ERROR | ER_MV_END); |
862 |
|
159454 |
atomic_fetch_add(&s->error_count, start_i - end_i - 1); |
863 |
|
|
} |
864 |
|
|
|
865 |
✓✓ |
162411 |
if (status & ER_MB_ERROR) { |
866 |
|
6 |
s->error_occurred = 1; |
867 |
|
6 |
atomic_store(&s->error_count, INT_MAX); |
868 |
|
|
} |
869 |
|
|
|
870 |
✓✓ |
162411 |
if (mask == ~0x7F) { |
871 |
|
157726 |
memset(&s->error_status_table[start_xy], 0, |
872 |
|
157726 |
(end_xy - start_xy) * sizeof(uint8_t)); |
873 |
|
|
} else { |
874 |
|
|
int i; |
875 |
✓✓ |
414133 |
for (i = start_xy; i < end_xy; i++) |
876 |
|
409448 |
s->error_status_table[i] &= mask; |
877 |
|
|
} |
878 |
|
|
|
879 |
✓✓ |
162411 |
if (end_i == s->mb_num) |
880 |
|
3835 |
atomic_store(&s->error_count, INT_MAX); |
881 |
|
|
else { |
882 |
|
158576 |
s->error_status_table[end_xy] &= mask; |
883 |
|
158576 |
s->error_status_table[end_xy] |= status; |
884 |
|
|
} |
885 |
|
|
|
886 |
|
162411 |
s->error_status_table[start_xy] |= VP_START; |
887 |
|
|
|
888 |
✓✓✓✓ ✓✓ |
277396 |
if (start_xy > 0 && !(s->avctx->active_thread_type & FF_THREAD_SLICE) && |
889 |
✓✗ |
203426 |
er_supported(s) && s->avctx->skip_top * s->mb_width < start_i) { |
890 |
|
88441 |
int prev_status = s->error_status_table[s->mb_index2xy[start_i - 1]]; |
891 |
|
|
|
892 |
|
88441 |
prev_status &= ~ VP_START; |
893 |
✓✓ |
88441 |
if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END)) { |
894 |
|
77 |
s->error_occurred = 1; |
895 |
|
77 |
atomic_store(&s->error_count, INT_MAX); |
896 |
|
|
} |
897 |
|
|
} |
898 |
|
|
} |
899 |
|
|
|
900 |
|
29492 |
void ff_er_frame_end(ERContext *s) |
901 |
|
|
{ |
902 |
|
29492 |
int *linesize = NULL; |
903 |
|
|
int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error; |
904 |
|
|
int distance; |
905 |
|
29492 |
int threshold_part[4] = { 100, 100, 100 }; |
906 |
|
29492 |
int threshold = 50; |
907 |
|
|
int is_intra_likely; |
908 |
|
29492 |
int size = s->b8_stride * 2 * s->mb_height; |
909 |
|
|
|
910 |
|
|
/* We do not support ER of field pictures yet, |
911 |
|
|
* though it should not crash if enabled. */ |
912 |
✓✗✓✓
|
29492 |
if (!s->avctx->error_concealment || !atomic_load(&s->error_count) || |
913 |
✓✗✓✓
|
1264 |
s->avctx->lowres || |
914 |
|
632 |
!er_supported(s) || |
915 |
|
30 |
atomic_load(&s->error_count) == 3 * s->mb_width * |
916 |
✗✓ |
30 |
(s->avctx->skip_top + s->avctx->skip_bottom)) { |
917 |
|
29462 |
return; |
918 |
|
|
} |
919 |
|
30 |
linesize = s->cur_pic.f->linesize; |
920 |
✓✓ |
84 |
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
921 |
|
83 |
int status = s->error_status_table[mb_x + (s->mb_height - 1) * s->mb_stride]; |
922 |
✓✓ |
83 |
if (status != 0x7F) |
923 |
|
29 |
break; |
924 |
|
|
} |
925 |
|
|
|
926 |
✓✓ |
30 |
if ( mb_x == s->mb_width |
927 |
✗✓ |
1 |
&& s->avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO |
928 |
|
|
&& (FFALIGN(s->avctx->height, 16)&16) |
929 |
|
|
&& atomic_load(&s->error_count) == 3 * s->mb_width * (s->avctx->skip_top + s->avctx->skip_bottom + 1) |
930 |
|
|
) { |
931 |
|
|
av_log(s->avctx, AV_LOG_DEBUG, "ignoring last missing slice\n"); |
932 |
|
|
return; |
933 |
|
|
} |
934 |
|
|
|
935 |
✓✓ |
30 |
if (s->last_pic.f) { |
936 |
✓✗ |
26 |
if (s->last_pic.f->width != s->cur_pic.f->width || |
937 |
✓✗ |
26 |
s->last_pic.f->height != s->cur_pic.f->height || |
938 |
✗✓ |
26 |
s->last_pic.f->format != s->cur_pic.f->format) { |
939 |
|
|
av_log(s->avctx, AV_LOG_WARNING, "Cannot use previous picture in error concealment\n"); |
940 |
|
|
memset(&s->last_pic, 0, sizeof(s->last_pic)); |
941 |
|
|
} |
942 |
|
|
} |
943 |
✓✓ |
30 |
if (s->next_pic.f) { |
944 |
✓✗ |
29 |
if (s->next_pic.f->width != s->cur_pic.f->width || |
945 |
✓✗ |
29 |
s->next_pic.f->height != s->cur_pic.f->height || |
946 |
✗✓ |
29 |
s->next_pic.f->format != s->cur_pic.f->format) { |
947 |
|
|
av_log(s->avctx, AV_LOG_WARNING, "Cannot use next picture in error concealment\n"); |
948 |
|
|
memset(&s->next_pic, 0, sizeof(s->next_pic)); |
949 |
|
|
} |
950 |
|
|
} |
951 |
|
|
|
952 |
✓✗✗✓
|
30 |
if (!s->cur_pic.motion_val[0] || !s->cur_pic.ref_index[0]) { |
953 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n"); |
954 |
|
|
|
955 |
|
|
for (i = 0; i < 2; i++) { |
956 |
|
|
s->ref_index_buf[i] = av_buffer_allocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t)); |
957 |
|
|
s->motion_val_buf[i] = av_buffer_allocz((size + 4) * 2 * sizeof(uint16_t)); |
958 |
|
|
if (!s->ref_index_buf[i] || !s->motion_val_buf[i]) |
959 |
|
|
break; |
960 |
|
|
s->cur_pic.ref_index[i] = s->ref_index_buf[i]->data; |
961 |
|
|
s->cur_pic.motion_val[i] = (int16_t (*)[2])s->motion_val_buf[i]->data + 4; |
962 |
|
|
} |
963 |
|
|
if (i < 2) { |
964 |
|
|
for (i = 0; i < 2; i++) { |
965 |
|
|
av_buffer_unref(&s->ref_index_buf[i]); |
966 |
|
|
av_buffer_unref(&s->motion_val_buf[i]); |
967 |
|
|
s->cur_pic.ref_index[i] = NULL; |
968 |
|
|
s->cur_pic.motion_val[i] = NULL; |
969 |
|
|
} |
970 |
|
|
return; |
971 |
|
|
} |
972 |
|
|
} |
973 |
|
|
|
974 |
✗✓ |
30 |
if (s->avctx->debug & FF_DEBUG_ER) { |
975 |
|
|
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { |
976 |
|
|
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
977 |
|
|
int status = s->error_status_table[mb_x + mb_y * s->mb_stride]; |
978 |
|
|
|
979 |
|
|
av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status); |
980 |
|
|
} |
981 |
|
|
av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
982 |
|
|
} |
983 |
|
|
} |
984 |
|
|
|
985 |
|
|
#if 1 |
986 |
|
|
/* handle overlapping slices */ |
987 |
✓✓ |
120 |
for (error_type = 1; error_type <= 3; error_type++) { |
988 |
|
90 |
int end_ok = 0; |
989 |
|
|
|
990 |
✓✓ |
35442 |
for (i = s->mb_num - 1; i >= 0; i--) { |
991 |
|
35352 |
const int mb_xy = s->mb_index2xy[i]; |
992 |
|
35352 |
int error = s->error_status_table[mb_xy]; |
993 |
|
|
|
994 |
✓✓ |
35352 |
if (error & (1 << error_type)) |
995 |
|
9696 |
end_ok = 1; |
996 |
✓✓ |
35352 |
if (error & (8 << error_type)) |
997 |
|
10083 |
end_ok = 1; |
998 |
|
|
|
999 |
✗✓ |
35352 |
if (!end_ok) |
1000 |
|
|
s->error_status_table[mb_xy] |= 1 << error_type; |
1001 |
|
|
|
1002 |
✓✓ |
35352 |
if (error & VP_START) |
1003 |
|
10086 |
end_ok = 0; |
1004 |
|
|
} |
1005 |
|
|
} |
1006 |
|
|
#endif |
1007 |
|
|
#if 1 |
1008 |
|
|
/* handle slices with partitions of different length */ |
1009 |
✓✓ |
30 |
if (s->partitioned_frame) { |
1010 |
|
29 |
int end_ok = 0; |
1011 |
|
|
|
1012 |
✓✓ |
11513 |
for (i = s->mb_num - 1; i >= 0; i--) { |
1013 |
|
11484 |
const int mb_xy = s->mb_index2xy[i]; |
1014 |
|
11484 |
int error = s->error_status_table[mb_xy]; |
1015 |
|
|
|
1016 |
✓✓ |
11484 |
if (error & ER_AC_END) |
1017 |
|
3312 |
end_ok = 0; |
1018 |
✓✓ |
11484 |
if ((error & ER_MV_END) || |
1019 |
✓✗ |
8172 |
(error & ER_DC_END) || |
1020 |
✗✓ |
8172 |
(error & ER_AC_ERROR)) |
1021 |
|
3312 |
end_ok = 1; |
1022 |
|
|
|
1023 |
✗✓ |
11484 |
if (!end_ok) |
1024 |
|
|
s->error_status_table[mb_xy]|= ER_AC_ERROR; |
1025 |
|
|
|
1026 |
✓✓ |
11484 |
if (error & VP_START) |
1027 |
|
3312 |
end_ok = 0; |
1028 |
|
|
} |
1029 |
|
|
} |
1030 |
|
|
#endif |
1031 |
|
|
/* handle missing slices */ |
1032 |
✗✓ |
30 |
if (s->avctx->err_recognition & AV_EF_EXPLODE) { |
1033 |
|
|
int end_ok = 1; |
1034 |
|
|
|
1035 |
|
|
// FIXME + 100 hack |
1036 |
|
|
for (i = s->mb_num - 2; i >= s->mb_width + 100; i--) { |
1037 |
|
|
const int mb_xy = s->mb_index2xy[i]; |
1038 |
|
|
int error1 = s->error_status_table[mb_xy]; |
1039 |
|
|
int error2 = s->error_status_table[s->mb_index2xy[i + 1]]; |
1040 |
|
|
|
1041 |
|
|
if (error1 & VP_START) |
1042 |
|
|
end_ok = 1; |
1043 |
|
|
|
1044 |
|
|
if (error2 == (VP_START | ER_MB_ERROR | ER_MB_END) && |
1045 |
|
|
error1 != (VP_START | ER_MB_ERROR | ER_MB_END) && |
1046 |
|
|
((error1 & ER_AC_END) || (error1 & ER_DC_END) || |
1047 |
|
|
(error1 & ER_MV_END))) { |
1048 |
|
|
// end & uninit |
1049 |
|
|
end_ok = 0; |
1050 |
|
|
} |
1051 |
|
|
|
1052 |
|
|
if (!end_ok) |
1053 |
|
|
s->error_status_table[mb_xy] |= ER_MB_ERROR; |
1054 |
|
|
} |
1055 |
|
|
} |
1056 |
|
|
|
1057 |
|
|
#if 1 |
1058 |
|
|
/* backward mark errors */ |
1059 |
|
30 |
distance = 9999999; |
1060 |
✓✓ |
120 |
for (error_type = 1; error_type <= 3; error_type++) { |
1061 |
✓✓ |
35442 |
for (i = s->mb_num - 1; i >= 0; i--) { |
1062 |
|
35352 |
const int mb_xy = s->mb_index2xy[i]; |
1063 |
|
35352 |
int error = s->error_status_table[mb_xy]; |
1064 |
|
|
|
1065 |
✓✓✓✓
|
35352 |
if (!s->mbskip_table || !s->mbskip_table[mb_xy]) // FIXME partition specific |
1066 |
|
35274 |
distance++; |
1067 |
✓✓ |
35352 |
if (error & (1 << error_type)) |
1068 |
|
9696 |
distance = 0; |
1069 |
|
|
|
1070 |
✓✓ |
35352 |
if (s->partitioned_frame) { |
1071 |
✓✓ |
34452 |
if (distance < threshold_part[error_type - 1]) |
1072 |
|
9546 |
s->error_status_table[mb_xy] |= 1 << error_type; |
1073 |
|
|
} else { |
1074 |
✓✓ |
900 |
if (distance < threshold) |
1075 |
|
297 |
s->error_status_table[mb_xy] |= 1 << error_type; |
1076 |
|
|
} |
1077 |
|
|
|
1078 |
✓✓ |
35352 |
if (error & VP_START) |
1079 |
|
10086 |
distance = 9999999; |
1080 |
|
|
} |
1081 |
|
|
} |
1082 |
|
|
#endif |
1083 |
|
|
|
1084 |
|
|
/* forward mark errors */ |
1085 |
|
30 |
error = 0; |
1086 |
✓✓ |
11814 |
for (i = 0; i < s->mb_num; i++) { |
1087 |
|
11784 |
const int mb_xy = s->mb_index2xy[i]; |
1088 |
|
11784 |
int old_error = s->error_status_table[mb_xy]; |
1089 |
|
|
|
1090 |
✓✓ |
11784 |
if (old_error & VP_START) { |
1091 |
|
3362 |
error = old_error & ER_MB_ERROR; |
1092 |
|
|
} else { |
1093 |
|
8422 |
error |= old_error & ER_MB_ERROR; |
1094 |
|
8422 |
s->error_status_table[mb_xy] |= error; |
1095 |
|
|
} |
1096 |
|
|
} |
1097 |
|
|
#if 1 |
1098 |
|
|
/* handle not partitioned case */ |
1099 |
✓✓ |
30 |
if (!s->partitioned_frame) { |
1100 |
✓✓ |
301 |
for (i = 0; i < s->mb_num; i++) { |
1101 |
|
300 |
const int mb_xy = s->mb_index2xy[i]; |
1102 |
|
300 |
int error = s->error_status_table[mb_xy]; |
1103 |
✓✓ |
300 |
if (error & ER_MB_ERROR) |
1104 |
|
99 |
error |= ER_MB_ERROR; |
1105 |
|
300 |
s->error_status_table[mb_xy] = error; |
1106 |
|
|
} |
1107 |
|
|
} |
1108 |
|
|
#endif |
1109 |
|
|
|
1110 |
|
30 |
dc_error = ac_error = mv_error = 0; |
1111 |
✓✓ |
11814 |
for (i = 0; i < s->mb_num; i++) { |
1112 |
|
11784 |
const int mb_xy = s->mb_index2xy[i]; |
1113 |
|
11784 |
int error = s->error_status_table[mb_xy]; |
1114 |
✓✓ |
11784 |
if (error & ER_DC_ERROR) |
1115 |
|
3281 |
dc_error++; |
1116 |
✓✓ |
11784 |
if (error & ER_AC_ERROR) |
1117 |
|
3281 |
ac_error++; |
1118 |
✓✓ |
11784 |
if (error & ER_MV_ERROR) |
1119 |
|
3281 |
mv_error++; |
1120 |
|
|
} |
1121 |
|
30 |
av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors in %c frame\n", |
1122 |
|
30 |
dc_error, ac_error, mv_error, av_get_picture_type_char(s->cur_pic.f->pict_type)); |
1123 |
|
|
|
1124 |
|
30 |
s->cur_pic.f->decode_error_flags |= FF_DECODE_ERROR_CONCEALMENT_ACTIVE; |
1125 |
|
|
|
1126 |
|
30 |
is_intra_likely = is_intra_more_likely(s); |
1127 |
|
|
|
1128 |
|
|
/* set unknown mb-type to most likely */ |
1129 |
✓✓ |
11814 |
for (i = 0; i < s->mb_num; i++) { |
1130 |
|
11784 |
const int mb_xy = s->mb_index2xy[i]; |
1131 |
|
11784 |
int error = s->error_status_table[mb_xy]; |
1132 |
✓✓✗✓
|
11784 |
if (!((error & ER_DC_ERROR) && (error & ER_MV_ERROR))) |
1133 |
|
8503 |
continue; |
1134 |
|
|
|
1135 |
✓✓ |
3281 |
if (is_intra_likely) |
1136 |
|
255 |
s->cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA4x4; |
1137 |
|
|
else |
1138 |
|
3026 |
s->cur_pic.mb_type[mb_xy] = MB_TYPE_16x16 | MB_TYPE_L0; |
1139 |
|
|
} |
1140 |
|
|
|
1141 |
|
|
// change inter to intra blocks if no reference frames are available |
1142 |
✓✓✗✓
|
30 |
if (!(s->last_pic.f && s->last_pic.f->data[0]) && |
1143 |
✓✓✗✓
|
4 |
!(s->next_pic.f && s->next_pic.f->data[0])) |
1144 |
✓✓ |
301 |
for (i = 0; i < s->mb_num; i++) { |
1145 |
|
300 |
const int mb_xy = s->mb_index2xy[i]; |
1146 |
✗✓ |
300 |
if (!IS_INTRA(s->cur_pic.mb_type[mb_xy])) |
1147 |
|
|
s->cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA4x4; |
1148 |
|
|
} |
1149 |
|
|
|
1150 |
|
|
/* handle inter blocks with damaged AC */ |
1151 |
✓✓ |
567 |
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { |
1152 |
✓✓ |
12321 |
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
1153 |
|
11784 |
const int mb_xy = mb_x + mb_y * s->mb_stride; |
1154 |
|
11784 |
const int mb_type = s->cur_pic.mb_type[mb_xy]; |
1155 |
✓✓✗✓
|
11784 |
const int dir = !(s->last_pic.f && s->last_pic.f->data[0]); |
1156 |
✓✓ |
11784 |
const int mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD; |
1157 |
|
|
int mv_type; |
1158 |
|
|
|
1159 |
|
11784 |
int error = s->error_status_table[mb_xy]; |
1160 |
|
|
|
1161 |
✓✓ |
11784 |
if (IS_INTRA(mb_type)) |
1162 |
|
4155 |
continue; // intra |
1163 |
✓✓ |
7629 |
if (error & ER_MV_ERROR) |
1164 |
|
3026 |
continue; // inter with damaged MV |
1165 |
✓✗ |
4603 |
if (!(error & ER_AC_ERROR)) |
1166 |
|
4603 |
continue; // undamaged inter |
1167 |
|
|
|
1168 |
|
|
if (IS_8X8(mb_type)) { |
1169 |
|
|
int mb_index = mb_x * 2 + mb_y * 2 * s->b8_stride; |
1170 |
|
|
int j; |
1171 |
|
|
mv_type = MV_TYPE_8X8; |
1172 |
|
|
for (j = 0; j < 4; j++) { |
1173 |
|
|
s->mv[0][j][0] = s->cur_pic.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][0]; |
1174 |
|
|
s->mv[0][j][1] = s->cur_pic.motion_val[dir][mb_index + (j & 1) + (j >> 1) * s->b8_stride][1]; |
1175 |
|
|
} |
1176 |
|
|
} else { |
1177 |
|
|
mv_type = MV_TYPE_16X16; |
1178 |
|
|
s->mv[0][0][0] = s->cur_pic.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][0]; |
1179 |
|
|
s->mv[0][0][1] = s->cur_pic.motion_val[dir][mb_x * 2 + mb_y * 2 * s->b8_stride][1]; |
1180 |
|
|
} |
1181 |
|
|
|
1182 |
|
|
s->decode_mb(s->opaque, 0 /* FIXME H.264 partitioned slices need this set */, |
1183 |
|
|
mv_dir, mv_type, &s->mv, mb_x, mb_y, 0, 0); |
1184 |
|
|
} |
1185 |
|
|
} |
1186 |
|
|
|
1187 |
|
|
/* guess MVs */ |
1188 |
✗✓ |
30 |
if (s->cur_pic.f->pict_type == AV_PICTURE_TYPE_B) { |
1189 |
|
|
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { |
1190 |
|
|
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
1191 |
|
|
int xy = mb_x * 2 + mb_y * 2 * s->b8_stride; |
1192 |
|
|
const int mb_xy = mb_x + mb_y * s->mb_stride; |
1193 |
|
|
const int mb_type = s->cur_pic.mb_type[mb_xy]; |
1194 |
|
|
int mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; |
1195 |
|
|
|
1196 |
|
|
int error = s->error_status_table[mb_xy]; |
1197 |
|
|
|
1198 |
|
|
if (IS_INTRA(mb_type)) |
1199 |
|
|
continue; |
1200 |
|
|
if (!(error & ER_MV_ERROR)) |
1201 |
|
|
continue; // inter with undamaged MV |
1202 |
|
|
if (!(error & ER_AC_ERROR)) |
1203 |
|
|
continue; // undamaged inter |
1204 |
|
|
|
1205 |
|
|
if (!(s->last_pic.f && s->last_pic.f->data[0])) |
1206 |
|
|
mv_dir &= ~MV_DIR_FORWARD; |
1207 |
|
|
if (!(s->next_pic.f && s->next_pic.f->data[0])) |
1208 |
|
|
mv_dir &= ~MV_DIR_BACKWARD; |
1209 |
|
|
|
1210 |
|
|
if (s->pp_time) { |
1211 |
|
|
int time_pp = s->pp_time; |
1212 |
|
|
int time_pb = s->pb_time; |
1213 |
|
|
|
1214 |
|
|
av_assert0(s->avctx->codec_id != AV_CODEC_ID_H264); |
1215 |
|
|
ff_thread_await_progress(s->next_pic.tf, mb_y, 0); |
1216 |
|
|
|
1217 |
|
|
s->mv[0][0][0] = s->next_pic.motion_val[0][xy][0] * time_pb / time_pp; |
1218 |
|
|
s->mv[0][0][1] = s->next_pic.motion_val[0][xy][1] * time_pb / time_pp; |
1219 |
|
|
s->mv[1][0][0] = s->next_pic.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp; |
1220 |
|
|
s->mv[1][0][1] = s->next_pic.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp; |
1221 |
|
|
} else { |
1222 |
|
|
s->mv[0][0][0] = 0; |
1223 |
|
|
s->mv[0][0][1] = 0; |
1224 |
|
|
s->mv[1][0][0] = 0; |
1225 |
|
|
s->mv[1][0][1] = 0; |
1226 |
|
|
} |
1227 |
|
|
|
1228 |
|
|
s->decode_mb(s->opaque, 0, mv_dir, MV_TYPE_16X16, &s->mv, |
1229 |
|
|
mb_x, mb_y, 0, 0); |
1230 |
|
|
} |
1231 |
|
|
} |
1232 |
|
|
} else |
1233 |
|
30 |
guess_mv(s); |
1234 |
|
|
|
1235 |
|
|
/* the filters below manipulate raw image, skip them */ |
1236 |
|
|
if (CONFIG_XVMC && s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) |
1237 |
|
|
goto ec_clean; |
1238 |
|
|
/* fill DC for inter blocks */ |
1239 |
✓✓ |
567 |
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { |
1240 |
✓✓ |
12321 |
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
1241 |
|
|
int dc, dcu, dcv, y, n; |
1242 |
|
|
int16_t *dc_ptr; |
1243 |
|
|
uint8_t *dest_y, *dest_cb, *dest_cr; |
1244 |
|
11784 |
const int mb_xy = mb_x + mb_y * s->mb_stride; |
1245 |
|
11784 |
const int mb_type = s->cur_pic.mb_type[mb_xy]; |
1246 |
|
|
|
1247 |
|
|
// error = s->error_status_table[mb_xy]; |
1248 |
|
|
|
1249 |
✓✓✓✓
|
11784 |
if (IS_INTRA(mb_type) && s->partitioned_frame) |
1250 |
|
3855 |
continue; |
1251 |
|
|
// if (error & ER_MV_ERROR) |
1252 |
|
|
// continue; // inter data damaged FIXME is this good? |
1253 |
|
|
|
1254 |
|
7929 |
dest_y = s->cur_pic.f->data[0] + mb_x * 16 + mb_y * 16 * linesize[0]; |
1255 |
|
7929 |
dest_cb = s->cur_pic.f->data[1] + mb_x * 8 + mb_y * 8 * linesize[1]; |
1256 |
|
7929 |
dest_cr = s->cur_pic.f->data[2] + mb_x * 8 + mb_y * 8 * linesize[2]; |
1257 |
|
|
|
1258 |
|
7929 |
dc_ptr = &s->dc_val[0][mb_x * 2 + mb_y * 2 * s->b8_stride]; |
1259 |
✓✓ |
39645 |
for (n = 0; n < 4; n++) { |
1260 |
|
31716 |
dc = 0; |
1261 |
✓✓ |
285444 |
for (y = 0; y < 8; y++) { |
1262 |
|
|
int x; |
1263 |
✓✓ |
2283552 |
for (x = 0; x < 8; x++) |
1264 |
|
2029824 |
dc += dest_y[x + (n & 1) * 8 + |
1265 |
|
2029824 |
(y + (n >> 1) * 8) * linesize[0]]; |
1266 |
|
|
} |
1267 |
|
31716 |
dc_ptr[(n & 1) + (n >> 1) * s->b8_stride] = (dc + 4) >> 3; |
1268 |
|
|
} |
1269 |
|
|
|
1270 |
✗✓ |
7929 |
if (!s->cur_pic.f->data[2]) |
1271 |
|
|
continue; |
1272 |
|
|
|
1273 |
|
7929 |
dcu = dcv = 0; |
1274 |
✓✓ |
71361 |
for (y = 0; y < 8; y++) { |
1275 |
|
|
int x; |
1276 |
✓✓ |
570888 |
for (x = 0; x < 8; x++) { |
1277 |
|
507456 |
dcu += dest_cb[x + y * linesize[1]]; |
1278 |
|
507456 |
dcv += dest_cr[x + y * linesize[2]]; |
1279 |
|
|
} |
1280 |
|
|
} |
1281 |
|
7929 |
s->dc_val[1][mb_x + mb_y * s->mb_stride] = (dcu + 4) >> 3; |
1282 |
|
7929 |
s->dc_val[2][mb_x + mb_y * s->mb_stride] = (dcv + 4) >> 3; |
1283 |
|
|
} |
1284 |
|
|
} |
1285 |
|
|
#if 1 |
1286 |
|
|
/* guess DC for damaged blocks */ |
1287 |
|
30 |
guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1); |
1288 |
|
30 |
guess_dc(s, s->dc_val[1], s->mb_width , s->mb_height , s->mb_stride, 0); |
1289 |
|
30 |
guess_dc(s, s->dc_val[2], s->mb_width , s->mb_height , s->mb_stride, 0); |
1290 |
|
|
#endif |
1291 |
|
|
|
1292 |
|
|
/* filter luma DC */ |
1293 |
|
30 |
filter181(s->dc_val[0], s->mb_width * 2, s->mb_height * 2, s->b8_stride); |
1294 |
|
|
|
1295 |
|
|
#if 1 |
1296 |
|
|
/* render DC only intra */ |
1297 |
✓✓ |
567 |
for (mb_y = 0; mb_y < s->mb_height; mb_y++) { |
1298 |
✓✓ |
12321 |
for (mb_x = 0; mb_x < s->mb_width; mb_x++) { |
1299 |
|
|
uint8_t *dest_y, *dest_cb, *dest_cr; |
1300 |
|
11784 |
const int mb_xy = mb_x + mb_y * s->mb_stride; |
1301 |
|
11784 |
const int mb_type = s->cur_pic.mb_type[mb_xy]; |
1302 |
|
|
|
1303 |
|
11784 |
int error = s->error_status_table[mb_xy]; |
1304 |
|
|
|
1305 |
✓✓ |
11784 |
if (IS_INTER(mb_type)) |
1306 |
|
7629 |
continue; |
1307 |
✓✓ |
4155 |
if (!(error & ER_AC_ERROR)) |
1308 |
|
3900 |
continue; // undamaged |
1309 |
|
|
|
1310 |
|
255 |
dest_y = s->cur_pic.f->data[0] + mb_x * 16 + mb_y * 16 * linesize[0]; |
1311 |
|
255 |
dest_cb = s->cur_pic.f->data[1] + mb_x * 8 + mb_y * 8 * linesize[1]; |
1312 |
|
255 |
dest_cr = s->cur_pic.f->data[2] + mb_x * 8 + mb_y * 8 * linesize[2]; |
1313 |
✗✓ |
255 |
if (!s->cur_pic.f->data[2]) |
1314 |
|
|
dest_cb = dest_cr = NULL; |
1315 |
|
|
|
1316 |
|
255 |
put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y); |
1317 |
|
|
} |
1318 |
|
|
} |
1319 |
|
|
#endif |
1320 |
|
|
|
1321 |
✗✓ |
30 |
if (s->avctx->error_concealment & FF_EC_DEBLOCK) { |
1322 |
|
|
/* filter horizontal block boundaries */ |
1323 |
|
30 |
h_block_filter(s, s->cur_pic.f->data[0], s->mb_width * 2, |
1324 |
|
30 |
s->mb_height * 2, linesize[0], 1); |
1325 |
|
|
|
1326 |
|
|
/* filter vertical block boundaries */ |
1327 |
|
30 |
v_block_filter(s, s->cur_pic.f->data[0], s->mb_width * 2, |
1328 |
|
30 |
s->mb_height * 2, linesize[0], 1); |
1329 |
|
|
|
1330 |
✗✓ |
30 |
if (s->cur_pic.f->data[2]) { |
1331 |
|
30 |
h_block_filter(s, s->cur_pic.f->data[1], s->mb_width, |
1332 |
|
30 |
s->mb_height, linesize[1], 0); |
1333 |
|
30 |
h_block_filter(s, s->cur_pic.f->data[2], s->mb_width, |
1334 |
|
30 |
s->mb_height, linesize[2], 0); |
1335 |
|
30 |
v_block_filter(s, s->cur_pic.f->data[1], s->mb_width, |
1336 |
|
30 |
s->mb_height, linesize[1], 0); |
1337 |
|
30 |
v_block_filter(s, s->cur_pic.f->data[2], s->mb_width, |
1338 |
|
30 |
s->mb_height, linesize[2], 0); |
1339 |
|
|
} |
1340 |
|
|
} |
1341 |
|
|
|
1342 |
|
|
ec_clean: |
1343 |
|
|
/* clean a few tables */ |
1344 |
✓✓ |
11814 |
for (i = 0; i < s->mb_num; i++) { |
1345 |
|
11784 |
const int mb_xy = s->mb_index2xy[i]; |
1346 |
|
11784 |
int error = s->error_status_table[mb_xy]; |
1347 |
|
|
|
1348 |
✓✓✓✗
|
11784 |
if (s->mbskip_table && s->cur_pic.f->pict_type != AV_PICTURE_TYPE_B && |
1349 |
✓✓ |
11484 |
(error & (ER_DC_ERROR | ER_MV_ERROR | ER_AC_ERROR))) { |
1350 |
|
3182 |
s->mbskip_table[mb_xy] = 0; |
1351 |
|
|
} |
1352 |
✓✓ |
11784 |
if (s->mbintra_table) |
1353 |
|
11484 |
s->mbintra_table[mb_xy] = 1; |
1354 |
|
|
} |
1355 |
|
|
|
1356 |
✓✓ |
90 |
for (i = 0; i < 2; i++) { |
1357 |
|
60 |
av_buffer_unref(&s->ref_index_buf[i]); |
1358 |
|
60 |
av_buffer_unref(&s->motion_val_buf[i]); |
1359 |
|
60 |
s->cur_pic.ref_index[i] = NULL; |
1360 |
|
60 |
s->cur_pic.motion_val[i] = NULL; |
1361 |
|
|
} |
1362 |
|
|
|
1363 |
|
30 |
memset(&s->cur_pic, 0, sizeof(ERPicture)); |
1364 |
|
30 |
memset(&s->last_pic, 0, sizeof(ERPicture)); |
1365 |
|
30 |
memset(&s->next_pic, 0, sizeof(ERPicture)); |
1366 |
|
|
} |