Mercurial > libavcodec.hg
annotate h264.c @ 5707:c46509aca422 libavcodec
Remove check for input buffer size as it does not guarantee that
decoder will not run out of output buffer bounds (and all suspected
decoders have their own checks now).
author | kostya |
---|---|
date | Mon, 24 Sep 2007 16:50:32 +0000 |
parents | c08c9340c7ca |
children | f45228f65e06 |
rev | line source |
---|---|
1168 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1168 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * 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:
3927
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1168 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3927
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1168 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * 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:
3927
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3029
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1168 | 20 */ |
2967 | 21 |
1168 | 22 /** |
23 * @file h264.c | |
24 * H.264 / AVC / MPEG4 part10 codec. | |
25 * @author Michael Niedermayer <michaelni@gmx.at> | |
26 */ | |
27 | |
28 #include "dsputil.h" | |
29 #include "avcodec.h" | |
30 #include "mpegvideo.h" | |
4975 | 31 #include "h264.h" |
1168 | 32 #include "h264data.h" |
4975 | 33 #include "h264_parser.h" |
1168 | 34 #include "golomb.h" |
35 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
36 #include "cabac.h" |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
37 |
3284
a224d9752912
don't force asserts in release builds. 2% faster h264.
lorenm
parents:
3219
diff
changeset
|
38 //#undef NDEBUG |
1168 | 39 #include <assert.h> |
40 | |
41 static VLC coeff_token_vlc[4]; | |
42 static VLC chroma_dc_coeff_token_vlc; | |
43 | |
44 static VLC total_zeros_vlc[15]; | |
45 static VLC chroma_dc_total_zeros_vlc[3]; | |
46 | |
47 static VLC run_vlc[6]; | |
48 static VLC run7_vlc; | |
49 | |
1234 | 50 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
51 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc); | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
52 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize); |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
53 static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize); |
1234 | 54 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
55 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 56 #ifdef WORDS_BIGENDIAN |
57 return (b&0xFFFF) + (a<<16); | |
58 #else | |
59 return (a&0xFFFF) + (b<<16); | |
60 #endif | |
61 } | |
62 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
63 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
64 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
65 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
66 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
67 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
68 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
69 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
70 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
71 |
1168 | 72 /** |
73 * fill a rectangle. | |
2392 | 74 * @param h height of the rectangle, should be a constant |
75 * @param w width of the rectangle, should be a constant | |
1168 | 76 * @param size the size of val (1 or 4), should be a constant |
77 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
78 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 79 uint8_t *p= (uint8_t*)vp; |
1168 | 80 assert(size==1 || size==4); |
3315 | 81 assert(w<=4); |
2967 | 82 |
1168 | 83 w *= size; |
84 stride *= size; | |
2967 | 85 |
2962 | 86 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 87 assert((stride&(w-1))==0); |
3315 | 88 if(w==2){ |
89 const uint16_t v= size==4 ? val : val*0x0101; | |
90 *(uint16_t*)(p + 0*stride)= v; | |
91 if(h==1) return; | |
92 *(uint16_t*)(p + 1*stride)= v; | |
93 if(h==2) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
94 *(uint16_t*)(p + 2*stride)= v; |
3315 | 95 *(uint16_t*)(p + 3*stride)= v; |
96 }else if(w==4){ | |
97 const uint32_t v= size==4 ? val : val*0x01010101; | |
98 *(uint32_t*)(p + 0*stride)= v; | |
99 if(h==1) return; | |
100 *(uint32_t*)(p + 1*stride)= v; | |
101 if(h==2) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
102 *(uint32_t*)(p + 2*stride)= v; |
3315 | 103 *(uint32_t*)(p + 3*stride)= v; |
104 }else if(w==8){ | |
105 //gcc can't optimize 64bit math on x86_32 | |
106 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
107 const uint64_t v= val*0x0100000001ULL; | |
108 *(uint64_t*)(p + 0*stride)= v; | |
109 if(h==1) return; | |
110 *(uint64_t*)(p + 1*stride)= v; | |
111 if(h==2) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
112 *(uint64_t*)(p + 2*stride)= v; |
3315 | 113 *(uint64_t*)(p + 3*stride)= v; |
114 }else if(w==16){ | |
115 const uint64_t v= val*0x0100000001ULL; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
116 *(uint64_t*)(p + 0+0*stride)= v; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
117 *(uint64_t*)(p + 8+0*stride)= v; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
118 *(uint64_t*)(p + 0+1*stride)= v; |
3315 | 119 *(uint64_t*)(p + 8+1*stride)= v; |
120 if(h==2) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
121 *(uint64_t*)(p + 0+2*stride)= v; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
122 *(uint64_t*)(p + 8+2*stride)= v; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
123 *(uint64_t*)(p + 0+3*stride)= v; |
3315 | 124 *(uint64_t*)(p + 8+3*stride)= v; |
125 #else | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
126 *(uint32_t*)(p + 0+0*stride)= val; |
3315 | 127 *(uint32_t*)(p + 4+0*stride)= val; |
128 if(h==1) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
129 *(uint32_t*)(p + 0+1*stride)= val; |
3315 | 130 *(uint32_t*)(p + 4+1*stride)= val; |
131 if(h==2) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
132 *(uint32_t*)(p + 0+2*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
133 *(uint32_t*)(p + 4+2*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
134 *(uint32_t*)(p + 0+3*stride)= val; |
3315 | 135 *(uint32_t*)(p + 4+3*stride)= val; |
136 }else if(w==16){ | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
137 *(uint32_t*)(p + 0+0*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
138 *(uint32_t*)(p + 4+0*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
139 *(uint32_t*)(p + 8+0*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
140 *(uint32_t*)(p +12+0*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
141 *(uint32_t*)(p + 0+1*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
142 *(uint32_t*)(p + 4+1*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
143 *(uint32_t*)(p + 8+1*stride)= val; |
3315 | 144 *(uint32_t*)(p +12+1*stride)= val; |
145 if(h==2) return; | |
5545
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
146 *(uint32_t*)(p + 0+2*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
147 *(uint32_t*)(p + 4+2*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
148 *(uint32_t*)(p + 8+2*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
149 *(uint32_t*)(p +12+2*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
150 *(uint32_t*)(p + 0+3*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
151 *(uint32_t*)(p + 4+3*stride)= val; |
397cb90b66d0
Statements like a = b = c = d = e; store from right-to-left, so if
gpoirier
parents:
5528
diff
changeset
|
152 *(uint32_t*)(p + 8+3*stride)= val; |
3315 | 153 *(uint32_t*)(p +12+3*stride)= val; |
154 #endif | |
1168 | 155 }else |
156 assert(0); | |
3315 | 157 assert(h==4); |
1168 | 158 } |
159 | |
3028 | 160 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 161 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
162 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 163 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
164 int topleft_type, top_type, topright_type, left_type[2]; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
165 int left_block[8]; |
1168 | 166 int i; |
167 | |
3482 | 168 //FIXME deblocking could skip the intra and nnz parts. |
169 if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[mb_xy-s->mb_stride]) && !FRAME_MBAFF) | |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
170 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
171 |
2967 | 172 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
173 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
174 top_xy = mb_xy - s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
175 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
176 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
177 left_xy[1] = left_xy[0] = mb_xy-1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
178 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
179 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
180 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
181 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
182 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
183 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
184 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
185 left_block[7]= 11; |
3316 | 186 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
187 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
188 const int top_pair_xy = pair_xy - s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
189 const int topleft_pair_xy = top_pair_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
190 const int topright_pair_xy = top_pair_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
191 const int topleft_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
192 const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
193 const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
194 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
195 const int curr_mb_frame_flag = !IS_INTERLACED(mb_type); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
196 const int bottom = (s->mb_y & 1); |
4600 | 197 tprintf(s->avctx, "fill_caches: curr_mb_frame_flag:%d, left_mb_frame_flag:%d, topleft_mb_frame_flag:%d, top_mb_frame_flag:%d, topright_mb_frame_flag:%d\n", curr_mb_frame_flag, left_mb_frame_flag, topleft_mb_frame_flag, top_mb_frame_flag, topright_mb_frame_flag); |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
198 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
199 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
200 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
201 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
202 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
203 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
204 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
205 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
206 : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
207 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
208 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
209 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
210 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
211 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
212 : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
213 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
214 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
215 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
216 if (left_mb_frame_flag != curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
217 left_xy[1] = left_xy[0] = pair_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
218 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
219 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
220 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
221 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
222 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
223 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
224 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
225 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
226 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
227 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
228 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
229 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
230 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
231 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
232 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
233 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
234 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
235 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
236 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
237 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
238 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
239 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
240 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
241 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
242 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
243 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
244 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
245 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
246 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
247 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
248 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
249 } |
1168 | 250 } |
251 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
252 h->top_mb_xy = top_xy; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
253 h->left_mb_xy[0] = left_xy[0]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
254 h->left_mb_xy[1] = left_xy[1]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
255 if(for_deblock){ |
3482 | 256 topleft_type = 0; |
257 topright_type = 0; | |
2449 | 258 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
259 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
260 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 261 |
262 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
263 int list; | |
264 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
265 for(i=0; i<16; i++) | |
266 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
4533 | 267 for(list=0; list<h->list_count; list++){ |
3316 | 268 if(USES_LIST(mb_type,list)){ |
269 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
270 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 271 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 272 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
273 dst[0] = src[0]; | |
274 dst[1] = src[1]; | |
275 dst[2] = src[2]; | |
276 dst[3] = src[3]; | |
277 } | |
278 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
279 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
280 ref += h->b8_stride; | |
281 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
282 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
283 }else{ | |
284 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
285 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
286 } | |
287 } | |
288 } | |
2449 | 289 }else{ |
290 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
291 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
292 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
293 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
294 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
295 } | |
1168 | 296 |
297 if(IS_INTRA(mb_type)){ | |
2967 | 298 h->topleft_samples_available= |
299 h->top_samples_available= | |
1168 | 300 h->left_samples_available= 0xFFFF; |
301 h->topright_samples_available= 0xEEEA; | |
302 | |
303 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
304 h->topleft_samples_available= 0xB3FF; | |
305 h->top_samples_available= 0x33FF; | |
306 h->topright_samples_available= 0x26EA; | |
307 } | |
308 for(i=0; i<2; i++){ | |
309 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
310 h->topleft_samples_available&= 0xDF5F; | |
311 h->left_samples_available&= 0x5F5F; | |
312 } | |
313 } | |
2967 | 314 |
1168 | 315 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
316 h->topleft_samples_available&= 0x7FFF; | |
2967 | 317 |
1168 | 318 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
319 h->topright_samples_available&= 0xFBFF; | |
2967 | 320 |
1168 | 321 if(IS_INTRA4x4(mb_type)){ |
322 if(IS_INTRA4x4(top_type)){ | |
323 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
324 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
325 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
326 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
327 }else{ | |
328 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
329 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
330 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
331 else{ |
1168 | 332 pred= 2; |
333 } | |
334 h->intra4x4_pred_mode_cache[4+8*0]= | |
335 h->intra4x4_pred_mode_cache[5+8*0]= | |
336 h->intra4x4_pred_mode_cache[6+8*0]= | |
337 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
338 } | |
339 for(i=0; i<2; i++){ | |
340 if(IS_INTRA4x4(left_type[i])){ | |
341 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
342 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
343 }else{ | |
344 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
345 if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred)) |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
346 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
347 else{ |
1168 | 348 pred= 2; |
349 } | |
350 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
351 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
352 } | |
353 } | |
354 } | |
355 } | |
2967 | 356 |
357 | |
1168 | 358 /* |
2967 | 359 0 . T T. T T T T |
360 1 L . .L . . . . | |
361 2 L . .L . . . . | |
362 3 . T TL . . . . | |
363 4 L . .L . . . . | |
364 5 L . .. . . . . | |
1168 | 365 */ |
366 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
367 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
368 h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
369 h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
370 h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
371 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 372 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
373 h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
374 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 375 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
376 h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
377 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 378 |
1168 | 379 }else{ |
2967 | 380 h->non_zero_count_cache[4+8*0]= |
1168 | 381 h->non_zero_count_cache[5+8*0]= |
382 h->non_zero_count_cache[6+8*0]= | |
383 h->non_zero_count_cache[7+8*0]= | |
2967 | 384 |
1168 | 385 h->non_zero_count_cache[1+8*0]= |
386 h->non_zero_count_cache[2+8*0]= | |
2967 | 387 |
1168 | 388 h->non_zero_count_cache[1+8*3]= |
2314 | 389 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 390 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
391 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
392 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
393 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
394 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
395 h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
396 h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
397 h->non_zero_count_cache[0+8*1 + 8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
398 h->non_zero_count_cache[0+8*4 + 8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
399 }else{ |
2967 | 400 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
401 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
402 h->non_zero_count_cache[0+8*1 + 8*i]= | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
403 h->non_zero_count_cache[0+8*4 + 8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
404 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
405 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
406 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
407 if( h->pps.cabac ) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
408 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
409 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
410 h->top_cbp = h->cbp_table[top_xy]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
411 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
412 h->top_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
413 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
414 h->top_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
415 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
416 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
417 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
418 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
419 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
420 h->left_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
421 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
422 h->left_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
423 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
424 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
425 h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
426 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
427 if (left_type[1]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
428 h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
429 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
430 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
431 |
1168 | 432 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
433 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 434 int list; |
4533 | 435 for(list=0; list<h->list_count; list++){ |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
436 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 437 /*if(!h->mv_cache_clean[list]){ |
438 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
439 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
440 h->mv_cache_clean[list]= 1; | |
441 }*/ | |
2396 | 442 continue; |
1168 | 443 } |
444 h->mv_cache_clean[list]= 0; | |
2967 | 445 |
3212 | 446 if(USES_LIST(top_type, list)){ |
1168 | 447 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
448 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
449 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
450 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
451 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
452 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
453 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
454 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
455 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
456 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
457 }else{ | |
2967 | 458 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
459 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
460 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 461 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
462 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
463 } | |
464 | |
4546 | 465 for(i=0; i<2; i++){ |
466 int cache_idx = scan8[0] - 1 + i*2*8; | |
467 if(USES_LIST(left_type[i], list)){ | |
468 const int b_xy= h->mb2b_xy[left_xy[i]] + 3; | |
469 const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1; | |
470 *(uint32_t*)h->mv_cache[list][cache_idx ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]]; | |
471 *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]]; | |
472 h->ref_cache[list][cache_idx ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)]; | |
473 h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)]; | |
474 }else{ | |
475 *(uint32_t*)h->mv_cache [list][cache_idx ]= | |
476 *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0; | |
477 h->ref_cache[list][cache_idx ]= | |
478 h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
479 } | |
1168 | 480 } |
481 | |
3519 | 482 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 483 continue; |
484 | |
3212 | 485 if(USES_LIST(topleft_type, list)){ |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
486 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
487 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
488 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
489 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
490 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
491 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
492 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
493 } |
2967 | 494 |
3212 | 495 if(USES_LIST(topright_type, list)){ |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
496 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
497 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
498 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
499 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy]; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
500 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
501 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
502 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
503 } |
2967 | 504 |
3519 | 505 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 506 continue; |
2967 | 507 |
508 h->ref_cache[list][scan8[5 ]+1] = | |
509 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
510 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 511 h->ref_cache[list][scan8[4 ]] = |
1168 | 512 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
513 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
514 *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]= | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
515 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 516 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
517 *(uint32_t*)h->mv_cache [list][scan8[12]]= 0; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
518 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
519 if( h->pps.cabac ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
520 /* XXX beurk, Load mvd */ |
3212 | 521 if(USES_LIST(top_type, list)){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
522 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
523 *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
524 *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
525 *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
526 *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
527 }else{ |
2967 | 528 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
529 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
530 *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]= | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
531 *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
532 } |
3212 | 533 if(USES_LIST(left_type[0], list)){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
534 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
535 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
536 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
537 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
538 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
539 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
540 } |
3212 | 541 if(USES_LIST(left_type[1], list)){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
542 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
543 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
544 *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
545 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
546 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
547 *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
548 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
549 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
550 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]= |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
551 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
552 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
553 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 554 |
555 if(h->slice_type == B_TYPE){ | |
556 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
557 | |
558 if(IS_DIRECT(top_type)){ | |
559 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
560 }else if(IS_8X8(top_type)){ | |
561 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
562 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
563 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
564 }else{ | |
565 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
566 } | |
2967 | 567 |
3316 | 568 if(IS_DIRECT(left_type[0])) |
569 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
570 else if(IS_8X8(left_type[0])) | |
571 h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)]; | |
572 else | |
573 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
574 | |
575 if(IS_DIRECT(left_type[1])) | |
2396 | 576 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 577 else if(IS_8X8(left_type[1])) |
578 h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)]; | |
579 else | |
2396 | 580 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 581 } |
582 } | |
583 | |
584 if(FRAME_MBAFF){ | |
585 #define MAP_MVS\ | |
586 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
587 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
588 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
589 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
590 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
591 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
592 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
593 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
594 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
595 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
596 if(MB_FIELD){ | |
597 #define MAP_F2F(idx, mb_type)\ | |
598 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
599 h->ref_cache[list][idx] <<= 1;\ | |
600 h->mv_cache[list][idx][1] /= 2;\ | |
601 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 602 } |
3316 | 603 MAP_MVS |
604 #undef MAP_F2F | |
605 }else{ | |
606 #define MAP_F2F(idx, mb_type)\ | |
607 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
608 h->ref_cache[list][idx] >>= 1;\ | |
609 h->mv_cache[list][idx][1] <<= 1;\ | |
610 h->mvd_cache[list][idx][1] <<= 1;\ | |
611 } | |
612 MAP_MVS | |
613 #undef MAP_F2F | |
2396 | 614 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
615 } |
1168 | 616 } |
617 } | |
618 #endif | |
2755 | 619 |
620 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 621 } |
622 | |
623 static inline void write_back_intra_pred_mode(H264Context *h){ | |
624 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
625 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 626 |
627 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
628 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
629 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
630 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
631 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
632 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
633 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
634 } | |
635 | |
636 /** | |
637 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
638 */ | |
639 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
640 MpegEncContext * const s = &h->s; | |
641 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
642 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
643 int i; | |
2967 | 644 |
1168 | 645 if(!(h->top_samples_available&0x8000)){ |
646 for(i=0; i<4; i++){ | |
647 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
648 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
649 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 650 return -1; |
651 } else if(status){ | |
652 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
653 } | |
654 } | |
655 } | |
2967 | 656 |
1168 | 657 if(!(h->left_samples_available&0x8000)){ |
658 for(i=0; i<4; i++){ | |
659 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
660 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
661 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); |
1168 | 662 return -1; |
663 } else if(status){ | |
664 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
665 } | |
666 } | |
667 } | |
668 | |
669 return 0; | |
670 } //FIXME cleanup like next | |
671 | |
672 /** | |
673 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
674 */ | |
675 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
676 MpegEncContext * const s = &h->s; | |
677 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
678 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 679 |
4529 | 680 if(mode > 6U) { |
2392 | 681 av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y); |
2163 | 682 return -1; |
2392 | 683 } |
2967 | 684 |
1168 | 685 if(!(h->top_samples_available&0x8000)){ |
686 mode= top[ mode ]; | |
687 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
688 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); |
1168 | 689 return -1; |
690 } | |
691 } | |
2967 | 692 |
1168 | 693 if(!(h->left_samples_available&0x8000)){ |
694 mode= left[ mode ]; | |
695 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
696 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); |
1168 | 697 return -1; |
2967 | 698 } |
1168 | 699 } |
700 | |
701 return mode; | |
702 } | |
703 | |
704 /** | |
705 * gets the predicted intra4x4 prediction mode. | |
706 */ | |
707 static inline int pred_intra_mode(H264Context *h, int n){ | |
708 const int index8= scan8[n]; | |
709 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
710 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
711 const int min= FFMIN(left, top); | |
712 | |
4600 | 713 tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min); |
1168 | 714 |
715 if(min<0) return DC_PRED; | |
716 else return min; | |
717 } | |
718 | |
719 static inline void write_back_non_zero_count(H264Context *h){ | |
720 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
721 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
722 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
723 h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
724 h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
725 h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
726 h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4]; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
727 h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
728 h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
729 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 730 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
731 h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
732 h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2]; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
733 h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1]; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
734 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
735 h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
736 h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5]; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
737 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 738 |
739 if(FRAME_MBAFF){ | |
740 // store all luma nnzs, for deblocking | |
741 int v = 0, i; | |
742 for(i=0; i<16; i++) | |
743 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
744 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
745 } | |
1168 | 746 } |
747 | |
748 /** | |
749 * gets the predicted number of non zero coefficients. | |
750 * @param n block index | |
751 */ | |
752 static inline int pred_non_zero_count(H264Context *h, int n){ | |
753 const int index8= scan8[n]; | |
754 const int left= h->non_zero_count_cache[index8 - 1]; | |
755 const int top = h->non_zero_count_cache[index8 - 8]; | |
756 int i= left + top; | |
2967 | 757 |
1168 | 758 if(i<64) i= (i+1)>>1; |
759 | |
4600 | 760 tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 761 |
762 return i&31; | |
763 } | |
764 | |
1169 | 765 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
766 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
4600 | 767 MpegEncContext *s = &h->s; |
1169 | 768 |
3316 | 769 /* there is no consistent mapping of mvs to neighboring locations that will |
770 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
771 if(FRAME_MBAFF){ | |
3776 | 772 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 773 const int16_t *mv; |
774 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
775 *C = h->mv_cache[list][scan8[0]-2]; | |
776 | |
777 if(!MB_FIELD | |
778 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
779 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
780 if(IS_INTERLACED(mb_types[topright_xy])){ | |
781 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
782 const int x4 = X4, y4 = Y4;\ | |
783 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
784 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
785 return LIST_NOT_USED;\ | |
786 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
787 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
788 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
789 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
790 | |
791 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
792 } | |
793 } | |
794 if(topright_ref == PART_NOT_AVAILABLE | |
795 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
796 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
797 if(!MB_FIELD | |
798 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
799 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
800 } | |
801 if(MB_FIELD | |
802 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
803 && i >= scan8[0]+8){ | |
804 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
805 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
806 } | |
807 } | |
808 #undef SET_DIAG_MV | |
809 } | |
810 | |
1169 | 811 if(topright_ref != PART_NOT_AVAILABLE){ |
812 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
813 return topright_ref; | |
814 }else{ | |
4600 | 815 tprintf(s->avctx, "topright MV not available\n"); |
1170 | 816 |
1169 | 817 *C= h->mv_cache[list][ i - 8 - 1 ]; |
818 return h->ref_cache[list][ i - 8 - 1 ]; | |
819 } | |
820 } | |
821 | |
1168 | 822 /** |
823 * gets the predicted MV. | |
824 * @param n the block index | |
825 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
826 * @param mx the x component of the predicted motion vector | |
827 * @param my the y component of the predicted motion vector | |
828 */ | |
829 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
830 const int index8= scan8[n]; | |
831 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
832 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
833 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
834 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 835 const int16_t * C; |
836 int diagonal_ref, match_count; | |
837 | |
1168 | 838 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 839 |
1168 | 840 /* mv_cache |
2967 | 841 B . . A T T T T |
1168 | 842 U . . L . . , . |
843 U . . L . . . . | |
844 U . . L . . , . | |
845 . . . L . . . . | |
846 */ | |
1169 | 847 |
848 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
849 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref); | |
4600 | 850 tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count); |
1169 | 851 if(match_count > 1){ //most common |
852 *mx= mid_pred(A[0], B[0], C[0]); | |
853 *my= mid_pred(A[1], B[1], C[1]); | |
854 }else if(match_count==1){ | |
855 if(left_ref==ref){ | |
856 *mx= A[0]; | |
2967 | 857 *my= A[1]; |
1169 | 858 }else if(top_ref==ref){ |
859 *mx= B[0]; | |
2967 | 860 *my= B[1]; |
1169 | 861 }else{ |
862 *mx= C[0]; | |
2967 | 863 *my= C[1]; |
1169 | 864 } |
865 }else{ | |
866 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
867 *mx= A[0]; | |
2967 | 868 *my= A[1]; |
1168 | 869 }else{ |
870 *mx= mid_pred(A[0], B[0], C[0]); | |
871 *my= mid_pred(A[1], B[1], C[1]); | |
872 } | |
1169 | 873 } |
2967 | 874 |
4600 | 875 tprintf(h->s.avctx, "pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list); |
1168 | 876 } |
877 | |
878 /** | |
879 * gets the directionally predicted 16x8 MV. | |
880 * @param n the block index | |
881 * @param mx the x component of the predicted motion vector | |
882 * @param my the y component of the predicted motion vector | |
883 */ | |
884 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
885 if(n==0){ | |
886 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
887 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
888 | |
4600 | 889 tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list); |
2967 | 890 |
1168 | 891 if(top_ref == ref){ |
892 *mx= B[0]; | |
893 *my= B[1]; | |
894 return; | |
895 } | |
896 }else{ | |
897 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
898 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 899 |
4600 | 900 tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 901 |
902 if(left_ref == ref){ | |
903 *mx= A[0]; | |
904 *my= A[1]; | |
905 return; | |
906 } | |
907 } | |
908 | |
909 //RARE | |
910 pred_motion(h, n, 4, list, ref, mx, my); | |
911 } | |
912 | |
913 /** | |
914 * gets the directionally predicted 8x16 MV. | |
915 * @param n the block index | |
916 * @param mx the x component of the predicted motion vector | |
917 * @param my the y component of the predicted motion vector | |
918 */ | |
919 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
920 if(n==0){ | |
921 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
922 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 923 |
4600 | 924 tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 925 |
926 if(left_ref == ref){ | |
927 *mx= A[0]; | |
928 *my= A[1]; | |
929 return; | |
930 } | |
931 }else{ | |
1169 | 932 const int16_t * C; |
933 int diagonal_ref; | |
934 | |
935 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 936 |
4600 | 937 tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list); |
1168 | 938 |
2967 | 939 if(diagonal_ref == ref){ |
1168 | 940 *mx= C[0]; |
941 *my= C[1]; | |
942 return; | |
943 } | |
944 } | |
945 | |
946 //RARE | |
947 pred_motion(h, n, 2, list, ref, mx, my); | |
948 } | |
949 | |
950 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
951 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
952 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
953 | |
4600 | 954 tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 955 |
956 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
957 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
958 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 959 |
1168 | 960 *mx = *my = 0; |
961 return; | |
962 } | |
2967 | 963 |
1168 | 964 pred_motion(h, 0, 4, 0, 0, mx, my); |
965 | |
966 return; | |
967 } | |
968 | |
2396 | 969 static inline void direct_dist_scale_factor(H264Context * const h){ |
970 const int poc = h->s.current_picture_ptr->poc; | |
971 const int poc1 = h->ref_list[1][0].poc; | |
972 int i; | |
973 for(i=0; i<h->ref_count[0]; i++){ | |
974 int poc0 = h->ref_list[0][i].poc; | |
4594 | 975 int td = av_clip(poc1 - poc0, -128, 127); |
2396 | 976 if(td == 0 /* FIXME || pic0 is a long-term ref */){ |
977 h->dist_scale_factor[i] = 256; | |
978 }else{ | |
4594 | 979 int tb = av_clip(poc - poc0, -128, 127); |
4001 | 980 int tx = (16384 + (FFABS(td) >> 1)) / td; |
4594 | 981 h->dist_scale_factor[i] = av_clip((tb*tx + 32) >> 6, -1024, 1023); |
2396 | 982 } |
983 } | |
3316 | 984 if(FRAME_MBAFF){ |
985 for(i=0; i<h->ref_count[0]; i++){ | |
986 h->dist_scale_factor_field[2*i] = | |
987 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
988 } | |
989 } | |
2396 | 990 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
991 static inline void direct_ref_list_init(H264Context * const h){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
992 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
993 Picture * const ref1 = &h->ref_list[1][0]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
994 Picture * const cur = s->current_picture_ptr; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
995 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
996 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
997 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
998 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
999 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1000 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1001 cur->ref_count[list] = h->ref_count[list]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1002 for(j=0; j<h->ref_count[list]; j++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1003 cur->ref_poc[list][j] = h->ref_list[list][j].poc; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1004 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1005 if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1006 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1007 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1008 for(i=0; i<ref1->ref_count[list]; i++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1009 const int poc = ref1->ref_poc[list][i]; |
3125 | 1010 h->map_col_to_list0[list][i] = 0; /* bogus; fills in for missing frames */ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1011 for(j=0; j<h->ref_count[list]; j++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1012 if(h->ref_list[list][j].poc == poc){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1013 h->map_col_to_list0[list][i] = j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1014 break; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1015 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1016 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1017 } |
3316 | 1018 if(FRAME_MBAFF){ |
1019 for(list=0; list<2; list++){ | |
1020 for(i=0; i<ref1->ref_count[list]; i++){ | |
1021 j = h->map_col_to_list0[list][i]; | |
1022 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1023 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1024 } | |
1025 } | |
1026 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1027 } |
2396 | 1028 |
1029 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1030 MpegEncContext * const s = &h->s; | |
1031 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1032 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1033 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1034 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1035 const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy]; | |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1036 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1037 const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1038 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1039 const int is_b8x8 = IS_8X8(*mb_type); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
1040 unsigned int sub_mb_type; |
2396 | 1041 int i8, i4; |
1042 | |
3316 | 1043 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1044 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1045 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1046 * so we know exactly what block size to use */ | |
1047 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1048 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1049 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1050 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1051 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1052 }else{ | |
1053 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1054 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1055 } |
1056 if(!is_b8x8) | |
1057 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1058 if(MB_FIELD) |
1059 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1060 |
4600 | 1061 tprintf(s->avctx, "mb_type = %08x, sub_mb_type = %08x, is_b8x8 = %d, mb_type_col = %08x\n", *mb_type, sub_mb_type, is_b8x8, mb_type_col); |
2967 | 1062 |
2396 | 1063 if(h->direct_spatial_mv_pred){ |
1064 int ref[2]; | |
1065 int mv[2][2]; | |
1066 int list; | |
1067 | |
3316 | 1068 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1069 | |
2396 | 1070 /* ref = min(neighbors) */ |
1071 for(list=0; list<2; list++){ | |
1072 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1073 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1074 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1075 if(refc == -2) | |
1076 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1077 ref[list] = refa; | |
1078 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1079 ref[list] = refb; | |
1080 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1081 ref[list] = refc; | |
1082 if(ref[list] < 0) | |
1083 ref[list] = -1; | |
1084 } | |
1085 | |
1086 if(ref[0] < 0 && ref[1] < 0){ | |
1087 ref[0] = ref[1] = 0; | |
1088 mv[0][0] = mv[0][1] = | |
1089 mv[1][0] = mv[1][1] = 0; | |
1090 }else{ | |
1091 for(list=0; list<2; list++){ | |
1092 if(ref[list] >= 0) | |
1093 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1094 else | |
1095 mv[list][0] = mv[list][1] = 0; | |
1096 } | |
1097 } | |
1098 | |
1099 if(ref[1] < 0){ | |
1100 *mb_type &= ~MB_TYPE_P0L1; | |
1101 sub_mb_type &= ~MB_TYPE_P0L1; | |
1102 }else if(ref[0] < 0){ | |
1103 *mb_type &= ~MB_TYPE_P0L0; | |
1104 sub_mb_type &= ~MB_TYPE_P0L0; | |
1105 } | |
1106 | |
1107 if(IS_16X16(*mb_type)){ | |
4540 | 1108 int a=0, b=0; |
1109 | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1110 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1); |
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1111 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1112 if(!IS_INTRA(mb_type_col) |
4001 | 1113 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1114 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1115 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1116 if(ref[0] > 0) |
4540 | 1117 a= pack16to32(mv[0][0],mv[0][1]); |
2396 | 1118 if(ref[1] > 0) |
4540 | 1119 b= pack16to32(mv[1][0],mv[1][1]); |
2396 | 1120 }else{ |
4540 | 1121 a= pack16to32(mv[0][0],mv[0][1]); |
1122 b= pack16to32(mv[1][0],mv[1][1]); | |
1123 } | |
1124 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4); | |
1125 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4); | |
2396 | 1126 }else{ |
1127 for(i8=0; i8<4; i8++){ | |
1128 const int x8 = i8&1; | |
1129 const int y8 = i8>>1; | |
2967 | 1130 |
2396 | 1131 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1132 continue; | |
1133 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1134 |
2396 | 1135 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1136 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1137 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1); |
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1138 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1139 |
2396 | 1140 /* col_zero_flag */ |
2967 | 1141 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1142 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1143 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1144 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1145 if(IS_SUB_8X8(sub_mb_type)){ |
1146 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1147 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1148 if(ref[0] == 0) |
1149 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1150 if(ref[1] == 0) | |
1151 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1152 } | |
1153 }else | |
2396 | 1154 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1155 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1156 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1157 if(ref[0] == 0) |
1158 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1159 if(ref[1] == 0) | |
1160 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1161 } | |
1162 } | |
1163 } | |
1164 } | |
1165 } | |
1166 }else{ /* direct temporal mv pred */ | |
3316 | 1167 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1168 const int *dist_scale_factor = h->dist_scale_factor; | |
1169 | |
1170 if(FRAME_MBAFF){ | |
1171 if(IS_INTERLACED(*mb_type)){ | |
1172 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1173 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1174 dist_scale_factor = h->dist_scale_factor_field; | |
1175 } | |
1176 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1177 /* FIXME assumes direct_8x8_inference == 1 */ | |
1178 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1179 int mb_types_col[2]; | |
1180 int y_shift; | |
1181 | |
1182 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1183 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1184 | (*mb_type & MB_TYPE_INTERLACED); | |
1185 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1186 | |
1187 if(IS_INTERLACED(*mb_type)){ | |
1188 /* frame to field scaling */ | |
1189 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1190 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1191 if(s->mb_y&1){ | |
1192 l1ref0 -= 2*h->b8_stride; | |
1193 l1ref1 -= 2*h->b8_stride; | |
1194 l1mv0 -= 4*h->b_stride; | |
1195 l1mv1 -= 4*h->b_stride; | |
1196 } | |
1197 y_shift = 0; | |
1198 | |
1199 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1200 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1201 && !is_b8x8) | |
1202 *mb_type |= MB_TYPE_16x8; | |
1203 else | |
1204 *mb_type |= MB_TYPE_8x8; | |
1205 }else{ | |
1206 /* field to frame scaling */ | |
1207 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1208 * but in MBAFF, top and bottom POC are equal */ | |
1209 int dy = (s->mb_y&1) ? 1 : 2; | |
1210 mb_types_col[0] = | |
1211 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1212 l1ref0 += dy*h->b8_stride; | |
1213 l1ref1 += dy*h->b8_stride; | |
1214 l1mv0 += 2*dy*h->b_stride; | |
1215 l1mv1 += 2*dy*h->b_stride; | |
1216 y_shift = 2; | |
1217 | |
1218 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1219 && !is_b8x8) | |
1220 *mb_type |= MB_TYPE_16x16; | |
1221 else | |
1222 *mb_type |= MB_TYPE_8x8; | |
1223 } | |
1224 | |
1225 for(i8=0; i8<4; i8++){ | |
1226 const int x8 = i8&1; | |
1227 const int y8 = i8>>1; | |
1228 int ref0, scale; | |
1229 const int16_t (*l1mv)[2]= l1mv0; | |
1230 | |
1231 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1232 continue; | |
1233 h->sub_mb_type[i8] = sub_mb_type; | |
1234 | |
1235 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1236 if(IS_INTRA(mb_types_col[y8])){ | |
1237 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1238 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1239 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1240 continue; | |
1241 } | |
1242 | |
1243 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1244 if(ref0 >= 0) | |
1245 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1246 else{ | |
1247 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1248 l1mv= l1mv1; | |
1249 } | |
1250 scale = dist_scale_factor[ref0]; | |
1251 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1252 | |
1253 { | |
1254 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1255 int my_col = (mv_col[1]<<y_shift)/2; | |
1256 int mx = (scale * mv_col[0] + 128) >> 8; | |
1257 int my = (scale * my_col + 128) >> 8; | |
1258 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1259 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1260 } | |
1261 } | |
1262 return; | |
1263 } | |
1264 } | |
1265 | |
1266 /* one-to-one mv scaling */ | |
1267 | |
2396 | 1268 if(IS_16X16(*mb_type)){ |
4541 | 1269 int ref, mv0, mv1; |
1270 | |
2396 | 1271 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); |
1272 if(IS_INTRA(mb_type_col)){ | |
4541 | 1273 ref=mv0=mv1=0; |
2396 | 1274 }else{ |
3316 | 1275 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1276 : map_col_to_list0[1][l1ref1[0]]; | |
1277 const int scale = dist_scale_factor[ref0]; | |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1278 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1279 int mv_l0[2]; |
3316 | 1280 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1281 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
4541 | 1282 ref= ref0; |
1283 mv0= pack16to32(mv_l0[0],mv_l0[1]); | |
1284 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1285 } | |
1286 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); | |
1287 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4); | |
1288 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4); | |
2396 | 1289 }else{ |
1290 for(i8=0; i8<4; i8++){ | |
1291 const int x8 = i8&1; | |
1292 const int y8 = i8>>1; | |
3316 | 1293 int ref0, scale; |
2834 | 1294 const int16_t (*l1mv)[2]= l1mv0; |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1295 |
2396 | 1296 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1297 continue; | |
1298 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1299 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1300 if(IS_INTRA(mb_type_col)){ |
1301 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1302 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1303 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1304 continue; | |
1305 } | |
2967 | 1306 |
2396 | 1307 ref0 = l1ref0[x8 + y8*h->b8_stride]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1308 if(ref0 >= 0) |
3316 | 1309 ref0 = map_col_to_list0[0][ref0]; |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1310 else{ |
3316 | 1311 ref0 = map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]]; |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1312 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1313 } |
3316 | 1314 scale = dist_scale_factor[ref0]; |
2967 | 1315 |
2396 | 1316 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1317 if(IS_SUB_8X8(sub_mb_type)){ |
1318 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1319 int mx = (scale * mv_col[0] + 128) >> 8; |
1320 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1321 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1322 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1323 }else | |
2396 | 1324 for(i4=0; i4<4; i4++){ |
2809
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1325 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1326 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1327 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1328 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1329 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1330 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1331 } | |
1332 } | |
1333 } | |
1334 } | |
1335 } | |
1336 | |
1168 | 1337 static inline void write_back_motion(H264Context *h, int mb_type){ |
1338 MpegEncContext * const s = &h->s; | |
1339 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1340 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1341 int list; | |
1342 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1343 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1344 fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1); |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1345 |
4533 | 1346 for(list=0; list<h->list_count; list++){ |
1168 | 1347 int y; |
3212 | 1348 if(!USES_LIST(mb_type, list)) |
2396 | 1349 continue; |
2967 | 1350 |
1168 | 1351 for(y=0; y<4; y++){ |
1352 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y]; | |
1353 *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y]; | |
1354 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1355 if( h->pps.cabac ) { |
3927 | 1356 if(IS_SKIP(mb_type)) |
1357 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1358 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1359 for(y=0; y<4; y++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1360 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1361 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1362 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1363 } |
3212 | 1364 |
1365 { | |
3776 | 1366 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1367 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1368 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1369 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1370 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1371 } |
1372 } | |
2967 | 1373 |
2396 | 1374 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1375 if(IS_8X8(mb_type)){ | |
3212 | 1376 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1377 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1378 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1379 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1380 } |
1381 } | |
1168 | 1382 } |
1383 | |
1384 /** | |
1385 * Decodes a network abstraction layer unit. | |
1386 * @param consumed is the number of bytes used as input | |
1387 * @param length is the length of the array | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1388 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1389 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1390 */ |
1391 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1392 int i, si, di; | |
1393 uint8_t *dst; | |
5174 | 1394 int bufidx; |
1168 | 1395 |
2979 | 1396 // src[0]&0x80; //forbidden bit |
1168 | 1397 h->nal_ref_idc= src[0]>>5; |
1398 h->nal_unit_type= src[0]&0x1F; | |
1399 | |
1400 src++; length--; | |
2967 | 1401 #if 0 |
1168 | 1402 for(i=0; i<length; i++) |
1403 printf("%2X ", src[i]); | |
1404 #endif | |
1405 for(i=0; i+1<length; i+=2){ | |
1406 if(src[i]) continue; | |
1407 if(i>0 && src[i-1]==0) i--; | |
1408 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1409 if(src[i+2]!=3){ | |
1410 /* startcode, so we must be past the end */ | |
1411 length=i; | |
1412 } | |
1413 break; | |
1414 } | |
1415 } | |
1416 | |
1417 if(i>=length-1){ //no escaped 0 | |
1418 *dst_length= length; | |
1419 *consumed= length+1; //+1 for the header | |
2967 | 1420 return src; |
1168 | 1421 } |
1422 | |
5174 | 1423 bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data |
1424 h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length); | |
1425 dst= h->rbsp_buffer[bufidx]; | |
1168 | 1426 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1427 if (dst == NULL){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1428 return NULL; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1429 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1430 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1431 //printf("decoding esc\n"); |
1168 | 1432 si=di=0; |
2967 | 1433 while(si<length){ |
1168 | 1434 //remove escapes (very rare 1:2^22) |
1435 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1436 if(src[si+2]==3){ //escape | |
1437 dst[di++]= 0; | |
1438 dst[di++]= 0; | |
1439 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1440 continue; |
1168 | 1441 }else //next start code |
1442 break; | |
1443 } | |
1444 | |
1445 dst[di++]= src[si++]; | |
1446 } | |
1447 | |
1448 *dst_length= di; | |
1449 *consumed= si + 1;//+1 for the header | |
5129 | 1450 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding) |
1168 | 1451 return dst; |
1452 } | |
1453 | |
1454 /** | |
1455 * identifies the exact end of the bitstream | |
1456 * @return the length of the trailing, or 0 if damaged | |
1457 */ | |
4600 | 1458 static int decode_rbsp_trailing(H264Context *h, uint8_t *src){ |
1168 | 1459 int v= *src; |
1460 int r; | |
1461 | |
4600 | 1462 tprintf(h->s.avctx, "rbsp trailing %X\n", v); |
1168 | 1463 |
1464 for(r=1; r<9; r++){ | |
1465 if(v&1) return r; | |
1466 v>>=1; | |
1467 } | |
1468 return 0; | |
1469 } | |
1470 | |
1471 /** | |
1472 * idct tranforms the 16 dc values and dequantize them. | |
1473 * @param qp quantization parameter | |
1474 */ | |
2919 | 1475 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1476 #define stride 16 |
1477 int i; | |
1478 int temp[16]; //FIXME check if this is a good idea | |
1479 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1480 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1481 | |
1482 //memset(block, 64, 2*256); | |
1483 //return; | |
1484 for(i=0; i<4; i++){ | |
1485 const int offset= y_offset[i]; | |
1486 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1487 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1488 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1489 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1490 | |
1491 temp[4*i+0]= z0+z3; | |
1492 temp[4*i+1]= z1+z2; | |
1493 temp[4*i+2]= z1-z2; | |
1494 temp[4*i+3]= z0-z3; | |
1495 } | |
1496 | |
1497 for(i=0; i<4; i++){ | |
1498 const int offset= x_offset[i]; | |
1499 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1500 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1501 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1502 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1503 | |
2919 | 1504 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1505 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1506 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1507 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1508 } |
1509 } | |
1510 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1511 #if 0 |
1168 | 1512 /** |
1513 * dct tranforms the 16 dc values. | |
1514 * @param qp quantization parameter ??? FIXME | |
1515 */ | |
1516 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1517 // const int qmul= dequant_coeff[qp][0]; | |
1518 int i; | |
1519 int temp[16]; //FIXME check if this is a good idea | |
1520 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1521 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1522 | |
1523 for(i=0; i<4; i++){ | |
1524 const int offset= y_offset[i]; | |
1525 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1526 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1527 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1528 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1529 | |
1530 temp[4*i+0]= z0+z3; | |
1531 temp[4*i+1]= z1+z2; | |
1532 temp[4*i+2]= z1-z2; | |
1533 temp[4*i+3]= z0-z3; | |
1534 } | |
1535 | |
1536 for(i=0; i<4; i++){ | |
1537 const int offset= x_offset[i]; | |
1538 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1539 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1540 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1541 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1542 | |
1543 block[stride*0 +offset]= (z0 + z3)>>1; | |
1544 block[stride*2 +offset]= (z1 + z2)>>1; | |
1545 block[stride*8 +offset]= (z1 - z2)>>1; | |
1546 block[stride*10+offset]= (z0 - z3)>>1; | |
1547 } | |
1548 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1549 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1550 |
1168 | 1551 #undef xStride |
1552 #undef stride | |
1553 | |
2919 | 1554 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1555 const int stride= 16*2; |
1556 const int xStride= 16; | |
1557 int a,b,c,d,e; | |
1558 | |
1559 a= block[stride*0 + xStride*0]; | |
1560 b= block[stride*0 + xStride*1]; | |
1561 c= block[stride*1 + xStride*0]; | |
1562 d= block[stride*1 + xStride*1]; | |
1563 | |
1564 e= a-b; | |
1565 a= a+b; | |
1566 b= c-d; | |
1567 c= c+d; | |
1568 | |
2919 | 1569 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1570 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1571 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1572 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1573 } |
1574 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1575 #if 0 |
1168 | 1576 static void chroma_dc_dct_c(DCTELEM *block){ |
1577 const int stride= 16*2; | |
1578 const int xStride= 16; | |
1579 int a,b,c,d,e; | |
1580 | |
1581 a= block[stride*0 + xStride*0]; | |
1582 b= block[stride*0 + xStride*1]; | |
1583 c= block[stride*1 + xStride*0]; | |
1584 d= block[stride*1 + xStride*1]; | |
1585 | |
1586 e= a-b; | |
1587 a= a+b; | |
1588 b= c-d; | |
1589 c= c+d; | |
1590 | |
1591 block[stride*0 + xStride*0]= (a+c); | |
1592 block[stride*0 + xStride*1]= (e+b); | |
1593 block[stride*1 + xStride*0]= (a-c); | |
1594 block[stride*1 + xStride*1]= (e-b); | |
1595 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1596 #endif |
1168 | 1597 |
1598 /** | |
1599 * gets the chroma qp. | |
1600 */ | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
1601 static inline int get_chroma_qp(H264Context *h, int t, int qscale){ |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
1602 return h->pps.chroma_qp_table[t][qscale & 0xff]; |
1168 | 1603 } |
1604 | |
5127 | 1605 //FIXME need to check that this does not overflow signed 32 bit for low qp, i am not sure, it's very close |
4553
1a714d3f0233
cosmetics: Fix a common typo, sepErate --> sepArate.
diego
parents:
4546
diff
changeset
|
1606 //FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away) |
1a714d3f0233
cosmetics: Fix a common typo, sepErate --> sepArate.
diego
parents:
4546
diff
changeset
|
1607 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int separate_dc){ |
1168 | 1608 int i; |
1609 const int * const quant_table= quant_coeff[qscale]; | |
1610 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1611 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1612 const unsigned int threshold2= (threshold1<<1); | |
1613 int last_non_zero; | |
1614 | |
4553
1a714d3f0233
cosmetics: Fix a common typo, sepErate --> sepArate.
diego
parents:
4546
diff
changeset
|
1615 if(separate_dc){ |
1168 | 1616 if(qscale<=18){ |
1617 //avoid overflows | |
1618 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1619 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1620 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1621 | |
1622 int level= block[0]*quant_coeff[qscale+18][0]; | |
1623 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1624 if(level>0){ | |
1625 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1626 block[0]= level; | |
1627 }else{ | |
1628 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1629 block[0]= -level; | |
1630 } | |
1631 // last_non_zero = i; | |
1632 }else{ | |
1633 block[0]=0; | |
1634 } | |
1635 }else{ | |
1636 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1637 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1638 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1639 | |
1640 int level= block[0]*quant_table[0]; | |
1641 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1642 if(level>0){ | |
1643 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
1644 block[0]= level; | |
1645 }else{ | |
1646 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
1647 block[0]= -level; | |
1648 } | |
1649 // last_non_zero = i; | |
1650 }else{ | |
1651 block[0]=0; | |
1652 } | |
1653 } | |
1654 last_non_zero= 0; | |
1655 i=1; | |
1656 }else{ | |
1657 last_non_zero= -1; | |
1658 i=0; | |
1659 } | |
1660 | |
1661 for(; i<16; i++){ | |
1662 const int j= scantable[i]; | |
1663 int level= block[j]*quant_table[j]; | |
1664 | |
1665 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
1666 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
1667 if(((unsigned)(level+threshold1))>threshold2){ | |
1668 if(level>0){ | |
1669 level= (bias + level)>>QUANT_SHIFT; | |
1670 block[j]= level; | |
1671 }else{ | |
1672 level= (bias - level)>>QUANT_SHIFT; | |
1673 block[j]= -level; | |
1674 } | |
1675 last_non_zero = i; | |
1676 }else{ | |
1677 block[j]=0; | |
1678 } | |
1679 } | |
1680 | |
1681 return last_non_zero; | |
1682 } | |
1683 | |
1684 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, | |
1685 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
1686 int src_x_offset, int src_y_offset, | |
1687 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
1688 MpegEncContext * const s = &h->s; | |
1689 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 1690 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 1691 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 1692 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
1693 uint8_t * src_cb, * src_cr; | |
1694 int extra_width= h->emu_edge_width; | |
1695 int extra_height= h->emu_edge_height; | |
1168 | 1696 int emu=0; |
1697 const int full_mx= mx>>2; | |
1698 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
1699 const int pic_width = 16*s->mb_width; |
3316 | 1700 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 1701 |
4390 | 1702 if(!pic->data[0]) //FIXME this is unacceptable, some senseable error concealment must be done for missing reference frames |
3125 | 1703 return; |
2967 | 1704 |
1168 | 1705 if(mx&7) extra_width -= 3; |
1706 if(my&7) extra_height -= 3; | |
2967 | 1707 |
1708 if( full_mx < 0-extra_width | |
1709 || full_my < 0-extra_height | |
1710 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
1711 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 1712 ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height); |
1713 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 1714 emu=1; |
1715 } | |
2967 | 1716 |
3316 | 1717 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 1718 if(!square){ |
3316 | 1719 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 1720 } |
2967 | 1721 |
5434 | 1722 if(ENABLE_GRAY && s->flags&CODEC_FLAG_GRAY) return; |
2967 | 1723 |
3316 | 1724 if(MB_MBAFF){ |
1725 // chroma offset when predicting from a field of opposite parity | |
1726 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
1727 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
1728 } | |
1729 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1730 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 1731 |
1732 if(emu){ | |
3316 | 1733 ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1); |
1734 src_cb= s->edge_emu_buffer; | |
1735 } | |
1736 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
1737 | |
1738 if(emu){ | |
1739 ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1); | |
1168 | 1740 src_cr= s->edge_emu_buffer; |
1741 } | |
3316 | 1742 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 1743 } |
1744 | |
2415 | 1745 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 1746 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1747 int x_offset, int y_offset, | |
1748 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
1749 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
1750 int list0, int list1){ | |
1751 MpegEncContext * const s = &h->s; | |
1752 qpel_mc_func *qpix_op= qpix_put; | |
1753 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 1754 |
3316 | 1755 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
1756 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
1757 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 1758 x_offset += 8*s->mb_x; |
3316 | 1759 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 1760 |
1168 | 1761 if(list0){ |
1169 | 1762 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 1763 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
1764 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
1765 qpix_op, chroma_op); | |
1766 | |
1767 qpix_op= qpix_avg; | |
1768 chroma_op= chroma_avg; | |
1769 } | |
1770 | |
1771 if(list1){ | |
1169 | 1772 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 1773 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
1774 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
1775 qpix_op, chroma_op); | |
1776 } | |
1777 } | |
1778 | |
2415 | 1779 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
1780 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
1781 int x_offset, int y_offset, | |
1782 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
1783 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
1784 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
1785 int list0, int list1){ | |
1786 MpegEncContext * const s = &h->s; | |
1787 | |
3316 | 1788 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
1789 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
1790 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 1791 x_offset += 8*s->mb_x; |
3316 | 1792 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 1793 |
2415 | 1794 if(list0 && list1){ |
1795 /* don't optimize for luma-only case, since B-frames usually | |
1796 * use implicit weights => chroma too. */ | |
1797 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 1798 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
1799 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 1800 int refn0 = h->ref_cache[0][ scan8[n] ]; |
1801 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
1802 | |
1803 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
1804 dest_y, dest_cb, dest_cr, | |
1805 x_offset, y_offset, qpix_put, chroma_put); | |
1806 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
1807 tmp_y, tmp_cb, tmp_cr, | |
1808 x_offset, y_offset, qpix_put, chroma_put); | |
1809 | |
1810 if(h->use_weight == 2){ | |
1811 int weight0 = h->implicit_weight[refn0][refn1]; | |
1812 int weight1 = 64 - weight0; | |
3316 | 1813 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
1814 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
1815 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 1816 }else{ |
3316 | 1817 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 1818 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 1819 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 1820 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 1821 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 1822 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 1823 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 1824 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 1825 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 1826 } |
1827 }else{ | |
1828 int list = list1 ? 1 : 0; | |
1829 int refn = h->ref_cache[list][ scan8[n] ]; | |
1830 Picture *ref= &h->ref_list[list][refn]; | |
1831 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
1832 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
1833 qpix_put, chroma_put); | |
1834 | |
3316 | 1835 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 1836 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
1837 if(h->use_weight_chroma){ | |
3316 | 1838 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 1839 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 1840 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 1841 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
1842 } | |
1843 } | |
1844 } | |
1845 | |
1846 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
1847 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
1848 int x_offset, int y_offset, | |
1849 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
1850 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 1851 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 1852 int list0, int list1){ |
1853 if((h->use_weight==2 && list0 && list1 | |
1854 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
1855 || h->use_weight==1) | |
1856 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
1857 x_offset, y_offset, qpix_put, chroma_put, | |
1858 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
1859 else | |
1860 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
1861 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
1862 } | |
1863 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1864 static inline void prefetch_motion(H264Context *h, int list){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1865 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1866 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1867 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1868 const int refn = h->ref_cache[list][scan8[0]]; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1869 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1870 const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1871 const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1872 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 1873 int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64; |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1874 s->dsp.prefetch(src[0]+off, s->linesize, 4); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1875 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1876 s->dsp.prefetch(src[1]+off, src[2]-src[1], 2); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1877 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1878 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1879 |
1168 | 1880 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
1881 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 1882 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
1883 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 1884 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
1885 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 1886 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 1887 |
1168 | 1888 assert(IS_INTER(mb_type)); |
2967 | 1889 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1890 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1891 |
1168 | 1892 if(IS_16X16(mb_type)){ |
1893 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
1894 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 1895 &weight_op[0], &weight_avg[0], |
1168 | 1896 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
1897 }else if(IS_16X8(mb_type)){ | |
1898 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
1899 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 1900 &weight_op[1], &weight_avg[1], |
1168 | 1901 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
1902 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
1903 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 1904 &weight_op[1], &weight_avg[1], |
1168 | 1905 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
1906 }else if(IS_8X16(mb_type)){ | |
3316 | 1907 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 1908 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 1909 &weight_op[2], &weight_avg[2], |
1168 | 1910 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 1911 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 1912 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 1913 &weight_op[2], &weight_avg[2], |
1168 | 1914 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
1915 }else{ | |
1916 int i; | |
2967 | 1917 |
1168 | 1918 assert(IS_8X8(mb_type)); |
1919 | |
1920 for(i=0; i<4; i++){ | |
1921 const int sub_mb_type= h->sub_mb_type[i]; | |
1922 const int n= 4*i; | |
1923 int x_offset= (i&1)<<2; | |
1924 int y_offset= (i&2)<<1; | |
1925 | |
1926 if(IS_SUB_8X8(sub_mb_type)){ | |
1927 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
1928 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 1929 &weight_op[3], &weight_avg[3], |
1168 | 1930 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
1931 }else if(IS_SUB_8X4(sub_mb_type)){ | |
1932 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
1933 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 1934 &weight_op[4], &weight_avg[4], |
1168 | 1935 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
1936 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
1937 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 1938 &weight_op[4], &weight_avg[4], |
1168 | 1939 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
1940 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 1941 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 1942 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 1943 &weight_op[5], &weight_avg[5], |
1168 | 1944 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 1945 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 1946 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 1947 &weight_op[5], &weight_avg[5], |
1168 | 1948 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
1949 }else{ | |
1950 int j; | |
1951 assert(IS_SUB_4X4(sub_mb_type)); | |
1952 for(j=0; j<4; j++){ | |
1953 int sub_x_offset= x_offset + 2*(j&1); | |
1954 int sub_y_offset= y_offset + (j&2); | |
1955 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
1956 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 1957 &weight_op[6], &weight_avg[6], |
1168 | 1958 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
1959 } | |
1960 } | |
1961 } | |
1962 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1963 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
1964 prefetch_motion(h, 1); |
1168 | 1965 } |
1966 | |
4783
011fb289e3b0
changes some function declarations from () to (void) as per ansi c.
gpoirier
parents:
4745
diff
changeset
|
1967 static void decode_init_vlc(void){ |
1168 | 1968 static int done = 0; |
1969 | |
1970 if (!done) { | |
1971 int i; | |
1972 done = 1; | |
1973 | |
2967 | 1974 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 1975 &chroma_dc_coeff_token_len [0], 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
1976 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 1977 |
1978 for(i=0; i<4; i++){ | |
2967 | 1979 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 1980 &coeff_token_len [i][0], 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
1981 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 1982 } |
1983 | |
1984 for(i=0; i<3; i++){ | |
1985 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
1986 &chroma_dc_total_zeros_len [i][0], 1, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
1987 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 1988 } |
1989 for(i=0; i<15; i++){ | |
2967 | 1990 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 1991 &total_zeros_len [i][0], 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
1992 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 1993 } |
1994 | |
1995 for(i=0; i<6; i++){ | |
2967 | 1996 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 1997 &run_len [i][0], 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
1998 &run_bits[i][0], 1, 1, 1); |
1168 | 1999 } |
2967 | 2000 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 2001 &run_len [6][0], 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2365
diff
changeset
|
2002 &run_bits[6][0], 1, 1, 1); |
1168 | 2003 } |
2004 } | |
2005 | |
2006 static void free_tables(H264Context *h){ | |
5079 | 2007 int i; |
5642 | 2008 H264Context *hx; |
1168 | 2009 av_freep(&h->intra4x4_pred_mode); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2010 av_freep(&h->chroma_pred_mode_table); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2011 av_freep(&h->cbp_table); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2012 av_freep(&h->mvd_table[0]); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2013 av_freep(&h->mvd_table[1]); |
2396 | 2014 av_freep(&h->direct_table); |
1168 | 2015 av_freep(&h->non_zero_count); |
2016 av_freep(&h->slice_table_base); | |
2017 h->slice_table= NULL; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2018 |
1168 | 2019 av_freep(&h->mb2b_xy); |
2020 av_freep(&h->mb2b8_xy); | |
2415 | 2021 |
5079 | 2022 for(i = 0; i < MAX_SPS_COUNT; i++) |
2023 av_freep(h->sps_buffers + i); | |
2024 | |
2025 for(i = 0; i < MAX_PPS_COUNT; i++) | |
2026 av_freep(h->pps_buffers + i); | |
5642 | 2027 |
2028 for(i = 0; i < h->s.avctx->thread_count; i++) { | |
2029 hx = h->thread_context[i]; | |
2030 if(!hx) continue; | |
2031 av_freep(&hx->top_borders[1]); | |
2032 av_freep(&hx->top_borders[0]); | |
2033 av_freep(&hx->s.obmc_scratchpad); | |
2034 av_freep(&hx->s.allocated_edge_emu_buffer); | |
2035 } | |
1168 | 2036 } |
2037 | |
2919 | 2038 static void init_dequant8_coeff_table(H264Context *h){ |
2039 int i,q,x; | |
3174 | 2040 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 2041 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
2042 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
2043 | |
2044 for(i=0; i<2; i++ ){ | |
2045 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
2046 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
2047 break; | |
2048 } | |
2049 | |
2050 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2051 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2052 int idx = ff_rem6[q]; |
2919 | 2053 for(x=0; x<64; x++) |
3174 | 2054 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
2055 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
2056 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 2057 } |
2058 } | |
2059 } | |
2060 | |
2061 static void init_dequant4_coeff_table(H264Context *h){ | |
2062 int i,j,q,x; | |
3005 | 2063 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 2064 for(i=0; i<6; i++ ){ |
2065 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
2066 for(j=0; j<i; j++){ | |
2067 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
2068 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
2069 break; | |
2070 } | |
2071 } | |
2072 if(j<i) | |
2073 continue; | |
2074 | |
2075 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2076 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2077 int idx = ff_rem6[q]; |
2919 | 2078 for(x=0; x<16; x++) |
3005 | 2079 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
2080 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 2081 h->pps.scaling_matrix4[i][x]) << shift; |
2082 } | |
2083 } | |
2084 } | |
2085 | |
2086 static void init_dequant_tables(H264Context *h){ | |
2087 int i,x; | |
2088 init_dequant4_coeff_table(h); | |
2089 if(h->pps.transform_8x8_mode) | |
2090 init_dequant8_coeff_table(h); | |
2091 if(h->sps.transform_bypass){ | |
2092 for(i=0; i<6; i++) | |
2093 for(x=0; x<16; x++) | |
2094 h->dequant4_coeff[i][0][x] = 1<<6; | |
2095 if(h->pps.transform_8x8_mode) | |
2096 for(i=0; i<2; i++) | |
2097 for(x=0; x<64; x++) | |
2098 h->dequant8_coeff[i][0][x] = 1<<6; | |
2099 } | |
2100 } | |
2101 | |
2102 | |
1168 | 2103 /** |
2104 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2105 * needs width/height |
1168 | 2106 */ |
2107 static int alloc_tables(H264Context *h){ | |
2108 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
2109 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 2110 int x,y; |
1168 | 2111 |
2112 CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8 * sizeof(uint8_t)) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2113 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2114 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 2115 CHECKED_ALLOCZ(h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(uint8_t)) |
2336 | 2116 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 2117 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2118 if( h->pps.cabac ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2119 CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t)) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2120 CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
2121 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 2122 CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t)); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2123 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2124 |
3316 | 2125 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
2126 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 2127 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
2128 CHECKED_ALLOCZ(h->mb2b_xy , big_mb_num * sizeof(uint32_t)); |
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
2129 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 2130 for(y=0; y<s->mb_height; y++){ |
2131 for(x=0; x<s->mb_width; 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:
1174
diff
changeset
|
2132 const int mb_xy= x + y*s->mb_stride; |
1168 | 2133 const int b_xy = 4*x + 4*y*h->b_stride; |
2134 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 2135 |
1168 | 2136 h->mb2b_xy [mb_xy]= b_xy; |
2137 h->mb2b8_xy[mb_xy]= b8_xy; | |
2138 } | |
2139 } | |
2415 | 2140 |
2417 | 2141 s->obmc_scratchpad = NULL; |
2142 | |
2920 | 2143 if(!h->dequant4_coeff[0]) |
2144 init_dequant_tables(h); | |
2145 | |
1168 | 2146 return 0; |
2147 fail: | |
2148 free_tables(h); | |
2149 return -1; | |
2150 } | |
2151 | |
5642 | 2152 /** |
2153 * Mimic alloc_tables(), but for every context thread. | |
2154 */ | |
2155 static void clone_tables(H264Context *dst, H264Context *src){ | |
2156 dst->intra4x4_pred_mode = src->intra4x4_pred_mode; | |
2157 dst->non_zero_count = src->non_zero_count; | |
2158 dst->slice_table = src->slice_table; | |
2159 dst->cbp_table = src->cbp_table; | |
2160 dst->mb2b_xy = src->mb2b_xy; | |
2161 dst->mb2b8_xy = src->mb2b8_xy; | |
2162 dst->chroma_pred_mode_table = src->chroma_pred_mode_table; | |
2163 dst->mvd_table[0] = src->mvd_table[0]; | |
2164 dst->mvd_table[1] = src->mvd_table[1]; | |
2165 dst->direct_table = src->direct_table; | |
2166 | |
2167 dst->s.obmc_scratchpad = NULL; | |
2168 ff_h264_pred_init(&dst->hpc, src->s.codec_id); | |
2169 } | |
2170 | |
2171 /** | |
2172 * Init context | |
2173 * Allocate buffers which are not shared amongst multiple threads. | |
2174 */ | |
2175 static int context_init(H264Context *h){ | |
2176 MpegEncContext * const s = &h->s; | |
2177 | |
2178 CHECKED_ALLOCZ(h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t)) | |
2179 CHECKED_ALLOCZ(h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t)) | |
2180 | |
2181 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) | |
2182 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, | |
2183 (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance | |
2184 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; | |
2185 return 0; | |
2186 fail: | |
2187 return -1; // free_tables will clean up for us | |
2188 } | |
2189 | |
1168 | 2190 static void common_init(H264Context *h){ |
2191 MpegEncContext * const s = &h->s; | |
2192 | |
2193 s->width = s->avctx->width; | |
2194 s->height = s->avctx->height; | |
2195 s->codec_id= s->avctx->codec->id; | |
2967 | 2196 |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5631
diff
changeset
|
2197 ff_h264_pred_init(&h->hpc, s->codec_id); |
1168 | 2198 |
2919 | 2199 h->dequant_coeff_pps= -1; |
1698 | 2200 s->unrestricted_mv=1; |
1168 | 2201 s->decode=1; //FIXME |
2920 | 2202 |
2203 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
2204 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 2205 } |
2206 | |
2207 static int decode_init(AVCodecContext *avctx){ | |
2208 H264Context *h= avctx->priv_data; | |
2209 MpegEncContext * const s = &h->s; | |
2210 | |
1892 | 2211 MPV_decode_defaults(s); |
2967 | 2212 |
1168 | 2213 s->avctx = avctx; |
2214 common_init(h); | |
2215 | |
2216 s->out_format = FMT_H264; | |
2217 s->workaround_bugs= avctx->workaround_bugs; | |
2218 | |
2219 // set defaults | |
2220 // s->decode_mb= ff_h263_decode_mb; | |
5338
5c1695f0f3e4
fix visual painting of MVs from h264: they are painted twice too long
gpoirier
parents:
5262
diff
changeset
|
2221 s->quarter_sample = 1; |
1168 | 2222 s->low_delay= 1; |
2223 avctx->pix_fmt= PIX_FMT_YUV420P; | |
2224 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
2225 decode_init_vlc(); |
2967 | 2226 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
2227 if(avctx->extradata_size > 0 && avctx->extradata && |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
2228 *(char *)avctx->extradata == 1){ |
2227 | 2229 h->is_avc = 1; |
2230 h->got_avcC = 0; | |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
2231 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
2232 h->is_avc = 0; |
2227 | 2233 } |
2234 | |
5642 | 2235 h->thread_context[0] = h; |
1168 | 2236 return 0; |
2237 } | |
2238 | |
2935 | 2239 static int frame_start(H264Context *h){ |
1168 | 2240 MpegEncContext * const s = &h->s; |
2241 int i; | |
2242 | |
2935 | 2243 if(MPV_frame_start(s, s->avctx) < 0) |
2244 return -1; | |
1168 | 2245 ff_er_frame_start(s); |
2246 | |
2247 assert(s->linesize && s->uvlinesize); | |
2248 | |
2249 for(i=0; i<16; i++){ | |
2250 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3); | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2251 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 2252 } |
2253 for(i=0; i<4; i++){ | |
2254 h->block_offset[16+i]= | |
2255 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3); | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2256 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2257 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 2258 } |
2259 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2260 /* can't be in alloc_tables because linesize isn't known there. |
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2261 * FIXME: redo bipred weight to not require extra buffer? */ |
5642 | 2262 for(i = 0; i < s->avctx->thread_count; i++) |
2263 if(!h->thread_context[i]->s.obmc_scratchpad) | |
2264 h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); | |
3316 | 2265 |
2266 /* some macroblocks will be accessed before they're available */ | |
5642 | 2267 if(FRAME_MBAFF || s->avctx->thread_count > 1) |
3316 | 2268 memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(uint8_t)); |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2269 |
1168 | 2270 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 2271 return 0; |
1168 | 2272 } |
2273 | |
5106 | 2274 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){ |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2275 MpegEncContext * const s = &h->s; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2276 int i; |
2967 | 2277 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2278 src_y -= linesize; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2279 src_cb -= uvlinesize; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2280 src_cr -= uvlinesize; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2281 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2282 // There are two lines saved, the line above the the top macroblock of a pair, |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2283 // and the line above the bottom macroblock |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2284 h->left_border[0]= h->top_borders[0][s->mb_x][15]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2285 for(i=1; i<17; i++){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2286 h->left_border[i]= src_y[15+i* linesize]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2287 } |
2967 | 2288 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2289 *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 16*linesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2290 *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2291 |
5434 | 2292 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2293 h->left_border[17 ]= h->top_borders[0][s->mb_x][16+7]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2294 h->left_border[17+9]= h->top_borders[0][s->mb_x][24+7]; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2295 for(i=1; i<9; i++){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2296 h->left_border[i+17 ]= src_cb[7+i*uvlinesize]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2297 h->left_border[i+17+9]= src_cr[7+i*uvlinesize]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2298 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2299 *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2300 *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2301 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2302 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2303 |
5106 | 2304 static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int simple){ |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2305 MpegEncContext * const s = &h->s; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2306 int temp8, i; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2307 uint64_t temp64; |
5177
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2308 int deblock_left; |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2309 int deblock_top; |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2310 int mb_xy; |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2311 |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2312 if(h->deblocking_filter == 2) { |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2313 mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2314 deblock_left = h->slice_table[mb_xy] == h->slice_table[mb_xy - 1]; |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2315 deblock_top = h->slice_table[mb_xy] == h->slice_table[h->top_mb_xy]; |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2316 } else { |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2317 deblock_left = (s->mb_x > 0); |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2318 deblock_top = (s->mb_y > 0); |
ea61020e5e87
Don't swap back un-deblocked lines for intra prediction when
gpoirier
parents:
5174
diff
changeset
|
2319 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2320 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2321 src_y -= linesize + 1; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2322 src_cb -= uvlinesize + 1; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2323 src_cr -= uvlinesize + 1; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2324 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2325 #define XCHG(a,b,t,xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2326 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2327 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2328 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2329 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2330 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2331 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2332 for(i = !deblock_top; i<17; i++){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2333 XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2334 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2335 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2336 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2337 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2338 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2339 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 2340 if(s->mb_x+1 < s->mb_width){ |
2755 | 2341 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
2342 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2343 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2344 |
5434 | 2345 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2346 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2347 for(i = !deblock_top; i<9; i++){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2348 XCHG(h->left_border[i+17 ], src_cb[i*uvlinesize], temp8, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2349 XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2350 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2351 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2352 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2353 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2354 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2355 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2356 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2357 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2358 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2359 static inline void backup_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2360 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2361 int i; |
2967 | 2362 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2363 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2364 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2365 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2366 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2367 // There are two lines saved, the line above the the top macroblock of a pair, |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2368 // and the line above the bottom macroblock |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2369 h->left_border[0]= h->top_borders[0][s->mb_x][15]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2370 h->left_border[1]= h->top_borders[1][s->mb_x][15]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2371 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2372 h->left_border[i]= src_y[15+i* linesize]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2373 } |
2967 | 2374 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2375 *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y + 32*linesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2376 *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+32*linesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2377 *(uint64_t*)(h->top_borders[1][s->mb_x]+0)= *(uint64_t*)(src_y + 33*linesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2378 *(uint64_t*)(h->top_borders[1][s->mb_x]+8)= *(uint64_t*)(src_y +8+33*linesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2379 |
5434 | 2380 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2381 h->left_border[34 ]= h->top_borders[0][s->mb_x][16+7]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2382 h->left_border[34+ 1]= h->top_borders[1][s->mb_x][16+7]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2383 h->left_border[34+18 ]= h->top_borders[0][s->mb_x][24+7]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2384 h->left_border[34+18+1]= h->top_borders[1][s->mb_x][24+7]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2385 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2386 h->left_border[i+34 ]= src_cb[7+i*uvlinesize]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2387 h->left_border[i+34+18]= src_cr[7+i*uvlinesize]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2388 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2389 *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+16*uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2390 *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+16*uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2391 *(uint64_t*)(h->top_borders[1][s->mb_x]+16)= *(uint64_t*)(src_cb+17*uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2392 *(uint64_t*)(h->top_borders[1][s->mb_x]+24)= *(uint64_t*)(src_cr+17*uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2393 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2394 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2395 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2396 static inline void xchg_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2397 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2398 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2399 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2400 int deblock_left = (s->mb_x > 0); |
3316 | 2401 int deblock_top = (s->mb_y > 1); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2402 |
4600 | 2403 tprintf(s->avctx, "xchg_pair_border: src_y:%p src_cb:%p src_cr:%p ls:%d uvls:%d\n", src_y, src_cb, src_cr, linesize, uvlinesize); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2404 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2405 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2406 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2407 src_cr -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2408 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2409 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2410 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2411 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2412 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2413 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2414 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2415 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2416 for(i = (!deblock_top)<<1; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2417 XCHG(h->left_border[i ], src_y [i* linesize], temp8, xchg); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2418 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2419 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2420 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2421 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2422 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2423 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2424 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+0), *(uint64_t*)(src_y +1 +linesize), temp64, xchg); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2425 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 2426 if(s->mb_x+1 < s->mb_width){ |
2427 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
2428 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
2429 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2430 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2431 |
5434 | 2432 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2433 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2434 for(i = (!deblock_top) << 1; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2435 XCHG(h->left_border[i+34 ], src_cb[i*uvlinesize], temp8, xchg); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2436 XCHG(h->left_border[i+34+18], src_cr[i*uvlinesize], temp8, xchg); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2437 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2438 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2439 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2440 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2441 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2442 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+16), *(uint64_t*)(src_cb+1 +uvlinesize), temp64, 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2443 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+24), *(uint64_t*)(src_cr+1 +uvlinesize), temp64, 1); |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
2444 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2445 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2446 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2447 |
4908
777f250df232
Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents:
4896
diff
changeset
|
2448 static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){ |
1168 | 2449 MpegEncContext * const s = &h->s; |
2450 const int mb_x= s->mb_x; | |
2451 const int mb_y= s->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:
1174
diff
changeset
|
2452 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 2453 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2454 uint8_t *dest_y, *dest_cb, *dest_cr; | |
2455 int linesize, uvlinesize /*dct_offset*/; | |
2456 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2457 int *block_offset = &h->block_offset[0]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2458 const unsigned int bottom = mb_y & 1; |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2459 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass), is_h264 = (simple || s->codec_id == CODEC_ID_H264); |
2763 | 2460 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2461 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 2462 |
2463 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
2464 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
2465 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
2466 | |
4000 | 2467 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
2468 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
2469 | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2470 if (!simple && MB_FIELD) { |
3316 | 2471 linesize = h->mb_linesize = s->linesize * 2; |
2472 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2473 block_offset = &h->block_offset[24]; |
1168 | 2474 if(mb_y&1){ //FIXME move out of this func? |
2475 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2476 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2477 dest_cr-= s->uvlinesize*7; |
1168 | 2478 } |
3316 | 2479 if(FRAME_MBAFF) { |
2480 int list; | |
4533 | 2481 for(list=0; list<h->list_count; list++){ |
3316 | 2482 if(!USES_LIST(mb_type, list)) |
2483 continue; | |
2484 if(IS_16X16(mb_type)){ | |
2485 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
2486 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
2487 }else{ | |
2488 for(i=0; i<16; i+=4){ | |
2489 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
2490 int ref = h->ref_cache[list][scan8[i]]; | |
2491 if(ref >= 0) | |
2492 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
2493 } | |
2494 } | |
2495 } | |
2496 } | |
1168 | 2497 } else { |
3316 | 2498 linesize = h->mb_linesize = s->linesize; |
2499 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 2500 // dct_offset = s->linesize * 16; |
2501 } | |
2967 | 2502 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2503 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2504 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2505 idct_add = IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2506 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2507 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2508 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2509 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2510 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2511 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2512 } |
1168 | 2513 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2514 if(!simple && FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3316 | 2515 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ |
2516 int mbt_y = mb_y&~1; | |
2517 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
2518 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
2519 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
2520 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
2521 } | |
2522 | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2523 if (!simple && IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2524 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2525 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2526 // The pixels are stored in h->mb array in the same order as levels, |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2527 // copy them in output in the correct order. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2528 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2529 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2530 for (x=0; x<4; x++) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2531 *(dest_y + block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x]; |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2532 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2533 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2534 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2535 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2536 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2537 for (x=0; x<4; x++) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2538 *(dest_cb + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x]; |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2539 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2540 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2541 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2542 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2543 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2544 for (x=0; x<4; x++) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2545 *(dest_cr + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x]; |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2546 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2547 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
2548 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2549 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2550 if(IS_INTRA(mb_type)){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2551 if(h->deblocking_filter && (simple || !FRAME_MBAFF)) |
5106 | 2552 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple); |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2553 |
5434 | 2554 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5631
diff
changeset
|
2555 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize); |
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5631
diff
changeset
|
2556 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize); |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2557 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2558 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2559 if(IS_INTRA4x4(mb_type)){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2560 if(simple || !s->encoding){ |
2755 | 2561 if(IS_8x8DCT(mb_type)){ |
2562 for(i=0; i<16; i+=4){ | |
2563 uint8_t * const ptr= dest_y + block_offset[i]; | |
2564 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ]; | |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2565 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5631
diff
changeset
|
2566 h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
4546 | 2567 (h->topright_samples_available<<i)&0x4000, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2568 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2569 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2570 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2571 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2572 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2573 } |
2755 | 2574 } |
2575 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2576 for(i=0; i<16; i++){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2577 uint8_t * const ptr= dest_y + block_offset[i]; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2578 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2579 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ]; |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2580 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2581 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2582 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2583 const int topright_avail= (h->topright_samples_available<<i)&0x8000; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2584 assert(mb_y || linesize <= block_offset[i]); |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2585 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2586 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2587 topright= (uint8_t*) &tr; |
2967 | 2588 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2589 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2590 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2591 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2592 |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5631
diff
changeset
|
2593 h->hpc.pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2594 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2595 if(nnz){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2596 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2597 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2598 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2599 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2600 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2601 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2602 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0); |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2603 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2604 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2605 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2606 }else{ |
5638
4a26dc4ca11d
Move H.264 intra prediction functions into their own context
kostya
parents:
5631
diff
changeset
|
2607 h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2608 if(is_h264){ |
2763 | 2609 if(!transform_bypass) |
2919 | 2610 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 2611 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2612 svq3_luma_dc_dequant_idct_c(h->mb, s->qscale); |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2613 } |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2614 if(h->deblocking_filter && (simple || !FRAME_MBAFF)) |
5106 | 2615 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple); |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2616 }else if(is_h264){ |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2617 hl_motion(h, dest_y, dest_cb, dest_cr, |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
2618 s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab, |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
2619 s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab, |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2620 s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab); |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2621 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2622 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2623 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2624 if(!IS_INTRA4x4(mb_type)){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2625 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2626 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2627 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2628 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2629 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2630 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2631 idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2632 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2633 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2634 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2635 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2636 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2637 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2638 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2639 idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2640 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2641 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2642 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2643 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2644 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2645 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2646 for(i=0; i<16; i++){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2647 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2648 uint8_t * const ptr= dest_y + block_offset[i]; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2649 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 2650 } |
1168 | 2651 } |
2652 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2653 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2654 |
5434 | 2655 if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2656 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2657 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2658 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2659 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2660 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2661 idct_dc_add = s->dsp.h264_idct_dc_add; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
2662 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp[0], h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
2663 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp[1], h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]); |
2763 | 2664 } |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2665 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2666 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2667 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2668 idct_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2669 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2670 idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize); |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2671 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2672 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2673 for(i=16; i<16+8; i++){ |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2674 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
2675 uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i]; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2676 svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2); |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
2677 } |
1250 | 2678 } |
1168 | 2679 } |
2680 } | |
2681 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2682 if(h->deblocking_filter) { |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2683 if (!simple && FRAME_MBAFF) { |
3316 | 2684 //FIXME try deblocking one mb at a time? |
2685 // the reduction in load/storing mvs and such might outweigh the extra backup/xchg_border | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2686 const int mb_y = s->mb_y - 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2687 uint8_t *pair_dest_y, *pair_dest_cb, *pair_dest_cr; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2688 const int mb_xy= mb_x + mb_y*s->mb_stride; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2689 const int mb_type_top = s->current_picture.mb_type[mb_xy]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2690 const int mb_type_bottom= s->current_picture.mb_type[mb_xy+s->mb_stride]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2691 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2692 pair_dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2693 pair_dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2694 pair_dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2695 |
3316 | 2696 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
2697 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
2698 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2699 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 2700 // deblock a pair |
2967 | 2701 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2702 s->mb_y--; |
4600 | 2703 tprintf(h->s.avctx, "call mbaff filter_mb mb_x:%d mb_y:%d pair_dest_y = %p, dest_y = %p\n", mb_x, mb_y, pair_dest_y, dest_y); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2704 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
2705 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
2706 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2707 filter_mb(h, mb_x, mb_y, pair_dest_y, pair_dest_cb, pair_dest_cr, linesize, uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2708 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2709 s->mb_y++; |
4600 | 2710 tprintf(h->s.avctx, "call mbaff filter_mb\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2711 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
2712 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy+s->mb_stride]); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
2713 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy+s->mb_stride]); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2714 filter_mb(h, mb_x, mb_y+1, dest_y, dest_cb, dest_cr, linesize, uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2715 } else { |
4600 | 2716 tprintf(h->s.avctx, "call filter_mb\n"); |
5106 | 2717 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, simple); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2718 fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
2719 filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2720 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2721 } |
1168 | 2722 } |
2723 | |
2724 /** | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2725 * Process a macroblock; this case avoids checks for expensive uncommon cases. |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2726 */ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2727 static void hl_decode_mb_simple(H264Context *h){ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2728 hl_decode_mb_internal(h, 1); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2729 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2730 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2731 /** |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2732 * Process a macroblock; this handles edge cases, such as interlacing. |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2733 */ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2734 static void av_noinline hl_decode_mb_complex(H264Context *h){ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2735 hl_decode_mb_internal(h, 0); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2736 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2737 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2738 static void hl_decode_mb(H264Context *h){ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2739 MpegEncContext * const s = &h->s; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2740 const int mb_x= s->mb_x; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2741 const int mb_y= s->mb_y; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2742 const int mb_xy= mb_x + mb_y*s->mb_stride; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2743 const int mb_type= s->current_picture.mb_type[mb_xy]; |
5434 | 2744 int is_complex = FRAME_MBAFF || MB_FIELD || IS_INTRA_PCM(mb_type) || s->codec_id != CODEC_ID_H264 || (ENABLE_GRAY && (s->flags&CODEC_FLAG_GRAY)) || s->encoding; |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2745 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2746 if(!s->decode) |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2747 return; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2748 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2749 if (is_complex) |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2750 hl_decode_mb_complex(h); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2751 else hl_decode_mb_simple(h); |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2752 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2753 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
2754 /** |
1168 | 2755 * fills the default_ref_list. |
2756 */ | |
2757 static int fill_default_ref_list(H264Context *h){ | |
2758 MpegEncContext * const s = &h->s; | |
2759 int i; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2760 int smallest_poc_greater_than_current = -1; |
2582 | 2761 Picture sorted_short_ref[32]; |
2967 | 2762 |
1168 | 2763 if(h->slice_type==B_TYPE){ |
2764 int out_i; | |
2713 | 2765 int limit= INT_MIN; |
1168 | 2766 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2767 /* sort frame according to poc in B slice */ |
1168 | 2768 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 2769 int best_i=INT_MIN; |
2255
507690ff49a2
assertion when playing AVC/H.264 streams fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2254
diff
changeset
|
2770 int best_poc=INT_MAX; |
1168 | 2771 |
2772 for(i=0; i<h->short_ref_count; i++){ | |
2773 const int poc= h->short_ref[i]->poc; | |
2774 if(poc > limit && poc < best_poc){ | |
2775 best_poc= poc; | |
2776 best_i= i; | |
2777 } | |
2778 } | |
2967 | 2779 |
2713 | 2780 assert(best_i != INT_MIN); |
2967 | 2781 |
1168 | 2782 limit= best_poc; |
2783 sorted_short_ref[out_i]= *h->short_ref[best_i]; | |
4600 | 2784 tprintf(h->s.avctx, "sorted poc: %d->%d poc:%d fn:%d\n", best_i, out_i, sorted_short_ref[out_i].poc, sorted_short_ref[out_i].frame_num); |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2785 if (-1 == smallest_poc_greater_than_current) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2786 if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2787 smallest_poc_greater_than_current = out_i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2788 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2789 } |
1168 | 2790 } |
2791 } | |
2792 | |
2793 if(s->picture_structure == PICT_FRAME){ | |
2794 if(h->slice_type==B_TYPE){ | |
2795 int list; | |
4600 | 2796 tprintf(h->s.avctx, "current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current); |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2797 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2798 // find the largest poc |
1168 | 2799 for(list=0; list<2; list++){ |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2800 int index = 0; |
2447 | 2801 int j= -99; |
2802 int step= list ? -1 : 1; | |
2803 | |
2804 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
2805 while(j<0 || j>= h->short_ref_count){ | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2806 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2807 return -1; |
2447 | 2808 step = -step; |
2809 j= smallest_poc_greater_than_current + (step>>1); | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2810 } |
2447 | 2811 if(sorted_short_ref[j].reference != 3) continue; |
2812 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
2813 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 2814 } |
2815 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2816 for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2817 if(h->long_ref[i] == NULL) continue; |
1168 | 2818 if(h->long_ref[i]->reference != 3) continue; |
2819 | |
2820 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
2821 h->default_ref_list[ list ][index++].pic_id= i;; | |
2822 } | |
2967 | 2823 |
2447 | 2824 if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){ |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2825 // swap the two first elements of L1 when |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2826 // L0 and L1 are identical |
1168 | 2827 Picture temp= h->default_ref_list[1][0]; |
2828 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 2829 h->default_ref_list[1][1] = temp; |
1168 | 2830 } |
2831 | |
2832 if(index < h->ref_count[ list ]) | |
2833 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
2834 } | |
2835 }else{ | |
2836 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
2837 for(i=0; i<h->short_ref_count; i++){ |
1168 | 2838 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
2839 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
2840 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
2841 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
2842 for(i = 0; i < 16; i++){ |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2843 if(h->long_ref[i] == NULL) continue; |
1168 | 2844 if(h->long_ref[i]->reference != 3) continue; |
2845 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
2846 h->default_ref_list[0][index++].pic_id= i;; | |
2847 } | |
2848 if(index < h->ref_count[0]) | |
2849 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
2850 } | |
2851 }else{ //FIELD | |
2852 if(h->slice_type==B_TYPE){ | |
2853 }else{ | |
2854 //FIXME second field balh | |
2855 } | |
2856 } | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2857 #ifdef TRACE |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2858 for (i=0; i<h->ref_count[0]; i++) { |
4600 | 2859 tprintf(h->s.avctx, "List0: %s fn:%d 0x%p\n", (h->default_ref_list[0][i].long_ref ? "LT" : "ST"), h->default_ref_list[0][i].pic_id, h->default_ref_list[0][i].data[0]); |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2860 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2861 if(h->slice_type==B_TYPE){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2862 for (i=0; i<h->ref_count[1]; i++) { |
4600 | 2863 tprintf(h->s.avctx, "List1: %s fn:%d 0x%p\n", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[0][i].data[0]); |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2864 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2865 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2866 #endif |
1168 | 2867 return 0; |
2868 } | |
2869 | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2870 static void print_short_term(H264Context *h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2871 static void print_long_term(H264Context *h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2872 |
1168 | 2873 static int decode_ref_pic_list_reordering(H264Context *h){ |
2874 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2875 int list, index; |
2967 | 2876 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2877 print_short_term(h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
2878 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2879 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 2880 |
4533 | 2881 for(list=0; list<h->list_count; list++){ |
1168 | 2882 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); |
2883 | |
2884 if(get_bits1(&s->gb)){ | |
2885 int pred= h->curr_pic_num; | |
2886 | |
2887 for(index=0; ; index++){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2888 unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2889 unsigned int pic_id; |
1168 | 2890 int i; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
2891 Picture *ref = NULL; |
2967 | 2892 |
2893 if(reordering_of_pic_nums_idc==3) | |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
2894 break; |
2967 | 2895 |
1168 | 2896 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
2897 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 2898 return -1; |
2899 } | |
2967 | 2900 |
1168 | 2901 if(reordering_of_pic_nums_idc<3){ |
2902 if(reordering_of_pic_nums_idc<2){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2903 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; |
1168 | 2904 |
2905 if(abs_diff_pic_num >= h->max_pic_num){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
2906 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 2907 return -1; |
2908 } | |
2909 | |
2910 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
2911 else pred+= abs_diff_pic_num; | |
2912 pred &= h->max_pic_num - 1; | |
2967 | 2913 |
2683 | 2914 for(i= h->short_ref_count-1; i>=0; i--){ |
2915 ref = h->short_ref[i]; | |
2916 assert(ref->reference == 3); | |
2917 assert(!ref->long_ref); | |
2918 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 2919 break; |
2920 } | |
2683 | 2921 if(i>=0) |
2922 ref->pic_id= ref->frame_num; | |
1168 | 2923 }else{ |
2924 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2925 if(pic_id>31){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2926 av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2927 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
2928 } |
2683 | 2929 ref = h->long_ref[pic_id]; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2930 if(ref){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2931 ref->pic_id= pic_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2932 assert(ref->reference == 3); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2933 assert(ref->long_ref); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2934 i=0; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2935 }else{ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2936 i=-1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
2937 } |
1168 | 2938 } |
2939 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
2940 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
2941 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 2942 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 2943 } else { |
2944 for(i=index; i+1<h->ref_count[list]; i++){ | |
2945 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
2946 break; | |
2650
d321fbf0b2ce
reverse 1 hunk from 1.96->1.97, fixes decoding of (MR1_BT_A.h264 and MR1_MW_A.264)
michael
parents:
2649
diff
changeset
|
2947 } |
d321fbf0b2ce
reverse 1 hunk from 1.96->1.97, fixes decoding of (MR1_BT_A.h264 and MR1_MW_A.264)
michael
parents:
2649
diff
changeset
|
2948 for(; i > index; i--){ |
d321fbf0b2ce
reverse 1 hunk from 1.96->1.97, fixes decoding of (MR1_BT_A.h264 and MR1_MW_A.264)
michael
parents:
2649
diff
changeset
|
2949 h->ref_list[list][i]= h->ref_list[list][i-1]; |
d321fbf0b2ce
reverse 1 hunk from 1.96->1.97, fixes decoding of (MR1_BT_A.h264 and MR1_MW_A.264)
michael
parents:
2649
diff
changeset
|
2950 } |
2683 | 2951 h->ref_list[list][index]= *ref; |
1168 | 2952 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
2953 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
2954 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 2955 return -1; |
2956 } | |
2957 } | |
2958 } | |
4533 | 2959 } |
2960 for(list=0; list<h->list_count; list++){ | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2961 for(index= 0; index < h->ref_count[list]; index++){ |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2962 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2963 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2964 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
2965 } |
2967 | 2966 |
2396 | 2967 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
2968 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
2969 direct_ref_list_init(h); |
2967 | 2970 return 0; |
1168 | 2971 } |
2972 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
2973 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 2974 int list, i, j; |
4533 | 2975 for(list=0; list<2; list++){ //FIXME try list_count |
3316 | 2976 for(i=0; i<h->ref_count[list]; i++){ |
2977 Picture *frame = &h->ref_list[list][i]; | |
2978 Picture *field = &h->ref_list[list][16+2*i]; | |
2979 field[0] = *frame; | |
2980 for(j=0; j<3; j++) | |
2981 field[0].linesize[j] <<= 1; | |
2982 field[1] = field[0]; | |
2983 for(j=0; j<3; j++) | |
2984 field[1].data[j] += frame->linesize[j]; | |
2985 | |
2986 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
2987 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
2988 for(j=0; j<2; j++){ | |
2989 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
2990 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
2991 } | |
2992 } | |
2993 } | |
2994 for(j=0; j<h->ref_count[1]; j++){ | |
2995 for(i=0; i<h->ref_count[0]; i++) | |
2996 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
2997 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
2998 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
2999 } | |
3000 } | |
3001 | |
1168 | 3002 static int pred_weight_table(H264Context *h){ |
3003 MpegEncContext * const s = &h->s; | |
3004 int list, i; | |
2415 | 3005 int luma_def, chroma_def; |
2967 | 3006 |
2415 | 3007 h->use_weight= 0; |
3008 h->use_weight_chroma= 0; | |
1168 | 3009 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
3010 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 3011 luma_def = 1<<h->luma_log2_weight_denom; |
3012 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 3013 |
3014 for(list=0; list<2; list++){ | |
3015 for(i=0; i<h->ref_count[list]; i++){ | |
3016 int luma_weight_flag, chroma_weight_flag; | |
2967 | 3017 |
1168 | 3018 luma_weight_flag= get_bits1(&s->gb); |
3019 if(luma_weight_flag){ | |
3020 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
3021 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 3022 if( h->luma_weight[list][i] != luma_def |
3023 || h->luma_offset[list][i] != 0) | |
3024 h->use_weight= 1; | |
3025 }else{ | |
3026 h->luma_weight[list][i]= luma_def; | |
3027 h->luma_offset[list][i]= 0; | |
1168 | 3028 } |
3029 | |
3030 chroma_weight_flag= get_bits1(&s->gb); | |
3031 if(chroma_weight_flag){ | |
3032 int j; | |
3033 for(j=0; j<2; j++){ | |
3034 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
3035 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 3036 if( h->chroma_weight[list][i][j] != chroma_def |
3037 || h->chroma_offset[list][i][j] != 0) | |
3038 h->use_weight_chroma= 1; | |
3039 } | |
3040 }else{ | |
3041 int j; | |
3042 for(j=0; j<2; j++){ | |
3043 h->chroma_weight[list][i][j]= chroma_def; | |
3044 h->chroma_offset[list][i][j]= 0; | |
1168 | 3045 } |
3046 } | |
3047 } | |
3048 if(h->slice_type != B_TYPE) break; | |
3049 } | |
2415 | 3050 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 3051 return 0; |
3052 } | |
3053 | |
2415 | 3054 static void implicit_weight_table(H264Context *h){ |
3055 MpegEncContext * const s = &h->s; | |
3056 int ref0, ref1; | |
3057 int cur_poc = s->current_picture_ptr->poc; | |
3058 | |
3059 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
3060 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
3061 h->use_weight= 0; | |
3062 h->use_weight_chroma= 0; | |
3063 return; | |
3064 } | |
3065 | |
3066 h->use_weight= 2; | |
3067 h->use_weight_chroma= 2; | |
3068 h->luma_log2_weight_denom= 5; | |
3069 h->chroma_log2_weight_denom= 5; | |
3070 | |
3071 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
3072 int poc0 = h->ref_list[0][ref0].poc; | |
3073 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 3074 int poc1 = h->ref_list[1][ref1].poc; |
4594 | 3075 int td = av_clip(poc1 - poc0, -128, 127); |
2415 | 3076 if(td){ |
4594 | 3077 int tb = av_clip(cur_poc - poc0, -128, 127); |
4001 | 3078 int tx = (16384 + (FFABS(td) >> 1)) / td; |
4594 | 3079 int dist_scale_factor = av_clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
2415 | 3080 if(dist_scale_factor < -64 || dist_scale_factor > 128) |
3081 h->implicit_weight[ref0][ref1] = 32; | |
3082 else | |
3083 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
3084 }else | |
3085 h->implicit_weight[ref0][ref1] = 32; | |
3086 } | |
3087 } | |
3088 } | |
3089 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3090 static inline void unreference_pic(H264Context *h, Picture *pic){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3091 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3092 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3093 if(pic == h->delayed_output_pic) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3094 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3095 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3096 for(i = 0; h->delayed_pic[i]; i++) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3097 if(pic == h->delayed_pic[i]){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3098 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3099 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3100 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3101 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3102 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3103 |
1168 | 3104 /** |
2392 | 3105 * instantaneous decoder refresh. |
1168 | 3106 */ |
3107 static void idr(H264Context *h){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3108 int i; |
1168 | 3109 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3110 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3111 if (h->long_ref[i] != NULL) { |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3112 unreference_pic(h, h->long_ref[i]); |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3113 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3114 } |
1168 | 3115 } |
3116 h->long_ref_count=0; | |
3117 | |
3118 for(i=0; i<h->short_ref_count; i++){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3119 unreference_pic(h, h->short_ref[i]); |
1168 | 3120 h->short_ref[i]= NULL; |
3121 } | |
3122 h->short_ref_count=0; | |
3123 } | |
3124 | |
2640 | 3125 /* forget old pics after a seek */ |
3126 static void flush_dpb(AVCodecContext *avctx){ | |
3127 H264Context *h= avctx->priv_data; | |
3128 int i; | |
3144 | 3129 for(i=0; i<16; i++) { |
3130 if(h->delayed_pic[i]) | |
3131 h->delayed_pic[i]->reference= 0; | |
2640 | 3132 h->delayed_pic[i]= NULL; |
3144 | 3133 } |
3134 if(h->delayed_output_pic) | |
3135 h->delayed_output_pic->reference= 0; | |
2640 | 3136 h->delayed_output_pic= NULL; |
3137 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
3138 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
3139 h->s.current_picture_ptr->reference= 0; |
2640 | 3140 } |
3141 | |
1168 | 3142 /** |
3143 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3144 * @return the removed picture or NULL if an error occurs |
1168 | 3145 */ |
3146 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 3147 MpegEncContext * const s = &h->s; |
1168 | 3148 int i; |
2967 | 3149 |
1169 | 3150 if(s->avctx->debug&FF_DEBUG_MMCO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3151 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 3152 |
1168 | 3153 for(i=0; i<h->short_ref_count; i++){ |
3154 Picture *pic= h->short_ref[i]; | |
1169 | 3155 if(s->avctx->debug&FF_DEBUG_MMCO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3156 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 3157 if(pic->frame_num == frame_num){ |
3158 h->short_ref[i]= NULL; | |
5643
bf02fa211648
Avoid a crash when H264 MMC operation causes the short term reference
benoit
parents:
5642
diff
changeset
|
3159 if (--h->short_ref_count) |
bf02fa211648
Avoid a crash when H264 MMC operation causes the short term reference
benoit
parents:
5642
diff
changeset
|
3160 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i)*sizeof(Picture*)); |
1168 | 3161 return pic; |
3162 } | |
3163 } | |
3164 return NULL; | |
3165 } | |
3166 | |
3167 /** | |
3168 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3169 * @return the removed picture or NULL if an error occurs |
1168 | 3170 */ |
3171 static Picture * remove_long(H264Context *h, int i){ | |
3172 Picture *pic; | |
3173 | |
3174 pic= h->long_ref[i]; | |
3175 h->long_ref[i]= NULL; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3176 if(pic) h->long_ref_count--; |
1168 | 3177 |
3178 return pic; | |
3179 } | |
3180 | |
3181 /** | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3182 * print short term list |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3183 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3184 static void print_short_term(H264Context *h) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3185 uint32_t i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3186 if(h->s.avctx->debug&FF_DEBUG_MMCO) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3187 av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n"); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3188 for(i=0; i<h->short_ref_count; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3189 Picture *pic= h->short_ref[i]; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3190 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3191 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3192 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3193 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3194 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3195 /** |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3196 * print long term list |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3197 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3198 static void print_long_term(H264Context *h) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3199 uint32_t i; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3200 if(h->s.avctx->debug&FF_DEBUG_MMCO) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3201 av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n"); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3202 for(i = 0; i < 16; i++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3203 Picture *pic= h->long_ref[i]; |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3204 if (pic) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3205 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3206 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3207 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3208 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3209 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3210 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3211 /** |
1168 | 3212 * Executes the reference picture marking (memory management control operations). |
3213 */ | |
3214 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
3215 MpegEncContext * const s = &h->s; | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3216 int i, j; |
1168 | 3217 int current_is_long=0; |
3218 Picture *pic; | |
2967 | 3219 |
1168 | 3220 if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3221 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 3222 |
1168 | 3223 for(i=0; i<mmco_count; i++){ |
3224 if(s->avctx->debug&FF_DEBUG_MMCO) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3225 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index); |
1168 | 3226 |
3227 switch(mmco[i].opcode){ | |
3228 case MMCO_SHORT2UNUSED: | |
3229 pic= remove_short(h, mmco[i].short_frame_num); | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3230 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3231 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3232 else if(s->avctx->debug&FF_DEBUG_MMCO) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3233 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 3234 break; |
3235 case MMCO_SHORT2LONG: | |
3236 pic= remove_long(h, mmco[i].long_index); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3237 if(pic) unreference_pic(h, pic); |
2967 | 3238 |
1168 | 3239 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3240 if (h->long_ref[ mmco[i].long_index ]){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3241 h->long_ref[ mmco[i].long_index ]->long_ref=1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3242 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3243 } |
1168 | 3244 break; |
3245 case MMCO_LONG2UNUSED: | |
3246 pic= remove_long(h, mmco[i].long_index); | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3247 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3248 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3249 else if(s->avctx->debug&FF_DEBUG_MMCO) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3250 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 3251 break; |
3252 case MMCO_LONG: | |
3253 pic= remove_long(h, mmco[i].long_index); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3254 if(pic) unreference_pic(h, pic); |
2967 | 3255 |
1168 | 3256 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
3257 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
3258 h->long_ref_count++; | |
2967 | 3259 |
1168 | 3260 current_is_long=1; |
3261 break; | |
3262 case MMCO_SET_MAX_LONG: | |
3263 assert(mmco[i].long_index <= 16); | |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3264 // just remove the long term which index is greater than new max |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3265 for(j = mmco[i].long_index; j<16; j++){ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3266 pic = remove_long(h, j); |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3267 if (pic) unreference_pic(h, pic); |
1168 | 3268 } |
3269 break; | |
3270 case MMCO_RESET: | |
3271 while(h->short_ref_count){ | |
3272 pic= remove_short(h, h->short_ref[0]->frame_num); | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3273 if(pic) unreference_pic(h, pic); |
1168 | 3274 } |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3275 for(j = 0; j < 16; j++) { |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3276 pic= remove_long(h, j); |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3277 if(pic) unreference_pic(h, pic); |
1168 | 3278 } |
3279 break; | |
3280 default: assert(0); | |
3281 } | |
3282 } | |
2967 | 3283 |
1168 | 3284 if(!current_is_long){ |
3285 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
3286 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3287 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3288 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 3289 } |
2967 | 3290 |
1168 | 3291 if(h->short_ref_count) |
1169 | 3292 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
3293 | |
3294 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 3295 h->short_ref[0]->long_ref=0; |
3296 h->short_ref_count++; | |
3297 } | |
2967 | 3298 |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3299 print_short_term(h); |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3300 print_long_term(h); |
2967 | 3301 return 0; |
1168 | 3302 } |
3303 | |
5172
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3304 static int decode_ref_pic_marking(H264Context *h, GetBitContext *gb){ |
1168 | 3305 MpegEncContext * const s = &h->s; |
3306 int i; | |
2967 | 3307 |
1168 | 3308 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
5172
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3309 s->broken_link= get_bits1(gb) -1; |
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3310 h->mmco[0].long_index= get_bits1(gb) - 1; // current_long_term_idx |
1168 | 3311 if(h->mmco[0].long_index == -1) |
3312 h->mmco_index= 0; | |
3313 else{ | |
3314 h->mmco[0].opcode= MMCO_LONG; | |
3315 h->mmco_index= 1; | |
2967 | 3316 } |
1168 | 3317 }else{ |
5172
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3318 if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag |
2967 | 3319 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
5172
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3320 MMCOOpcode opcode= get_ue_golomb(gb); |
1168 | 3321 |
3322 h->mmco[i].opcode= opcode; | |
3323 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
5172
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3324 h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields |
1168 | 3325 /* if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2844
diff
changeset
|
3326 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 3327 return -1; |
3328 }*/ | |
3329 } | |
3330 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
5172
60a4f209838b
Decouple bit context from h264 context in decode_ref_pic_marking()
gpoirier
parents:
5170
diff
changeset
|
3331 unsigned int long_index= get_ue_golomb(gb); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3332 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ long_index >= 16){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3333 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 3334 return -1; |
3335 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3336 h->mmco[i].long_index= long_index; |
1168 | 3337 } |
2967 | 3338 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3339 if(opcode > (unsigned)MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3340 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 3341 return -1; |
3342 } | |
2255
507690ff49a2
assertion when playing AVC/H.264 streams fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2254
diff
changeset
|
3343 if(opcode == MMCO_END) |
507690ff49a2
assertion when playing AVC/H.264 streams fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2254
diff
changeset
|
3344 break; |
1168 | 3345 } |
3346 h->mmco_index= i; | |
3347 }else{ | |
3348 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
3349 | |
3350 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
3351 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
3352 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
3353 h->mmco_index= 1; | |
3354 }else | |
3355 h->mmco_index= 0; | |
3356 } | |
3357 } | |
2967 | 3358 |
3359 return 0; | |
1168 | 3360 } |
3361 | |
3362 static int init_poc(H264Context *h){ | |
3363 MpegEncContext * const s = &h->s; | |
3364 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
3365 int field_poc[2]; | |
3366 | |
3367 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
3368 h->frame_num_offset= 0; | |
3369 }else{ | |
3370 if(h->frame_num < h->prev_frame_num) | |
3371 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
3372 else | |
3373 h->frame_num_offset= h->prev_frame_num_offset; | |
3374 } | |
3375 | |
3376 if(h->sps.poc_type==0){ | |
3377 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
3378 | |
2649
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
3379 if(h->nal_unit_type == NAL_IDR_SLICE){ |
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
3380 h->prev_poc_msb= |
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
3381 h->prev_poc_lsb= 0; |
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
3382 } |
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
3383 |
1168 | 3384 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
3385 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
3386 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
3387 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
3388 else | |
3389 h->poc_msb = h->prev_poc_msb; | |
3390 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 3391 field_poc[0] = |
1168 | 3392 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 3393 if(s->picture_structure == PICT_FRAME) |
1168 | 3394 field_poc[1] += h->delta_poc_bottom; |
3395 }else if(h->sps.poc_type==1){ | |
3396 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
3397 int i; | |
3398 | |
3399 if(h->sps.poc_cycle_length != 0) | |
3400 abs_frame_num = h->frame_num_offset + h->frame_num; | |
3401 else | |
3402 abs_frame_num = 0; | |
3403 | |
3404 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
3405 abs_frame_num--; | |
2967 | 3406 |
1168 | 3407 expected_delta_per_poc_cycle = 0; |
3408 for(i=0; i < h->sps.poc_cycle_length; i++) | |
3409 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
3410 | |
3411 if(abs_frame_num > 0){ | |
3412 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
3413 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
3414 | |
3415 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
3416 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
3417 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
3418 } else | |
3419 expectedpoc = 0; | |
3420 | |
2967 | 3421 if(h->nal_ref_idc == 0) |
1168 | 3422 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 3423 |
1168 | 3424 field_poc[0] = expectedpoc + h->delta_poc[0]; |
3425 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
3426 | |
3427 if(s->picture_structure == PICT_FRAME) | |
3428 field_poc[1] += h->delta_poc[1]; | |
3429 }else{ | |
3430 int poc; | |
3431 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
3432 poc= 0; | |
3433 }else{ | |
3434 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
3435 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
3436 } | |
3437 field_poc[0]= poc; | |
3438 field_poc[1]= poc; | |
3439 } | |
2967 | 3440 |
1168 | 3441 if(s->picture_structure != PICT_BOTTOM_FIELD) |
3442 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
3443 if(s->picture_structure != PICT_TOP_FIELD) | |
3444 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
3445 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
3446 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
3447 | |
3448 return 0; | |
3449 } | |
3450 | |
5160
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3451 |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3452 /** |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3453 * initialize scan tables |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3454 */ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3455 static void init_scan_tables(H264Context *h){ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3456 MpegEncContext * const s = &h->s; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3457 int i; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3458 if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3459 memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t)); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3460 memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t)); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3461 }else{ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3462 for(i=0; i<16; i++){ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3463 #define T(x) (x>>2) | ((x<<2) & 0xF) |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3464 h->zigzag_scan[i] = T(zigzag_scan[i]); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3465 h-> field_scan[i] = T( field_scan[i]); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3466 #undef T |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3467 } |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3468 } |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3469 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3470 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3471 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3472 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3473 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3474 }else{ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3475 for(i=0; i<64; i++){ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3476 #define T(x) (x>>3) | ((x&7)<<3) |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3477 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3478 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3479 h->field_scan8x8[i] = T(field_scan8x8[i]); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3480 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3481 #undef T |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3482 } |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3483 } |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3484 if(h->sps.transform_bypass){ //FIXME same ugly |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3485 h->zigzag_scan_q0 = zigzag_scan; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3486 h->zigzag_scan8x8_q0 = zigzag_scan8x8; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3487 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3488 h->field_scan_q0 = field_scan; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3489 h->field_scan8x8_q0 = field_scan8x8; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3490 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3491 }else{ |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3492 h->zigzag_scan_q0 = h->zigzag_scan; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3493 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3494 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3495 h->field_scan_q0 = h->field_scan; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3496 h->field_scan8x8_q0 = h->field_scan8x8; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3497 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3498 } |
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3499 } |
5642 | 3500 |
3501 /** | |
3502 * Replicates H264 "master" context to thread contexts. | |
3503 */ | |
3504 static void clone_slice(H264Context *dst, H264Context *src) | |
3505 { | |
3506 memcpy(dst->block_offset, src->block_offset, sizeof(dst->block_offset)); | |
3507 dst->s.current_picture_ptr = src->s.current_picture_ptr; | |
3508 dst->s.current_picture = src->s.current_picture; | |
3509 dst->s.linesize = src->s.linesize; | |
3510 dst->s.uvlinesize = src->s.uvlinesize; | |
3511 | |
3512 dst->prev_poc_msb = src->prev_poc_msb; | |
3513 dst->prev_poc_lsb = src->prev_poc_lsb; | |
3514 dst->prev_frame_num_offset = src->prev_frame_num_offset; | |
3515 dst->prev_frame_num = src->prev_frame_num; | |
3516 dst->short_ref_count = src->short_ref_count; | |
3517 | |
3518 memcpy(dst->short_ref, src->short_ref, sizeof(dst->short_ref)); | |
3519 memcpy(dst->long_ref, src->long_ref, sizeof(dst->long_ref)); | |
3520 memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list)); | |
3521 memcpy(dst->ref_list, src->ref_list, sizeof(dst->ref_list)); | |
5685
070a376d496b
fix image corruption when with multi-threaded decoding.
gpoirier
parents:
5647
diff
changeset
|
3522 |
070a376d496b
fix image corruption when with multi-threaded decoding.
gpoirier
parents:
5647
diff
changeset
|
3523 memcpy(dst->dequant4_coeff, src->dequant4_coeff, sizeof(src->dequant4_coeff)); |
070a376d496b
fix image corruption when with multi-threaded decoding.
gpoirier
parents:
5647
diff
changeset
|
3524 memcpy(dst->dequant8_coeff, src->dequant8_coeff, sizeof(src->dequant8_coeff)); |
5642 | 3525 } |
3526 | |
1168 | 3527 /** |
3528 * decodes a slice header. | |
3529 * this will allso call MPV_common_init() and frame_start() as needed | |
5642 | 3530 * |
3531 * @param h h264context | |
3532 * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding) | |
3533 * | |
3534 * @return 0 if okay, <0 if an error occured, 1 if decoding must not be multithreaded | |
1168 | 3535 */ |
5642 | 3536 static int decode_slice_header(H264Context *h, H264Context *h0){ |
1168 | 3537 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3538 unsigned int first_mb_in_slice; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3539 unsigned int pps_id; |
1168 | 3540 int num_ref_idx_active_override_flag; |
3541 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
5642 | 3542 unsigned int slice_type, tmp, i; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3543 int default_ref_list_done = 0; |
1168 | 3544 |
3545 s->current_picture.reference= h->nal_ref_idc != 0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3546 s->dropable= h->nal_ref_idc == 0; |
1168 | 3547 |
3548 first_mb_in_slice= get_ue_golomb(&s->gb); | |
3549 | |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
3550 if((s->flags2 & CODEC_FLAG2_CHUNKS) && first_mb_in_slice == 0){ |
5642 | 3551 h0->current_slice = 0; |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
3552 s->current_picture_ptr= NULL; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
3553 } |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
3554 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3555 slice_type= get_ue_golomb(&s->gb); |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3556 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3557 av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y); |
2392 | 3558 return -1; |
1168 | 3559 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3560 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3561 slice_type -= 5; |
1168 | 3562 h->slice_type_fixed=1; |
3563 }else | |
3564 h->slice_type_fixed=0; | |
2967 | 3565 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3566 slice_type= slice_type_map[ slice_type ]; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3567 if (slice_type == I_TYPE |
5642 | 3568 || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) { |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3569 default_ref_list_done = 1; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3570 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3571 h->slice_type= slice_type; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3572 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3573 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 3574 |
1168 | 3575 pps_id= get_ue_golomb(&s->gb); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3576 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3577 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 3578 return -1; |
3579 } | |
5642 | 3580 if(!h0->pps_buffers[pps_id]) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3581 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 3582 return -1; |
3583 } | |
5642 | 3584 h->pps= *h0->pps_buffers[pps_id]; |
3585 | |
3586 if(!h0->sps_buffers[h->pps.sps_id]) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3587 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 3588 return -1; |
3589 } | |
5642 | 3590 h->sps = *h0->sps_buffers[h->pps.sps_id]; |
2919 | 3591 |
5685
070a376d496b
fix image corruption when with multi-threaded decoding.
gpoirier
parents:
5647
diff
changeset
|
3592 if(h == h0 && h->dequant_coeff_pps != pps_id){ |
4363 | 3593 h->dequant_coeff_pps = pps_id; |
2919 | 3594 init_dequant_tables(h); |
3595 } | |
2967 | 3596 |
1168 | 3597 s->mb_width= h->sps.mb_width; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3598 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 3599 |
3178 | 3600 h->b_stride= s->mb_width*4; |
3601 h->b8_stride= s->mb_width*2; | |
1168 | 3602 |
1371 | 3603 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 3604 if(h->sps.frame_mbs_only_flag) |
1371 | 3605 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 3606 else |
1371 | 3607 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 3608 |
3609 if (s->context_initialized | |
1548 | 3610 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
5642 | 3611 if(h != h0) |
3612 return -1; // width / height changed during parallelized decoding | |
1168 | 3613 free_tables(h); |
3614 MPV_common_end(s); | |
3615 } | |
3616 if (!s->context_initialized) { | |
5642 | 3617 if(h != h0) |
3618 return -1; // we cant (re-)initialize context during parallel decoding | |
1168 | 3619 if (MPV_common_init(s) < 0) |
3620 return -1; | |
2967 | 3621 |
5160
13386224ff72
Factor out init_scan_tables(), patch by Andreas ªÓman %andreas A olebyn.nu%
gpoirier
parents:
5153
diff
changeset
|
3622 init_scan_tables(h); |
1168 | 3623 alloc_tables(h); |
3624 | |
5642 | 3625 for(i = 1; i < s->avctx->thread_count; i++) { |
3626 H264Context *c; | |
3627 c = h->thread_context[i] = av_malloc(sizeof(H264Context)); | |
3628 memcpy(c, h, sizeof(MpegEncContext)); | |
3629 memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext)); | |
3630 c->sps = h->sps; | |
3631 c->pps = h->pps; | |
3632 init_scan_tables(c); | |
3633 clone_tables(c, h); | |
3634 } | |
3635 | |
3636 for(i = 0; i < s->avctx->thread_count; i++) | |
3637 if(context_init(h->thread_context[i]) < 0) | |
3638 return -1; | |
3639 | |
1168 | 3640 s->avctx->width = s->width; |
3641 s->avctx->height = s->height; | |
1548 | 3642 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 3643 if(!s->avctx->sample_aspect_ratio.den) |
3644 s->avctx->sample_aspect_ratio.den = 1; | |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3645 |
2648 | 3646 if(h->sps.timing_info_present_flag){ |
3052 | 3647 s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale}; |
3063
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
3648 if(h->x264_build > 0 && h->x264_build < 44) |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
3649 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
3650 av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den, |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
3651 s->avctx->time_base.num, s->avctx->time_base.den, 1<<30); |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
3652 } |
1168 | 3653 } |
3654 | |
5642 | 3655 if(h0->current_slice == 0){ |
2935 | 3656 if(frame_start(h) < 0) |
3657 return -1; | |
1168 | 3658 } |
5642 | 3659 if(h != h0) |
3660 clone_slice(h, h0); | |
1168 | 3661 |
1169 | 3662 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 3663 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
3664 | |
3316 | 3665 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3666 h->mb_aff_frame = 0; |
1168 | 3667 if(h->sps.frame_mbs_only_flag){ |
3668 s->picture_structure= PICT_FRAME; | |
3669 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3670 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 3671 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 3672 av_log(h->s.avctx, AV_LOG_ERROR, "PAFF interlacing is not implemented\n"); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3673 } else { |
1168 | 3674 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3675 h->mb_aff_frame = h->sps.mb_aff; |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3676 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3677 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3678 assert(s->mb_num == s->mb_width * s->mb_height); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3679 if(first_mb_in_slice << h->mb_aff_frame >= s->mb_num || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3680 first_mb_in_slice >= s->mb_num){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3681 av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3682 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3683 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3684 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 3685 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3686 assert(s->mb_y < s->mb_height); |
2967 | 3687 |
1168 | 3688 if(s->picture_structure==PICT_FRAME){ |
3689 h->curr_pic_num= h->frame_num; | |
3690 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
3691 }else{ | |
3692 h->curr_pic_num= 2*h->frame_num; | |
3693 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
3694 } | |
2967 | 3695 |
1168 | 3696 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 3697 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 3698 } |
2967 | 3699 |
1168 | 3700 if(h->sps.poc_type==0){ |
3701 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 3702 |
1168 | 3703 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
3704 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
3705 } | |
3706 } | |
2967 | 3707 |
1168 | 3708 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
3709 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 3710 |
1168 | 3711 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
3712 h->delta_poc[1]= get_se_golomb(&s->gb); | |
3713 } | |
2967 | 3714 |
1168 | 3715 init_poc(h); |
2967 | 3716 |
1168 | 3717 if(h->pps.redundant_pic_cnt_present){ |
3718 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
3719 } | |
3720 | |
3721 //set defaults, might be overriden a few line later | |
3722 h->ref_count[0]= h->pps.ref_count[0]; | |
3723 h->ref_count[1]= h->pps.ref_count[1]; | |
3724 | |
3725 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
3726 if(h->slice_type == B_TYPE){ | |
3727 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 3728 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
3729 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 3730 } |
3731 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 3732 |
1168 | 3733 if(num_ref_idx_active_override_flag){ |
3734 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
3735 if(h->slice_type==B_TYPE) | |
3736 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
3737 | |
4532 | 3738 if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3739 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3740 h->ref_count[0]= h->ref_count[1]= 1; |
1168 | 3741 return -1; |
3742 } | |
3743 } | |
4532 | 3744 if(h->slice_type == B_TYPE) |
3745 h->list_count= 2; | |
3746 else | |
3747 h->list_count= 1; | |
3748 }else | |
3749 h->list_count= 0; | |
1168 | 3750 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
3751 if(!default_ref_list_done){ |
1168 | 3752 fill_default_ref_list(h); |
3753 } | |
3754 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3755 if(decode_ref_pic_list_reordering(h) < 0) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3756 return -1; |
1168 | 3757 |
2967 | 3758 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 3759 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
3760 pred_weight_table(h); | |
2415 | 3761 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
3762 implicit_weight_table(h); | |
3763 else | |
3764 h->use_weight = 0; | |
2967 | 3765 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
3766 if(s->current_picture.reference) |
5642 | 3767 decode_ref_pic_marking(h0, &s->gb); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3768 |
3316 | 3769 if(FRAME_MBAFF) |
3770 fill_mbaff_ref_list(h); | |
3771 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3772 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac ){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3773 tmp = get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3774 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3775 av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3776 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3777 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3778 h->cabac_init_idc= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3779 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3780 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3781 h->last_qscale_diff = 0; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3782 tmp = h->pps.init_qp + get_se_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3783 if(tmp>51){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3784 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); |
1898 | 3785 return -1; |
3786 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3787 s->qscale= tmp; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
3788 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
3789 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); |
1168 | 3790 //FIXME qscale / qp ... stuff |
3791 if(h->slice_type == SP_TYPE){ | |
1453 | 3792 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 3793 } |
3794 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 3795 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 3796 } |
3797 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3798 h->deblocking_filter = 1; |
1898 | 3799 h->slice_alpha_c0_offset = 0; |
3800 h->slice_beta_offset = 0; | |
1168 | 3801 if( h->pps.deblocking_filter_parameters_present ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3802 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3803 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3804 av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3805 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3806 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3807 h->deblocking_filter= tmp; |
2967 | 3808 if(h->deblocking_filter < 2) |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3809 h->deblocking_filter^= 1; // 1<->0 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3810 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3811 if( h->deblocking_filter ) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3812 h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3813 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 3814 } |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
3815 } |
5642 | 3816 |
5698
9a26cb6747a9
Apply skip_loop_filter before checking if we can parallelize with the selected
reimar
parents:
5694
diff
changeset
|
3817 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
9a26cb6747a9
Apply skip_loop_filter before checking if we can parallelize with the selected
reimar
parents:
5694
diff
changeset
|
3818 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) |
9a26cb6747a9
Apply skip_loop_filter before checking if we can parallelize with the selected
reimar
parents:
5694
diff
changeset
|
3819 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) |
9a26cb6747a9
Apply skip_loop_filter before checking if we can parallelize with the selected
reimar
parents:
5694
diff
changeset
|
3820 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
9a26cb6747a9
Apply skip_loop_filter before checking if we can parallelize with the selected
reimar
parents:
5694
diff
changeset
|
3821 h->deblocking_filter= 0; |
9a26cb6747a9
Apply skip_loop_filter before checking if we can parallelize with the selected
reimar
parents:
5694
diff
changeset
|
3822 |
5642 | 3823 if(h->deblocking_filter == 1 && h0->max_contexts > 1) { |
5646 | 3824 if(s->avctx->flags2 & CODEC_FLAG2_FAST) { |
3825 /* Cheat slightly for speed: | |
3826 Dont bother to deblock across slices */ | |
3827 h->deblocking_filter = 2; | |
3828 } else { | |
5647 | 3829 h0->max_contexts = 1; |
3830 if(!h0->single_decode_warning) { | |
3831 av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n"); | |
3832 h0->single_decode_warning = 1; | |
3833 } | |
3834 if(h != h0) | |
3835 return 1; // deblocking switched inside frame | |
5646 | 3836 } |
5642 | 3837 } |
3838 | |
1168 | 3839 #if 0 //FMO |
3840 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
3841 slice_group_change_cycle= get_bits(&s->gb, ?); | |
3842 #endif | |
3843 | |
5642 | 3844 h0->last_slice_type = slice_type; |
3845 h->slice_num = ++h0->current_slice; | |
2392 | 3846 |
3316 | 3847 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
3848 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
3849 | |
1168 | 3850 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3851 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n", |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3852 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3853 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 3854 first_mb_in_slice, |
1264 | 3855 av_get_pict_type_char(h->slice_type), |
1168 | 3856 pps_id, h->frame_num, |
3857 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
3858 h->ref_count[0], h->ref_count[1], | |
3859 s->qscale, | |
2583 | 3860 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 3861 h->use_weight, |
3862 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 3863 ); |
3864 } | |
3865 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3866 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !s->current_picture.reference){ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3867 s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3868 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3869 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3870 s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3871 s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3872 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
3873 |
1168 | 3874 return 0; |
3875 } | |
3876 | |
3877 /** | |
3878 * | |
3879 */ | |
3880 static inline int get_level_prefix(GetBitContext *gb){ | |
3881 unsigned int buf; | |
3882 int log; | |
2967 | 3883 |
1168 | 3884 OPEN_READER(re, gb); |
3885 UPDATE_CACHE(re, gb); | |
3886 buf=GET_CACHE(re, gb); | |
2967 | 3887 |
1168 | 3888 log= 32 - av_log2(buf); |
3889 #ifdef TRACE | |
3890 print_bin(buf>>(32-log), log); | |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
3891 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__); |
1168 | 3892 #endif |
3893 | |
3894 LAST_SKIP_BITS(re, gb, log); | |
3895 CLOSE_READER(re, gb); | |
3896 | |
3897 return log-1; | |
3898 } | |
3899 | |
2755 | 3900 static inline int get_dct8x8_allowed(H264Context *h){ |
3901 int i; | |
3902 for(i=0; i<4; i++){ | |
3903 if(!IS_SUB_8X8(h->sub_mb_type[i]) | |
2781
899a2ea0907c
parenthesing to avoid compiler errors in the future - compared asm outputs, behaviour didnt changed
alex
parents:
2774
diff
changeset
|
3904 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 3905 return 0; |
3906 } | |
3907 return 1; | |
3908 } | |
3909 | |
1168 | 3910 /** |
3911 * decodes a residual block. | |
3912 * @param n block index | |
3913 * @param scantable scantable | |
3914 * @param max_coeff number of coefficients in the block | |
3915 * @return <0 if an error occured | |
3916 */ | |
2919 | 3917 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 3918 MpegEncContext * const s = &h->s; |
3919 static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}; | |
2897 | 3920 int level[16]; |
3921 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 3922 |
3923 //FIXME put trailing_onex into the context | |
3924 | |
3925 if(n == CHROMA_DC_BLOCK_INDEX){ | |
3926 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
3927 total_coeff= coeff_token>>2; | |
2967 | 3928 }else{ |
1168 | 3929 if(n == LUMA_DC_BLOCK_INDEX){ |
3930 total_coeff= pred_non_zero_count(h, 0); | |
3931 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
3932 total_coeff= coeff_token>>2; | |
3933 }else{ | |
3934 total_coeff= pred_non_zero_count(h, n); | |
3935 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
3936 total_coeff= coeff_token>>2; | |
3937 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
3938 } | |
3939 } | |
3940 | |
3941 //FIXME set last_non_zero? | |
3942 | |
3943 if(total_coeff==0) | |
3944 return 0; | |
4391
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
3945 if(total_coeff > (unsigned)max_coeff) { |
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
3946 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff); |
4270 | 3947 return -1; |
3948 } | |
2967 | 3949 |
1168 | 3950 trailing_ones= coeff_token&3; |
4600 | 3951 tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 3952 assert(total_coeff<=16); |
2967 | 3953 |
1168 | 3954 for(i=0; i<trailing_ones; i++){ |
3955 level[i]= 1 - 2*get_bits1(gb); | |
3956 } | |
3957 | |
2897 | 3958 if(i<total_coeff) { |
1168 | 3959 int level_code, mask; |
2897 | 3960 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
3961 int prefix= get_level_prefix(gb); | |
3962 | |
3963 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 3964 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
3965 if(suffix_length) | |
3966 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
3967 else | |
3968 level_code= (prefix<<suffix_length); //part | |
3969 }else if(prefix==14){ | |
3970 if(suffix_length) | |
3971 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
3972 else | |
3973 level_code= prefix + get_bits(gb, 4); //part | |
3974 }else if(prefix==15){ | |
3975 level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3976 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 3977 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3978 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 3979 return -1; |
3980 } | |
3981 | |
2897 | 3982 if(trailing_ones < 3) level_code += 2; |
3983 | |
3984 suffix_length = 1; | |
3985 if(level_code > 5) | |
3986 suffix_length++; | |
1168 | 3987 mask= -(level_code&1); |
3988 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 3989 i++; |
3990 | |
3991 //remaining coefficients have suffix_length > 0 | |
3992 for(;i<total_coeff;i++) { | |
3993 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
3994 prefix = get_level_prefix(gb); | |
3995 if(prefix<15){ | |
3996 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
3997 }else if(prefix==15){ | |
3998 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
3999 }else{ | |
4000 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4001 return -1; | |
4002 } | |
4003 mask= -(level_code&1); | |
4004 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4005 if(level_code > suffix_limit[suffix_length]) | |
4006 suffix_length++; | |
4007 } | |
1168 | 4008 } |
4009 | |
4010 if(total_coeff == max_coeff) | |
4011 zeros_left=0; | |
4012 else{ | |
4013 if(n == CHROMA_DC_BLOCK_INDEX) | |
4014 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4015 else | |
4016 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4017 } | |
2897 | 4018 |
4019 coeff_num = zeros_left + total_coeff - 1; | |
4020 j = scantable[coeff_num]; | |
4021 if(n > 24){ | |
4022 block[j] = level[0]; | |
4023 for(i=1;i<total_coeff;i++) { | |
4024 if(zeros_left <= 0) | |
4025 run_before = 0; | |
4026 else if(zeros_left < 7){ | |
4027 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4028 }else{ | |
4029 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4030 } | |
4031 zeros_left -= run_before; | |
4032 coeff_num -= 1 + run_before; | |
4033 j= scantable[ coeff_num ]; | |
4034 | |
4035 block[j]= level[i]; | |
4036 } | |
4037 }else{ | |
2919 | 4038 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4039 for(i=1;i<total_coeff;i++) { |
4040 if(zeros_left <= 0) | |
4041 run_before = 0; | |
4042 else if(zeros_left < 7){ | |
4043 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4044 }else{ | |
4045 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4046 } | |
4047 zeros_left -= run_before; | |
4048 coeff_num -= 1 + run_before; | |
4049 j= scantable[ coeff_num ]; | |
4050 | |
2919 | 4051 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 4052 } |
1168 | 4053 } |
4054 | |
4055 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4056 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4057 return -1; |
4058 } | |
2897 | 4059 |
1168 | 4060 return 0; |
4061 } | |
4062 | |
3316 | 4063 static void predict_field_decoding_flag(H264Context *h){ |
4064 MpegEncContext * const s = &h->s; | |
4065 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
4066 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
4067 ? s->current_picture.mb_type[mb_xy-1] | |
4068 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
4069 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
4070 : 0; | |
4071 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
4072 } | |
4073 | |
1168 | 4074 /** |
2396 | 4075 * decodes a P_SKIP or B_SKIP macroblock |
4076 */ | |
4077 static void decode_mb_skip(H264Context *h){ | |
4078 MpegEncContext * const s = &h->s; | |
4079 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
4080 int mb_type=0; |
2967 | 4081 |
2396 | 4082 memset(h->non_zero_count[mb_xy], 0, 16); |
4083 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
4084 | |
3316 | 4085 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4086 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
4087 |
2396 | 4088 if( h->slice_type == B_TYPE ) |
4089 { | |
4090 // just for fill_caches. pred_direct_motion will set the real mb_type | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
4091 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 4092 |
2449 | 4093 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 4094 pred_direct_motion(h, &mb_type); |
3927 | 4095 mb_type|= MB_TYPE_SKIP; |
2396 | 4096 } |
4097 else | |
4098 { | |
4099 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
4100 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 4101 |
2449 | 4102 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 4103 pred_pskip_motion(h, &mx, &my); |
4104 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
4105 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
4106 } | |
4107 | |
4108 write_back_motion(h, mb_type); | |
3927 | 4109 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 4110 s->current_picture.qscale_table[mb_xy]= s->qscale; |
4111 h->slice_table[ mb_xy ]= h->slice_num; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2623
diff
changeset
|
4112 h->prev_mb_skipped= 1; |
2396 | 4113 } |
4114 | |
4115 /** | |
1168 | 4116 * decodes a macroblock |
4117 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
4118 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4119 static int decode_mb_cavlc(H264Context *h){ |
1168 | 4120 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
4121 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4122 int partition_count; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4123 unsigned int mb_type, cbp; |
2755 | 4124 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 4125 |
2967 | 4126 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 4127 |
4600 | 4128 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 4129 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
4130 down the code */ | |
1168 | 4131 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
4132 if(s->mb_skip_run==-1) | |
4133 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 4134 |
1168 | 4135 if (s->mb_skip_run--) { |
3316 | 4136 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
4137 if(s->mb_skip_run==0) | |
4138 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
4139 else | |
4140 predict_field_decoding_flag(h); | |
4141 } | |
2396 | 4142 decode_mb_skip(h); |
1168 | 4143 return 0; |
4144 } | |
4145 } | |
3316 | 4146 if(FRAME_MBAFF){ |
4147 if( (s->mb_y&1) == 0 ) | |
4148 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 4149 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4150 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 4151 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2623
diff
changeset
|
4152 h->prev_mb_skipped= 0; |
2967 | 4153 |
1168 | 4154 mb_type= get_ue_golomb(&s->gb); |
4155 if(h->slice_type == B_TYPE){ | |
4156 if(mb_type < 23){ | |
4157 partition_count= b_mb_type_info[mb_type].partition_count; | |
4158 mb_type= b_mb_type_info[mb_type].type; | |
4159 }else{ | |
4160 mb_type -= 23; | |
4161 goto decode_intra_mb; | |
4162 } | |
4163 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
4164 if(mb_type < 5){ | |
4165 partition_count= p_mb_type_info[mb_type].partition_count; | |
4166 mb_type= p_mb_type_info[mb_type].type; | |
4167 }else{ | |
4168 mb_type -= 5; | |
4169 goto decode_intra_mb; | |
4170 } | |
4171 }else{ | |
4172 assert(h->slice_type == I_TYPE); | |
4173 decode_intra_mb: | |
4174 if(mb_type > 25){ | |
3954 | 4175 av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y); |
1168 | 4176 return -1; |
4177 } | |
4178 partition_count=0; | |
4179 cbp= i_mb_type_info[mb_type].cbp; | |
4180 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
4181 mb_type= i_mb_type_info[mb_type].type; | |
4182 } | |
4183 | |
3316 | 4184 if(MB_FIELD) |
1168 | 4185 mb_type |= MB_TYPE_INTERLACED; |
4186 | |
4187 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 4188 |
1168 | 4189 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4190 unsigned int x, y; |
2967 | 4191 |
5127 | 4192 // We assume these blocks are very rare so we do not optimize it. |
1168 | 4193 align_get_bits(&s->gb); |
2967 | 4194 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4195 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 4196 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4197 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 4198 for(x=0; x<16; x++){ |
4600 | 4199 tprintf(s->avctx, "LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4200 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 4201 } |
4202 } | |
4203 for(y=0; y<8; y++){ | |
4204 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
4205 for(x=0; x<8; x++){ | |
4600 | 4206 tprintf(s->avctx, "CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4207 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 4208 } |
4209 } | |
4210 for(y=0; y<8; y++){ | |
4211 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
4212 for(x=0; x<8; x++){ | |
4600 | 4213 tprintf(s->avctx, "CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4214 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 4215 } |
4216 } | |
2967 | 4217 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4218 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4219 s->current_picture.qscale_table[mb_xy]= 0; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
4220 h->chroma_qp[0] = get_chroma_qp(h, 0, 0); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
4221 h->chroma_qp[1] = get_chroma_qp(h, 1, 0); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4222 // All coeffs are present |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4223 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 4224 |
2755 | 4225 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 4226 return 0; |
4227 } | |
2967 | 4228 |
3316 | 4229 if(MB_MBAFF){ |
4230 h->ref_count[0] <<= 1; | |
4231 h->ref_count[1] <<= 1; | |
4232 } | |
4233 | |
2449 | 4234 fill_caches(h, mb_type, 0); |
1168 | 4235 |
4236 //mb_pred | |
4237 if(IS_INTRA(mb_type)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4238 int pred_mode; |
1168 | 4239 // init_top_left_availability(h); |
4240 if(IS_INTRA4x4(mb_type)){ | |
4241 int i; | |
2755 | 4242 int di = 1; |
4243 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
4244 mb_type |= MB_TYPE_8x8DCT; | |
4245 di = 4; | |
4246 } | |
1168 | 4247 |
4248 // fill_intra4x4_pred_table(h); | |
2755 | 4249 for(i=0; i<16; i+=di){ |
3409 | 4250 int mode= pred_intra_mode(h, i); |
4251 | |
4252 if(!get_bits1(&s->gb)){ | |
1168 | 4253 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 4254 mode = rem_mode + (rem_mode >= mode); |
1168 | 4255 } |
2967 | 4256 |
2755 | 4257 if(di==4) |
4258 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
4259 else | |
4260 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 4261 } |
4262 write_back_intra_pred_mode(h); | |
4263 if( check_intra4x4_pred_mode(h) < 0) | |
4264 return -1; | |
4265 }else{ | |
4266 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
4267 if(h->intra16x16_pred_mode < 0) | |
4268 return -1; | |
4269 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4270 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4271 pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb)); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4272 if(pred_mode < 0) |
1168 | 4273 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4274 h->chroma_pred_mode= pred_mode; |
1168 | 4275 }else if(partition_count==4){ |
4276 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 4277 |
1168 | 4278 if(h->slice_type == B_TYPE){ |
4279 for(i=0; i<4; i++){ | |
4280 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4281 if(h->sub_mb_type[i] >=13){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4282 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 4283 return -1; |
4284 } | |
4285 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4286 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4287 } | |
2396 | 4288 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 4289 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 4290 pred_direct_motion(h, &mb_type); |
3003 | 4291 h->ref_cache[0][scan8[4]] = |
4292 h->ref_cache[1][scan8[4]] = | |
4293 h->ref_cache[0][scan8[12]] = | |
4294 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
4295 } | |
1168 | 4296 }else{ |
4297 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
4298 for(i=0; i<4; i++){ | |
4299 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4300 if(h->sub_mb_type[i] >=4){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4301 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 4302 return -1; |
4303 } | |
4304 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4305 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4306 } | |
4307 } | |
2967 | 4308 |
4533 | 4309 for(list=0; list<h->list_count; list++){ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4310 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 4311 for(i=0; i<4; i++){ |
2396 | 4312 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
4313 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4314 unsigned int tmp = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4315 if(tmp>=ref_count){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4316 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4317 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4318 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4319 ref[list][i]= tmp; |
1168 | 4320 }else{ |
4321 //FIXME | |
4322 ref[list][i] = -1; | |
4323 } | |
4324 } | |
4325 } | |
2967 | 4326 |
2755 | 4327 if(dct8x8_allowed) |
4328 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 4329 |
4533 | 4330 for(list=0; list<h->list_count; list++){ |
1168 | 4331 for(i=0; i<4; i++){ |
3003 | 4332 if(IS_DIRECT(h->sub_mb_type[i])) { |
4333 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
4334 continue; | |
4335 } | |
1168 | 4336 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
4337 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
4338 | |
2396 | 4339 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 4340 const int sub_mb_type= h->sub_mb_type[i]; |
4341 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
4342 for(j=0; j<sub_partition_count[i]; j++){ | |
4343 int mx, my; | |
4344 const int index= 4*i + block_width*j; | |
4345 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
4346 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
4347 mx += get_se_golomb(&s->gb); | |
4348 my += get_se_golomb(&s->gb); | |
4600 | 4349 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 4350 |
1168 | 4351 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 4352 mv_cache[ 1 ][0]= |
1168 | 4353 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 4354 mv_cache[ 1 ][1]= |
1168 | 4355 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
4356 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4530 | 4357 mv_cache[ 1 ][0]= mx; |
4358 mv_cache[ 1 ][1]= my; | |
1168 | 4359 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 4360 mv_cache[ 8 ][0]= mx; |
4361 mv_cache[ 8 ][1]= my; | |
1168 | 4362 } |
4530 | 4363 mv_cache[ 0 ][0]= mx; |
4364 mv_cache[ 0 ][1]= my; | |
1168 | 4365 } |
4366 }else{ | |
4367 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
4368 p[0] = p[1]= | |
4369 p[8] = p[9]= 0; | |
4370 } | |
4371 } | |
4372 } | |
2396 | 4373 }else if(IS_DIRECT(mb_type)){ |
4374 pred_direct_motion(h, &mb_type); | |
2755 | 4375 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 4376 }else{ |
1168 | 4377 int list, mx, my, i; |
4378 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
4379 if(IS_16X16(mb_type)){ | |
4534 | 4380 for(list=0; list<h->list_count; list++){ |
4381 unsigned int val; | |
1168 | 4382 if(IS_DIR(mb_type, 0, list)){ |
4534 | 4383 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4384 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4385 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4386 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4387 } |
2523 | 4388 }else |
4534 | 4389 val= LIST_NOT_USED&0xFF; |
4390 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
4391 } | |
4392 for(list=0; list<h->list_count; list++){ | |
4393 unsigned int val; | |
1168 | 4394 if(IS_DIR(mb_type, 0, list)){ |
4395 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
4396 mx += get_se_golomb(&s->gb); | |
4397 my += get_se_golomb(&s->gb); | |
4600 | 4398 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 4399 |
4534 | 4400 val= pack16to32(mx,my); |
2523 | 4401 }else |
4534 | 4402 val=0; |
4403 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4); | |
1168 | 4404 } |
4405 } | |
4406 else if(IS_16X8(mb_type)){ | |
4534 | 4407 for(list=0; list<h->list_count; list++){ |
1168 | 4408 for(i=0; i<2; i++){ |
4534 | 4409 unsigned int val; |
1168 | 4410 if(IS_DIR(mb_type, i, list)){ |
4534 | 4411 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4412 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4413 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4414 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4415 } |
2523 | 4416 }else |
4534 | 4417 val= LIST_NOT_USED&0xFF; |
4418 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
1168 | 4419 } |
4534 | 4420 } |
4421 for(list=0; list<h->list_count; list++){ | |
1168 | 4422 for(i=0; i<2; i++){ |
4534 | 4423 unsigned int val; |
1168 | 4424 if(IS_DIR(mb_type, i, list)){ |
4425 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
4426 mx += get_se_golomb(&s->gb); | |
4427 my += get_se_golomb(&s->gb); | |
4600 | 4428 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 4429 |
4534 | 4430 val= pack16to32(mx,my); |
2396 | 4431 }else |
4534 | 4432 val=0; |
4433 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4); | |
1168 | 4434 } |
4435 } | |
4436 }else{ | |
4437 assert(IS_8X16(mb_type)); | |
4534 | 4438 for(list=0; list<h->list_count; list++){ |
1168 | 4439 for(i=0; i<2; i++){ |
4534 | 4440 unsigned int val; |
1168 | 4441 if(IS_DIR(mb_type, i, list)){ //FIXME optimize |
4534 | 4442 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4443 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4444 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4445 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4446 } |
2523 | 4447 }else |
4534 | 4448 val= LIST_NOT_USED&0xFF; |
4449 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
1168 | 4450 } |
4534 | 4451 } |
4452 for(list=0; list<h->list_count; list++){ | |
1168 | 4453 for(i=0; i<2; i++){ |
4534 | 4454 unsigned int val; |
1168 | 4455 if(IS_DIR(mb_type, i, list)){ |
4456 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
4457 mx += get_se_golomb(&s->gb); | |
4458 my += get_se_golomb(&s->gb); | |
4600 | 4459 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 4460 |
4534 | 4461 val= pack16to32(mx,my); |
2396 | 4462 }else |
4534 | 4463 val=0; |
4464 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4); | |
1168 | 4465 } |
4466 } | |
4467 } | |
4468 } | |
2967 | 4469 |
1168 | 4470 if(IS_INTER(mb_type)) |
4471 write_back_motion(h, mb_type); | |
2967 | 4472 |
1168 | 4473 if(!IS_INTRA16x16(mb_type)){ |
4474 cbp= get_ue_golomb(&s->gb); | |
4475 if(cbp > 47){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4476 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 4477 return -1; |
4478 } | |
2967 | 4479 |
1168 | 4480 if(IS_INTRA4x4(mb_type)) |
4481 cbp= golomb_to_intra4x4_cbp[cbp]; | |
4482 else | |
4483 cbp= golomb_to_inter_cbp[cbp]; | |
4484 } | |
3651 | 4485 h->cbp = cbp; |
1168 | 4486 |
2755 | 4487 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
4488 if(get_bits1(&s->gb)) | |
4489 mb_type |= MB_TYPE_8x8DCT; | |
4490 } | |
4491 s->current_picture.mb_type[mb_xy]= mb_type; | |
4492 | |
1168 | 4493 if(cbp || IS_INTRA16x16(mb_type)){ |
4494 int i8x8, i4x4, chroma_idx; | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
4495 int dquant; |
1168 | 4496 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; |
3174 | 4497 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 4498 |
1168 | 4499 // fill_non_zero_count_cache(h); |
4500 | |
4501 if(IS_INTERLACED(mb_type)){ | |
3316 | 4502 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 4503 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 4504 dc_scan= luma_dc_field_scan; |
4505 }else{ | |
3316 | 4506 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 4507 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 4508 dc_scan= luma_dc_zigzag_scan; |
4509 } | |
4510 | |
4511 dquant= get_se_golomb(&s->gb); | |
4512 | |
4513 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4514 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y); |
1168 | 4515 return -1; |
4516 } | |
2967 | 4517 |
1168 | 4518 s->qscale += dquant; |
4519 if(((unsigned)s->qscale) > 51){ | |
4520 if(s->qscale<0) s->qscale+= 52; | |
4521 else s->qscale-= 52; | |
4522 } | |
2967 | 4523 |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
4524 h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
4525 h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale); |
1168 | 4526 if(IS_INTRA16x16(mb_type)){ |
2919 | 4527 if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4528 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 4529 } |
4530 | |
4531 assert((cbp&15) == 0 || (cbp&15) == 15); | |
4532 | |
4533 if(cbp&15){ | |
4534 for(i8x8=0; i8x8<4; i8x8++){ | |
4535 for(i4x4=0; i4x4<4; i4x4++){ | |
4536 const int index= i4x4 + 4*i8x8; | |
2919 | 4537 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 4538 return -1; |
4539 } | |
4540 } | |
4541 } | |
4542 }else{ | |
1636 | 4543 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 4544 } |
4545 }else{ | |
4546 for(i8x8=0; i8x8<4; i8x8++){ | |
4547 if(cbp & (1<<i8x8)){ | |
2755 | 4548 if(IS_8x8DCT(mb_type)){ |
4549 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 4550 uint8_t *nnz; |
2755 | 4551 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 4552 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 4553 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 4554 return -1; |
4555 } | |
2757 | 4556 nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
4557 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 4558 }else{ |
4559 for(i4x4=0; i4x4<4; i4x4++){ | |
4560 const int index= i4x4 + 4*i8x8; | |
2967 | 4561 |
2919 | 4562 if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){ |
2755 | 4563 return -1; |
4564 } | |
1168 | 4565 } |
4566 } | |
4567 }else{ | |
4568 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
4569 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
4570 } | |
4571 } | |
4572 } | |
2967 | 4573 |
1168 | 4574 if(cbp&0x30){ |
4575 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 4576 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 4577 return -1; |
4578 } | |
4579 } | |
4580 | |
4581 if(cbp&0x20){ | |
4582 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
4583 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]]; |
1168 | 4584 for(i4x4=0; i4x4<4; i4x4++){ |
4585 const int index= 16 + 4*chroma_idx + i4x4; | |
5225
099c495618c1
Compute the dequant coefficient table ptr outside the loop,
gpoirier
parents:
5215
diff
changeset
|
4586 if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){ |
1168 | 4587 return -1; |
4588 } | |
4589 } | |
4590 } | |
4591 }else{ | |
4592 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
4593 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
4594 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
4595 } | |
4596 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4597 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4598 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4599 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4600 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 4601 } |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
4602 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 4603 write_back_non_zero_count(h); |
4604 | |
3316 | 4605 if(MB_MBAFF){ |
4606 h->ref_count[0] >>= 1; | |
4607 h->ref_count[1] >>= 1; | |
4608 } | |
4609 | |
1168 | 4610 return 0; |
4611 } | |
4612 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4613 static int decode_cabac_field_decoding_flag(H264Context *h) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4614 MpegEncContext * const s = &h->s; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4615 const int mb_x = s->mb_x; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4616 const int mb_y = s->mb_y & ~1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4617 const int mba_xy = mb_x - 1 + mb_y *s->mb_stride; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4618 const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4619 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4620 unsigned int ctx = 0; |
2967 | 4621 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4622 if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4623 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4624 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4625 if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4626 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4627 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4628 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4629 return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] ); |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4630 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4631 |
2312 | 4632 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
4633 uint8_t *state= &h->cabac_state[ctx_base]; | |
4634 int mb_type; | |
2967 | 4635 |
2312 | 4636 if(intra_slice){ |
4637 MpegEncContext * const s = &h->s; | |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
4638 const int mba_xy = h->left_mb_xy[0]; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
4639 const int mbb_xy = h->top_mb_xy; |
2312 | 4640 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4641 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4642 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4643 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4644 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4645 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 4646 return 0; /* I4x4 */ |
4647 state += 2; | |
4648 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4649 if( get_cabac_noinline( &h->cabac, &state[0] ) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4650 return 0; /* I4x4 */ |
2312 | 4651 } |
4652 | |
4653 if( get_cabac_terminate( &h->cabac ) ) | |
4654 return 25; /* PCM */ | |
4655 | |
4656 mb_type = 1; /* I16x16 */ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4657 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */ |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4658 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */ |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4659 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] ); |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4660 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] ); |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4661 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 4662 return mb_type; |
4663 } | |
4664 | |
4665 static int decode_cabac_mb_type( H264Context *h ) { | |
4666 MpegEncContext * const s = &h->s; | |
4667 | |
4668 if( h->slice_type == I_TYPE ) { | |
4669 return decode_cabac_intra_mb_type(h, 3, 1); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4670 } else if( h->slice_type == P_TYPE ) { |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4671 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4672 /* P-type */ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4673 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 4674 /* P_L0_D16x16, P_8x8 */ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4675 return 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4676 } else { |
3138 | 4677 /* P_L0_D8x16, P_L0_D16x8 */ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4678 return 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4679 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4680 } else { |
2312 | 4681 return decode_cabac_intra_mb_type(h, 17, 0) + 5; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4682 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4683 } else if( h->slice_type == B_TYPE ) { |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
4684 const int mba_xy = h->left_mb_xy[0]; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
4685 const int mbb_xy = h->top_mb_xy; |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4686 int ctx = 0; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4687 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4688 |
3138 | 4689 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) ) |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4690 ctx++; |
3138 | 4691 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) ) |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4692 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4693 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4694 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ) |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4695 return 0; /* B_Direct_16x16 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4696 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4697 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) { |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4698 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */ |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4699 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4700 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4701 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3; |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4702 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2; |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4703 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1; |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4704 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4705 if( bits < 8 ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4706 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4707 else if( bits == 13 ) { |
2312 | 4708 return decode_cabac_intra_mb_type(h, 32, 0) + 23; |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4709 } else if( bits == 14 ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4710 return 11; /* B_L1_L0_8x16 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4711 else if( bits == 15 ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4712 return 22; /* B_8x8 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4713 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4714 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4715 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4716 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4717 /* TODO SI/SP frames? */ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4718 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4719 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4720 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4721 |
3316 | 4722 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4723 MpegEncContext * const s = &h->s; |
3316 | 4724 int mba_xy, mbb_xy; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4725 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4726 |
3316 | 4727 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
4728 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
4729 mba_xy = mb_xy - 1; | |
4730 if( (mb_y&1) | |
4731 && h->slice_table[mba_xy] == h->slice_num | |
4732 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
4733 mba_xy += s->mb_stride; | |
4734 if( MB_FIELD ){ | |
4735 mbb_xy = mb_xy - s->mb_stride; | |
4736 if( !(mb_y&1) | |
4737 && h->slice_table[mbb_xy] == h->slice_num | |
4738 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
4739 mbb_xy -= s->mb_stride; | |
4740 }else | |
4741 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
4742 }else{ | |
4743 int mb_xy = mb_x + mb_y*s->mb_stride; | |
4744 mba_xy = mb_xy - 1; | |
4745 mbb_xy = mb_xy - s->mb_stride; | |
4746 } | |
4747 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4748 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] )) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4749 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4750 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] )) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4751 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4752 |
3138 | 4753 if( h->slice_type == B_TYPE ) |
4754 ctx += 13; | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4755 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4756 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4757 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4758 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4759 int mode = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4760 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4761 if( get_cabac( &h->cabac, &h->cabac_state[68] ) ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4762 return pred_mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4763 |
2928 | 4764 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
4765 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
4766 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
4767 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4768 if( mode >= pred_mode ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4769 return mode + 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4770 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4771 return mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4772 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4773 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4774 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4775 const int mba_xy = h->left_mb_xy[0]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
4776 const int mbb_xy = h->top_mb_xy; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4777 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4778 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4779 |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4780 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4781 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4782 ctx++; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
4783 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4784 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4785 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4786 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4787 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4788 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4789 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4790 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4791 return 1; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4792 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4793 return 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4794 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4795 return 3; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4796 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4797 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4798 static int decode_cabac_mb_cbp_luma( H264Context *h) { |
5694
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4799 int cbp_b, cbp_a, ctx, cbp = 0; |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4800 |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4801 cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1; |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4802 cbp_b = h->slice_table[h->top_mb_xy] == h->slice_num ? h->top_cbp : -1; |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4803 |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4804 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04); |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4805 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]); |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4806 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08); |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4807 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1; |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4808 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01); |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4809 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2; |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4810 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02); |
7c2ce28a0314
Simplify H.264 decode_cabac_mb_cbp_luma(), giving a ~0.5% speedup.
diego
parents:
5685
diff
changeset
|
4811 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4812 return cbp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4813 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4814 static int decode_cabac_mb_cbp_chroma( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4815 int ctx; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4816 int cbp_a, cbp_b; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4817 |
2314 | 4818 cbp_a = (h->left_cbp>>4)&0x03; |
4819 cbp_b = (h-> top_cbp>>4)&0x03; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4820 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4821 ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4822 if( cbp_a > 0 ) ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4823 if( cbp_b > 0 ) ctx += 2; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4824 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4825 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4826 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4827 ctx = 4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4828 if( cbp_a == 2 ) ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4829 if( cbp_b == 2 ) ctx += 2; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4830 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4831 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4832 static int decode_cabac_mb_dqp( H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4833 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4834 int mbn_xy; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4835 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4836 int val = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4837 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4838 if( s->mb_x > 0 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4839 mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4840 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4841 mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4842 |
3316 | 4843 if( h->last_qscale_diff != 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4844 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4845 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4846 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4847 if( ctx < 2 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4848 ctx = 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4849 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4850 ctx = 3; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4851 val++; |
3128 | 4852 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
4853 return INT_MIN; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4854 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4855 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4856 if( val&0x01 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4857 return (val + 1)/2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4858 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4859 return -(val + 1)/2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4860 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4861 static int decode_cabac_p_mb_sub_type( H264Context *h ) { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4862 if( get_cabac( &h->cabac, &h->cabac_state[21] ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4863 return 0; /* 8x8 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4864 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4865 return 1; /* 8x4 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4866 if( get_cabac( &h->cabac, &h->cabac_state[23] ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4867 return 2; /* 4x8 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4868 return 3; /* 4x4 */ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4869 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4870 static int decode_cabac_b_mb_sub_type( H264Context *h ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4871 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4872 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4873 return 0; /* B_Direct_8x8 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4874 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) ) |
2311
cdbb2f30e08b
small typo patch by (Gildas Bazin <gbazin at altern dot org>)
michael
parents:
2310
diff
changeset
|
4875 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */ |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4876 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4877 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4878 if( get_cabac( &h->cabac, &h->cabac_state[39] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4879 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4880 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4881 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4882 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4883 type += get_cabac( &h->cabac, &h->cabac_state[39] ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4884 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
4885 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4886 |
2755 | 4887 static inline int decode_cabac_mb_transform_size( H264Context *h ) { |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
4888 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 4889 } |
4890 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4891 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4892 int refa = h->ref_cache[list][scan8[n] - 1]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4893 int refb = h->ref_cache[list][scan8[n] - 8]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4894 int ref = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4895 int ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4896 |
2396 | 4897 if( h->slice_type == B_TYPE) { |
4898 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
4899 ctx++; | |
4900 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
4901 ctx += 2; | |
4902 } else { | |
4903 if( refa > 0 ) | |
4904 ctx++; | |
4905 if( refb > 0 ) | |
4906 ctx += 2; | |
4907 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4908 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4909 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4910 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4911 if( ctx < 4 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4912 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4913 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4914 ctx = 5; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4915 if(ref >= 32 /*h->ref_list[list]*/){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4916 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_ref\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4917 return 0; //FIXME we should return -1 and check the return everywhere |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4918 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4919 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4920 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4921 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4922 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4923 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4924 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) + |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4925 abs( h->mvd_cache[list][scan8[n] - 8][l] ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4926 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 4927 int ctx, mvd; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4928 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4929 if( amvd < 3 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4930 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4931 else if( amvd > 32 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4932 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4933 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4934 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4935 |
2317 | 4936 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
4937 return 0; | |
4938 | |
4939 mvd= 1; | |
4940 ctx= 3; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4941 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4942 mvd++; |
2317 | 4943 if( ctx < 6 ) |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4944 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4945 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4946 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4947 if( mvd >= 9 ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4948 int k = 3; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4949 while( get_cabac_bypass( &h->cabac ) ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4950 mvd += 1 << k; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4951 k++; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4952 if(k>24){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4953 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4954 return INT_MIN; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4955 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4956 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4957 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4958 if( get_cabac_bypass( &h->cabac ) ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4959 mvd += 1 << k; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4960 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4961 } |
4042 | 4962 return get_cabac_bypass_sign( &h->cabac, -mvd ); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4963 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
4964 |
4908
777f250df232
Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents:
4896
diff
changeset
|
4965 static inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 4966 int nza, nzb; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4967 int ctx = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4968 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4969 if( cat == 0 ) { |
2314 | 4970 nza = h->left_cbp&0x100; |
4971 nzb = h-> top_cbp&0x100; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4972 } else if( cat == 1 || cat == 2 ) { |
2314 | 4973 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
4974 nzb = h->non_zero_count_cache[scan8[idx] - 8]; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4975 } else if( cat == 3 ) { |
2314 | 4976 nza = (h->left_cbp>>(6+idx))&0x01; |
4977 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
4978 } else { | |
4979 assert(cat == 4); | |
4980 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
4981 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
4982 } | |
4983 | |
4984 if( nza > 0 ) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4985 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4986 |
2314 | 4987 if( nzb > 0 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4988 ctx += 2; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4989 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4990 return ctx + 4 * cat; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4991 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4992 |
5006
28ebdd244a07
Change some leftover __attribute__((unused)) and __attribute__((used)) to
reimar
parents:
4984
diff
changeset
|
4993 static const attribute_used uint8_t last_coeff_flag_offset_8x8[63] = { |
4051 | 4994 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
4995 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
4996 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
4997 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
4998 }; | |
4999 | |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5000 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5001 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5002 static const int significant_coeff_flag_offset[2][6] = { |
5003 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
5004 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
5005 }; | |
5006 static const int last_coeff_flag_offset[2][6] = { | |
5007 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
5008 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
5009 }; | |
5010 static const int coeff_abs_level_m1_offset[6] = { | |
5011 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
5012 }; | |
4007 | 5013 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 5014 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 5015 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
5016 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 5017 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
5018 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
5019 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
5020 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
5021 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 5022 }; |
5023 | |
5024 int index[64]; | |
2313 | 5025 |
5262 | 5026 int av_unused last; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5027 int coeff_count = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5028 |
2316 | 5029 int abslevel1 = 1; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5030 int abslevelgt1 = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5031 |
2898 | 5032 uint8_t *significant_coeff_ctx_base; |
5033 uint8_t *last_coeff_ctx_base; | |
5034 uint8_t *abs_level_m1_ctx_base; | |
2755 | 5035 |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5036 #ifndef ARCH_X86 |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5037 #define CABAC_ON_STACK |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5038 #endif |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5039 #ifdef CABAC_ON_STACK |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5040 #define CC &cc |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5041 CABACContext cc; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5042 cc.range = h->cabac.range; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5043 cc.low = h->cabac.low; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5044 cc.bytestream= h->cabac.bytestream; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5045 #else |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5046 #define CC &h->cabac |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5047 #endif |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5048 |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5049 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5050 /* cat: 0-> DC 16x16 n = 0 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5051 * 1-> AC 16x16 n = luma4x4idx |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5052 * 2-> Luma4x4 n = luma4x4idx |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5053 * 3-> DC Chroma n = iCbCr |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5054 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 5055 * 5-> Luma8x8 n = 4 * luma8x8idx |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5056 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5057 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5058 /* read coded block flag */ |
2898 | 5059 if( cat != 5 ) { |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5060 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 5061 if( cat == 1 || cat == 2 ) |
5062 h->non_zero_count_cache[scan8[n]] = 0; | |
5063 else if( cat == 4 ) | |
5064 h->non_zero_count_cache[scan8[16+n]] = 0; | |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5065 #ifdef CABAC_ON_STACK |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5066 h->cabac.range = cc.range ; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5067 h->cabac.low = cc.low ; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5068 h->cabac.bytestream= cc.bytestream; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5069 #endif |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5070 return; |
2755 | 5071 } |
2898 | 5072 } |
5073 | |
5074 significant_coeff_ctx_base = h->cabac_state | |
3316 | 5075 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 5076 last_coeff_ctx_base = h->cabac_state |
3316 | 5077 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 5078 abs_level_m1_ctx_base = h->cabac_state |
5079 + coeff_abs_level_m1_offset[cat]; | |
5080 | |
5081 if( cat == 5 ) { | |
5082 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
5083 for(last= 0; last < coefs; last++) { \ | |
5084 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \ | |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5085 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 5086 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
5087 index[coeff_count++] = last; \ | |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5088 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 5089 last= max_coeff; \ |
5090 break; \ | |
5091 } \ | |
5092 } \ | |
4037
53be304c7f54
x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents:
4016
diff
changeset
|
5093 }\ |
53be304c7f54
x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents:
4016
diff
changeset
|
5094 if( last == max_coeff -1 ) {\ |
53be304c7f54
x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents:
4016
diff
changeset
|
5095 index[coeff_count++] = last;\ |
2898 | 5096 } |
4009 | 5097 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; |
5547 | 5098 #if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) |
4051 | 5099 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
5100 } else { | |
5101 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
5102 #else | |
3316 | 5103 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 5104 } else { |
5105 DECODE_SIGNIFICANCE( max_coeff - 1, last, last ); | |
4037
53be304c7f54
x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents:
4016
diff
changeset
|
5106 #endif |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5107 } |
2316 | 5108 assert(coeff_count > 0); |
5109 | |
5110 if( cat == 0 ) | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5111 h->cbp_table[mb_xy] |= 0x100; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5112 else if( cat == 1 || cat == 2 ) |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5113 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 5114 else if( cat == 3 ) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5115 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 5116 else if( cat == 4 ) |
5117 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 5118 else { |
2755 | 5119 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
5120 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 5121 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5122 |
4041
0113ceb0f953
1 variable less in decode_cabac_residual() no speed change (but less vars means less things gcc can load and store redundantly)
michael
parents:
4040
diff
changeset
|
5123 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 5124 uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base; |
4041
0113ceb0f953
1 variable less in decode_cabac_residual() no speed change (but less vars means less things gcc can load and store redundantly)
michael
parents:
4040
diff
changeset
|
5125 int j= scantable[index[coeff_count]]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5126 |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5127 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 5128 if( !qmul ) { |
4040 | 5129 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 5130 }else{ |
4040 | 5131 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 5132 } |
2967 | 5133 |
2313 | 5134 abslevel1++; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5135 } else { |
2313 | 5136 int coeff_abs = 2; |
2898 | 5137 ctx = 5 + FFMIN( 4, abslevelgt1 ) + abs_level_m1_ctx_base; |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5138 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 5139 coeff_abs++; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5140 } |
2313 | 5141 |
5142 if( coeff_abs >= 15 ) { | |
5143 int j = 0; | |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5144 while( get_cabac_bypass( CC ) ) { |
2313 | 5145 j++; |
5146 } | |
2967 | 5147 |
4016 | 5148 coeff_abs=1; |
2313 | 5149 while( j-- ) { |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5150 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 5151 } |
4016 | 5152 coeff_abs+= 14; |
2313 | 5153 } |
5154 | |
2898 | 5155 if( !qmul ) { |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5156 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 5157 else block[j] = coeff_abs; |
5158 }else{ | |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5159 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 5160 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 5161 } |
2967 | 5162 |
2313 | 5163 abslevelgt1++; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5164 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5165 } |
4038
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5166 #ifdef CABAC_ON_STACK |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5167 h->cabac.range = cc.range ; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5168 h->cabac.low = cc.low ; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5169 h->cabac.bytestream= cc.bytestream; |
16697bdf4ac2
copy cabac context onto the stack for the c code in decode_cabac_residual() (15% faster on P3 but still slower then the current asm)
michael
parents:
4037
diff
changeset
|
5170 #endif |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5171 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5172 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5173 |
4908
777f250df232
Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents:
4896
diff
changeset
|
5174 static inline void compute_mb_neighbors(H264Context *h) |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5175 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5176 MpegEncContext * const s = &h->s; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5177 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5178 h->top_mb_xy = mb_xy - s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5179 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 5180 if(FRAME_MBAFF){ |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5181 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5182 const int top_pair_xy = pair_xy - s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5183 const int top_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]); |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5184 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 5185 const int curr_mb_frame_flag = !MB_FIELD; |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5186 const int bottom = (s->mb_y & 1); |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5187 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5188 ? !curr_mb_frame_flag // bottom macroblock |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5189 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5190 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5191 h->top_mb_xy -= s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5192 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5193 if (left_mb_frame_flag != curr_mb_frame_flag) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5194 h->left_mb_xy[0] = pair_xy - 1; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5195 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5196 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5197 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5198 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5199 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5200 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5201 * decodes a macroblock |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5202 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5203 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5204 static int decode_mb_cabac(H264Context *h) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5205 MpegEncContext * const s = &h->s; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5206 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5207 int mb_type, partition_count, cbp = 0; |
2755 | 5208 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5209 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5210 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5211 |
4600 | 5212 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5213 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 5214 int skip; |
5215 /* a skipped mb needs the aff flag from the following mb */ | |
5216 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
5217 predict_field_decoding_flag(h); | |
5218 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
5219 skip = h->next_mb_skipped; | |
5220 else | |
5221 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y ); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5222 /* read skip flags */ |
3316 | 5223 if( skip ) { |
5224 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
5225 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
5226 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
5227 if(h->next_mb_skipped) | |
5228 predict_field_decoding_flag(h); | |
5229 else | |
5230 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
5231 } | |
5232 | |
2396 | 5233 decode_mb_skip(h); |
5234 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5235 h->cbp_table[mb_xy] = 0; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5236 h->chroma_pred_mode_table[mb_xy] = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5237 h->last_qscale_diff = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5238 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5239 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5240 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5241 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5242 } |
3316 | 5243 if(FRAME_MBAFF){ |
5244 if( (s->mb_y&1) == 0 ) | |
5245 h->mb_mbaff = | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5246 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5247 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5248 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5249 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2623
diff
changeset
|
5250 h->prev_mb_skipped = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5251 |
3077 | 5252 compute_mb_neighbors(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5253 if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5254 av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5255 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5256 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5257 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5258 if( h->slice_type == B_TYPE ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5259 if( mb_type < 23 ){ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5260 partition_count= b_mb_type_info[mb_type].partition_count; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5261 mb_type= b_mb_type_info[mb_type].type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5262 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5263 mb_type -= 23; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5264 goto decode_intra_mb; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5265 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5266 } else if( h->slice_type == P_TYPE ) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5267 if( mb_type < 5) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5268 partition_count= p_mb_type_info[mb_type].partition_count; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5269 mb_type= p_mb_type_info[mb_type].type; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5270 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5271 mb_type -= 5; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5272 goto decode_intra_mb; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5273 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5274 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5275 assert(h->slice_type == I_TYPE); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5276 decode_intra_mb: |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5277 partition_count = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5278 cbp= i_mb_type_info[mb_type].cbp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5279 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5280 mb_type= i_mb_type_info[mb_type].type; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5281 } |
3316 | 5282 if(MB_FIELD) |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5283 mb_type |= MB_TYPE_INTERLACED; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5284 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5285 h->slice_table[ mb_xy ]= h->slice_num; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5286 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5287 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5288 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5289 unsigned int x, y; |
2967 | 5290 |
5127 | 5291 // We assume these blocks are very rare so we do not optimize it. |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5292 // FIXME The two following lines get the bitstream position in the cabac |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5293 // decode, I think it should be done by a function in cabac.h (or cabac.c). |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5294 ptr= h->cabac.bytestream; |
4344 | 5295 if(h->cabac.low&0x1) ptr--; |
5296 if(CABAC_BITS==16){ | |
5297 if(h->cabac.low&0x1FF) ptr--; | |
5298 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5299 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5300 // The pixels are stored in the same order as levels in h->mb array. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5301 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5302 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5303 for(x=0; x<16; x++){ |
4600 | 5304 tprintf(s->avctx, "LUMA ICPM LEVEL (%3d)\n", *ptr); |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5305 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5306 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5307 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5308 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5309 const int index= 256 + 4*(y&3) + 32*(y>>2); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5310 for(x=0; x<8; x++){ |
4600 | 5311 tprintf(s->avctx, "CHROMA U ICPM LEVEL (%3d)\n", *ptr); |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5312 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5313 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5314 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5315 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5316 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5317 for(x=0; x<8; x++){ |
4600 | 5318 tprintf(s->avctx, "CHROMA V ICPM LEVEL (%3d)\n", *ptr); |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5319 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5320 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5321 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5322 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5323 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5324 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5325 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5326 h->cbp_table[mb_xy] = 0x1ef; |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5327 h->chroma_pred_mode_table[mb_xy] = 0; |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5328 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5329 s->current_picture.qscale_table[mb_xy]= 0; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
5330 h->chroma_qp[0] = get_chroma_qp(h, 0, 0); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
5331 h->chroma_qp[1] = get_chroma_qp(h, 1, 0); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5332 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5333 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 5334 s->current_picture.mb_type[mb_xy]= mb_type; |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5335 return 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5336 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5337 |
3316 | 5338 if(MB_MBAFF){ |
5339 h->ref_count[0] <<= 1; | |
5340 h->ref_count[1] <<= 1; | |
5341 } | |
5342 | |
2449 | 5343 fill_caches(h, mb_type, 0); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5344 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5345 if( IS_INTRA( mb_type ) ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5346 int i, pred_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5347 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 5348 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
5349 mb_type |= MB_TYPE_8x8DCT; | |
5350 for( i = 0; i < 16; i+=4 ) { | |
5351 int pred = pred_intra_mode( h, i ); | |
5352 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
5353 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5354 } | |
5355 } else { | |
5356 for( i = 0; i < 16; i++ ) { | |
5357 int pred = pred_intra_mode( h, i ); | |
5358 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5359 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5360 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 5361 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5362 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5363 write_back_intra_pred_mode(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5364 if( check_intra4x4_pred_mode(h) < 0 ) return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5365 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5366 h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5367 if( h->intra16x16_pred_mode < 0 ) return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5368 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5369 h->chroma_pred_mode_table[mb_xy] = |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5370 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5371 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5372 pred_mode= check_intra_pred_mode( h, pred_mode ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5373 if( pred_mode < 0 ) return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5374 h->chroma_pred_mode= pred_mode; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5375 } else if( partition_count == 4 ) { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5376 int i, j, sub_partition_count[4], list, ref[2][4]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5377 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5378 if( h->slice_type == B_TYPE ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5379 for( i = 0; i < 4; i++ ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5380 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5381 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5382 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5383 } |
3482 | 5384 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
5385 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 5386 pred_direct_motion(h, &mb_type); |
5425 | 5387 h->ref_cache[0][scan8[4]] = |
5388 h->ref_cache[1][scan8[4]] = | |
5389 h->ref_cache[0][scan8[12]] = | |
5390 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
2396 | 5391 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { |
5392 for( i = 0; i < 4; i++ ) | |
5393 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
5394 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
5395 } | |
5396 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5397 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5398 for( i = 0; i < 4; i++ ) { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5399 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5400 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5401 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5402 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5403 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5404 |
4533 | 5405 for( list = 0; list < h->list_count; list++ ) { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5406 for( i = 0; i < 4; i++ ) { |
2396 | 5407 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5408 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5409 if( h->ref_count[list] > 1 ) |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5410 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5411 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5412 ref[list][i] = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5413 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5414 ref[list][i] = -1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5415 } |
2110 | 5416 h->ref_cache[list][ scan8[4*i]+1 ]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5417 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5418 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5419 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5420 |
2755 | 5421 if(dct8x8_allowed) |
5422 dct8x8_allowed = get_dct8x8_allowed(h); | |
5423 | |
4533 | 5424 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5425 for(i=0; i<4; i++){ |
5425 | 5426 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; |
2396 | 5427 if(IS_DIRECT(h->sub_mb_type[i])){ |
5428 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
5429 continue; | |
5430 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5431 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5432 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5433 const int sub_mb_type= h->sub_mb_type[i]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5434 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5435 for(j=0; j<sub_partition_count[i]; j++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5436 int mpx, mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5437 int mx, my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5438 const int index= 4*i + block_width*j; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5439 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5440 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5441 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5442 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5443 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5444 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 ); |
4600 | 5445 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5446 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5447 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 5448 mv_cache[ 1 ][0]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5449 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 5450 mv_cache[ 1 ][1]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5451 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5452 |
4530 | 5453 mvd_cache[ 1 ][0]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5454 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
4530 | 5455 mvd_cache[ 1 ][1]= |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5456 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5457 }else if(IS_SUB_8X4(sub_mb_type)){ |
4530 | 5458 mv_cache[ 1 ][0]= mx; |
5459 mv_cache[ 1 ][1]= my; | |
5460 | |
5461 mvd_cache[ 1 ][0]= mx - mpx; | |
5462 mvd_cache[ 1 ][1]= my - mpy; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5463 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 5464 mv_cache[ 8 ][0]= mx; |
5465 mv_cache[ 8 ][1]= my; | |
5466 | |
5467 mvd_cache[ 8 ][0]= mx - mpx; | |
5468 mvd_cache[ 8 ][1]= my - mpy; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5469 } |
4530 | 5470 mv_cache[ 0 ][0]= mx; |
5471 mv_cache[ 0 ][1]= my; | |
5472 | |
5473 mvd_cache[ 0 ][0]= mx - mpx; | |
5474 mvd_cache[ 0 ][1]= my - mpy; | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5475 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5476 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5477 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5478 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0]; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5479 p[0] = p[1] = p[8] = p[9] = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5480 pd[0]= pd[1]= pd[8]= pd[9]= 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5481 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5482 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5483 } |
2396 | 5484 } else if( IS_DIRECT(mb_type) ) { |
5485 pred_direct_motion(h, &mb_type); | |
5486 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
5487 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 5488 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5489 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5490 int list, mx, my, i, mpx, mpy; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5491 if(IS_16X16(mb_type)){ |
4534 | 5492 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5493 if(IS_DIR(mb_type, 0, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5494 const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5495 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); |
2523 | 5496 }else |
4534 | 5497 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too |
5498 } | |
5499 for(list=0; list<h->list_count; list++){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5500 if(IS_DIR(mb_type, 0, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5501 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5502 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5503 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5504 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 ); |
4600 | 5505 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5506 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5507 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5508 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5509 }else |
5510 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5511 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5512 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5513 else if(IS_16X8(mb_type)){ |
4533 | 5514 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5515 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5516 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5517 const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5518 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 5519 }else |
5520 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5521 } |
4533 | 5522 } |
5523 for(list=0; list<h->list_count; list++){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5524 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5525 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5526 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5527 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5528 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 ); |
4600 | 5529 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5530 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5531 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5532 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 5533 }else{ |
2396 | 5534 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
5535 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5536 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5537 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5538 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5539 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5540 assert(IS_8X16(mb_type)); |
4533 | 5541 for(list=0; list<h->list_count; list++){ |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5542 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5543 if(IS_DIR(mb_type, i, list)){ //FIXME optimize |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5544 const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5545 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 5546 }else |
5547 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5548 } |
4533 | 5549 } |
5550 for(list=0; list<h->list_count; list++){ | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5551 for(i=0; i<2; i++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5552 if(IS_DIR(mb_type, i, list)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5553 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5554 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5555 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5556 |
4600 | 5557 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5558 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5559 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 5560 }else{ |
2396 | 5561 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
5562 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5563 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5564 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5565 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5566 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5567 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5568 |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5569 if( IS_INTER( mb_type ) ) { |
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5570 h->chroma_pred_mode_table[mb_xy] = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5571 write_back_motion( h, mb_type ); |
1956
0eb2947f56f6
h264 hurry up fix and a tiny cabac clean patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1935
diff
changeset
|
5572 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5573 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5574 if( !IS_INTRA16x16( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5575 cbp = decode_cabac_mb_cbp_luma( h ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5576 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5577 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5578 |
3651 | 5579 h->cbp_table[mb_xy] = h->cbp = cbp; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5580 |
2755 | 5581 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
5582 if( decode_cabac_mb_transform_size( h ) ) | |
5583 mb_type |= MB_TYPE_8x8DCT; | |
5584 } | |
5585 s->current_picture.mb_type[mb_xy]= mb_type; | |
5586 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5587 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 5588 const uint8_t *scan, *scan8x8, *dc_scan; |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5589 const uint32_t *qmul; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5590 int dqp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5591 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5592 if(IS_INTERLACED(mb_type)){ |
3316 | 5593 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 5594 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5595 dc_scan= luma_dc_field_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5596 }else{ |
3316 | 5597 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 5598 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5599 dc_scan= luma_dc_zigzag_scan; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5600 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5601 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5602 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h ); |
2883
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
5603 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
5604 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y); |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
5605 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
5606 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5607 s->qscale += dqp; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5608 if(((unsigned)s->qscale) > 51){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5609 if(s->qscale<0) s->qscale+= 52; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5610 else s->qscale-= 52; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5611 } |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
5612 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
5613 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5614 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5615 if( IS_INTRA16x16( mb_type ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5616 int i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5617 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5618 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16); |
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5619 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5620 if( cbp&15 ) { |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5621 qmul = h->dequant4_coeff[0][s->qscale]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5622 for( i = 0; i < 16; i++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5623 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5624 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5625 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5626 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5627 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5628 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5629 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5630 int i8x8, i4x4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5631 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5632 if( cbp & (1<<i8x8) ) { |
2755 | 5633 if( IS_8x8DCT(mb_type) ) { |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5634 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, |
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5635 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5636 } else { |
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5637 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5638 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5639 const int index = 4*i8x8 + i4x4; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5640 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
5641 //START_TIMER |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5642 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16); |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
5643 //STOP_TIMER("decode_residual") |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5644 } |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5645 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5646 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5647 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5648 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5649 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5650 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5651 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5652 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5653 if( cbp&0x30 ){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5654 int c; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5655 for( c = 0; c < 2; c++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5656 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5657 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5658 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5659 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5660 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5661 if( cbp&0x20 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5662 int c, i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5663 for( c = 0; c < 2; c++ ) { |
5705
c08c9340c7ca
factor out dequant table lookup outside loops, gives a 1-2% speed-up
gpoirier
parents:
5698
diff
changeset
|
5664 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5665 for( i = 0; i < 4; i++ ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5666 const int index = 16 + 4 * c + i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5667 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
5528
4c3b1222ff57
Don't check the return value of decode_cabac_residual since it always
conrad
parents:
5508
diff
changeset
|
5668 decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, qmul, 15); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5669 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5670 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5671 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5672 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5673 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5674 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5675 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5676 } else { |
2315 | 5677 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
5678 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
5679 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5680 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 5681 h->last_qscale_diff = 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5682 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5683 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5684 s->current_picture.qscale_table[mb_xy]= s->qscale; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5685 write_back_non_zero_count(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5686 |
3316 | 5687 if(MB_MBAFF){ |
5688 h->ref_count[0] >>= 1; | |
5689 h->ref_count[1] >>= 1; | |
5690 } | |
5691 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5692 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5693 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5694 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5695 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
5696 static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5697 int i, d; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5698 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5699 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5700 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5701 |
2633 | 5702 if( bS[0] < 4 ) { |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
5703 int8_t tc[4]; |
2633 | 5704 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5705 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 5706 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
5707 } else { | |
5708 /* 16px edge length, because bS=4 is triggered by being at | |
5709 * the edge of an intra MB, so all 4 bS are the same */ | |
5710 for( d = 0; d < 16; d++ ) { | |
1898 | 5711 const int p0 = pix[-1]; |
5712 const int p1 = pix[-2]; | |
5713 const int p2 = pix[-3]; | |
5714 | |
5715 const int q0 = pix[0]; | |
5716 const int q1 = pix[1]; | |
5717 const int q2 = pix[2]; | |
5718 | |
4001 | 5719 if( FFABS( p0 - q0 ) < alpha && |
5720 FFABS( p1 - p0 ) < beta && | |
5721 FFABS( q1 - q0 ) < beta ) { | |
5722 | |
5723 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
5724 if( FFABS( p2 - p0 ) < beta) | |
1898 | 5725 { |
5726 const int p3 = pix[-4]; | |
5727 /* p0', p1', p2' */ | |
5728 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
5729 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
5730 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
5731 } else { | |
5732 /* p0' */ | |
5733 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5734 } | |
4001 | 5735 if( FFABS( q2 - q0 ) < beta) |
1898 | 5736 { |
5737 const int q3 = pix[3]; | |
5738 /* q0', q1', q2' */ | |
5739 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
5740 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
5741 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
5742 } else { | |
5743 /* q0' */ | |
5744 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5745 } | |
5746 }else{ | |
5747 /* p0', q0' */ | |
5748 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5749 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5750 } | |
4600 | 5751 tprintf(h->s.avctx, "filter_mb_edgev i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, p2, p1, p0, q0, q1, q2, pix[-2], pix[-1], pix[0], pix[1]); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5752 } |
1898 | 5753 pix += stride; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5754 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5755 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5756 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
5757 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 5758 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5759 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5760 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5761 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5762 |
2633 | 5763 if( bS[0] < 4 ) { |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
5764 int8_t tc[4]; |
2633 | 5765 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5766 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 5767 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
5768 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
5769 h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5770 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5771 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5772 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
5773 static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5774 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5775 for( i = 0; i < 16; i++, pix += stride) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5776 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5777 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5778 int beta; |
2967 | 5779 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5780 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5781 int bS_index = (i >> 1); |
3316 | 5782 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5783 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5784 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5785 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5786 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5787 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5788 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5789 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5790 |
3316 | 5791 qp_index = MB_FIELD ? (i >> 3) : (i & 1); |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5792 index_a = qp[qp_index] + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5793 alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5794 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5795 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5796 if( bS[bS_index] < 4 ) { |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5797 const int tc0 = (tc0_table+52)[index_a][bS[bS_index] - 1]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5798 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5799 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5800 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5801 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5802 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5803 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5804 |
4001 | 5805 if( FFABS( p0 - q0 ) < alpha && |
5806 FFABS( p1 - p0 ) < beta && | |
5807 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5808 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5809 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5810 |
4001 | 5811 if( FFABS( p2 - p0 ) < beta ) { |
4594 | 5812 pix[-2] = p1 + av_clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5813 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5814 } |
4001 | 5815 if( FFABS( q2 - q0 ) < beta ) { |
4594 | 5816 pix[1] = q1 + av_clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5817 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5818 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5819 |
4594 | 5820 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
5821 pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ | |
5822 pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ | |
4600 | 5823 tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5824 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5825 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5826 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5827 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5828 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5829 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5830 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5831 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5832 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5833 |
4001 | 5834 if( FFABS( p0 - q0 ) < alpha && |
5835 FFABS( p1 - p0 ) < beta && | |
5836 FFABS( q1 - q0 ) < beta ) { | |
5837 | |
5838 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
5839 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5840 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5841 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5842 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5843 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5844 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5845 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5846 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5847 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5848 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5849 } |
4001 | 5850 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5851 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5852 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5853 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5854 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5855 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5856 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5857 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5858 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5859 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5860 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5861 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5862 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5863 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5864 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5865 } |
4600 | 5866 tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, p2, p1, p0, q0, q1, q2, pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5867 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5868 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5869 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5870 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
5871 static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5872 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5873 for( i = 0; i < 8; i++, pix += stride) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5874 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5875 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5876 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5877 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5878 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5879 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5880 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5881 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5882 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5883 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5884 |
3316 | 5885 qp_index = MB_FIELD ? (i >> 2) : (i & 1); |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5886 index_a = qp[qp_index] + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5887 alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5888 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 5889 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5890 if( bS[bS_index] < 4 ) { |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5891 const int tc = (tc0_table+52)[index_a][bS[bS_index] - 1] + 1; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5892 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5893 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5894 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5895 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5896 |
4001 | 5897 if( FFABS( p0 - q0 ) < alpha && |
5898 FFABS( p1 - p0 ) < beta && | |
5899 FFABS( q1 - q0 ) < beta ) { | |
4594 | 5900 const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
5901 | |
5902 pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ | |
5903 pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ | |
4600 | 5904 tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5905 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5906 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5907 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5908 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5909 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5910 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5911 |
4001 | 5912 if( FFABS( p0 - q0 ) < alpha && |
5913 FFABS( p1 - p0 ) < beta && | |
5914 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5915 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5916 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5917 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ |
4600 | 5918 tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, pix[-3], p1, p0, q0, q1, pix[2], pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5919 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5920 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5921 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5922 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5923 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
5924 static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5925 int i, d; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5926 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5927 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5928 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5929 const int pix_next = stride; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5930 |
2633 | 5931 if( bS[0] < 4 ) { |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
5932 int8_t tc[4]; |
2633 | 5933 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5934 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 5935 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
5936 } else { | |
5937 /* 16px edge length, see filter_mb_edgev */ | |
5938 for( d = 0; d < 16; d++ ) { | |
1898 | 5939 const int p0 = pix[-1*pix_next]; |
5940 const int p1 = pix[-2*pix_next]; | |
5941 const int p2 = pix[-3*pix_next]; | |
5942 const int q0 = pix[0]; | |
5943 const int q1 = pix[1*pix_next]; | |
5944 const int q2 = pix[2*pix_next]; | |
5945 | |
4001 | 5946 if( FFABS( p0 - q0 ) < alpha && |
5947 FFABS( p1 - p0 ) < beta && | |
5948 FFABS( q1 - q0 ) < beta ) { | |
1898 | 5949 |
5950 const int p3 = pix[-4*pix_next]; | |
5951 const int q3 = pix[ 3*pix_next]; | |
5952 | |
4001 | 5953 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
5954 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 5955 /* p0', p1', p2' */ |
5956 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
5957 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
5958 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
5959 } else { | |
5960 /* p0' */ | |
5961 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5962 } | |
4001 | 5963 if( FFABS( q2 - q0 ) < beta) { |
1898 | 5964 /* q0', q1', q2' */ |
5965 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
5966 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
5967 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
5968 } else { | |
5969 /* q0' */ | |
5970 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5971 } | |
5972 }else{ | |
5973 /* p0', q0' */ | |
5974 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
5975 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
5976 } | |
4600 | 5977 tprintf(h->s.avctx, "filter_mb_edgeh i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, bS[i], p2, p1, p0, q0, q1, q2, pix[-2*pix_next], pix[-pix_next], pix[0], pix[pix_next]); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5978 } |
1898 | 5979 pix++; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5980 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5981 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5982 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5983 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
5984 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 5985 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5986 const int index_a = qp + h->slice_alpha_c0_offset; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5987 const int alpha = (alpha_table+52)[index_a]; |
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5988 const int beta = (beta_table+52)[qp + h->slice_beta_offset]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5989 |
2633 | 5990 if( bS[0] < 4 ) { |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
5991 int8_t tc[4]; |
2633 | 5992 for(i=0; i<4; i++) |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
5993 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 5994 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
5995 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
5996 h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5997 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5998 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
5999 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6000 static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6001 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6002 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6003 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6004 |
5093
f0ffa056b77c
filter_mb_fast() doesn't handle h->deblocking_filter==2 (skip slice edges), so delegate that case to filter_mb().
lorenm
parents:
5083
diff
changeset
|
6005 mb_xy = mb_x + mb_y*s->mb_stride; |
f0ffa056b77c
filter_mb_fast() doesn't handle h->deblocking_filter==2 (skip slice edges), so delegate that case to filter_mb().
lorenm
parents:
5083
diff
changeset
|
6006 |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6007 if(mb_x==0 || mb_y==0 || !s->dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff || |
5093
f0ffa056b77c
filter_mb_fast() doesn't handle h->deblocking_filter==2 (skip slice edges), so delegate that case to filter_mb().
lorenm
parents:
5083
diff
changeset
|
6008 (h->deblocking_filter == 2 && (h->slice_table[mb_xy] != h->slice_table[h->top_mb_xy] || |
f0ffa056b77c
filter_mb_fast() doesn't handle h->deblocking_filter==2 (skip slice edges), so delegate that case to filter_mb().
lorenm
parents:
5083
diff
changeset
|
6009 h->slice_table[mb_xy] != h->slice_table[mb_xy - 1]))) { |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6010 filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6011 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6012 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6013 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6014 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6015 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6016 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6017 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6018 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6019 qpc = get_chroma_qp( h, 0, qp ); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6020 qpc0 = get_chroma_qp( h, 0, qp0 ); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6021 qpc1 = get_chroma_qp( h, 0, qp1 ); |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6022 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6023 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6024 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6025 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 6026 qp_thresh = 15 - h->slice_alpha_c0_offset; |
6027 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
6028 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
6029 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6030 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6031 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6032 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6033 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6034 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6035 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6036 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6037 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6038 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6039 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6040 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6041 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6042 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6043 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6044 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6045 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6046 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6047 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6048 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6049 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6050 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6051 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6052 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6053 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6054 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6055 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6056 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6057 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6058 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6059 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6060 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 6061 int edges; |
6062 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
6063 edges = 4; | |
6064 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
6065 } else { | |
6066 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
6067 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
6068 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
6069 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
6070 ? 3 : 0; | |
6071 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
6072 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
6073 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
6074 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
6075 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6076 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6077 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6078 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6079 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6080 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6081 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6082 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6083 filter_mb_edge##hv( h, &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir );\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6084 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6085 filter_mb_edgec##hv( h, &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6086 filter_mb_edgec##hv( h, &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6087 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6088 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6089 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6090 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6091 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6092 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6093 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6094 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6095 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6096 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6097 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6098 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6099 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6100 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6101 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6102 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6103 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6104 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6105 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6106 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6107 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6108 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6109 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6110 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6111 static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6112 MpegEncContext * const s = &h->s; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6113 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 6114 const int mb_type = s->current_picture.mb_type[mb_xy]; |
6115 const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6116 int first_vertical_edge_done = 0; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6117 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
6118 /* FIXME: A given frame may occupy more than one position in |
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
6119 * the reference list. So ref2frm should be populated with |
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
6120 * frame numbers, not indices. */ |
3316 | 6121 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
6122 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31}; | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6123 |
3101 | 6124 //for sufficiently low qp, filtering wouldn't do anything |
6125 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 6126 if(!FRAME_MBAFF){ |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6127 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, FFMAX(h->pps.chroma_qp_index_offset[0], h->pps.chroma_qp_index_offset[1])); |
3101 | 6128 int qp = s->current_picture.qscale_table[mb_xy]; |
6129 if(qp <= qp_thresh | |
6130 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
6131 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
6132 return; | |
6133 } | |
6134 } | |
6135 | |
3316 | 6136 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6137 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6138 && h->slice_table[mb_xy-1] != 255 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6139 // and current and left pair do not have the same interlaced type |
3316 | 6140 && (IS_INTERLACED(mb_type) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1])) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6141 // and left mb is in the same slice if deblocking_filter == 2 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6142 && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6143 /* First vertical edge is different in MBAFF frames |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6144 * There are 8 different bS to compute and 2 different Qp |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6145 */ |
3316 | 6146 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
6147 const int left_mb_xy[2] = { pair_xy-1, pair_xy-1+s->mb_stride }; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6148 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6149 int qp[2]; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6150 int bqp[2]; |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6151 int rqp[2]; |
3316 | 6152 int mb_qp, mbn0_qp, mbn1_qp; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6153 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6154 first_vertical_edge_done = 1; |
3316 | 6155 |
6156 if( IS_INTRA(mb_type) ) | |
6157 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
6158 else { | |
6159 for( i = 0; i < 8; i++ ) { | |
6160 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
6161 | |
6162 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
6163 bS[i] = 4; | |
6164 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
6165 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
6166 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
6167 bS[i] = 2; | |
6168 else | |
6169 bS[i] = 1; | |
6170 } | |
6171 } | |
6172 | |
6173 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
6174 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
6175 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
6176 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6177 bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) + |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6178 get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1; |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6179 rqp[0] = ( get_chroma_qp( h, 1, mb_qp ) + |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6180 get_chroma_qp( h, 1, mbn0_qp ) + 1 ) >> 1; |
3316 | 6181 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6182 bqp[1] = ( get_chroma_qp( h, 0, mb_qp ) + |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6183 get_chroma_qp( h, 0, mbn1_qp ) + 1 ) >> 1; |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6184 rqp[1] = ( get_chroma_qp( h, 1, mb_qp ) + |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6185 get_chroma_qp( h, 1, mbn1_qp ) + 1 ) >> 1; |
3316 | 6186 |
6187 /* Filter edge */ | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6188 tprintf(s->avctx, "filter mb:%d/%d MBAFF, QPy:%d/%d, QPb:%d/%d QPr:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], bqp[0], bqp[1], rqp[0], rqp[1], linesize, uvlinesize); |
4600 | 6189 { int i; for (i = 0; i < 8; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); } |
3316 | 6190 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6191 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, bqp ); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6192 filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, rqp ); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6193 } |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6194 /* dir : 0 -> vertical edge, 1 -> horizontal edge */ |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6195 for( dir = 0; dir < 2; dir++ ) |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6196 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6197 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6198 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 6199 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 6200 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
6201 | |
3101 | 6202 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
6203 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 6204 // how often to recheck mv-based bS when iterating between edges |
6205 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
6206 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
6207 // how often to recheck mv-based bS when iterating along each edge | |
6208 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
6209 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6210 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6211 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6212 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6213 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6214 |
2454 | 6215 if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy]) |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6216 start = 1; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6217 |
3316 | 6218 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
6219 && !IS_INTERLACED(mb_type) | |
6220 && IS_INTERLACED(mbm_type) | |
6221 ) { | |
6222 // This is a special case in the norm where the filtering must | |
6223 // be done twice (one each of the field) even if we are in a | |
6224 // frame macroblock. | |
6225 // | |
6226 static const int nnz_idx[4] = {4,5,6,3}; | |
6227 unsigned int tmp_linesize = 2 * linesize; | |
6228 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
6229 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6230 int qp; |
3316 | 6231 int i, j; |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6232 int16_t bS[4]; |
3316 | 6233 |
6234 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
6235 if( IS_INTRA(mb_type) || | |
6236 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
6237 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
6238 } else { | |
6239 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
6240 for( i = 0; i < 4; i++ ) { | |
6241 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
6242 mbn_nnz[nnz_idx[i]] != 0 ) | |
6243 bS[i] = 2; | |
6244 else | |
6245 bS[i] = 1; | |
6246 } | |
6247 } | |
6248 // Do not use s->qscale as luma quantizer because it has not the same | |
6249 // value in IPCM macroblocks. | |
6250 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
4600 | 6251 tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize); |
6252 { int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); } | |
3316 | 6253 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6254 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6255 ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6256 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6257 ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1); |
3316 | 6258 } |
6259 | |
6260 start = 1; | |
6261 } | |
6262 | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6263 /* Calculate bS */ |
2924 | 6264 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6265 /* mbn_xy: neighbor macroblock */ |
2924 | 6266 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
6267 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6268 int16_t bS[4]; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6269 int qp; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6270 |
2924 | 6271 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 6272 continue; |
6273 | |
2924 | 6274 if( IS_INTRA(mb_type) || |
6275 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6276 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6277 if (edge == 0) { |
2924 | 6278 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 6279 || ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0)) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6280 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6281 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6282 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6283 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6284 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6285 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6286 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6287 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6288 bS[0] = bS[1] = bS[2] = bS[3] = value; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6289 } else { |
2924 | 6290 int i, l; |
6291 int mv_done; | |
6292 | |
6293 if( edge & mask_edge ) { | |
6294 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
6295 mv_done = 1; | |
6296 } | |
3316 | 6297 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
6298 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
6299 mv_done = 1; | |
6300 } | |
2924 | 6301 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
6302 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
6303 int bn_idx= b_idx - (dir ? 8:1); | |
6304 int v = 0; | |
6305 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
6306 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 6307 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
6308 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 6309 } |
6310 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
6311 mv_done = 1; | |
6312 } | |
6313 else | |
6314 mv_done = 0; | |
6315 | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6316 for( i = 0; i < 4; i++ ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6317 int x = dir == 0 ? edge : i; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6318 int y = dir == 0 ? i : edge; |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6319 int b_idx= 8 + 4 + x + 8*y; |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6320 int bn_idx= b_idx - (dir ? 8:1); |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6321 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6322 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 6323 h->non_zero_count_cache[bn_idx] != 0 ) { |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6324 bS[i] = 2; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6325 } |
2924 | 6326 else if(!mv_done) |
2523 | 6327 { |
6328 bS[i] = 0; | |
6329 for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
6330 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 6331 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
6332 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 6333 bS[i] = 1; |
6334 break; | |
6335 } | |
6336 } | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6337 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6338 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6339 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6340 if(bS[0]+bS[1]+bS[2]+bS[3] == 0) |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6341 continue; |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6342 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6343 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6344 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6345 // Do not use s->qscale as luma quantizer because it has not the same |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6346 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6347 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; |
4600 | 6348 //tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]); |
6349 tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize); | |
6350 { int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); } | |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6351 if( dir == 0 ) { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6352 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 6353 if( (edge&1) == 0 ) { |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6354 filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6355 ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6356 filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6357 ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6358 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6359 } else { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6360 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 6361 if( (edge&1) == 0 ) { |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6362 filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6363 ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6364 filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6365 ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1); |
1897
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6366 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6367 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6368 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6369 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6370 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6371 |
5642 | 6372 static int decode_slice(struct AVCodecContext *avctx, H264Context *h){ |
1168 | 6373 MpegEncContext * const s = &h->s; |
6374 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
6375 | |
6376 s->mb_skip_run= -1; | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6377 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6378 if( h->pps.cabac ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6379 int i; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6380 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6381 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6382 align_get_bits( &s->gb ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6383 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6384 /* init cabac */ |
3993
8b7c59b7af01
make state transition tables global as they are constant and the code is slightly faster that way
michael
parents:
3991
diff
changeset
|
6385 ff_init_cabac_states( &h->cabac); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6386 ff_init_cabac_decoder( &h->cabac, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6387 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 6388 ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6389 /* calculate pre-state */ |
2755 | 6390 for( i= 0; i < 460; i++ ) { |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6391 int pre; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6392 if( h->slice_type == I_TYPE ) |
4594 | 6393 pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6394 else |
4594 | 6395 pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6396 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6397 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
6398 h->cabac_state[i] = 2 * ( 63 - pre ) + 0; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6399 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
6400 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 6401 } |
6402 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6403 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
6404 //START_TIMER |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6405 int ret = decode_mb_cabac(h); |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6406 int eos; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
6407 //STOP_TIMER("decode_mb_cabac") |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6408 |
2163 | 6409 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6410 |
3316 | 6411 if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ? |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6412 s->mb_y++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6413 |
2163 | 6414 if(ret>=0) ret = decode_mb_cabac(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6415 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
6416 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6417 s->mb_y--; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6418 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6419 eos = get_cabac_terminate( &h->cabac ); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6420 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
6421 if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) { |
5153 | 6422 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6423 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6424 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6425 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6426 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6427 if( ++s->mb_x >= s->mb_width ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6428 s->mb_x = 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6429 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 6430 ++s->mb_y; |
3316 | 6431 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6432 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6433 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6434 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6435 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6436 if( eos || s->mb_y >= s->mb_height ) { |
4600 | 6437 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6438 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6439 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6440 } |
1168 | 6441 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6442 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6443 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6444 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6445 int ret = decode_mb_cavlc(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6446 |
2163 | 6447 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6448 |
3316 | 6449 if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ? |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6450 s->mb_y++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6451 ret = decode_mb_cavlc(h); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6452 |
2163 | 6453 if(ret>=0) hl_decode_mb(h); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6454 s->mb_y--; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6455 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6456 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6457 if(ret<0){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6458 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6459 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6460 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6461 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6462 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6463 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6464 if(++s->mb_x >= s->mb_width){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6465 s->mb_x=0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6466 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6467 ++s->mb_y; |
3316 | 6468 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6469 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6470 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
6471 if(s->mb_y >= s->mb_height){ |
4600 | 6472 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6473 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6474 if(get_bits_count(&s->gb) == s->gb.size_in_bits ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6475 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6476 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6477 return 0; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6478 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6479 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6480 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6481 return -1; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6482 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6483 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6484 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6485 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6486 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
4600 | 6487 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6488 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 6489 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); |
6490 | |
6491 return 0; | |
6492 }else{ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6493 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
1168 | 6494 |
6495 return -1; | |
6496 } | |
6497 } | |
6498 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6499 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6500 |
1168 | 6501 #if 0 |
6502 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
6503 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
6504 int ret= decode_mb(h); | |
2967 | 6505 |
1168 | 6506 hl_decode_mb(h); |
6507 | |
6508 if(ret<0){ | |
3177 | 6509 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 6510 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); |
6511 | |
6512 return -1; | |
6513 } | |
2967 | 6514 |
1168 | 6515 if(++s->mb_x >= s->mb_width){ |
6516 s->mb_x=0; | |
6517 if(++s->mb_y >= s->mb_height){ | |
6518 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
6519 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); | |
6520 | |
6521 return 0; | |
6522 }else{ | |
6523 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); | |
6524 | |
6525 return -1; | |
6526 } | |
6527 } | |
6528 } | |
2967 | 6529 |
1168 | 6530 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
6531 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
6532 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); | |
6533 | |
6534 return 0; | |
6535 }else{ | |
6536 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); | |
6537 | |
6538 return -1; | |
6539 } | |
6540 } | |
6541 } | |
6542 s->mb_x=0; | |
6543 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
6544 } | |
6545 #endif | |
6546 return -1; //not reached | |
6547 } | |
6548 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6549 static int decode_unregistered_user_data(H264Context *h, int size){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6550 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6551 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6552 int e, build, i; |
2967 | 6553 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6554 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6555 return -1; |
2967 | 6556 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6557 for(i=0; i<sizeof(user_data)-1 && i<size; i++){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6558 user_data[i]= get_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6559 } |
2967 | 6560 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6561 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6562 e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6563 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6564 h->x264_build= build; |
2967 | 6565 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6566 if(s->avctx->debug & FF_DEBUG_BUGS) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6567 av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6568 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6569 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6570 skip_bits(&s->gb, 8); |
2967 | 6571 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6572 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6573 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6574 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6575 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6576 MpegEncContext * const s = &h->s; |
2967 | 6577 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6578 while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6579 int size, type; |
2967 | 6580 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6581 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6582 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6583 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6584 }while(get_bits(&s->gb, 8) == 255); |
2967 | 6585 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6586 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6587 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6588 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6589 }while(get_bits(&s->gb, 8) == 255); |
2967 | 6590 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6591 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6592 case 5: |
3318 | 6593 if(decode_unregistered_user_data(h, size) < 0) |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6594 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6595 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6596 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6597 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6598 } |
2967 | 6599 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6600 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6601 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6602 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6603 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6604 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6605 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
6606 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6607 static inline void decode_hrd_parameters(H264Context *h, SPS *sps){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6608 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6609 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6610 cpb_count = get_ue_golomb(&s->gb) + 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6611 get_bits(&s->gb, 4); /* bit_rate_scale */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6612 get_bits(&s->gb, 4); /* cpb_size_scale */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6613 for(i=0; i<cpb_count; i++){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6614 get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6615 get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6616 get_bits1(&s->gb); /* cbr_flag */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6617 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6618 get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6619 get_bits(&s->gb, 5); /* cpb_removal_delay_length_minus1 */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6620 get_bits(&s->gb, 5); /* dpb_output_delay_length_minus1 */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6621 get_bits(&s->gb, 5); /* time_offset_length */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6622 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6623 |
1168 | 6624 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
6625 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6626 int aspect_ratio_info_present_flag; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6627 unsigned int aspect_ratio_idc; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6628 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 6629 |
6630 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 6631 |
1168 | 6632 if( aspect_ratio_info_present_flag ) { |
6633 aspect_ratio_idc= get_bits(&s->gb, 8); | |
6634 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 6635 sps->sar.num= get_bits(&s->gb, 16); |
6636 sps->sar.den= get_bits(&s->gb, 16); | |
3196
15157293beea
fixing coverity warnig CID: 253 (reading over the end of the aspect_ratio array for illegal aspect ratios)
michael
parents:
3178
diff
changeset
|
6637 }else if(aspect_ratio_idc < 14){ |
1548 | 6638 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 6639 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6640 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 6641 return -1; |
6642 } | |
6643 }else{ | |
2967 | 6644 sps->sar.num= |
1548 | 6645 sps->sar.den= 0; |
1168 | 6646 } |
6647 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height); | |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6648 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6649 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6650 get_bits1(&s->gb); /* overscan_appropriate_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6651 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6652 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6653 if(get_bits1(&s->gb)){ /* video_signal_type_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6654 get_bits(&s->gb, 3); /* video_format */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6655 get_bits1(&s->gb); /* video_full_range_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6656 if(get_bits1(&s->gb)){ /* colour_description_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6657 get_bits(&s->gb, 8); /* colour_primaries */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6658 get_bits(&s->gb, 8); /* transfer_characteristics */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6659 get_bits(&s->gb, 8); /* matrix_coefficients */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6660 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6661 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6662 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6663 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6664 get_ue_golomb(&s->gb); /* chroma_sample_location_type_top_field */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6665 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6666 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6667 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6668 sps->timing_info_present_flag = get_bits1(&s->gb); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6669 if(sps->timing_info_present_flag){ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6670 sps->num_units_in_tick = get_bits_long(&s->gb, 32); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6671 sps->time_scale = get_bits_long(&s->gb, 32); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6672 sps->fixed_frame_rate_flag = get_bits1(&s->gb); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6673 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (M«©ns Rullg«©rd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
6674 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6675 nal_hrd_parameters_present_flag = get_bits1(&s->gb); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6676 if(nal_hrd_parameters_present_flag) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6677 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6678 vcl_hrd_parameters_present_flag = get_bits1(&s->gb); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6679 if(vcl_hrd_parameters_present_flag) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6680 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6681 if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6682 get_bits1(&s->gb); /* low_delay_hrd_flag */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6683 get_bits1(&s->gb); /* pic_struct_present_flag */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6684 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6685 sps->bitstream_restriction_flag = get_bits1(&s->gb); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6686 if(sps->bitstream_restriction_flag){ |
4389 | 6687 unsigned int num_reorder_frames; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6688 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6689 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6690 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6691 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6692 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
4389 | 6693 num_reorder_frames= get_ue_golomb(&s->gb); |
6694 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/ | |
6695 | |
6696 if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){ | |
6697 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames); | |
6698 return -1; | |
6699 } | |
6700 | |
6701 sps->num_reorder_frames= num_reorder_frames; | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6702 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
6703 |
1168 | 6704 return 0; |
6705 } | |
6706 | |
3004 | 6707 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
6708 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 6709 MpegEncContext * const s = &h->s; |
6710 int i, last = 8, next = 8; | |
6711 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 6712 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
6713 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 6714 else |
6715 for(i=0;i<size;i++){ | |
6716 if(next) | |
6717 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 6718 if(!i && !next){ /* matrix not written, we use the preset one */ |
6719 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 6720 break; |
6721 } | |
6722 last = factors[scan[i]] = next ? next : last; | |
6723 } | |
6724 } | |
6725 | |
6726 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
6727 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
6728 MpegEncContext * const s = &h->s; | |
6729 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
6730 const uint8_t *fallback[4] = { | |
6731 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
6732 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
6733 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
6734 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
6735 }; | |
6736 if(get_bits1(&s->gb)){ | |
6737 sps->scaling_matrix_present |= is_sps; | |
3004 | 6738 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
6739 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
6740 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
6741 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
6742 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
6743 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 6744 if(is_sps || pps->transform_8x8_mode){ |
3004 | 6745 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
6746 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 6747 } |
6748 } else if(fallback_sps) { | |
6749 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
6750 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
6751 } | |
6752 } | |
6753 | |
5079 | 6754 /** |
6755 * Returns and optionally allocates SPS / PPS structures in the supplied array 'vec' | |
6756 */ | |
6757 static void * | |
6758 alloc_parameter_set(H264Context *h, void **vec, const unsigned int id, const unsigned int max, | |
6759 const size_t size, const char *name) | |
6760 { | |
6761 if(id>=max) { | |
6762 av_log(h->s.avctx, AV_LOG_ERROR, "%s_id (%d) out of range\n", name, id); | |
6763 return NULL; | |
6764 } | |
6765 | |
6766 if(!vec[id]) { | |
6767 vec[id] = av_mallocz(size); | |
6768 if(vec[id] == NULL) | |
6769 av_log(h->s.avctx, AV_LOG_ERROR, "cannot allocate memory for %s\n", name); | |
6770 } | |
6771 return vec[id]; | |
6772 } | |
6773 | |
1168 | 6774 static inline int decode_seq_parameter_set(H264Context *h){ |
6775 MpegEncContext * const s = &h->s; | |
1371 | 6776 int profile_idc, level_idc; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6777 unsigned int sps_id, tmp, mb_width, mb_height; |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
6778 int i; |
1168 | 6779 SPS *sps; |
2967 | 6780 |
1168 | 6781 profile_idc= get_bits(&s->gb, 8); |
1371 | 6782 get_bits1(&s->gb); //constraint_set0_flag |
6783 get_bits1(&s->gb); //constraint_set1_flag | |
6784 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 6785 get_bits1(&s->gb); //constraint_set3_flag |
6786 get_bits(&s->gb, 4); // reserved | |
1168 | 6787 level_idc= get_bits(&s->gb, 8); |
6788 sps_id= get_ue_golomb(&s->gb); | |
2967 | 6789 |
5079 | 6790 sps = alloc_parameter_set(h, (void **)h->sps_buffers, sps_id, MAX_SPS_COUNT, sizeof(SPS), "sps"); |
6791 if(sps == NULL) | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
6792 return -1; |
5079 | 6793 |
1168 | 6794 sps->profile_idc= profile_idc; |
6795 sps->level_idc= level_idc; | |
2312 | 6796 |
2755 | 6797 if(sps->profile_idc >= 100){ //high profile |
6798 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
6799 get_bits1(&s->gb); //residual_color_transform_flag | |
6800 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
6801 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 6802 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 6803 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
6804 }else | |
6805 sps->scaling_matrix_present = 0; | |
2755 | 6806 |
1168 | 6807 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
6808 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 6809 |
1168 | 6810 if(sps->poc_type == 0){ //FIXME #define |
6811 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
6812 } else if(sps->poc_type == 1){//FIXME #define | |
6813 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
6814 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
6815 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6816 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6817 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6818 if(tmp >= sizeof(sps->offset_for_ref_frame) / sizeof(sps->offset_for_ref_frame[0])){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6819 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", tmp); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6820 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6821 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6822 sps->poc_cycle_length= tmp; |
2967 | 6823 |
1168 | 6824 for(i=0; i<sps->poc_cycle_length; i++) |
6825 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6826 }else if(sps->poc_type != 2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6827 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 6828 return -1; |
6829 } | |
6830 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6831 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6832 if(tmp > MAX_PICTURE_COUNT-2){ |
2254
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
6833 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n"); |
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
6834 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6835 sps->ref_frame_count= tmp; |
1371 | 6836 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6837 mb_width= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6838 mb_height= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6839 if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6840 avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6841 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n"); |
2422 | 6842 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6843 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6844 sps->mb_width = mb_width; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6845 sps->mb_height= mb_height; |
2422 | 6846 |
1168 | 6847 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
6848 if(!sps->frame_mbs_only_flag) | |
6849 sps->mb_aff= get_bits1(&s->gb); | |
6850 else | |
6851 sps->mb_aff= 0; | |
6852 | |
6853 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
6854 | |
3316 | 6855 #ifndef ALLOW_INTERLACE |
6856 if(sps->mb_aff) | |
3954 | 6857 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 6858 #endif |
6859 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
6860 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
6861 | |
1371 | 6862 sps->crop= get_bits1(&s->gb); |
6863 if(sps->crop){ | |
6864 sps->crop_left = get_ue_golomb(&s->gb); | |
6865 sps->crop_right = get_ue_golomb(&s->gb); | |
6866 sps->crop_top = get_ue_golomb(&s->gb); | |
6867 sps->crop_bottom= get_ue_golomb(&s->gb); | |
6868 if(sps->crop_left || sps->crop_top){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2623
diff
changeset
|
6869 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 6870 } |
6871 }else{ | |
2967 | 6872 sps->crop_left = |
6873 sps->crop_right = | |
6874 sps->crop_top = | |
1371 | 6875 sps->crop_bottom= 0; |
6876 } | |
6877 | |
1168 | 6878 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
6879 if( sps->vui_parameters_present_flag ) | |
6880 decode_vui_parameters(h, sps); | |
2967 | 6881 |
1168 | 6882 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
6883 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n", |
1168 | 6884 sps_id, sps->profile_idc, sps->level_idc, |
6885 sps->poc_type, | |
6886 sps->ref_frame_count, | |
6887 sps->mb_width, sps->mb_height, | |
6888 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
6889 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 6890 sps->crop_left, sps->crop_right, |
6891 sps->crop_top, sps->crop_bottom, | |
1168 | 6892 sps->vui_parameters_present_flag ? "VUI" : "" |
6893 ); | |
6894 } | |
6895 return 0; | |
6896 } | |
6897 | |
5226
65bffcc5571a
Precompute a chroma_qp table with index offset for each pps,
gpoirier
parents:
5225
diff
changeset
|
6898 static void |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6899 build_qp_table(PPS *pps, int t, int index) |
5226
65bffcc5571a
Precompute a chroma_qp table with index offset for each pps,
gpoirier
parents:
5225
diff
changeset
|
6900 { |
65bffcc5571a
Precompute a chroma_qp table with index offset for each pps,
gpoirier
parents:
5225
diff
changeset
|
6901 int i; |
65bffcc5571a
Precompute a chroma_qp table with index offset for each pps,
gpoirier
parents:
5225
diff
changeset
|
6902 for(i = 0; i < 255; i++) |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6903 pps->chroma_qp_table[t][i & 0xff] = chroma_qp[av_clip(i + index, 0, 51)]; |
5226
65bffcc5571a
Precompute a chroma_qp table with index offset for each pps,
gpoirier
parents:
5225
diff
changeset
|
6904 } |
65bffcc5571a
Precompute a chroma_qp table with index offset for each pps,
gpoirier
parents:
5225
diff
changeset
|
6905 |
2755 | 6906 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 6907 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6908 unsigned int tmp, pps_id= get_ue_golomb(&s->gb); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
6909 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
6910 |
5079 | 6911 pps = alloc_parameter_set(h, (void **)h->pps_buffers, pps_id, MAX_PPS_COUNT, sizeof(PPS), "pps"); |
6912 if(pps == NULL) | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
6913 return -1; |
2967 | 6914 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6915 tmp= get_ue_golomb(&s->gb); |
5079 | 6916 if(tmp>=MAX_SPS_COUNT || h->sps_buffers[tmp] == NULL){ |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6917 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n"); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6918 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6919 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6920 pps->sps_id= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6921 |
1168 | 6922 pps->cabac= get_bits1(&s->gb); |
6923 pps->pic_order_present= get_bits1(&s->gb); | |
6924 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
6925 if(pps->slice_group_count > 1 ){ | |
6926 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb); | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6927 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 6928 switch(pps->mb_slice_group_map_type){ |
6929 case 0: | |
6930 #if 0 | |
6931 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
6932 | run_length[ i ] |1 |ue(v) | | |
6933 #endif | |
6934 break; | |
6935 case 2: | |
6936 #if 0 | |
6937 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
6938 |{ | | | | |
6939 | top_left_mb[ i ] |1 |ue(v) | | |
6940 | bottom_right_mb[ i ] |1 |ue(v) | | |
6941 | } | | | | |
6942 #endif | |
6943 break; | |
6944 case 3: | |
6945 case 4: | |
6946 case 5: | |
6947 #if 0 | |
6948 | slice_group_change_direction_flag |1 |u(1) | | |
6949 | slice_group_change_rate_minus1 |1 |ue(v) | | |
6950 #endif | |
6951 break; | |
6952 case 6: | |
6953 #if 0 | |
6954 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
6955 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
6956 |) | | | | |
6957 | slice_group_id[ i ] |1 |u(v) | | |
6958 #endif | |
1214 | 6959 break; |
1168 | 6960 } |
6961 } | |
6962 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
6963 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4531 | 6964 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
6965 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6966 pps->ref_count[0]= pps->ref_count[1]= 1; |
1168 | 6967 return -1; |
6968 } | |
2967 | 6969 |
1168 | 6970 pps->weighted_pred= get_bits1(&s->gb); |
6971 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
6972 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
6973 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6974 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb); |
1168 | 6975 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); |
6976 pps->constrained_intra_pred= get_bits1(&s->gb); | |
6977 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 6978 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
6979 pps->transform_8x8_mode= 0; |
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
6980 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 6981 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
6982 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 6983 |
6984 if(get_bits_count(&s->gb) < bit_length){ | |
6985 pps->transform_8x8_mode= get_bits1(&s->gb); | |
5079 | 6986 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6987 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6988 } else { |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6989 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0]; |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6990 } |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6991 |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6992 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0]); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6993 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1]) { |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6994 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1]); |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6995 h->pps.chroma_qp_diff= 1; |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6996 } else |
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
6997 memcpy(pps->chroma_qp_table[1], pps->chroma_qp_table[0], 256); |
2967 | 6998 |
1168 | 6999 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
7000 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n", |
1168 | 7001 pps_id, pps->sps_id, |
7002 pps->cabac ? "CABAC" : "CAVLC", | |
7003 pps->slice_group_count, | |
7004 pps->ref_count[0], pps->ref_count[1], | |
7005 pps->weighted_pred ? "weighted" : "", | |
5231
07a97575d0c4
Add support for streams with different chroma_qp_index_offset
gpoirier
parents:
5226
diff
changeset
|
7006 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1], |
1168 | 7007 pps->deblocking_filter_parameters_present ? "LPAR" : "", |
7008 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7009 pps->redundant_pic_cnt_present ? "REDU" : "", |
7010 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7011 ); |
7012 } | |
2967 | 7013 |
1168 | 7014 return 0; |
7015 } | |
7016 | |
5642 | 7017 /** |
7018 * Call decode_slice() for each context. | |
7019 * | |
7020 * @param h h264 master context | |
7021 * @param context_count number of contexts to execute | |
7022 */ | |
7023 static void execute_decode_slices(H264Context *h, int context_count){ | |
7024 MpegEncContext * const s = &h->s; | |
7025 AVCodecContext * const avctx= s->avctx; | |
7026 H264Context *hx; | |
7027 int i; | |
7028 | |
7029 if(context_count == 1) { | |
7030 decode_slice(avctx, h); | |
7031 } else { | |
7032 for(i = 1; i < context_count; i++) { | |
7033 hx = h->thread_context[i]; | |
7034 hx->s.error_resilience = avctx->error_resilience; | |
7035 hx->s.error_count = 0; | |
7036 } | |
7037 | |
7038 avctx->execute(avctx, (void *)decode_slice, | |
7039 (void **)h->thread_context, NULL, context_count); | |
7040 | |
7041 /* pull back stuff from slices to master context */ | |
7042 hx = h->thread_context[context_count - 1]; | |
7043 s->mb_x = hx->s.mb_x; | |
7044 s->mb_y = hx->s.mb_y; | |
7045 for(i = 1; i < context_count; i++) | |
7046 h->s.error_count += h->thread_context[i]->s.error_count; | |
7047 } | |
7048 } | |
7049 | |
7050 | |
1168 | 7051 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
7052 MpegEncContext * const s = &h->s; | |
7053 AVCodecContext * const avctx= s->avctx; | |
7054 int buf_index=0; | |
5642 | 7055 H264Context *hx; ///< thread context |
7056 int context_count = 0; | |
7057 | |
7058 h->max_contexts = avctx->thread_count; | |
1322 | 7059 #if 0 |
1168 | 7060 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7061 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7062 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 7063 } |
7064 #endif | |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7065 if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){ |
5642 | 7066 h->current_slice = 0; |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7067 s->current_picture_ptr= NULL; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7068 } |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7069 |
1168 | 7070 for(;;){ |
7071 int consumed; | |
7072 int dst_length; | |
7073 int bit_length; | |
7074 uint8_t *ptr; | |
2227 | 7075 int i, nalsize = 0; |
5642 | 7076 int err; |
2967 | 7077 |
5170 | 7078 if(h->is_avc) { |
7079 if(buf_index >= buf_size) break; | |
7080 nalsize = 0; | |
7081 for(i = 0; i < h->nal_length_size; i++) | |
7082 nalsize = (nalsize << 8) | buf[buf_index++]; | |
7083 if(nalsize <= 1 || (nalsize+buf_index > buf_size)){ | |
7084 if(nalsize == 1){ | |
7085 buf_index++; | |
7086 continue; | |
7087 }else{ | |
7088 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
7089 break; | |
7090 } | |
7091 } | |
7092 } else { | |
7093 // start code prefix search | |
7094 for(; buf_index + 3 < buf_size; buf_index++){ | |
7095 // This should always succeed in the first iteration. | |
7096 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
7097 break; | |
7098 } | |
7099 | |
7100 if(buf_index+3 >= buf_size) break; | |
7101 | |
7102 buf_index+=3; | |
7103 } | |
2967 | 7104 |
5642 | 7105 hx = h->thread_context[context_count]; |
7106 | |
7107 ptr= decode_nal(hx, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); | |
4828
58f1856608f6
scenario: A properly coded frame is followed by an end of sequence NAL unit,
diego
parents:
4795
diff
changeset
|
7108 if (ptr==NULL || dst_length < 0){ |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7109 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7110 } |
4829
e3161603a048
Remove a NAL unit's trailing zero bytes even when dst_length is 1.
diego
parents:
4828
diff
changeset
|
7111 while(ptr[dst_length - 1] == 0 && dst_length > 0) |
3341 | 7112 dst_length--; |
4830
5a523aee7379
When dst_length == 0 bit_length has to be 0, too, but the current code still
diego
parents:
4829
diff
changeset
|
7113 bit_length= !dst_length ? 0 : (8*dst_length - decode_rbsp_trailing(h, ptr + dst_length - 1)); |
1168 | 7114 |
7115 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
5642 | 7116 av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length); |
1168 | 7117 } |
2967 | 7118 |
2227 | 7119 if (h->is_avc && (nalsize != consumed)) |
7120 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
7121 | |
1168 | 7122 buf_index += consumed; |
7123 | |
5127 | 7124 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME do not discard SEI id |
2792 | 7125 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 7126 continue; |
2967 | 7127 |
5642 | 7128 again: |
7129 err = 0; | |
7130 switch(hx->nal_unit_type){ | |
1168 | 7131 case NAL_IDR_SLICE: |
5642 | 7132 if (h->nal_unit_type != NAL_IDR_SLICE) { |
7133 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices"); | |
7134 return -1; | |
7135 } | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7136 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 7137 case NAL_SLICE: |
5642 | 7138 init_get_bits(&hx->s.gb, ptr, bit_length); |
7139 hx->intra_gb_ptr= | |
7140 hx->inter_gb_ptr= &hx->s.gb; | |
7141 hx->s.data_partitioning = 0; | |
7142 | |
7143 if((err = decode_slice_header(hx, h))) | |
7144 break; | |
7145 | |
7146 s->current_picture_ptr->key_frame= (hx->nal_unit_type == NAL_IDR_SLICE); | |
7147 if(hx->redundant_pic_count==0 && hx->s.hurry_up < 5 | |
7148 && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) | |
7149 && (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type!=B_TYPE) | |
7150 && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type==I_TYPE) | |
2793 | 7151 && avctx->skip_frame < AVDISCARD_ALL) |
5642 | 7152 context_count++; |
1168 | 7153 break; |
7154 case NAL_DPA: | |
5642 | 7155 init_get_bits(&hx->s.gb, ptr, bit_length); |
7156 hx->intra_gb_ptr= | |
7157 hx->inter_gb_ptr= NULL; | |
7158 hx->s.data_partitioning = 1; | |
7159 | |
7160 err = decode_slice_header(hx, h); | |
1168 | 7161 break; |
7162 case NAL_DPB: | |
5642 | 7163 init_get_bits(&hx->intra_gb, ptr, bit_length); |
7164 hx->intra_gb_ptr= &hx->intra_gb; | |
1168 | 7165 break; |
7166 case NAL_DPC: | |
5642 | 7167 init_get_bits(&hx->inter_gb, ptr, bit_length); |
7168 hx->inter_gb_ptr= &hx->inter_gb; | |
7169 | |
7170 if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning | |
4354
d18568fb0187
Avoid calling decode_slice when context_initialized is not set.
reimar
parents:
4344
diff
changeset
|
7171 && s->context_initialized |
2793 | 7172 && s->hurry_up < 5 |
5642 | 7173 && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) |
7174 && (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type!=B_TYPE) | |
7175 && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type==I_TYPE) | |
2793 | 7176 && avctx->skip_frame < AVDISCARD_ALL) |
5642 | 7177 context_count++; |
1168 | 7178 break; |
7179 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7180 init_get_bits(&s->gb, ptr, bit_length); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7181 decode_sei(h); |
1168 | 7182 break; |
7183 case NAL_SPS: | |
7184 init_get_bits(&s->gb, ptr, bit_length); | |
7185 decode_seq_parameter_set(h); | |
2967 | 7186 |
1168 | 7187 if(s->flags& CODEC_FLAG_LOW_DELAY) |
7188 s->low_delay=1; | |
2967 | 7189 |
2538 | 7190 if(avctx->has_b_frames < 2) |
7191 avctx->has_b_frames= !s->low_delay; | |
1168 | 7192 break; |
7193 case NAL_PPS: | |
7194 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 7195 |
2755 | 7196 decode_picture_parameter_set(h, bit_length); |
1168 | 7197 |
7198 break; | |
2960 | 7199 case NAL_AUD: |
7200 case NAL_END_SEQUENCE: | |
7201 case NAL_END_STREAM: | |
7202 case NAL_FILLER_DATA: | |
7203 case NAL_SPS_EXT: | |
7204 case NAL_AUXILIARY_SLICE: | |
1168 | 7205 break; |
2979 | 7206 default: |
5631 | 7207 av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", h->nal_unit_type, bit_length); |
2967 | 7208 } |
5642 | 7209 |
7210 if(context_count == h->max_contexts) { | |
7211 execute_decode_slices(h, context_count); | |
7212 context_count = 0; | |
7213 } | |
7214 | |
7215 if (err < 0) | |
7216 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
7217 else if(err == 1) { | |
7218 /* Slice could not be decoded in parallel mode, copy down | |
7219 * NAL unit stuff to context 0 and restart. Note that | |
7220 * rbsp_buffer is not transfered, but since we no longer | |
7221 * run in parallel mode this should not be an issue. */ | |
7222 h->nal_unit_type = hx->nal_unit_type; | |
7223 h->nal_ref_idc = hx->nal_ref_idc; | |
7224 hx = h; | |
7225 goto again; | |
7226 } | |
7227 } | |
7228 if(context_count) | |
7229 execute_decode_slices(h, context_count); | |
1168 | 7230 return buf_index; |
7231 } | |
7232 | |
7233 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7234 * returns the number of bytes consumed for building the current frame |
1168 | 7235 */ |
7236 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
7237 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
7238 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7239 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 7240 |
1168 | 7241 return pos; |
7242 }else{ | |
5127 | 7243 if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...) |
1168 | 7244 if(pos+10>buf_size) pos=buf_size; // oops ;) |
7245 | |
7246 return pos; | |
7247 } | |
7248 } | |
7249 | |
2967 | 7250 static int decode_frame(AVCodecContext *avctx, |
1168 | 7251 void *data, int *data_size, |
7252 uint8_t *buf, int buf_size) | |
7253 { | |
7254 H264Context *h = avctx->priv_data; | |
7255 MpegEncContext *s = &h->s; | |
2967 | 7256 AVFrame *pict = data; |
1168 | 7257 int buf_index; |
2967 | 7258 |
1168 | 7259 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
7260 s->flags2= avctx->flags2; |
1168 | 7261 |
7262 /* no supplementary picture */ | |
7263 if (buf_size == 0) { | |
4556 | 7264 Picture *out; |
7265 int i, out_idx; | |
7266 | |
7267 //FIXME factorize this with the output code below | |
7268 out = h->delayed_pic[0]; | |
7269 out_idx = 0; | |
7270 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++) | |
7271 if(h->delayed_pic[i]->poc < out->poc){ | |
7272 out = h->delayed_pic[i]; | |
7273 out_idx = i; | |
7274 } | |
7275 | |
7276 for(i=out_idx; h->delayed_pic[i]; i++) | |
7277 h->delayed_pic[i] = h->delayed_pic[i+1]; | |
7278 | |
7279 if(out){ | |
7280 *data_size = sizeof(AVFrame); | |
7281 *pict= *(AVFrame*)out; | |
7282 } | |
7283 | |
1168 | 7284 return 0; |
7285 } | |
2967 | 7286 |
1168 | 7287 if(s->flags&CODEC_FLAG_TRUNCATED){ |
4975 | 7288 int next= ff_h264_find_frame_end(h, buf, buf_size); |
2967 | 7289 |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4908
diff
changeset
|
7290 if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 ) |
1168 | 7291 return buf_size; |
7292 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
7293 } | |
7294 | |
2227 | 7295 if(h->is_avc && !h->got_avcC) { |
7296 int i, cnt, nalsize; | |
7297 unsigned char *p = avctx->extradata; | |
7298 if(avctx->extradata_size < 7) { | |
7299 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
7300 return -1; | |
7301 } | |
7302 if(*p != 1) { | |
7303 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
7304 return -1; | |
7305 } | |
7306 /* sps and pps in the avcC always have length coded with 2 bytes, | |
7307 so put a fake nal_length_size = 2 while parsing them */ | |
7308 h->nal_length_size = 2; | |
7309 // Decode sps from avcC | |
7310 cnt = *(p+5) & 0x1f; // Number of sps | |
7311 p += 6; | |
7312 for (i = 0; i < cnt; i++) { | |
4364 | 7313 nalsize = AV_RB16(p) + 2; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7314 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 7315 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
7316 return -1; | |
7317 } | |
7318 p += nalsize; | |
2967 | 7319 } |
2227 | 7320 // Decode pps from avcC |
7321 cnt = *(p++); // Number of pps | |
7322 for (i = 0; i < cnt; i++) { | |
4364 | 7323 nalsize = AV_RB16(p) + 2; |
2227 | 7324 if(decode_nal_units(h, p, nalsize) != nalsize) { |
7325 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
7326 return -1; | |
7327 } | |
7328 p += nalsize; | |
2967 | 7329 } |
2227 | 7330 // Now store right nal length size, that will be use to parse all other nals |
7331 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
7332 // Do not reparse avcC | |
7333 h->got_avcC = 1; | |
7334 } | |
7335 | |
4507
b80c704183e9
always decode extradata when of non-avc stream (like RTSP)
gpoirier
parents:
4391
diff
changeset
|
7336 if(avctx->frame_number==0 && !h->is_avc && s->avctx->extradata_size){ |
2967 | 7337 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 7338 return -1; |
7339 } | |
7340 | |
7341 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 7342 if(buf_index < 0) |
1168 | 7343 return -1; |
7344 | |
4620 | 7345 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){ |
5629
7e5ebda833e9
Remove error raising when explicitely skipping frame
benoit
parents:
5547
diff
changeset
|
7346 if (avctx->skip_frame >= AVDISCARD_NONREF || s->hurry_up) return 0; |
4620 | 7347 av_log(avctx, AV_LOG_ERROR, "no frame!\n"); |
7348 return -1; | |
7349 } | |
7350 | |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7351 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){ |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7352 Picture *out = s->current_picture_ptr; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7353 Picture *cur = s->current_picture_ptr; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7354 Picture *prev = h->delayed_output_pic; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7355 int i, pics, cross_idr, out_of_order, out_idx; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7356 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7357 s->mb_y= 0; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7358 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7359 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7360 s->current_picture_ptr->pict_type= s->pict_type; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7361 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7362 h->prev_frame_num_offset= h->frame_num_offset; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7363 h->prev_frame_num= h->frame_num; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7364 if(s->current_picture_ptr->reference){ |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7365 h->prev_poc_msb= h->poc_msb; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7366 h->prev_poc_lsb= h->poc_lsb; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7367 } |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7368 if(s->current_picture_ptr->reference) |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7369 execute_ref_pic_marking(h, h->mmco, h->mmco_index); |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7370 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7371 ff_er_frame_end(s); |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7372 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7373 MPV_frame_end(s); |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7374 |
2967 | 7375 //FIXME do something with unavailable reference frames |
7376 | |
2561 | 7377 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7378 *data_size = sizeof(AVFrame); |
2561 | 7379 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7380 /* Sort B-frames into display order */ |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7381 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7382 if(h->sps.bitstream_restriction_flag |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7383 && s->avctx->has_b_frames < h->sps.num_reorder_frames){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7384 s->avctx->has_b_frames = h->sps.num_reorder_frames; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7385 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7386 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7387 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
7388 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7389 while(h->delayed_pic[pics]) pics++; |
4388 | 7390 |
7391 assert(pics+1 < sizeof(h->delayed_pic) / sizeof(h->delayed_pic[0])); | |
7392 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7393 h->delayed_pic[pics++] = cur; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7394 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7395 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7396 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
7397 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7398 for(i=0; h->delayed_pic[i]; i++) |
2649
b2e6c5e9240b
fix decoding of conformace streams AUD_MW_E.264 and BA1_FT_C.264 again (there where last correctly decoded with h264.c rev 1.96)
michael
parents:
2648
diff
changeset
|
7399 if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7400 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7401 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7402 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
7403 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7404 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7405 if(h->delayed_pic[i]->poc < out->poc){ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7406 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7407 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7408 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7409 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7410 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 7411 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
7412 { } | |
7413 else if(prev && pics <= s->avctx->has_b_frames) | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7414 out = prev; |
2923 | 7415 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 7416 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7417 ((!cross_idr && prev && out->poc > prev->poc + 2) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7418 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7419 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7420 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7421 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7422 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7423 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7424 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7425 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7426 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7427 if(out_of_order || pics > s->avctx->has_b_frames){ |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7428 for(i=out_idx; h->delayed_pic[i]; i++) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7429 h->delayed_pic[i] = h->delayed_pic[i+1]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7430 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7431 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
7432 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7433 *data_size = 0; |
2561 | 7434 else |
7435 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7436 if(prev && prev != out && prev->reference == 1) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7437 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7438 h->delayed_output_pic = out; |
2441
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
7439 #endif |
2409 | 7440 |
2937 | 7441 if(out) |
7442 *pict= *(AVFrame*)out; | |
7443 else | |
7444 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
7445 } | |
7446 | |
7447 assert(pict->data[0] || !*data_size); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1698
diff
changeset
|
7448 ff_print_debug_info(s, pict); |
1168 | 7449 //printf("out %d\n", (int)pict->data[0]); |
7450 #if 0 //? | |
7451 | |
7452 /* Return the Picture timestamp as the frame number */ | |
7453 /* we substract 1 because it is added on utils.c */ | |
7454 avctx->frame_number = s->picture_number - 1; | |
7455 #endif | |
7456 return get_consumed_bytes(s, buf_index, buf_size); | |
7457 } | |
7458 #if 0 | |
7459 static inline void fill_mb_avail(H264Context *h){ | |
7460 MpegEncContext * const s = &h->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:
1174
diff
changeset
|
7461 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 7462 |
7463 if(s->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:
1174
diff
changeset
|
7464 h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num; |
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:
1174
diff
changeset
|
7465 h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num; |
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:
1174
diff
changeset
|
7466 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 7467 }else{ |
7468 h->mb_avail[0]= | |
7469 h->mb_avail[1]= | |
7470 h->mb_avail[2]= 0; | |
7471 } | |
7472 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
7473 h->mb_avail[4]= 1; //FIXME move out | |
7474 h->mb_avail[5]= 0; //FIXME move out | |
7475 } | |
7476 #endif | |
7477 | |
7478 #if 0 //selftest | |
5380
389366aa3458
Fix the self tests which are contained in some codecs and are using random().
takis
parents:
5338
diff
changeset
|
7479 #undef random |
1168 | 7480 #define COUNT 8000 |
7481 #define SIZE (COUNT*40) | |
7482 int main(){ | |
7483 int i; | |
7484 uint8_t temp[SIZE]; | |
7485 PutBitContext pb; | |
7486 GetBitContext gb; | |
7487 // int int_temp[10000]; | |
7488 DSPContext dsp; | |
7489 AVCodecContext avctx; | |
2967 | 7490 |
1168 | 7491 dsputil_init(&dsp, &avctx); |
7492 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
7493 init_put_bits(&pb, temp, SIZE); |
1168 | 7494 printf("testing unsigned exp golomb\n"); |
7495 for(i=0; i<COUNT; i++){ | |
7496 START_TIMER | |
7497 set_ue_golomb(&pb, i); | |
7498 STOP_TIMER("set_ue_golomb"); | |
7499 } | |
7500 flush_put_bits(&pb); | |
2967 | 7501 |
1168 | 7502 init_get_bits(&gb, temp, 8*SIZE); |
7503 for(i=0; i<COUNT; i++){ | |
7504 int j, s; | |
2967 | 7505 |
1168 | 7506 s= show_bits(&gb, 24); |
2967 | 7507 |
1168 | 7508 START_TIMER |
7509 j= get_ue_golomb(&gb); | |
7510 if(j != i){ | |
5127 | 7511 printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); |
1168 | 7512 // return -1; |
7513 } | |
7514 STOP_TIMER("get_ue_golomb"); | |
7515 } | |
2967 | 7516 |
7517 | |
1524 | 7518 init_put_bits(&pb, temp, SIZE); |
1168 | 7519 printf("testing signed exp golomb\n"); |
7520 for(i=0; i<COUNT; i++){ | |
7521 START_TIMER | |
7522 set_se_golomb(&pb, i - COUNT/2); | |
7523 STOP_TIMER("set_se_golomb"); | |
7524 } | |
7525 flush_put_bits(&pb); | |
2967 | 7526 |
1168 | 7527 init_get_bits(&gb, temp, 8*SIZE); |
7528 for(i=0; i<COUNT; i++){ | |
7529 int j, s; | |
2967 | 7530 |
1168 | 7531 s= show_bits(&gb, 24); |
2967 | 7532 |
1168 | 7533 START_TIMER |
7534 j= get_se_golomb(&gb); | |
7535 if(j != i - COUNT/2){ | |
5127 | 7536 printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); |
1168 | 7537 // return -1; |
7538 } | |
7539 STOP_TIMER("get_se_golomb"); | |
7540 } | |
7541 | |
7542 printf("testing 4x4 (I)DCT\n"); | |
2967 | 7543 |
1168 | 7544 DCTELEM block[16]; |
7545 uint8_t src[16], ref[16]; | |
7546 uint64_t error= 0, max_error=0; | |
7547 | |
7548 for(i=0; i<COUNT; i++){ | |
7549 int j; | |
7550 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
7551 for(j=0; j<16; j++){ | |
7552 ref[j]= random()%255; | |
7553 src[j]= random()%255; | |
7554 } | |
7555 | |
7556 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 7557 |
1168 | 7558 //normalize |
7559 for(j=0; j<16; j++){ | |
7560 // printf("%d ", block[j]); | |
7561 block[j]= block[j]*4; | |
7562 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
7563 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
7564 } | |
7565 // printf("\n"); | |
2967 | 7566 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
7567 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 7568 /* for(j=0; j<16; j++){ |
7569 printf("%d ", ref[j]); | |
7570 } | |
7571 printf("\n");*/ | |
2967 | 7572 |
1168 | 7573 for(j=0; j<16; j++){ |
4001 | 7574 int diff= FFABS(src[j] - ref[j]); |
2967 | 7575 |
1168 | 7576 error+= diff*diff; |
7577 max_error= FFMAX(max_error, diff); | |
7578 } | |
7579 } | |
7580 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
7581 #if 0 | |
7582 printf("testing quantizer\n"); | |
7583 for(qp=0; qp<52; qp++){ | |
7584 for(i=0; i<16; i++) | |
7585 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 7586 |
1168 | 7587 } |
7588 #endif | |
7589 printf("Testing NAL layer\n"); | |
2967 | 7590 |
1168 | 7591 uint8_t bitstream[COUNT]; |
7592 uint8_t nal[COUNT*2]; | |
7593 H264Context h; | |
7594 memset(&h, 0, sizeof(H264Context)); | |
2967 | 7595 |
1168 | 7596 for(i=0; i<COUNT; i++){ |
7597 int zeros= i; | |
7598 int nal_length; | |
7599 int consumed; | |
7600 int out_length; | |
7601 uint8_t *out; | |
7602 int j; | |
2967 | 7603 |
1168 | 7604 for(j=0; j<COUNT; j++){ |
7605 bitstream[j]= (random() % 255) + 1; | |
7606 } | |
2967 | 7607 |
1168 | 7608 for(j=0; j<zeros; j++){ |
7609 int pos= random() % COUNT; | |
7610 while(bitstream[pos] == 0){ | |
7611 pos++; | |
7612 pos %= COUNT; | |
7613 } | |
7614 bitstream[pos]=0; | |
7615 } | |
2967 | 7616 |
1168 | 7617 START_TIMER |
2967 | 7618 |
1168 | 7619 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
7620 if(nal_length<0){ | |
7621 printf("encoding failed\n"); | |
7622 return -1; | |
7623 } | |
2967 | 7624 |
1168 | 7625 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
7626 | |
7627 STOP_TIMER("NAL") | |
2967 | 7628 |
1168 | 7629 if(out_length != COUNT){ |
7630 printf("incorrect length %d %d\n", out_length, COUNT); | |
7631 return -1; | |
7632 } | |
2967 | 7633 |
1168 | 7634 if(consumed != nal_length){ |
7635 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
7636 return -1; | |
7637 } | |
2967 | 7638 |
1168 | 7639 if(memcmp(bitstream, out, COUNT)){ |
5127 | 7640 printf("mismatch\n"); |
1168 | 7641 return -1; |
7642 } | |
7643 } | |
2967 | 7644 |
1168 | 7645 printf("Testing RBSP\n"); |
2967 | 7646 |
7647 | |
1168 | 7648 return 0; |
7649 } | |
7650 #endif | |
7651 | |
7652 | |
7653 static int decode_end(AVCodecContext *avctx) | |
7654 { | |
7655 H264Context *h = avctx->priv_data; | |
7656 MpegEncContext *s = &h->s; | |
2967 | 7657 |
5174 | 7658 av_freep(&h->rbsp_buffer[0]); |
7659 av_freep(&h->rbsp_buffer[1]); | |
1168 | 7660 free_tables(h); //FIXME cleanup init stuff perhaps |
7661 MPV_common_end(s); | |
7662 | |
7663 // memset(h, 0, sizeof(H264Context)); | |
2967 | 7664 |
1168 | 7665 return 0; |
7666 } | |
7667 | |
7668 | |
7669 AVCodec h264_decoder = { | |
7670 "h264", | |
7671 CODEC_TYPE_VIDEO, | |
7672 CODEC_ID_H264, | |
7673 sizeof(H264Context), | |
7674 decode_init, | |
7675 NULL, | |
7676 decode_end, | |
7677 decode_frame, | |
2453 | 7678 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 7679 .flush= flush_dpb, |
1168 | 7680 }; |
7681 | |
1234 | 7682 #include "svq3.c" |