Mercurial > libavcodec.hg
annotate error_resilience.c @ 12223:93e27a5401de libavcodec
Convert VP8 macroblock structures to a ring buffer.
Uses a slightly nonintuitive ring buffer size of (width+height*2) to simplify
addressing logic.
Also split out the segmentation map to a separate structure, necessary to
implement the ring buffer.
author | darkshikari |
---|---|
date | Thu, 22 Jul 2010 11:45:18 +0000 |
parents | 7dd2a45249a9 |
children |
rev | line source |
---|---|
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1 /* |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
2 * Error resilience / concealment |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
3 * |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1731
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
9 * modify it under the terms of the GNU Lesser General Public |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
10 * License as published by the Free Software Foundation; either |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
16 * Lesser General Public License for more details. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
17 * |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
21 */ |
2967 | 22 |
1106 | 23 /** |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11628
diff
changeset
|
24 * @file |
1106 | 25 * Error resilience / concealment. |
26 */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
27 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
28 #include <limits.h> |
2967 | 29 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
30 #include "avcodec.h" |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
31 #include "dsputil.h" |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
32 #include "mpegvideo.h" |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
33 #include "h264.h" |
11628 | 34 #include "rectangle.h" |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
35 |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
36 /* |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
37 * H264 redefines mb_intra so it is not mistakely used (its uninitialized in h264) |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
38 * but error concealment must support both h264 and h263 thus we must undo this |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
39 */ |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
40 #undef mb_intra |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
41 |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
42 static void decode_mb(MpegEncContext *s, int ref){ |
1389 | 43 s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* s->linesize ) + s->mb_x * 16; |
10609
f864e7927dff
4:2:2 4:4:4 bugfix for the error concealment code.
michael
parents:
10605
diff
changeset
|
44 s->dest[1] = s->current_picture.data[1] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift); |
f864e7927dff
4:2:2 4:4:4 bugfix for the error concealment code.
michael
parents:
10605
diff
changeset
|
45 s->dest[2] = s->current_picture.data[2] + (s->mb_y * (16>>s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16>>s->chroma_x_shift); |
1389 | 46 |
11514
2a8845a2687f
fix compilation with --disable-everything --enable-decoder=mpeg2video
aurel
parents:
11511
diff
changeset
|
47 if(CONFIG_H264_DECODER && s->codec_id == CODEC_ID_H264){ |
11502
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
48 H264Context *h= (void*)s; |
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
49 h->mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
50 memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache)); |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
51 assert(ref>=0); |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
52 if(ref >= h->ref_count[0]) //FIXME it is posible albeit uncommon that slice references differ between slices, we take the easy approuch and ignore it for now. If this turns out to have any relevance in practice then correct remapping should be added |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
53 ref=0; |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
54 fill_rectangle(&s->current_picture.ref_index[0][4*h->mb_xy], 2, 2, 2, ref, 1); |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
55 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); |
11502
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
56 fill_rectangle(h->mv_cache[0][ scan8[0] ], 4, 4, 8, pack16to32(s->mv[0][0][0],s->mv[0][0][1]), 4); |
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
57 assert(!FRAME_MBAFF); |
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
58 ff_h264_hl_decode_mb(h); |
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
59 }else{ |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
60 assert(ref==0); |
2967 | 61 MPV_decode_mb(s, s->block); |
11502
eb86fea1146b
Use H264s MC instead of mpeg4-asp qpel for h264 error resilience.
michael
parents:
11484
diff
changeset
|
62 } |
1389 | 63 } |
64 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
65 /** |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
66 * @param stride the number of MVs to get to the next row |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
67 * @param mv_step the number of MVs per row or column in a macroblock |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
68 */ |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
69 static void set_mv_strides(MpegEncContext *s, int *mv_step, int *stride){ |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
70 if(s->codec_id == CODEC_ID_H264){ |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
71 H264Context *h= (void*)s; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
72 assert(s->quarter_sample); |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
73 *mv_step= 4; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
74 *stride= h->b_stride; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
75 }else{ |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
76 *mv_step= 2; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
77 *stride= s->b8_stride; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
78 } |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
79 } |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
80 |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
81 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
82 * replaces the current MB with a flat dc only version. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
83 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
84 static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
85 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
86 int dc, dcu, dcv, y, i; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
87 for(i=0; i<4; i++){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
88 dc= s->dc_val[0][mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
89 if(dc<0) dc=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
90 else if(dc>2040) dc=2040; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
91 for(y=0; y<8; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
92 int x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
93 for(x=0; x<8; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
94 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
95 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
96 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
97 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
98 dcu = s->dc_val[1][mb_x + mb_y*s->mb_stride]; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
99 dcv = s->dc_val[2][mb_x + mb_y*s->mb_stride]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
100 if (dcu<0 ) dcu=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
101 else if(dcu>2040) dcu=2040; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
102 if (dcv<0 ) dcv=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
103 else if(dcv>2040) dcv=2040; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
104 for(y=0; y<8; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
105 int x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
106 for(x=0; x<8; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
107 dest_cb[x + y*(s->uvlinesize)]= dcu/8; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
108 dest_cr[x + y*(s->uvlinesize)]= dcv/8; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
109 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
110 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
111 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
112 |
3781 | 113 static void filter181(int16_t *data, int width, int height, int stride){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
114 int x,y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
115 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
116 /* horizontal filter */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
117 for(y=1; y<height-1; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
118 int prev_dc= data[0 + y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
119 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
120 for(x=1; x<width-1; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
121 int dc; |
2967 | 122 |
123 dc= - prev_dc | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
124 + data[x + y*stride]*8 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
125 - data[x + 1 + y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
126 dc= (dc*10923 + 32768)>>16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
127 prev_dc= data[x + y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
128 data[x + y*stride]= dc; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
129 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
130 } |
2967 | 131 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
132 /* vertical filter */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
133 for(x=1; x<width-1; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
134 int prev_dc= data[x]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
135 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
136 for(y=1; y<height-1; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
137 int dc; |
2967 | 138 |
139 dc= - prev_dc | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
140 + data[x + y *stride]*8 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
141 - data[x + (y+1)*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
142 dc= (dc*10923 + 32768)>>16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
143 prev_dc= data[x + y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
144 data[x + y*stride]= dc; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
145 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
146 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
147 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
148 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
149 /** |
5127 | 150 * guess the dc of blocks which do not have an undamaged dc |
2979 | 151 * @param w width in 8 pixel blocks |
152 * @param h height in 8 pixel blocks | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
153 */ |
3781 | 154 static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, int is_luma){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
155 int b_x, b_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
156 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
157 for(b_y=0; b_y<h; b_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
158 for(b_x=0; b_x<w; b_x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
159 int color[4]={1024,1024,1024,1024}; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
160 int distance[4]={9999,9999,9999,9999}; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
161 int mb_index, error, j; |
1064 | 162 int64_t guess, weight_sum; |
2967 | 163 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
164 mb_index= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
2967 | 165 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
166 error= s->error_status_table[mb_index]; |
2967 | 167 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
168 if(IS_INTER(s->current_picture.mb_type[mb_index])) continue; //inter |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
169 if(!(error&DC_ERROR)) continue; //dc-ok |
2967 | 170 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
171 /* right block */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
172 for(j=b_x+1; j<w; j++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
173 int mb_index_j= (j>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
174 int error_j= s->error_status_table[mb_index_j]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
175 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
176 if(intra_j==0 || !(error_j&DC_ERROR)){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
177 color[0]= dc[j + b_y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
178 distance[0]= j-b_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
179 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
180 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
181 } |
2967 | 182 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
183 /* left block */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
184 for(j=b_x-1; j>=0; j--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
185 int mb_index_j= (j>>is_luma) + (b_y>>is_luma)*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
186 int error_j= s->error_status_table[mb_index_j]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
187 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
188 if(intra_j==0 || !(error_j&DC_ERROR)){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
189 color[1]= dc[j + b_y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
190 distance[1]= b_x-j; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
191 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
192 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
193 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
194 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
195 /* bottom block */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
196 for(j=b_y+1; j<h; j++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
197 int mb_index_j= (b_x>>is_luma) + (j>>is_luma)*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
198 int error_j= s->error_status_table[mb_index_j]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
199 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
200 if(intra_j==0 || !(error_j&DC_ERROR)){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
201 color[2]= dc[b_x + j*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
202 distance[2]= j-b_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
203 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
204 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
205 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
206 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
207 /* top block */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
208 for(j=b_y-1; j>=0; j--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
209 int mb_index_j= (b_x>>is_luma) + (j>>is_luma)*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
210 int error_j= s->error_status_table[mb_index_j]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
211 int intra_j= IS_INTRA(s->current_picture.mb_type[mb_index_j]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
212 if(intra_j==0 || !(error_j&DC_ERROR)){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
213 color[3]= dc[b_x + j*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
214 distance[3]= b_y-j; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
215 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
216 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
217 } |
2967 | 218 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
219 weight_sum=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
220 guess=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
221 for(j=0; j<4; j++){ |
1064 | 222 int64_t weight= 256*256*256*16/distance[j]; |
223 guess+= weight*(int64_t)color[j]; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
224 weight_sum+= weight; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
225 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
226 guess= (guess + weight_sum/2) / weight_sum; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
227 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
228 dc[b_x + b_y*stride]= guess; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
229 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
230 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
231 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
232 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
233 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
234 * simple horizontal deblocking filter used for error resilience |
2979 | 235 * @param w width in 8 pixel blocks |
236 * @param h height in 8 pixel blocks | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
237 */ |
1064 | 238 static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){ |
11483
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
239 int b_x, b_y, mvx_stride, mvy_stride; |
4176 | 240 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
11483
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
241 set_mv_strides(s, &mvx_stride, &mvy_stride); |
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
242 mvx_stride >>= is_luma; |
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
243 mvy_stride *= mvx_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
244 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
245 for(b_y=0; b_y<h; b_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
246 for(b_x=0; b_x<w-1; b_x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
247 int y; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
248 int left_status = s->error_status_table[( b_x >>is_luma) + (b_y>>is_luma)*s->mb_stride]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
249 int right_status= s->error_status_table[((b_x+1)>>is_luma) + (b_y>>is_luma)*s->mb_stride]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
250 int left_intra= IS_INTRA(s->current_picture.mb_type [( b_x >>is_luma) + (b_y>>is_luma)*s->mb_stride]); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
251 int right_intra= IS_INTRA(s->current_picture.mb_type [((b_x+1)>>is_luma) + (b_y>>is_luma)*s->mb_stride]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
252 int left_damage = left_status&(DC_ERROR|AC_ERROR|MV_ERROR); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
253 int right_damage= right_status&(DC_ERROR|AC_ERROR|MV_ERROR); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
254 int offset= b_x*8 + b_y*stride*8; |
11483
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
255 int16_t *left_mv= s->current_picture.motion_val[0][mvy_stride*b_y + mvx_stride* b_x ]; |
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
256 int16_t *right_mv= s->current_picture.motion_val[0][mvy_stride*b_y + mvx_stride*(b_x+1)]; |
2967 | 257 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
258 if(!(left_damage||right_damage)) continue; // both undamaged |
2967 | 259 |
260 if( (!left_intra) && (!right_intra) | |
4001 | 261 && FFABS(left_mv[0]-right_mv[0]) + FFABS(left_mv[1]+right_mv[1]) < 2) continue; |
2967 | 262 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
263 for(y=0; y<8; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
264 int a,b,c,d; |
2967 | 265 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
266 a= dst[offset + 7 + y*stride] - dst[offset + 6 + y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
267 b= dst[offset + 8 + y*stride] - dst[offset + 7 + y*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
268 c= dst[offset + 9 + y*stride] - dst[offset + 8 + y*stride]; |
2967 | 269 |
4001 | 270 d= FFABS(b) - ((FFABS(a) + FFABS(c) + 1)>>1); |
847 | 271 d= FFMAX(d, 0); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
272 if(b<0) d= -d; |
2967 | 273 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
274 if(d==0) continue; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
275 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
276 if(!(left_damage && right_damage)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
277 d= d*16/9; |
2967 | 278 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
279 if(left_damage){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
280 dst[offset + 7 + y*stride] = cm[dst[offset + 7 + y*stride] + ((d*7)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
281 dst[offset + 6 + y*stride] = cm[dst[offset + 6 + y*stride] + ((d*5)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
282 dst[offset + 5 + y*stride] = cm[dst[offset + 5 + y*stride] + ((d*3)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
283 dst[offset + 4 + y*stride] = cm[dst[offset + 4 + y*stride] + ((d*1)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
284 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
285 if(right_damage){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
286 dst[offset + 8 + y*stride] = cm[dst[offset + 8 + y*stride] - ((d*7)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
287 dst[offset + 9 + y*stride] = cm[dst[offset + 9 + y*stride] - ((d*5)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
288 dst[offset + 10+ y*stride] = cm[dst[offset +10 + y*stride] - ((d*3)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
289 dst[offset + 11+ y*stride] = cm[dst[offset +11 + y*stride] - ((d*1)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
290 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
291 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
292 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
293 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
294 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
295 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
296 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
297 * simple vertical deblocking filter used for error resilience |
2979 | 298 * @param w width in 8 pixel blocks |
299 * @param h height in 8 pixel blocks | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
300 */ |
1064 | 301 static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){ |
11483
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
302 int b_x, b_y, mvx_stride, mvy_stride; |
4176 | 303 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
11483
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
304 set_mv_strides(s, &mvx_stride, &mvy_stride); |
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
305 mvx_stride >>= is_luma; |
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
306 mvy_stride *= mvx_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
307 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
308 for(b_y=0; b_y<h-1; b_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
309 for(b_x=0; b_x<w; b_x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
310 int x; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
311 int top_status = s->error_status_table[(b_x>>is_luma) + ( b_y >>is_luma)*s->mb_stride]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
312 int bottom_status= s->error_status_table[(b_x>>is_luma) + ((b_y+1)>>is_luma)*s->mb_stride]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
313 int top_intra= IS_INTRA(s->current_picture.mb_type [(b_x>>is_luma) + ( b_y >>is_luma)*s->mb_stride]); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
314 int bottom_intra= IS_INTRA(s->current_picture.mb_type [(b_x>>is_luma) + ((b_y+1)>>is_luma)*s->mb_stride]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
315 int top_damage = top_status&(DC_ERROR|AC_ERROR|MV_ERROR); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
316 int bottom_damage= bottom_status&(DC_ERROR|AC_ERROR|MV_ERROR); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
317 int offset= b_x*8 + b_y*stride*8; |
11483
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
318 int16_t *top_mv= s->current_picture.motion_val[0][mvy_stride* b_y + mvx_stride*b_x]; |
b16c5c5705df
Ensure that the deblock filter accesses the correct MVs for h264.
michael
parents:
11467
diff
changeset
|
319 int16_t *bottom_mv= s->current_picture.motion_val[0][mvy_stride*(b_y+1) + mvx_stride*b_x]; |
2967 | 320 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
321 if(!(top_damage||bottom_damage)) continue; // both undamaged |
2967 | 322 |
323 if( (!top_intra) && (!bottom_intra) | |
4001 | 324 && FFABS(top_mv[0]-bottom_mv[0]) + FFABS(top_mv[1]+bottom_mv[1]) < 2) continue; |
2967 | 325 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
326 for(x=0; x<8; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
327 int a,b,c,d; |
2967 | 328 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
329 a= dst[offset + x + 7*stride] - dst[offset + x + 6*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
330 b= dst[offset + x + 8*stride] - dst[offset + x + 7*stride]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
331 c= dst[offset + x + 9*stride] - dst[offset + x + 8*stride]; |
2967 | 332 |
4001 | 333 d= FFABS(b) - ((FFABS(a) + FFABS(c)+1)>>1); |
847 | 334 d= FFMAX(d, 0); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
335 if(b<0) d= -d; |
2967 | 336 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
337 if(d==0) continue; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
338 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
339 if(!(top_damage && bottom_damage)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
340 d= d*16/9; |
2967 | 341 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
342 if(top_damage){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
343 dst[offset + x + 7*stride] = cm[dst[offset + x + 7*stride] + ((d*7)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
344 dst[offset + x + 6*stride] = cm[dst[offset + x + 6*stride] + ((d*5)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
345 dst[offset + x + 5*stride] = cm[dst[offset + x + 5*stride] + ((d*3)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
346 dst[offset + x + 4*stride] = cm[dst[offset + x + 4*stride] + ((d*1)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
347 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
348 if(bottom_damage){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
349 dst[offset + x + 8*stride] = cm[dst[offset + x + 8*stride] - ((d*7)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
350 dst[offset + x + 9*stride] = cm[dst[offset + x + 9*stride] - ((d*5)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
351 dst[offset + x + 10*stride] = cm[dst[offset + x + 10*stride] - ((d*3)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
352 dst[offset + x + 11*stride] = cm[dst[offset + x + 11*stride] - ((d*1)>>4)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
353 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
354 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
355 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
356 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
357 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
358 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
359 static void guess_mv(MpegEncContext *s){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
360 uint8_t fixed[s->mb_stride * s->mb_height]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
361 #define MV_FROZEN 3 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
362 #define MV_CHANGED 2 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
363 #define MV_UNCHANGED 1 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
364 const int mb_stride = s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
365 const int mb_width = s->mb_width; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
366 const int mb_height= s->mb_height; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
367 int i, depth, num_avail; |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
368 int mb_x, mb_y, mot_step, mot_stride; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
369 |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
370 set_mv_strides(s, &mot_step, &mot_stride); |
2967 | 371 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
372 num_avail=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
373 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
374 const int mb_xy= s->mb_index2xy[ i ]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
375 int f=0; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
376 int error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
377 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
378 if(IS_INTRA(s->current_picture.mb_type[mb_xy])) f=MV_FROZEN; //intra //FIXME check |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
379 if(!(error&MV_ERROR)) f=MV_FROZEN; //inter with undamaged MV |
2967 | 380 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
381 fixed[mb_xy]= f; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
382 if(f==MV_FROZEN) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
383 num_avail++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
384 } |
2967 | 385 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
386 if((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) || num_avail <= mb_width/2){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
387 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
388 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
389 const int mb_xy= mb_x + mb_y*s->mb_stride; |
2967 | 390 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
391 if(IS_INTRA(s->current_picture.mb_type[mb_xy])) continue; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
392 if(!(s->error_status_table[mb_xy]&MV_ERROR)) continue; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
393 |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
394 s->mv_dir = s->last_picture.data[0] ? MV_DIR_FORWARD : MV_DIR_BACKWARD; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
395 s->mb_intra=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
396 s->mv_type = MV_TYPE_16X16; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2570
diff
changeset
|
397 s->mb_skipped=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
398 |
2979 | 399 s->dsp.clear_blocks(s->block[0]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
400 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
401 s->mb_x= mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
402 s->mb_y= mb_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
403 s->mv[0][0][0]= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
404 s->mv[0][0][1]= 0; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
405 decode_mb(s, 0); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
406 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
407 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
408 return; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
409 } |
2967 | 410 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
411 for(depth=0;; depth++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
412 int changed, pass, none_left; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
413 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
414 none_left=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
415 changed=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
416 for(pass=0; (changed || pass<2) && pass<10; pass++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
417 int mb_x, mb_y; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
418 int score_sum=0; |
2967 | 419 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
420 changed=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
421 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
422 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
423 const int mb_xy= mb_x + mb_y*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
424 int mv_predictor[8][2]={{0}}; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
425 int ref[8]={0}; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
426 int pred_count=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
427 int j; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
428 int best_score=256*256*256*64; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
429 int best_pred=0; |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
430 const int mot_index= (mb_x + mb_y*mot_stride) * mot_step; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
431 int prev_x= s->current_picture.motion_val[0][mot_index][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
432 int prev_y= s->current_picture.motion_val[0][mot_index][1]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
433 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
434 if((mb_x^mb_y^pass)&1) continue; |
2967 | 435 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
436 if(fixed[mb_xy]==MV_FROZEN) continue; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
437 assert(!IS_INTRA(s->current_picture.mb_type[mb_xy])); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
438 assert(s->last_picture_ptr && s->last_picture_ptr->data[0]); |
2967 | 439 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
440 j=0; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
441 if(mb_x>0 && fixed[mb_xy-1 ]==MV_FROZEN) j=1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
442 if(mb_x+1<mb_width && fixed[mb_xy+1 ]==MV_FROZEN) j=1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
443 if(mb_y>0 && fixed[mb_xy-mb_stride]==MV_FROZEN) j=1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
444 if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_FROZEN) j=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
445 if(j==0) continue; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
446 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
447 j=0; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
448 if(mb_x>0 && fixed[mb_xy-1 ]==MV_CHANGED) j=1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
449 if(mb_x+1<mb_width && fixed[mb_xy+1 ]==MV_CHANGED) j=1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
450 if(mb_y>0 && fixed[mb_xy-mb_stride]==MV_CHANGED) j=1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
451 if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]==MV_CHANGED) j=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
452 if(j==0 && pass>1) continue; |
2967 | 453 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
454 none_left=0; |
2967 | 455 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
456 if(mb_x>0 && fixed[mb_xy-1]){ |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
457 mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index - mot_step][0]; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
458 mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index - mot_step][1]; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
459 ref [pred_count] = s->current_picture.ref_index[0][4*(mb_xy-1)]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
460 pred_count++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
461 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
462 if(mb_x+1<mb_width && fixed[mb_xy+1]){ |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
463 mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index + mot_step][0]; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
464 mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index + mot_step][1]; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
465 ref [pred_count] = s->current_picture.ref_index[0][4*(mb_xy+1)]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
466 pred_count++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
467 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
468 if(mb_y>0 && fixed[mb_xy-mb_stride]){ |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
469 mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index - mot_stride*mot_step][0]; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
470 mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index - mot_stride*mot_step][1]; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
471 ref [pred_count] = s->current_picture.ref_index[0][4*(mb_xy-s->mb_stride)]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
472 pred_count++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
473 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
474 if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){ |
11467
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
475 mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index + mot_stride*mot_step][0]; |
c9f240e43ef9
Fix guess_mv() so that it works correctly with 4x4 MV blocks.
michael
parents:
11292
diff
changeset
|
476 mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index + mot_stride*mot_step][1]; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
477 ref [pred_count] = s->current_picture.ref_index[0][4*(mb_xy+s->mb_stride)]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
478 pred_count++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
479 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
480 if(pred_count==0) continue; |
2967 | 481 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
482 if(pred_count>1){ |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
483 int sum_x=0, sum_y=0, sum_r=0; |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
484 int max_x, max_y, min_x, min_y, max_r, min_r; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
485 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
486 for(j=0; j<pred_count; j++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
487 sum_x+= mv_predictor[j][0]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
488 sum_y+= mv_predictor[j][1]; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
489 sum_r+= ref[j]; |
11531
31033caa5344
Change ref_index structure so it matches how its organized in h264.
michael
parents:
11514
diff
changeset
|
490 if(j && ref[j] != ref[j-1]) |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
491 goto skip_mean_and_median; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
492 } |
2967 | 493 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
494 /* mean */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
495 mv_predictor[pred_count][0] = sum_x/j; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
496 mv_predictor[pred_count][1] = sum_y/j; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
497 ref [pred_count] = sum_r/j; |
2967 | 498 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
499 /* median */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
500 if(pred_count>=3){ |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
501 min_y= min_x= min_r= 99999; |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
502 max_y= max_x= max_r=-99999; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
503 }else{ |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
504 min_x=min_y=max_x=max_y=min_r=max_r=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
505 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
506 for(j=0; j<pred_count; j++){ |
847 | 507 max_x= FFMAX(max_x, mv_predictor[j][0]); |
508 max_y= FFMAX(max_y, mv_predictor[j][1]); | |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
509 max_r= FFMAX(max_r, ref[j]); |
847 | 510 min_x= FFMIN(min_x, mv_predictor[j][0]); |
511 min_y= FFMIN(min_y, mv_predictor[j][1]); | |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
512 min_r= FFMIN(min_r, ref[j]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
513 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
514 mv_predictor[pred_count+1][0] = sum_x - max_x - min_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
515 mv_predictor[pred_count+1][1] = sum_y - max_y - min_y; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
516 ref [pred_count+1] = sum_r - max_r - min_r; |
2967 | 517 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
518 if(pred_count==4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
519 mv_predictor[pred_count+1][0] /= 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
520 mv_predictor[pred_count+1][1] /= 2; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
521 ref [pred_count+1] /= 2; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
522 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
523 pred_count+=2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
524 } |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
525 skip_mean_and_median: |
2967 | 526 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
527 /* zero MV */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
528 pred_count++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
529 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
530 /* last MV */ |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
531 mv_predictor[pred_count][0]= s->current_picture.motion_val[0][mot_index][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
532 mv_predictor[pred_count][1]= s->current_picture.motion_val[0][mot_index][1]; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
533 ref [pred_count] = s->current_picture.ref_index[0][4*mb_xy]; |
2967 | 534 pred_count++; |
535 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
536 s->mv_dir = MV_DIR_FORWARD; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
537 s->mb_intra=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
538 s->mv_type = MV_TYPE_16X16; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2570
diff
changeset
|
539 s->mb_skipped=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
540 |
2979 | 541 s->dsp.clear_blocks(s->block[0]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
542 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
543 s->mb_x= mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
544 s->mb_y= mb_y; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
545 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
546 for(j=0; j<pred_count; j++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
547 int score=0; |
1064 | 548 uint8_t *src= s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
549 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
550 s->current_picture.motion_val[0][mot_index][0]= s->mv[0][0][0]= mv_predictor[j][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
551 s->current_picture.motion_val[0][mot_index][1]= s->mv[0][0][1]= mv_predictor[j][1]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
552 |
11531
31033caa5344
Change ref_index structure so it matches how its organized in h264.
michael
parents:
11514
diff
changeset
|
553 if(ref[j]<0) //predictor intra or otherwise not available |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
554 continue; |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
555 |
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
556 decode_mb(s, ref[j]); |
2967 | 557 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
558 if(mb_x>0 && fixed[mb_xy-1]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
559 int k; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
560 for(k=0; k<16; k++) |
4001 | 561 score += FFABS(src[k*s->linesize-1 ]-src[k*s->linesize ]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
562 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
563 if(mb_x+1<mb_width && fixed[mb_xy+1]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
564 int k; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
565 for(k=0; k<16; k++) |
4001 | 566 score += FFABS(src[k*s->linesize+15]-src[k*s->linesize+16]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
567 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
568 if(mb_y>0 && fixed[mb_xy-mb_stride]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
569 int k; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
570 for(k=0; k<16; k++) |
4001 | 571 score += FFABS(src[k-s->linesize ]-src[k ]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
572 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
573 if(mb_y+1<mb_height && fixed[mb_xy+mb_stride]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
574 int k; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
575 for(k=0; k<16; k++) |
4001 | 576 score += FFABS(src[k+s->linesize*15]-src[k+s->linesize*16]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
577 } |
2967 | 578 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
579 if(score <= best_score){ // <= will favor the last MV |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
580 best_score= score; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
581 best_pred= j; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
582 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
583 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
584 score_sum+= best_score; |
11484
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
585 s->mv[0][0][0]= mv_predictor[best_pred][0]; |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
586 s->mv[0][0][1]= mv_predictor[best_pred][1]; |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
587 |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
588 for(i=0; i<mot_step; i++) |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
589 for(j=0; j<mot_step; j++){ |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
590 s->current_picture.motion_val[0][mot_index+i+j*mot_stride][0]= s->mv[0][0][0]; |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
591 s->current_picture.motion_val[0][mot_index+i+j*mot_stride][1]= s->mv[0][0][1]; |
5330f17dc769
Make sure all mvs of a mb are set in the error concealment code.
michael
parents:
11483
diff
changeset
|
592 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
593 |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
594 decode_mb(s, ref[best_pred]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
595 |
2967 | 596 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
597 if(s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
598 fixed[mb_xy]=MV_CHANGED; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
599 changed++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
600 }else |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
601 fixed[mb_xy]=MV_UNCHANGED; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
602 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
603 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
604 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
605 // printf(".%d/%d", changed, score_sum); fflush(stdout); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
606 } |
2967 | 607 |
608 if(none_left) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
609 return; |
2967 | 610 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
611 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
612 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
613 if(fixed[mb_xy]) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
614 fixed[mb_xy]=MV_FROZEN; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
615 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
616 // printf(":"); fflush(stdout); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
617 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
618 } |
2967 | 619 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
620 static int is_intra_more_likely(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
621 int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y; |
2967 | 622 |
7924 | 623 if(!s->last_picture_ptr || !s->last_picture_ptr->data[0]) return 1; //no previous frame available -> use spatial prediction |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
624 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
625 undamaged_count=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
626 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
627 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
628 const int error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
629 if(!((error&DC_ERROR) && (error&MV_ERROR))) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
630 undamaged_count++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
631 } |
2967 | 632 |
11557
53822d92c3f7
Make sure the EC code does not attempt to use inter based concealment if there
michael
parents:
11531
diff
changeset
|
633 if(s->codec_id == CODEC_ID_H264){ |
53822d92c3f7
Make sure the EC code does not attempt to use inter based concealment if there
michael
parents:
11531
diff
changeset
|
634 H264Context *h= (void*)s; |
53822d92c3f7
Make sure the EC code does not attempt to use inter based concealment if there
michael
parents:
11531
diff
changeset
|
635 if(h->ref_count[0] <= 0 || !h->ref_list[0][0].data[0]) |
53822d92c3f7
Make sure the EC code does not attempt to use inter based concealment if there
michael
parents:
11531
diff
changeset
|
636 return 1; |
53822d92c3f7
Make sure the EC code does not attempt to use inter based concealment if there
michael
parents:
11531
diff
changeset
|
637 } |
53822d92c3f7
Make sure the EC code does not attempt to use inter based concealment if there
michael
parents:
11531
diff
changeset
|
638 |
6525 | 639 if(undamaged_count < 5) return 0; //almost all MBs damaged -> use temporal prediction |
2967 | 640 |
5730
4134f79e37b3
On bitstream error is_intra_more_likely() could use dsp.sad[0]() that will segfault when xvmc is in use.
iive
parents:
5127
diff
changeset
|
641 //prevent dsp.sad() check, that requires access to the image |
8948
886ef38c7b36
Get rid of some '#if CONFIG_MPEG_XVMC_DECODER' preprocessor checks around if
diego
parents:
8832
diff
changeset
|
642 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration && s->pict_type == FF_I_TYPE) |
886ef38c7b36
Get rid of some '#if CONFIG_MPEG_XVMC_DECODER' preprocessor checks around if
diego
parents:
8832
diff
changeset
|
643 return 1; |
5730
4134f79e37b3
On bitstream error is_intra_more_likely() could use dsp.sad[0]() that will segfault when xvmc is in use.
iive
parents:
5127
diff
changeset
|
644 |
2967 | 645 skip_amount= FFMAX(undamaged_count/50, 1); //check only upto 50 MBs |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
646 is_intra_likely=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
647 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
648 j=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
649 for(mb_y= 0; mb_y<s->mb_height-1; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
650 for(mb_x= 0; mb_x<s->mb_width; mb_x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
651 int error; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
652 const int mb_xy= mb_x + mb_y*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
653 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
654 error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
655 if((error&DC_ERROR) && (error&MV_ERROR)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
656 continue; //skip damaged |
2967 | 657 |
658 j++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
659 if((j%skip_amount) != 0) continue; //skip a few to speed things up |
2967 | 660 |
6481 | 661 if(s->pict_type==FF_I_TYPE){ |
1064 | 662 uint8_t *mb_ptr = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize; |
663 uint8_t *last_mb_ptr= s->last_picture.data [0] + mb_x*16 + mb_y*16*s->linesize; | |
2967 | 664 |
2979 | 665 is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr , s->linesize, 16); |
1708 | 666 is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
667 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
668 if(IS_INTRA(s->current_picture.mb_type[mb_xy])) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
669 is_intra_likely++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
670 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
671 is_intra_likely--; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
672 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
673 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
674 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
675 //printf("is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type); |
2967 | 676 return is_intra_likely > 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
677 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
678 |
1144 | 679 void ff_er_frame_start(MpegEncContext *s){ |
7831 | 680 if(!s->error_recognition) return; |
1144 | 681 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
682 memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_stride*s->mb_height*sizeof(uint8_t)); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
683 s->error_count= 3*s->mb_num; |
1144 | 684 } |
685 | |
686 /** | |
687 * adds a slice. | |
688 * @param endx x component of the last macroblock, can be -1 for the last of the previous line | |
689 * @param status the status at the end (MV_END, AC_ERROR, ...), it is assumed that no earlier end or | |
6524 | 690 * error of the same type occurred |
1144 | 691 */ |
692 void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status){ | |
4594 | 693 const int start_i= av_clip(startx + starty * s->mb_width , 0, s->mb_num-1); |
694 const int end_i = av_clip(endx + endy * s->mb_width , 0, s->mb_num); | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
695 const int start_xy= s->mb_index2xy[start_i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
696 const int end_xy = s->mb_index2xy[end_i]; |
1144 | 697 int mask= -1; |
2967 | 698 |
9062 | 699 if(s->avctx->hwaccel) |
700 return; | |
701 | |
4503 | 702 if(start_i > end_i || start_xy > end_xy){ |
703 av_log(s->avctx, AV_LOG_ERROR, "internal error, slice end before start\n"); | |
704 return; | |
705 } | |
706 | |
7831 | 707 if(!s->error_recognition) return; |
1144 | 708 |
709 mask &= ~VP_START; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
710 if(status & (AC_ERROR|AC_END)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
711 mask &= ~(AC_ERROR|AC_END); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
712 s->error_count -= end_i - start_i + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
713 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
714 if(status & (DC_ERROR|DC_END)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
715 mask &= ~(DC_ERROR|DC_END); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
716 s->error_count -= end_i - start_i + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
717 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
718 if(status & (MV_ERROR|MV_END)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
719 mask &= ~(MV_ERROR|MV_END); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
720 s->error_count -= end_i - start_i + 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
721 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
722 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
723 if(status & (AC_ERROR|DC_ERROR|MV_ERROR)) s->error_count= INT_MAX; |
1144 | 724 |
725 if(mask == ~0x7F){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
726 memset(&s->error_status_table[start_xy], 0, (end_xy - start_xy) * sizeof(uint8_t)); |
1144 | 727 }else{ |
728 int i; | |
729 for(i=start_xy; i<end_xy; i++){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
730 s->error_status_table[ i ] &= mask; |
1144 | 731 } |
732 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
733 |
2967 | 734 if(end_i == s->mb_num) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
735 s->error_count= INT_MAX; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
736 else{ |
1144 | 737 s->error_status_table[end_xy] &= mask; |
738 s->error_status_table[end_xy] |= status; | |
739 } | |
2967 | 740 |
1175
d2fd27d01df8
fixing slice decoding, dunno why the regression tests didnt catch that ...
michaelni
parents:
1144
diff
changeset
|
741 s->error_status_table[start_xy] |= VP_START; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
742 |
2095 | 743 if(start_xy > 0 && s->avctx->thread_count <= 1 && s->avctx->skip_top*s->mb_width < start_i){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
744 int prev_status= s->error_status_table[ s->mb_index2xy[start_i - 1] ]; |
2967 | 745 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
746 prev_status &= ~ VP_START; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
747 if(prev_status != (MV_END|DC_END|AC_END)) s->error_count= INT_MAX; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
748 } |
1144 | 749 } |
750 | |
751 void ff_er_frame_end(MpegEncContext *s){ | |
2444 | 752 int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
753 int distance; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
754 int threshold_part[4]= {100,100,100}; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
755 int threshold= 50; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
756 int is_intra_likely; |
2357 | 757 int size = s->b8_stride * 2 * s->mb_height; |
758 Picture *pic= s->current_picture_ptr; | |
2967 | 759 |
7940
8dc81763fb42
Do not attempt to perform error concealment in lowres mode as this is
michael
parents:
7924
diff
changeset
|
760 if(!s->error_recognition || s->error_count==0 || s->avctx->lowres || |
9012
15a3df8c01fd
More approved hunks for VAAPI & our new and cleaner hwaccel API.
michael
parents:
8948
diff
changeset
|
761 s->avctx->hwaccel || |
8557
24c5744c3e96
Move VDPAU check, make future VDPAU patches smaller.
cehoyos
parents:
8342
diff
changeset
|
762 s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU || |
10605
2c2827f792a1
Disable error resilience for field pictures, this was never supported,
michael
parents:
9381
diff
changeset
|
763 s->picture_structure != PICT_FRAME || // we dont support ER of field pictures yet, though it should not crash if enabled |
2095 | 764 s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return; |
1144 | 765 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
766 if(s->current_picture.motion_val[0] == NULL){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1417
diff
changeset
|
767 av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n"); |
2967 | 768 |
1731 | 769 for(i=0; i<2; i++){ |
11292
411ab09ada91
Get rid of mb2b8_xy and b8_stride, change arrays organized based on b8_stride to
michael
parents:
10609
diff
changeset
|
770 pic->ref_index[i]= av_mallocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t)); |
2570 | 771 pic->motion_val_base[i]= av_mallocz((size+4) * 2 * sizeof(uint16_t)); |
772 pic->motion_val[i]= pic->motion_val_base[i]+4; | |
1731 | 773 } |
774 pic->motion_subsample_log2= 3; | |
775 s->current_picture= *s->current_picture_ptr; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
776 } |
2967 | 777 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
778 if(s->avctx->debug&FF_DEBUG_ER){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
779 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
780 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
781 int status= s->error_status_table[mb_x + mb_y*s->mb_stride]; |
2967 | 782 |
783 av_log(s->avctx, AV_LOG_DEBUG, "%2X ", status); | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
784 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1417
diff
changeset
|
785 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1144 | 786 } |
787 } | |
2967 | 788 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
789 #if 1 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
790 /* handle overlapping slices */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
791 for(error_type=1; error_type<=3; error_type++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
792 int end_ok=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
793 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
794 for(i=s->mb_num-1; i>=0; i--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
795 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
796 int error= s->error_status_table[mb_xy]; |
2967 | 797 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
798 if(error&(1<<error_type)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
799 end_ok=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
800 if(error&(8<<error_type)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
801 end_ok=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
802 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
803 if(!end_ok) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
804 s->error_status_table[mb_xy]|= 1<<error_type; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
805 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
806 if(error&VP_START) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
807 end_ok=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
808 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
809 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
810 #endif |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
811 #if 1 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
812 /* handle slices with partitions of different length */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
813 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
814 int end_ok=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
815 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
816 for(i=s->mb_num-1; i>=0; i--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
817 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
818 int error= s->error_status_table[mb_xy]; |
2967 | 819 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
820 if(error&AC_END) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
821 end_ok=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
822 if((error&MV_END) || (error&DC_END) || (error&AC_ERROR)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
823 end_ok=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
824 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
825 if(!end_ok) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
826 s->error_status_table[mb_xy]|= AC_ERROR; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
827 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
828 if(error&VP_START) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
829 end_ok=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
830 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
831 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
832 #endif |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
833 /* handle missing slices */ |
7831 | 834 if(s->error_recognition>=4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
835 int end_ok=1; |
2967 | 836 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
837 for(i=s->mb_num-2; i>=s->mb_width+100; i--){ //FIXME +100 hack |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
838 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
839 int error1= s->error_status_table[mb_xy ]; |
1285 | 840 int error2= s->error_status_table[s->mb_index2xy[i+1]]; |
2967 | 841 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
842 if(error1&VP_START) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
843 end_ok=1; |
2967 | 844 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
845 if( error2==(VP_START|DC_ERROR|AC_ERROR|MV_ERROR|AC_END|DC_END|MV_END) |
2967 | 846 && error1!=(VP_START|DC_ERROR|AC_ERROR|MV_ERROR|AC_END|DC_END|MV_END) |
6350 | 847 && ((error1&AC_END) || (error1&DC_END) || (error1&MV_END))){ //end & uninit |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
848 end_ok=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
849 } |
2967 | 850 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
851 if(!end_ok) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
852 s->error_status_table[mb_xy]|= DC_ERROR|AC_ERROR|MV_ERROR; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
853 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
854 } |
2967 | 855 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
856 #if 1 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
857 /* backward mark errors */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
858 distance=9999999; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
859 for(error_type=1; error_type<=3; error_type++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
860 for(i=s->mb_num-1; i>=0; i--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
861 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
862 int error= s->error_status_table[mb_xy]; |
2967 | 863 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
864 if(!s->mbskip_table[mb_xy]) //FIXME partition specific |
2967 | 865 distance++; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
866 if(error&(1<<error_type)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
867 distance= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
868 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
869 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
870 if(distance < threshold_part[error_type-1]) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
871 s->error_status_table[mb_xy]|= 1<<error_type; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
872 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
873 if(distance < threshold) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
874 s->error_status_table[mb_xy]|= 1<<error_type; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
875 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
876 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
877 if(error&VP_START) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
878 distance= 9999999; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
879 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
880 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
881 #endif |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
882 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
883 /* forward mark errors */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
884 error=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
885 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
886 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
887 int old_error= s->error_status_table[mb_xy]; |
2967 | 888 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
889 if(old_error&VP_START) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
890 error= old_error& (DC_ERROR|AC_ERROR|MV_ERROR); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
891 else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
892 error|= old_error& (DC_ERROR|AC_ERROR|MV_ERROR); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
893 s->error_status_table[mb_xy]|= error; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
894 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
895 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
896 #if 1 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
897 /* handle not partitioned case */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
898 if(!s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
899 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
900 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
901 error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
902 if(error&(AC_ERROR|DC_ERROR|MV_ERROR)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
903 error|= AC_ERROR|DC_ERROR|MV_ERROR; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
904 s->error_status_table[mb_xy]= error; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
905 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
906 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
907 #endif |
2444 | 908 |
909 dc_error= ac_error= mv_error=0; | |
910 for(i=0; i<s->mb_num; i++){ | |
911 const int mb_xy= s->mb_index2xy[i]; | |
912 error= s->error_status_table[mb_xy]; | |
913 if(error&DC_ERROR) dc_error ++; | |
914 if(error&AC_ERROR) ac_error ++; | |
915 if(error&MV_ERROR) mv_error ++; | |
916 } | |
917 av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\n", dc_error, ac_error, mv_error); | |
918 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
919 is_intra_likely= is_intra_more_likely(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
920 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
921 /* set unknown mb-type to most likely */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
922 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
923 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
924 error= s->error_status_table[mb_xy]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
925 if(!((error&DC_ERROR) && (error&MV_ERROR))) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
926 continue; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
927 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
928 if(is_intra_likely) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
929 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA4x4; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
930 else |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
931 s->current_picture.mb_type[mb_xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
932 } |
2967 | 933 |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
934 // change inter to intra blocks if no reference frames are available |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
935 if (!s->last_picture.data[0] && !s->next_picture.data[0]) |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
936 for(i=0; i<s->mb_num; i++){ |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
937 const int mb_xy= s->mb_index2xy[i]; |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
938 if(!IS_INTRA(s->current_picture.mb_type[mb_xy])) |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
939 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA4x4; |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
940 } |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
941 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
942 /* handle inter blocks with damaged AC */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
943 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
944 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
945 const int mb_xy= mb_x + mb_y * s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
946 const int mb_type= s->current_picture.mb_type[mb_xy]; |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
947 int dir = !s->last_picture.data[0]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
948 error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
949 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
950 if(IS_INTRA(mb_type)) continue; //intra |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
951 if(error&MV_ERROR) continue; //inter with damaged MV |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
952 if(!(error&AC_ERROR)) continue; //undamaged inter |
2967 | 953 |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
954 s->mv_dir = dir ? MV_DIR_BACKWARD : MV_DIR_FORWARD; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
955 s->mb_intra=0; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2570
diff
changeset
|
956 s->mb_skipped=0; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
957 if(IS_8X8(mb_type)){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
958 int mb_index= mb_x*2 + mb_y*2*s->b8_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
959 int j; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
960 s->mv_type = MV_TYPE_8X8; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
961 for(j=0; j<4; j++){ |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
962 s->mv[0][j][0] = s->current_picture.motion_val[dir][ mb_index + (j&1) + (j>>1)*s->b8_stride ][0]; |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
963 s->mv[0][j][1] = s->current_picture.motion_val[dir][ mb_index + (j&1) + (j>>1)*s->b8_stride ][1]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
964 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
965 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
966 s->mv_type = MV_TYPE_16X16; |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
967 s->mv[0][0][0] = s->current_picture.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][0]; |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
968 s->mv[0][0][1] = s->current_picture.motion_val[dir][ mb_x*2 + mb_y*2*s->b8_stride ][1]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
969 } |
2967 | 970 |
2979 | 971 s->dsp.clear_blocks(s->block[0]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
972 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
973 s->mb_x= mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
974 s->mb_y= mb_y; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
975 decode_mb(s, 0/*FIXME h264 partitioned slices need this set*/); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
976 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
977 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
978 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
979 /* guess MVs */ |
6481 | 980 if(s->pict_type==FF_B_TYPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
981 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
982 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
983 int xy= mb_x*2 + mb_y*2*s->b8_stride; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
984 const int mb_xy= mb_x + mb_y * s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
985 const int mb_type= s->current_picture.mb_type[mb_xy]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
986 error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
987 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
988 if(IS_INTRA(mb_type)) continue; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
989 if(!(error&MV_ERROR)) continue; //inter with undamaged MV |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
990 if(!(error&AC_ERROR)) continue; //undamaged inter |
2967 | 991 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
992 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD; |
9381
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
993 if(!s->last_picture.data[0]) s->mv_dir &= ~MV_DIR_FORWARD; |
7dfbd59b04e5
Make sure error resilience does not try to use unavailable reference frames.
reimar
parents:
9062
diff
changeset
|
994 if(!s->next_picture.data[0]) s->mv_dir &= ~MV_DIR_BACKWARD; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
995 s->mb_intra=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
996 s->mv_type = MV_TYPE_16X16; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2570
diff
changeset
|
997 s->mb_skipped=0; |
2967 | 998 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
999 if(s->pp_time){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1000 int time_pp= s->pp_time; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1001 int time_pb= s->pb_time; |
2967 | 1002 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
1003 s->mv[0][0][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
1004 s->mv[0][0][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
1005 s->mv[1][0][0] = s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1598
diff
changeset
|
1006 s->mv[1][0][1] = s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1007 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1008 s->mv[0][0][0]= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1009 s->mv[0][0][1]= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1010 s->mv[1][0][0]= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1011 s->mv[1][0][1]= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1012 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
1013 |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
1014 s->dsp.clear_blocks(s->block[0]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1015 s->mb_x= mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1016 s->mb_y= mb_y; |
11510
927b985f73f4
Error concealment of h264 with multiple references.
michael
parents:
11502
diff
changeset
|
1017 decode_mb(s, 0); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1018 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1019 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1020 }else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1021 guess_mv(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1022 |
1381 | 1023 /* the filters below are not XvMC compatible, skip them */ |
8948
886ef38c7b36
Get rid of some '#if CONFIG_MPEG_XVMC_DECODER' preprocessor checks around if
diego
parents:
8832
diff
changeset
|
1024 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) |
886ef38c7b36
Get rid of some '#if CONFIG_MPEG_XVMC_DECODER' preprocessor checks around if
diego
parents:
8832
diff
changeset
|
1025 goto ec_clean; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1026 /* fill DC for inter blocks */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1027 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1028 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1029 int dc, dcu, dcv, y, n; |
3781 | 1030 int16_t *dc_ptr; |
1064 | 1031 uint8_t *dest_y, *dest_cb, *dest_cr; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1032 const int mb_xy= mb_x + mb_y * s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1033 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 1034 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1035 error= s->error_status_table[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1036 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1037 if(IS_INTRA(mb_type) && s->partitioned_frame) continue; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1038 // if(error&MV_ERROR) continue; //inter data damaged FIXME is this good? |
2967 | 1039 |
903 | 1040 dest_y = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize; |
1041 dest_cb= s->current_picture.data[1] + mb_x*8 + mb_y*8 *s->uvlinesize; | |
1042 dest_cr= s->current_picture.data[2] + mb_x*8 + mb_y*8 *s->uvlinesize; | |
2967 | 1043 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1044 dc_ptr= &s->dc_val[0][mb_x*2 + mb_y*2*s->b8_stride]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1045 for(n=0; n<4; n++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1046 dc=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1047 for(y=0; y<8; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1048 int x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1049 for(x=0; x<8; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1050 dc+= dest_y[x + (n&1)*8 + (y + (n>>1)*8)*s->linesize]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1051 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1052 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1053 dc_ptr[(n&1) + (n>>1)*s->b8_stride]= (dc+4)>>3; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1054 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1055 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1056 dcu=dcv=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1057 for(y=0; y<8; y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1058 int x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1059 for(x=0; x<8; x++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1060 dcu+=dest_cb[x + y*(s->uvlinesize)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1061 dcv+=dest_cr[x + y*(s->uvlinesize)]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1062 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1063 } |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1064 s->dc_val[1][mb_x + mb_y*s->mb_stride]= (dcu+4)>>3; |
2967 | 1065 s->dc_val[2][mb_x + mb_y*s->mb_stride]= (dcv+4)>>3; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1066 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1067 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1068 #if 1 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1069 /* guess DC for damaged blocks */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1070 guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1071 guess_dc(s, s->dc_val[1], s->mb_width , s->mb_height , s->mb_stride, 0); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1072 guess_dc(s, s->dc_val[2], s->mb_width , s->mb_height , s->mb_stride, 0); |
2967 | 1073 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1074 /* filter luma DC */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1827
diff
changeset
|
1075 filter181(s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride); |
2967 | 1076 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1077 #if 1 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1078 /* render DC only intra */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1079 for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1080 for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
1064 | 1081 uint8_t *dest_y, *dest_cb, *dest_cr; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1082 const int mb_xy= mb_x + mb_y * s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1083 const int mb_type= s->current_picture.mb_type[mb_xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1084 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1085 error= s->error_status_table[mb_xy]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1086 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1087 if(IS_INTER(mb_type)) continue; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1088 if(!(error&AC_ERROR)) continue; //undamaged |
2967 | 1089 |
903 | 1090 dest_y = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize; |
1091 dest_cb= s->current_picture.data[1] + mb_x*8 + mb_y*8 *s->uvlinesize; | |
1092 dest_cr= s->current_picture.data[2] + mb_x*8 + mb_y*8 *s->uvlinesize; | |
2967 | 1093 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1094 put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1095 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1096 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1097 #endif |
2967 | 1098 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1099 if(s->avctx->error_concealment&FF_EC_DEBLOCK){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1100 /* filter horizontal block boundaries */ |
903 | 1101 h_block_filter(s, s->current_picture.data[0], s->mb_width*2, s->mb_height*2, s->linesize , 1); |
1102 h_block_filter(s, s->current_picture.data[1], s->mb_width , s->mb_height , s->uvlinesize, 0); | |
1103 h_block_filter(s, s->current_picture.data[2], s->mb_width , s->mb_height , s->uvlinesize, 0); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1104 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1105 /* filter vertical block boundaries */ |
903 | 1106 v_block_filter(s, s->current_picture.data[0], s->mb_width*2, s->mb_height*2, s->linesize , 1); |
1107 v_block_filter(s, s->current_picture.data[1], s->mb_width , s->mb_height , s->uvlinesize, 0); | |
1108 v_block_filter(s, s->current_picture.data[2], s->mb_width , s->mb_height , s->uvlinesize, 0); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1109 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1110 |
1381 | 1111 ec_clean: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1112 /* clean a few tables */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1113 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1114 const int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1115 int error= s->error_status_table[mb_xy]; |
2967 | 1116 |
6481 | 1117 if(s->pict_type!=FF_B_TYPE && (error&(DC_ERROR|MV_ERROR|AC_ERROR))){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1118 s->mbskip_table[mb_xy]=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1119 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
1120 s->mbintra_table[mb_xy]=1; |
2967 | 1121 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
diff
changeset
|
1122 } |