Mercurial > libavcodec.hg
annotate h264.c @ 5062:2dd00b1cc94b libavcodec
Remove mdct.o and fft.o from fft-test prerequisites list.
Both objects were added to the link command, resulting in multiple definitions
of symbols. Now linking works in the general case when mdct.o and fft.o are
compiled into libavcodec.a.
author | diego |
---|---|
date | Tue, 22 May 2007 07:08:38 +0000 |
parents | ed6b3efebf1e |
children | 27afc3835257 |
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 * |
21 */ | |
2967 | 22 |
1168 | 23 /** |
24 * @file h264.c | |
25 * H.264 / AVC / MPEG4 part10 codec. | |
26 * @author Michael Niedermayer <michaelni@gmx.at> | |
27 */ | |
28 | |
29 #include "dsputil.h" | |
30 #include "avcodec.h" | |
31 #include "mpegvideo.h" | |
4975 | 32 #include "h264.h" |
1168 | 33 #include "h264data.h" |
4975 | 34 #include "h264_parser.h" |
1168 | 35 #include "golomb.h" |
36 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
37 #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
|
38 |
3284
a224d9752912
don't force asserts in release builds. 2% faster h264.
lorenm
parents:
3219
diff
changeset
|
39 //#undef NDEBUG |
1168 | 40 #include <assert.h> |
41 | |
42 static VLC coeff_token_vlc[4]; | |
43 static VLC chroma_dc_coeff_token_vlc; | |
44 | |
45 static VLC total_zeros_vlc[15]; | |
46 static VLC chroma_dc_total_zeros_vlc[3]; | |
47 | |
48 static VLC run_vlc[6]; | |
49 static VLC run7_vlc; | |
50 | |
1234 | 51 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
52 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
|
53 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
|
54 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 | 55 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
56 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 57 #ifdef WORDS_BIGENDIAN |
58 return (b&0xFFFF) + (a<<16); | |
59 #else | |
60 return (a&0xFFFF) + (b<<16); | |
61 #endif | |
62 } | |
63 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
64 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
65 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
|
66 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
67 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
68 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
69 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
|
70 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
71 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
72 |
1168 | 73 /** |
74 * fill a rectangle. | |
2392 | 75 * @param h height of the rectangle, should be a constant |
76 * @param w width of the rectangle, should be a constant | |
1168 | 77 * @param size the size of val (1 or 4), should be a constant |
78 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
79 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 80 uint8_t *p= (uint8_t*)vp; |
1168 | 81 assert(size==1 || size==4); |
3315 | 82 assert(w<=4); |
2967 | 83 |
1168 | 84 w *= size; |
85 stride *= size; | |
2967 | 86 |
2962 | 87 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 88 assert((stride&(w-1))==0); |
3315 | 89 if(w==2){ |
90 const uint16_t v= size==4 ? val : val*0x0101; | |
91 *(uint16_t*)(p + 0*stride)= v; | |
92 if(h==1) return; | |
93 *(uint16_t*)(p + 1*stride)= v; | |
94 if(h==2) return; | |
1168 | 95 *(uint16_t*)(p + 2*stride)= |
3315 | 96 *(uint16_t*)(p + 3*stride)= v; |
97 }else if(w==4){ | |
98 const uint32_t v= size==4 ? val : val*0x01010101; | |
99 *(uint32_t*)(p + 0*stride)= v; | |
100 if(h==1) return; | |
101 *(uint32_t*)(p + 1*stride)= v; | |
102 if(h==2) return; | |
1168 | 103 *(uint32_t*)(p + 2*stride)= |
3315 | 104 *(uint32_t*)(p + 3*stride)= v; |
105 }else if(w==8){ | |
106 //gcc can't optimize 64bit math on x86_32 | |
107 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
108 const uint64_t v= val*0x0100000001ULL; | |
109 *(uint64_t*)(p + 0*stride)= v; | |
110 if(h==1) return; | |
111 *(uint64_t*)(p + 1*stride)= v; | |
112 if(h==2) return; | |
1168 | 113 *(uint64_t*)(p + 2*stride)= |
3315 | 114 *(uint64_t*)(p + 3*stride)= v; |
115 }else if(w==16){ | |
116 const uint64_t v= val*0x0100000001ULL; | |
1168 | 117 *(uint64_t*)(p + 0+0*stride)= |
118 *(uint64_t*)(p + 8+0*stride)= | |
119 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 120 *(uint64_t*)(p + 8+1*stride)= v; |
121 if(h==2) return; | |
1168 | 122 *(uint64_t*)(p + 0+2*stride)= |
123 *(uint64_t*)(p + 8+2*stride)= | |
124 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 125 *(uint64_t*)(p + 8+3*stride)= v; |
126 #else | |
127 *(uint32_t*)(p + 0+0*stride)= | |
128 *(uint32_t*)(p + 4+0*stride)= val; | |
129 if(h==1) return; | |
130 *(uint32_t*)(p + 0+1*stride)= | |
131 *(uint32_t*)(p + 4+1*stride)= val; | |
132 if(h==2) return; | |
133 *(uint32_t*)(p + 0+2*stride)= | |
134 *(uint32_t*)(p + 4+2*stride)= | |
135 *(uint32_t*)(p + 0+3*stride)= | |
136 *(uint32_t*)(p + 4+3*stride)= val; | |
137 }else if(w==16){ | |
138 *(uint32_t*)(p + 0+0*stride)= | |
139 *(uint32_t*)(p + 4+0*stride)= | |
140 *(uint32_t*)(p + 8+0*stride)= | |
141 *(uint32_t*)(p +12+0*stride)= | |
142 *(uint32_t*)(p + 0+1*stride)= | |
143 *(uint32_t*)(p + 4+1*stride)= | |
144 *(uint32_t*)(p + 8+1*stride)= | |
145 *(uint32_t*)(p +12+1*stride)= val; | |
146 if(h==2) return; | |
147 *(uint32_t*)(p + 0+2*stride)= | |
148 *(uint32_t*)(p + 4+2*stride)= | |
149 *(uint32_t*)(p + 8+2*stride)= | |
150 *(uint32_t*)(p +12+2*stride)= | |
151 *(uint32_t*)(p + 0+3*stride)= | |
152 *(uint32_t*)(p + 4+3*stride)= | |
153 *(uint32_t*)(p + 8+3*stride)= | |
154 *(uint32_t*)(p +12+3*stride)= val; | |
155 #endif | |
1168 | 156 }else |
157 assert(0); | |
3315 | 158 assert(h==4); |
1168 | 159 } |
160 | |
3028 | 161 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 162 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
|
163 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 164 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
165 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
|
166 int left_block[8]; |
1168 | 167 int i; |
168 | |
3482 | 169 //FIXME deblocking could skip the intra and nnz parts. |
170 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
|
171 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
172 |
2967 | 173 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
174 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
175 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
|
176 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
177 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
178 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
|
179 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
180 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
181 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
182 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
183 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
184 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
185 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
186 left_block[7]= 11; |
3316 | 187 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
188 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
|
189 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
|
190 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
|
191 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
|
192 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
|
193 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
|
194 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
|
195 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
|
196 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
|
197 const int bottom = (s->mb_y & 1); |
4600 | 198 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
|
199 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
200 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
201 : (!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
|
202 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
203 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
204 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
205 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
206 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
207 : (!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
|
208 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
209 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
210 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
211 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
212 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
213 : (!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
|
214 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
215 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
216 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
217 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
|
218 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
|
219 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
220 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
221 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
222 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
223 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
224 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
225 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
226 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
227 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
228 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
229 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
230 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
231 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
232 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
233 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
234 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
235 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
236 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
237 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
238 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
239 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
240 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
241 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
242 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
243 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
244 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
245 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
246 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
247 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
248 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
249 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
250 } |
1168 | 251 } |
252 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
253 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
|
254 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
|
255 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
|
256 if(for_deblock){ |
3482 | 257 topleft_type = 0; |
258 topright_type = 0; | |
2449 | 259 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
260 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
261 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 262 |
263 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
264 int list; | |
265 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
266 for(i=0; i<16; i++) | |
267 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
4533 | 268 for(list=0; list<h->list_count; list++){ |
3316 | 269 if(USES_LIST(mb_type,list)){ |
270 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
271 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 272 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 273 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
274 dst[0] = src[0]; | |
275 dst[1] = src[1]; | |
276 dst[2] = src[2]; | |
277 dst[3] = src[3]; | |
278 } | |
279 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
280 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
281 ref += h->b8_stride; | |
282 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
283 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
284 }else{ | |
285 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
286 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
287 } | |
288 } | |
289 } | |
2449 | 290 }else{ |
291 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
292 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
293 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
294 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
295 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
296 } | |
1168 | 297 |
298 if(IS_INTRA(mb_type)){ | |
2967 | 299 h->topleft_samples_available= |
300 h->top_samples_available= | |
1168 | 301 h->left_samples_available= 0xFFFF; |
302 h->topright_samples_available= 0xEEEA; | |
303 | |
304 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
305 h->topleft_samples_available= 0xB3FF; | |
306 h->top_samples_available= 0x33FF; | |
307 h->topright_samples_available= 0x26EA; | |
308 } | |
309 for(i=0; i<2; i++){ | |
310 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
311 h->topleft_samples_available&= 0xDF5F; | |
312 h->left_samples_available&= 0x5F5F; | |
313 } | |
314 } | |
2967 | 315 |
1168 | 316 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
317 h->topleft_samples_available&= 0x7FFF; | |
2967 | 318 |
1168 | 319 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
320 h->topright_samples_available&= 0xFBFF; | |
2967 | 321 |
1168 | 322 if(IS_INTRA4x4(mb_type)){ |
323 if(IS_INTRA4x4(top_type)){ | |
324 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
325 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
326 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
327 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
328 }else{ | |
329 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
330 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
|
331 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
332 else{ |
1168 | 333 pred= 2; |
334 } | |
335 h->intra4x4_pred_mode_cache[4+8*0]= | |
336 h->intra4x4_pred_mode_cache[5+8*0]= | |
337 h->intra4x4_pred_mode_cache[6+8*0]= | |
338 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
339 } | |
340 for(i=0; i<2; i++){ | |
341 if(IS_INTRA4x4(left_type[i])){ | |
342 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
343 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
344 }else{ | |
345 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
346 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
|
347 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
348 else{ |
1168 | 349 pred= 2; |
350 } | |
351 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
352 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
353 } | |
354 } | |
355 } | |
356 } | |
2967 | 357 |
358 | |
1168 | 359 /* |
2967 | 360 0 . T T. T T T T |
361 1 L . .L . . . . | |
362 2 L . .L . . . . | |
363 3 . T TL . . . . | |
364 4 L . .L . . . . | |
365 5 L . .. . . . . | |
1168 | 366 */ |
367 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
368 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
369 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
|
370 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
|
371 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
|
372 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 373 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
374 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
|
375 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 376 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
377 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
|
378 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 379 |
1168 | 380 }else{ |
2967 | 381 h->non_zero_count_cache[4+8*0]= |
1168 | 382 h->non_zero_count_cache[5+8*0]= |
383 h->non_zero_count_cache[6+8*0]= | |
384 h->non_zero_count_cache[7+8*0]= | |
2967 | 385 |
1168 | 386 h->non_zero_count_cache[1+8*0]= |
387 h->non_zero_count_cache[2+8*0]= | |
2967 | 388 |
1168 | 389 h->non_zero_count_cache[1+8*3]= |
2314 | 390 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 391 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
392 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
393 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
394 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
395 if(left_type[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*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
|
397 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
|
398 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
|
399 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
|
400 }else{ |
2967 | 401 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
402 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
403 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
|
404 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
|
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 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
408 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
|
409 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
410 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
|
411 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
|
412 } 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
|
413 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
|
414 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
415 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
|
416 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
417 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
418 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
|
419 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
|
420 } 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
|
421 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
|
422 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
423 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
|
424 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
425 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
|
426 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
|
427 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
428 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
|
429 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
|
430 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
431 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
432 |
1168 | 433 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
434 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 435 int list; |
4533 | 436 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
|
437 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 438 /*if(!h->mv_cache_clean[list]){ |
439 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
440 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
441 h->mv_cache_clean[list]= 1; | |
442 }*/ | |
2396 | 443 continue; |
1168 | 444 } |
445 h->mv_cache_clean[list]= 0; | |
2967 | 446 |
3212 | 447 if(USES_LIST(top_type, list)){ |
1168 | 448 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
449 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
450 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
451 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
452 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
453 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
454 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
455 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
456 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
457 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
458 }else{ | |
2967 | 459 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
460 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
461 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 462 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
463 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
464 } | |
465 | |
4546 | 466 for(i=0; i<2; i++){ |
467 int cache_idx = scan8[0] - 1 + i*2*8; | |
468 if(USES_LIST(left_type[i], list)){ | |
469 const int b_xy= h->mb2b_xy[left_xy[i]] + 3; | |
470 const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1; | |
471 *(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]]; | |
472 *(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]]; | |
473 h->ref_cache[list][cache_idx ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)]; | |
474 h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)]; | |
475 }else{ | |
476 *(uint32_t*)h->mv_cache [list][cache_idx ]= | |
477 *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0; | |
478 h->ref_cache[list][cache_idx ]= | |
479 h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
480 } | |
1168 | 481 } |
482 | |
3519 | 483 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 484 continue; |
485 | |
3212 | 486 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
|
487 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
|
488 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
|
489 *(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
|
490 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
|
491 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
492 *(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
|
493 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
|
494 } |
2967 | 495 |
3212 | 496 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
|
497 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
|
498 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
|
499 *(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
|
500 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
|
501 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
502 *(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
|
503 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
|
504 } |
2967 | 505 |
3519 | 506 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 507 continue; |
2967 | 508 |
509 h->ref_cache[list][scan8[5 ]+1] = | |
510 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
511 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 512 h->ref_cache[list][scan8[4 ]] = |
1168 | 513 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
514 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
515 *(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
|
516 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 517 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
518 *(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
|
519 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
520 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
|
521 /* XXX beurk, Load mvd */ |
3212 | 522 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
|
523 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
|
524 *(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
|
525 *(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
|
526 *(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
|
527 *(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
|
528 }else{ |
2967 | 529 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
530 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
531 *(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
|
532 *(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
|
533 } |
3212 | 534 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
|
535 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
|
536 *(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
|
537 *(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
|
538 }else{ |
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 + 0*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
540 *(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
|
541 } |
3212 | 542 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
|
543 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
|
544 *(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
|
545 *(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
|
546 }else{ |
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 + 2*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
548 *(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
|
549 } |
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[5 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
551 *(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
|
552 *(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
|
553 *(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
|
554 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 555 |
556 if(h->slice_type == B_TYPE){ | |
557 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
558 | |
559 if(IS_DIRECT(top_type)){ | |
560 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
561 }else if(IS_8X8(top_type)){ | |
562 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
563 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
564 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
565 }else{ | |
566 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
567 } | |
2967 | 568 |
3316 | 569 if(IS_DIRECT(left_type[0])) |
570 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
571 else if(IS_8X8(left_type[0])) | |
572 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)]; | |
573 else | |
574 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
575 | |
576 if(IS_DIRECT(left_type[1])) | |
2396 | 577 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 578 else if(IS_8X8(left_type[1])) |
579 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)]; | |
580 else | |
2396 | 581 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 582 } |
583 } | |
584 | |
585 if(FRAME_MBAFF){ | |
586 #define MAP_MVS\ | |
587 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
588 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
589 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
590 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
591 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
592 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
593 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
594 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
595 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
596 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
597 if(MB_FIELD){ | |
598 #define MAP_F2F(idx, mb_type)\ | |
599 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
600 h->ref_cache[list][idx] <<= 1;\ | |
601 h->mv_cache[list][idx][1] /= 2;\ | |
602 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 603 } |
3316 | 604 MAP_MVS |
605 #undef MAP_F2F | |
606 }else{ | |
607 #define MAP_F2F(idx, mb_type)\ | |
608 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
609 h->ref_cache[list][idx] >>= 1;\ | |
610 h->mv_cache[list][idx][1] <<= 1;\ | |
611 h->mvd_cache[list][idx][1] <<= 1;\ | |
612 } | |
613 MAP_MVS | |
614 #undef MAP_F2F | |
2396 | 615 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
616 } |
1168 | 617 } |
618 } | |
619 #endif | |
2755 | 620 |
621 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 622 } |
623 | |
624 static inline void write_back_intra_pred_mode(H264Context *h){ | |
625 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
|
626 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 627 |
628 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
629 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
630 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
631 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
632 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
633 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
634 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
635 } | |
636 | |
637 /** | |
638 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
639 */ | |
640 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
641 MpegEncContext * const s = &h->s; | |
642 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
643 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
644 int i; | |
2967 | 645 |
1168 | 646 if(!(h->top_samples_available&0x8000)){ |
647 for(i=0; i<4; i++){ | |
648 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
649 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
650 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 | 651 return -1; |
652 } else if(status){ | |
653 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
654 } | |
655 } | |
656 } | |
2967 | 657 |
1168 | 658 if(!(h->left_samples_available&0x8000)){ |
659 for(i=0; i<4; i++){ | |
660 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
661 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
662 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 | 663 return -1; |
664 } else if(status){ | |
665 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
666 } | |
667 } | |
668 } | |
669 | |
670 return 0; | |
671 } //FIXME cleanup like next | |
672 | |
673 /** | |
674 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
675 */ | |
676 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
677 MpegEncContext * const s = &h->s; | |
678 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
679 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 680 |
4529 | 681 if(mode > 6U) { |
2392 | 682 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 | 683 return -1; |
2392 | 684 } |
2967 | 685 |
1168 | 686 if(!(h->top_samples_available&0x8000)){ |
687 mode= top[ mode ]; | |
688 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
689 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 | 690 return -1; |
691 } | |
692 } | |
2967 | 693 |
1168 | 694 if(!(h->left_samples_available&0x8000)){ |
695 mode= left[ mode ]; | |
696 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
697 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 | 698 return -1; |
2967 | 699 } |
1168 | 700 } |
701 | |
702 return mode; | |
703 } | |
704 | |
705 /** | |
706 * gets the predicted intra4x4 prediction mode. | |
707 */ | |
708 static inline int pred_intra_mode(H264Context *h, int n){ | |
709 const int index8= scan8[n]; | |
710 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
711 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
712 const int min= FFMIN(left, top); | |
713 | |
4600 | 714 tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min); |
1168 | 715 |
716 if(min<0) return DC_PRED; | |
717 else return min; | |
718 } | |
719 | |
720 static inline void write_back_non_zero_count(H264Context *h){ | |
721 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
|
722 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
|
723 |
2551
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][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
|
725 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
|
726 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
|
727 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
|
728 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
|
729 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
|
730 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 731 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
732 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
|
733 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
|
734 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
|
735 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
736 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
|
737 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
|
738 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 739 |
740 if(FRAME_MBAFF){ | |
741 // store all luma nnzs, for deblocking | |
742 int v = 0, i; | |
743 for(i=0; i<16; i++) | |
744 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
745 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
746 } | |
1168 | 747 } |
748 | |
749 /** | |
750 * gets the predicted number of non zero coefficients. | |
751 * @param n block index | |
752 */ | |
753 static inline int pred_non_zero_count(H264Context *h, int n){ | |
754 const int index8= scan8[n]; | |
755 const int left= h->non_zero_count_cache[index8 - 1]; | |
756 const int top = h->non_zero_count_cache[index8 - 8]; | |
757 int i= left + top; | |
2967 | 758 |
1168 | 759 if(i<64) i= (i+1)>>1; |
760 | |
4600 | 761 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 | 762 |
763 return i&31; | |
764 } | |
765 | |
1169 | 766 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
767 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
4600 | 768 MpegEncContext *s = &h->s; |
1169 | 769 |
3316 | 770 /* there is no consistent mapping of mvs to neighboring locations that will |
771 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
772 if(FRAME_MBAFF){ | |
3776 | 773 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 774 const int16_t *mv; |
775 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
776 *C = h->mv_cache[list][scan8[0]-2]; | |
777 | |
778 if(!MB_FIELD | |
779 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
780 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
781 if(IS_INTERLACED(mb_types[topright_xy])){ | |
782 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
783 const int x4 = X4, y4 = Y4;\ | |
784 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
785 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
786 return LIST_NOT_USED;\ | |
787 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
788 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
789 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
790 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
791 | |
792 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
793 } | |
794 } | |
795 if(topright_ref == PART_NOT_AVAILABLE | |
796 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
797 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
798 if(!MB_FIELD | |
799 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
800 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
801 } | |
802 if(MB_FIELD | |
803 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
804 && i >= scan8[0]+8){ | |
805 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
806 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
807 } | |
808 } | |
809 #undef SET_DIAG_MV | |
810 } | |
811 | |
1169 | 812 if(topright_ref != PART_NOT_AVAILABLE){ |
813 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
814 return topright_ref; | |
815 }else{ | |
4600 | 816 tprintf(s->avctx, "topright MV not available\n"); |
1170 | 817 |
1169 | 818 *C= h->mv_cache[list][ i - 8 - 1 ]; |
819 return h->ref_cache[list][ i - 8 - 1 ]; | |
820 } | |
821 } | |
822 | |
1168 | 823 /** |
824 * gets the predicted MV. | |
825 * @param n the block index | |
826 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
827 * @param mx the x component of the predicted motion vector | |
828 * @param my the y component of the predicted motion vector | |
829 */ | |
830 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
831 const int index8= scan8[n]; | |
832 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
833 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
834 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
835 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 836 const int16_t * C; |
837 int diagonal_ref, match_count; | |
838 | |
1168 | 839 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 840 |
1168 | 841 /* mv_cache |
2967 | 842 B . . A T T T T |
1168 | 843 U . . L . . , . |
844 U . . L . . . . | |
845 U . . L . . , . | |
846 . . . L . . . . | |
847 */ | |
1169 | 848 |
849 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
850 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref); | |
4600 | 851 tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count); |
1169 | 852 if(match_count > 1){ //most common |
853 *mx= mid_pred(A[0], B[0], C[0]); | |
854 *my= mid_pred(A[1], B[1], C[1]); | |
855 }else if(match_count==1){ | |
856 if(left_ref==ref){ | |
857 *mx= A[0]; | |
2967 | 858 *my= A[1]; |
1169 | 859 }else if(top_ref==ref){ |
860 *mx= B[0]; | |
2967 | 861 *my= B[1]; |
1169 | 862 }else{ |
863 *mx= C[0]; | |
2967 | 864 *my= C[1]; |
1169 | 865 } |
866 }else{ | |
867 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
868 *mx= A[0]; | |
2967 | 869 *my= A[1]; |
1168 | 870 }else{ |
871 *mx= mid_pred(A[0], B[0], C[0]); | |
872 *my= mid_pred(A[1], B[1], C[1]); | |
873 } | |
1169 | 874 } |
2967 | 875 |
4600 | 876 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 | 877 } |
878 | |
879 /** | |
880 * gets the directionally predicted 16x8 MV. | |
881 * @param n the block index | |
882 * @param mx the x component of the predicted motion vector | |
883 * @param my the y component of the predicted motion vector | |
884 */ | |
885 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
886 if(n==0){ | |
887 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
888 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
889 | |
4600 | 890 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 | 891 |
1168 | 892 if(top_ref == ref){ |
893 *mx= B[0]; | |
894 *my= B[1]; | |
895 return; | |
896 } | |
897 }else{ | |
898 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
899 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 900 |
4600 | 901 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 | 902 |
903 if(left_ref == ref){ | |
904 *mx= A[0]; | |
905 *my= A[1]; | |
906 return; | |
907 } | |
908 } | |
909 | |
910 //RARE | |
911 pred_motion(h, n, 4, list, ref, mx, my); | |
912 } | |
913 | |
914 /** | |
915 * gets the directionally predicted 8x16 MV. | |
916 * @param n the block index | |
917 * @param mx the x component of the predicted motion vector | |
918 * @param my the y component of the predicted motion vector | |
919 */ | |
920 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
921 if(n==0){ | |
922 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
923 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 924 |
4600 | 925 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 | 926 |
927 if(left_ref == ref){ | |
928 *mx= A[0]; | |
929 *my= A[1]; | |
930 return; | |
931 } | |
932 }else{ | |
1169 | 933 const int16_t * C; |
934 int diagonal_ref; | |
935 | |
936 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 937 |
4600 | 938 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 | 939 |
2967 | 940 if(diagonal_ref == ref){ |
1168 | 941 *mx= C[0]; |
942 *my= C[1]; | |
943 return; | |
944 } | |
945 } | |
946 | |
947 //RARE | |
948 pred_motion(h, n, 2, list, ref, mx, my); | |
949 } | |
950 | |
951 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
952 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
953 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
954 | |
4600 | 955 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 | 956 |
957 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
958 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
959 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 960 |
1168 | 961 *mx = *my = 0; |
962 return; | |
963 } | |
2967 | 964 |
1168 | 965 pred_motion(h, 0, 4, 0, 0, mx, my); |
966 | |
967 return; | |
968 } | |
969 | |
2396 | 970 static inline void direct_dist_scale_factor(H264Context * const h){ |
971 const int poc = h->s.current_picture_ptr->poc; | |
972 const int poc1 = h->ref_list[1][0].poc; | |
973 int i; | |
974 for(i=0; i<h->ref_count[0]; i++){ | |
975 int poc0 = h->ref_list[0][i].poc; | |
4594 | 976 int td = av_clip(poc1 - poc0, -128, 127); |
2396 | 977 if(td == 0 /* FIXME || pic0 is a long-term ref */){ |
978 h->dist_scale_factor[i] = 256; | |
979 }else{ | |
4594 | 980 int tb = av_clip(poc - poc0, -128, 127); |
4001 | 981 int tx = (16384 + (FFABS(td) >> 1)) / td; |
4594 | 982 h->dist_scale_factor[i] = av_clip((tb*tx + 32) >> 6, -1024, 1023); |
2396 | 983 } |
984 } | |
3316 | 985 if(FRAME_MBAFF){ |
986 for(i=0; i<h->ref_count[0]; i++){ | |
987 h->dist_scale_factor_field[2*i] = | |
988 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
989 } | |
990 } | |
2396 | 991 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
992 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
|
993 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
994 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
|
995 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
|
996 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
997 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
998 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
999 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1000 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1001 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1002 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
|
1003 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
|
1004 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
|
1005 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1006 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
|
1007 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1008 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1009 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
|
1010 const int poc = ref1->ref_poc[list][i]; |
3125 | 1011 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
|
1012 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
|
1013 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
|
1014 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
|
1015 break; |
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 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1018 } |
3316 | 1019 if(FRAME_MBAFF){ |
1020 for(list=0; list<2; list++){ | |
1021 for(i=0; i<ref1->ref_count[list]; i++){ | |
1022 j = h->map_col_to_list0[list][i]; | |
1023 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1024 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1025 } | |
1026 } | |
1027 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1028 } |
2396 | 1029 |
1030 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1031 MpegEncContext * const s = &h->s; | |
1032 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1033 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1034 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1035 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1036 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
|
1037 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1038 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
|
1039 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1040 const int is_b8x8 = IS_8X8(*mb_type); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
1041 unsigned int sub_mb_type; |
2396 | 1042 int i8, i4; |
1043 | |
3316 | 1044 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1045 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1046 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1047 * so we know exactly what block size to use */ | |
1048 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1049 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1050 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1051 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1052 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1053 }else{ | |
1054 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1055 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1056 } |
1057 if(!is_b8x8) | |
1058 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1059 if(MB_FIELD) |
1060 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1061 |
4600 | 1062 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 | 1063 |
2396 | 1064 if(h->direct_spatial_mv_pred){ |
1065 int ref[2]; | |
1066 int mv[2][2]; | |
1067 int list; | |
1068 | |
3316 | 1069 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1070 | |
2396 | 1071 /* ref = min(neighbors) */ |
1072 for(list=0; list<2; list++){ | |
1073 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1074 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1075 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1076 if(refc == -2) | |
1077 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1078 ref[list] = refa; | |
1079 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1080 ref[list] = refb; | |
1081 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1082 ref[list] = refc; | |
1083 if(ref[list] < 0) | |
1084 ref[list] = -1; | |
1085 } | |
1086 | |
1087 if(ref[0] < 0 && ref[1] < 0){ | |
1088 ref[0] = ref[1] = 0; | |
1089 mv[0][0] = mv[0][1] = | |
1090 mv[1][0] = mv[1][1] = 0; | |
1091 }else{ | |
1092 for(list=0; list<2; list++){ | |
1093 if(ref[list] >= 0) | |
1094 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1095 else | |
1096 mv[list][0] = mv[list][1] = 0; | |
1097 } | |
1098 } | |
1099 | |
1100 if(ref[1] < 0){ | |
1101 *mb_type &= ~MB_TYPE_P0L1; | |
1102 sub_mb_type &= ~MB_TYPE_P0L1; | |
1103 }else if(ref[0] < 0){ | |
1104 *mb_type &= ~MB_TYPE_P0L0; | |
1105 sub_mb_type &= ~MB_TYPE_P0L0; | |
1106 } | |
1107 | |
1108 if(IS_16X16(*mb_type)){ | |
4540 | 1109 int a=0, b=0; |
1110 | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1111 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
|
1112 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1113 if(!IS_INTRA(mb_type_col) |
4001 | 1114 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1115 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1116 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1117 if(ref[0] > 0) |
4540 | 1118 a= pack16to32(mv[0][0],mv[0][1]); |
2396 | 1119 if(ref[1] > 0) |
4540 | 1120 b= pack16to32(mv[1][0],mv[1][1]); |
2396 | 1121 }else{ |
4540 | 1122 a= pack16to32(mv[0][0],mv[0][1]); |
1123 b= pack16to32(mv[1][0],mv[1][1]); | |
1124 } | |
1125 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4); | |
1126 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4); | |
2396 | 1127 }else{ |
1128 for(i8=0; i8<4; i8++){ | |
1129 const int x8 = i8&1; | |
1130 const int y8 = i8>>1; | |
2967 | 1131 |
2396 | 1132 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1133 continue; | |
1134 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1135 |
2396 | 1136 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1137 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
|
1138 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
|
1139 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1140 |
2396 | 1141 /* col_zero_flag */ |
2967 | 1142 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1143 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1144 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1145 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1146 if(IS_SUB_8X8(sub_mb_type)){ |
1147 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1148 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1149 if(ref[0] == 0) |
1150 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1151 if(ref[1] == 0) | |
1152 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1153 } | |
1154 }else | |
2396 | 1155 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1156 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1157 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1158 if(ref[0] == 0) |
1159 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1160 if(ref[1] == 0) | |
1161 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1162 } | |
1163 } | |
1164 } | |
1165 } | |
1166 } | |
1167 }else{ /* direct temporal mv pred */ | |
3316 | 1168 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1169 const int *dist_scale_factor = h->dist_scale_factor; | |
1170 | |
1171 if(FRAME_MBAFF){ | |
1172 if(IS_INTERLACED(*mb_type)){ | |
1173 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1174 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1175 dist_scale_factor = h->dist_scale_factor_field; | |
1176 } | |
1177 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1178 /* FIXME assumes direct_8x8_inference == 1 */ | |
1179 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1180 int mb_types_col[2]; | |
1181 int y_shift; | |
1182 | |
1183 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1184 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1185 | (*mb_type & MB_TYPE_INTERLACED); | |
1186 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1187 | |
1188 if(IS_INTERLACED(*mb_type)){ | |
1189 /* frame to field scaling */ | |
1190 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1191 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1192 if(s->mb_y&1){ | |
1193 l1ref0 -= 2*h->b8_stride; | |
1194 l1ref1 -= 2*h->b8_stride; | |
1195 l1mv0 -= 4*h->b_stride; | |
1196 l1mv1 -= 4*h->b_stride; | |
1197 } | |
1198 y_shift = 0; | |
1199 | |
1200 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1201 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1202 && !is_b8x8) | |
1203 *mb_type |= MB_TYPE_16x8; | |
1204 else | |
1205 *mb_type |= MB_TYPE_8x8; | |
1206 }else{ | |
1207 /* field to frame scaling */ | |
1208 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1209 * but in MBAFF, top and bottom POC are equal */ | |
1210 int dy = (s->mb_y&1) ? 1 : 2; | |
1211 mb_types_col[0] = | |
1212 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1213 l1ref0 += dy*h->b8_stride; | |
1214 l1ref1 += dy*h->b8_stride; | |
1215 l1mv0 += 2*dy*h->b_stride; | |
1216 l1mv1 += 2*dy*h->b_stride; | |
1217 y_shift = 2; | |
1218 | |
1219 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1220 && !is_b8x8) | |
1221 *mb_type |= MB_TYPE_16x16; | |
1222 else | |
1223 *mb_type |= MB_TYPE_8x8; | |
1224 } | |
1225 | |
1226 for(i8=0; i8<4; i8++){ | |
1227 const int x8 = i8&1; | |
1228 const int y8 = i8>>1; | |
1229 int ref0, scale; | |
1230 const int16_t (*l1mv)[2]= l1mv0; | |
1231 | |
1232 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1233 continue; | |
1234 h->sub_mb_type[i8] = sub_mb_type; | |
1235 | |
1236 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1237 if(IS_INTRA(mb_types_col[y8])){ | |
1238 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1239 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1240 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1241 continue; | |
1242 } | |
1243 | |
1244 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1245 if(ref0 >= 0) | |
1246 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1247 else{ | |
1248 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1249 l1mv= l1mv1; | |
1250 } | |
1251 scale = dist_scale_factor[ref0]; | |
1252 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1253 | |
1254 { | |
1255 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1256 int my_col = (mv_col[1]<<y_shift)/2; | |
1257 int mx = (scale * mv_col[0] + 128) >> 8; | |
1258 int my = (scale * my_col + 128) >> 8; | |
1259 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1260 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1261 } | |
1262 } | |
1263 return; | |
1264 } | |
1265 } | |
1266 | |
1267 /* one-to-one mv scaling */ | |
1268 | |
2396 | 1269 if(IS_16X16(*mb_type)){ |
4541 | 1270 int ref, mv0, mv1; |
1271 | |
2396 | 1272 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); |
1273 if(IS_INTRA(mb_type_col)){ | |
4541 | 1274 ref=mv0=mv1=0; |
2396 | 1275 }else{ |
3316 | 1276 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1277 : map_col_to_list0[1][l1ref1[0]]; | |
1278 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
|
1279 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1280 int mv_l0[2]; |
3316 | 1281 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1282 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
4541 | 1283 ref= ref0; |
1284 mv0= pack16to32(mv_l0[0],mv_l0[1]); | |
1285 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1286 } | |
1287 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); | |
1288 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4); | |
1289 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4); | |
2396 | 1290 }else{ |
1291 for(i8=0; i8<4; i8++){ | |
1292 const int x8 = i8&1; | |
1293 const int y8 = i8>>1; | |
3316 | 1294 int ref0, scale; |
2834 | 1295 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
|
1296 |
2396 | 1297 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1298 continue; | |
1299 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1300 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1301 if(IS_INTRA(mb_type_col)){ |
1302 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1303 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1304 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1305 continue; | |
1306 } | |
2967 | 1307 |
2396 | 1308 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
|
1309 if(ref0 >= 0) |
3316 | 1310 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
|
1311 else{ |
3316 | 1312 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
|
1313 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1314 } |
3316 | 1315 scale = dist_scale_factor[ref0]; |
2967 | 1316 |
2396 | 1317 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1318 if(IS_SUB_8X8(sub_mb_type)){ |
1319 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1320 int mx = (scale * mv_col[0] + 128) >> 8; |
1321 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1322 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1323 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1324 }else | |
2396 | 1325 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
|
1326 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1327 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1328 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1329 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1330 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1331 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1332 } | |
1333 } | |
1334 } | |
1335 } | |
1336 } | |
1337 | |
1168 | 1338 static inline void write_back_motion(H264Context *h, int mb_type){ |
1339 MpegEncContext * const s = &h->s; | |
1340 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1341 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1342 int list; | |
1343 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1344 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1345 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
|
1346 |
4533 | 1347 for(list=0; list<h->list_count; list++){ |
1168 | 1348 int y; |
3212 | 1349 if(!USES_LIST(mb_type, list)) |
2396 | 1350 continue; |
2967 | 1351 |
1168 | 1352 for(y=0; y<4; y++){ |
1353 *(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]; | |
1354 *(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]; | |
1355 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1356 if( h->pps.cabac ) { |
3927 | 1357 if(IS_SKIP(mb_type)) |
1358 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1359 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1360 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
|
1361 *(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
|
1362 *(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
|
1363 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1364 } |
3212 | 1365 |
1366 { | |
3776 | 1367 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1368 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1369 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1370 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1371 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1372 } |
1373 } | |
2967 | 1374 |
2396 | 1375 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1376 if(IS_8X8(mb_type)){ | |
3212 | 1377 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1378 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1379 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1380 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1381 } |
1382 } | |
1168 | 1383 } |
1384 | |
1385 /** | |
1386 * Decodes a network abstraction layer unit. | |
1387 * @param consumed is the number of bytes used as input | |
1388 * @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
|
1389 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1390 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1391 */ |
1392 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1393 int i, si, di; | |
1394 uint8_t *dst; | |
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 | |
1423 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1424 dst= h->rbsp_buffer; | |
1425 | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1426 if (dst == NULL){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1427 return NULL; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1428 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1429 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1430 //printf("decoding esc\n"); |
1168 | 1431 si=di=0; |
2967 | 1432 while(si<length){ |
1168 | 1433 //remove escapes (very rare 1:2^22) |
1434 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1435 if(src[si+2]==3){ //escape | |
1436 dst[di++]= 0; | |
1437 dst[di++]= 0; | |
1438 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1439 continue; |
1168 | 1440 }else //next start code |
1441 break; | |
1442 } | |
1443 | |
1444 dst[di++]= src[si++]; | |
1445 } | |
1446 | |
1447 *dst_length= di; | |
1448 *consumed= si + 1;//+1 for the header | |
1449 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1450 return dst; | |
1451 } | |
1452 | |
1453 /** | |
1454 * identifies the exact end of the bitstream | |
1455 * @return the length of the trailing, or 0 if damaged | |
1456 */ | |
4600 | 1457 static int decode_rbsp_trailing(H264Context *h, uint8_t *src){ |
1168 | 1458 int v= *src; |
1459 int r; | |
1460 | |
4600 | 1461 tprintf(h->s.avctx, "rbsp trailing %X\n", v); |
1168 | 1462 |
1463 for(r=1; r<9; r++){ | |
1464 if(v&1) return r; | |
1465 v>>=1; | |
1466 } | |
1467 return 0; | |
1468 } | |
1469 | |
1470 /** | |
1471 * idct tranforms the 16 dc values and dequantize them. | |
1472 * @param qp quantization parameter | |
1473 */ | |
2919 | 1474 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1475 #define stride 16 |
1476 int i; | |
1477 int temp[16]; //FIXME check if this is a good idea | |
1478 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1479 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1480 | |
1481 //memset(block, 64, 2*256); | |
1482 //return; | |
1483 for(i=0; i<4; i++){ | |
1484 const int offset= y_offset[i]; | |
1485 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1486 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1487 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1488 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1489 | |
1490 temp[4*i+0]= z0+z3; | |
1491 temp[4*i+1]= z1+z2; | |
1492 temp[4*i+2]= z1-z2; | |
1493 temp[4*i+3]= z0-z3; | |
1494 } | |
1495 | |
1496 for(i=0; i<4; i++){ | |
1497 const int offset= x_offset[i]; | |
1498 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1499 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1500 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1501 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1502 | |
2919 | 1503 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1504 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1505 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1506 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1507 } |
1508 } | |
1509 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1510 #if 0 |
1168 | 1511 /** |
1512 * dct tranforms the 16 dc values. | |
1513 * @param qp quantization parameter ??? FIXME | |
1514 */ | |
1515 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1516 // const int qmul= dequant_coeff[qp][0]; | |
1517 int i; | |
1518 int temp[16]; //FIXME check if this is a good idea | |
1519 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1520 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1521 | |
1522 for(i=0; i<4; i++){ | |
1523 const int offset= y_offset[i]; | |
1524 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1525 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1526 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1527 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1528 | |
1529 temp[4*i+0]= z0+z3; | |
1530 temp[4*i+1]= z1+z2; | |
1531 temp[4*i+2]= z1-z2; | |
1532 temp[4*i+3]= z0-z3; | |
1533 } | |
1534 | |
1535 for(i=0; i<4; i++){ | |
1536 const int offset= x_offset[i]; | |
1537 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1538 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1539 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1540 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1541 | |
1542 block[stride*0 +offset]= (z0 + z3)>>1; | |
1543 block[stride*2 +offset]= (z1 + z2)>>1; | |
1544 block[stride*8 +offset]= (z1 - z2)>>1; | |
1545 block[stride*10+offset]= (z0 - z3)>>1; | |
1546 } | |
1547 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1548 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1549 |
1168 | 1550 #undef xStride |
1551 #undef stride | |
1552 | |
2919 | 1553 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1554 const int stride= 16*2; |
1555 const int xStride= 16; | |
1556 int a,b,c,d,e; | |
1557 | |
1558 a= block[stride*0 + xStride*0]; | |
1559 b= block[stride*0 + xStride*1]; | |
1560 c= block[stride*1 + xStride*0]; | |
1561 d= block[stride*1 + xStride*1]; | |
1562 | |
1563 e= a-b; | |
1564 a= a+b; | |
1565 b= c-d; | |
1566 c= c+d; | |
1567 | |
2919 | 1568 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1569 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1570 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1571 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1572 } |
1573 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1574 #if 0 |
1168 | 1575 static void chroma_dc_dct_c(DCTELEM *block){ |
1576 const int stride= 16*2; | |
1577 const int xStride= 16; | |
1578 int a,b,c,d,e; | |
1579 | |
1580 a= block[stride*0 + xStride*0]; | |
1581 b= block[stride*0 + xStride*1]; | |
1582 c= block[stride*1 + xStride*0]; | |
1583 d= block[stride*1 + xStride*1]; | |
1584 | |
1585 e= a-b; | |
1586 a= a+b; | |
1587 b= c-d; | |
1588 c= c+d; | |
1589 | |
1590 block[stride*0 + xStride*0]= (a+c); | |
1591 block[stride*0 + xStride*1]= (e+b); | |
1592 block[stride*1 + xStride*0]= (a-c); | |
1593 block[stride*1 + xStride*1]= (e-b); | |
1594 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1595 #endif |
1168 | 1596 |
1597 /** | |
1598 * gets the chroma qp. | |
1599 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1600 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 1601 |
4594 | 1602 return chroma_qp[av_clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 1603 } |
1604 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1605 //FIXME need to check that this doesnt 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 void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
1685 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
1686 ((uint32_t*)(src+0*stride))[0]= a; | |
1687 ((uint32_t*)(src+1*stride))[0]= a; | |
1688 ((uint32_t*)(src+2*stride))[0]= a; | |
1689 ((uint32_t*)(src+3*stride))[0]= a; | |
1690 } | |
1691 | |
1692 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
1693 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
1694 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
1695 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
1696 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
1697 } | |
1698 | |
1699 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1700 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
1701 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 1702 |
1703 ((uint32_t*)(src+0*stride))[0]= | |
1704 ((uint32_t*)(src+1*stride))[0]= | |
1705 ((uint32_t*)(src+2*stride))[0]= | |
1706 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 1707 } |
1708 | |
1709 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1710 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 1711 |
1712 ((uint32_t*)(src+0*stride))[0]= | |
1713 ((uint32_t*)(src+1*stride))[0]= | |
1714 ((uint32_t*)(src+2*stride))[0]= | |
1715 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 1716 } |
1717 | |
1718 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
1719 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 1720 |
1721 ((uint32_t*)(src+0*stride))[0]= | |
1722 ((uint32_t*)(src+1*stride))[0]= | |
1723 ((uint32_t*)(src+2*stride))[0]= | |
1724 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 1725 } |
1726 | |
1727 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 1728 ((uint32_t*)(src+0*stride))[0]= |
1729 ((uint32_t*)(src+1*stride))[0]= | |
1730 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 1731 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
1732 } | |
1733 | |
1734 | |
1735 #define LOAD_TOP_RIGHT_EDGE\ | |
5023
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1736 const int attribute_unused t4= topright[0];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1737 const int attribute_unused t5= topright[1];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1738 const int attribute_unused t6= topright[2];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1739 const int attribute_unused t7= topright[3];\ |
1168 | 1740 |
1741 #define LOAD_LEFT_EDGE\ | |
5023
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1742 const int attribute_unused l0= src[-1+0*stride];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1743 const int attribute_unused l1= src[-1+1*stride];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1744 const int attribute_unused l2= src[-1+2*stride];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1745 const int attribute_unused l3= src[-1+3*stride];\ |
1168 | 1746 |
1747 #define LOAD_TOP_EDGE\ | |
5023
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1748 const int attribute_unused t0= src[ 0-1*stride];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1749 const int attribute_unused t1= src[ 1-1*stride];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1750 const int attribute_unused t2= src[ 2-1*stride];\ |
ed6b3efebf1e
Move attribute_unused to variable declarations in macros instead of
reimar
parents:
5006
diff
changeset
|
1751 const int attribute_unused t3= src[ 3-1*stride];\ |
1168 | 1752 |
1753 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
1754 const int lt= src[-1-1*stride]; | |
1755 LOAD_TOP_EDGE | |
1756 LOAD_LEFT_EDGE | |
1757 | |
2967 | 1758 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 1759 src[0+2*stride]= |
2967 | 1760 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 1761 src[0+1*stride]= |
1762 src[1+2*stride]= | |
2967 | 1763 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 1764 src[0+0*stride]= |
1765 src[1+1*stride]= | |
1766 src[2+2*stride]= | |
2967 | 1767 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 1768 src[1+0*stride]= |
1769 src[2+1*stride]= | |
1770 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
1771 src[2+0*stride]= | |
1772 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1773 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 1774 } |
1168 | 1775 |
1776 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 1777 LOAD_TOP_EDGE |
1778 LOAD_TOP_RIGHT_EDGE | |
1779 // LOAD_LEFT_EDGE | |
1168 | 1780 |
1781 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
1782 src[1+0*stride]= | |
1783 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
1784 src[2+0*stride]= | |
1785 src[1+1*stride]= | |
1786 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
1787 src[3+0*stride]= | |
1788 src[2+1*stride]= | |
1789 src[1+2*stride]= | |
1790 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
1791 src[3+1*stride]= | |
1792 src[2+2*stride]= | |
1793 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
1794 src[3+2*stride]= | |
1795 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
1796 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 1797 } |
1168 | 1798 |
1799 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
1800 const int lt= src[-1-1*stride]; | |
2967 | 1801 LOAD_TOP_EDGE |
1802 LOAD_LEFT_EDGE | |
1168 | 1803 |
1804 src[0+0*stride]= | |
1805 src[1+2*stride]=(lt + t0 + 1)>>1; | |
1806 src[1+0*stride]= | |
1807 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
1808 src[2+0*stride]= | |
1809 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
1810 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
1811 src[0+1*stride]= | |
1812 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
1813 src[1+1*stride]= | |
1814 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
1815 src[2+1*stride]= | |
1816 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1817 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1818 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
1819 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 1820 } |
1168 | 1821 |
1822 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 1823 LOAD_TOP_EDGE |
1824 LOAD_TOP_RIGHT_EDGE | |
1168 | 1825 |
1826 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
1827 src[1+0*stride]= | |
1828 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
1829 src[2+0*stride]= | |
1830 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
1831 src[3+0*stride]= | |
1832 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
1833 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
1834 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1835 src[1+1*stride]= | |
1836 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1837 src[2+1*stride]= | |
1838 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
1839 src[3+1*stride]= | |
1840 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
1841 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 1842 } |
1168 | 1843 |
1844 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 1845 LOAD_LEFT_EDGE |
1168 | 1846 |
1847 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
1848 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1849 src[2+0*stride]= | |
1850 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
1851 src[3+0*stride]= | |
1852 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1853 src[2+1*stride]= | |
1854 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
1855 src[3+1*stride]= | |
1856 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
1857 src[3+2*stride]= | |
1858 src[1+3*stride]= | |
1859 src[0+3*stride]= | |
1860 src[2+2*stride]= | |
1861 src[2+3*stride]= | |
1862 src[3+3*stride]=l3; | |
1282 | 1863 } |
2967 | 1864 |
1168 | 1865 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
1866 const int lt= src[-1-1*stride]; | |
2967 | 1867 LOAD_TOP_EDGE |
1868 LOAD_LEFT_EDGE | |
1168 | 1869 |
1870 src[0+0*stride]= | |
1871 src[2+1*stride]=(lt + l0 + 1)>>1; | |
1872 src[1+0*stride]= | |
1873 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
1874 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
1875 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
1876 src[0+1*stride]= | |
1877 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
1878 src[1+1*stride]= | |
1879 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
1880 src[0+2*stride]= | |
1881 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
1882 src[1+2*stride]= | |
1883 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1884 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
1885 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 1886 } |
1168 | 1887 |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
1888 void ff_pred16x16_vertical_c(uint8_t *src, int stride){ |
1168 | 1889 int i; |
1890 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
1891 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
1892 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
1893 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 1894 |
1168 | 1895 for(i=0; i<16; i++){ |
1896 ((uint32_t*)(src+i*stride))[0]= a; | |
1897 ((uint32_t*)(src+i*stride))[1]= b; | |
1898 ((uint32_t*)(src+i*stride))[2]= c; | |
1899 ((uint32_t*)(src+i*stride))[3]= d; | |
1900 } | |
1901 } | |
1902 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
1903 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){ |
1168 | 1904 int i; |
1905 | |
1906 for(i=0; i<16; i++){ | |
1907 ((uint32_t*)(src+i*stride))[0]= | |
1908 ((uint32_t*)(src+i*stride))[1]= | |
1909 ((uint32_t*)(src+i*stride))[2]= | |
1910 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
1911 } | |
1912 } | |
1913 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
1914 void ff_pred16x16_dc_c(uint8_t *src, int stride){ |
1168 | 1915 int i, dc=0; |
1916 | |
1917 for(i=0;i<16; i++){ | |
1918 dc+= src[-1+i*stride]; | |
1919 } | |
2967 | 1920 |
1168 | 1921 for(i=0;i<16; i++){ |
1922 dc+= src[i-stride]; | |
1923 } | |
1924 | |
1925 dc= 0x01010101*((dc + 16)>>5); | |
1926 | |
1927 for(i=0; i<16; i++){ | |
1928 ((uint32_t*)(src+i*stride))[0]= | |
1929 ((uint32_t*)(src+i*stride))[1]= | |
1930 ((uint32_t*)(src+i*stride))[2]= | |
1931 ((uint32_t*)(src+i*stride))[3]= dc; | |
1932 } | |
1933 } | |
1934 | |
1935 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
1936 int i, dc=0; | |
1937 | |
1938 for(i=0;i<16; i++){ | |
1939 dc+= src[-1+i*stride]; | |
1940 } | |
2967 | 1941 |
1168 | 1942 dc= 0x01010101*((dc + 8)>>4); |
1943 | |
1944 for(i=0; i<16; i++){ | |
1945 ((uint32_t*)(src+i*stride))[0]= | |
1946 ((uint32_t*)(src+i*stride))[1]= | |
1947 ((uint32_t*)(src+i*stride))[2]= | |
1948 ((uint32_t*)(src+i*stride))[3]= dc; | |
1949 } | |
1950 } | |
1951 | |
1952 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
1953 int i, dc=0; | |
1954 | |
1955 for(i=0;i<16; i++){ | |
1956 dc+= src[i-stride]; | |
1957 } | |
1958 dc= 0x01010101*((dc + 8)>>4); | |
1959 | |
1960 for(i=0; i<16; i++){ | |
1961 ((uint32_t*)(src+i*stride))[0]= | |
1962 ((uint32_t*)(src+i*stride))[1]= | |
1963 ((uint32_t*)(src+i*stride))[2]= | |
1964 ((uint32_t*)(src+i*stride))[3]= dc; | |
1965 } | |
1966 } | |
1967 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
1968 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){ |
1168 | 1969 int i; |
1970 | |
1971 for(i=0; i<16; i++){ | |
1972 ((uint32_t*)(src+i*stride))[0]= | |
1973 ((uint32_t*)(src+i*stride))[1]= | |
1974 ((uint32_t*)(src+i*stride))[2]= | |
1975 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
1976 } | |
1977 } | |
1978 | |
1234 | 1979 static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){ |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1980 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1981 int a; |
4176 | 1982 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1983 const uint8_t * const src0 = src+7-stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1984 const uint8_t *src1 = src+8*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1985 const uint8_t *src2 = src1-2*stride; // == src+6*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1986 int H = src0[1] - src0[-1]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1987 int V = src1[0] - src2[ 0]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1988 for(k=2; k<=8; ++k) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1989 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1990 H += k*(src0[k] - src0[-k]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1991 V += k*(src1[0] - src2[ 0]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
1992 } |
1234 | 1993 if(svq3){ |
1994 H = ( 5*(H/4) ) / 16; | |
1995 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
1996 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
1997 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
1998 i = H; H = V; V = i; |
1234 | 1999 }else{ |
2000 H = ( 5*H+32 ) >> 6; | |
2001 V = ( 5*V+32 ) >> 6; | |
2002 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2003 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2004 a = 16*(src1[0] + src2[16] + 1) - 7*(V+H); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2005 for(j=16; j>0; --j) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2006 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2007 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2008 for(i=-16; i<0; i+=4) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2009 src[16+i] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2010 src[17+i] = cm[ (b+ H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2011 src[18+i] = cm[ (b+2*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2012 src[19+i] = cm[ (b+3*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2013 b += 4*H; |
1168 | 2014 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2015 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2016 } |
1168 | 2017 } |
2018 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2019 void ff_pred16x16_plane_c(uint8_t *src, int stride){ |
1234 | 2020 pred16x16_plane_compat_c(src, stride, 0); |
2021 } | |
2022 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2023 void ff_pred8x8_vertical_c(uint8_t *src, int stride){ |
1168 | 2024 int i; |
2025 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2026 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2027 |
1168 | 2028 for(i=0; i<8; i++){ |
2029 ((uint32_t*)(src+i*stride))[0]= a; | |
2030 ((uint32_t*)(src+i*stride))[1]= b; | |
2031 } | |
2032 } | |
2033 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2034 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){ |
1168 | 2035 int i; |
2036 | |
2037 for(i=0; i<8; i++){ | |
2038 ((uint32_t*)(src+i*stride))[0]= | |
2039 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2040 } | |
2041 } | |
2042 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2043 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){ |
1168 | 2044 int i; |
2045 | |
2755 | 2046 for(i=0; i<8; i++){ |
2967 | 2047 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2048 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2049 } | |
2050 } | |
2051 | |
2052 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2053 int i; | |
2054 int dc0, dc2; | |
2055 | |
2056 dc0=dc2=0; | |
2057 for(i=0;i<4; i++){ | |
2058 dc0+= src[-1+i*stride]; | |
2059 dc2+= src[-1+(i+4)*stride]; | |
2060 } | |
2061 dc0= 0x01010101*((dc0 + 2)>>2); | |
2062 dc2= 0x01010101*((dc2 + 2)>>2); | |
2063 | |
2064 for(i=0; i<4; i++){ | |
2065 ((uint32_t*)(src+i*stride))[0]= | |
2066 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2067 } | |
2068 for(i=4; i<8; i++){ | |
2069 ((uint32_t*)(src+i*stride))[0]= | |
2070 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2071 } | |
2072 } | |
2073 | |
2074 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2075 int i; | |
2076 int dc0, dc1; | |
2077 | |
2078 dc0=dc1=0; | |
2079 for(i=0;i<4; i++){ | |
2080 dc0+= src[i-stride]; | |
2081 dc1+= src[4+i-stride]; | |
2082 } | |
2083 dc0= 0x01010101*((dc0 + 2)>>2); | |
2084 dc1= 0x01010101*((dc1 + 2)>>2); | |
2085 | |
2086 for(i=0; i<4; i++){ | |
2087 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2088 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2089 } | |
2090 for(i=4; i<8; i++){ | |
2091 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2092 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2093 } | |
2094 } | |
2095 | |
2096 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2097 void ff_pred8x8_dc_c(uint8_t *src, int stride){ |
1168 | 2098 int i; |
2099 int dc0, dc1, dc2, dc3; | |
2100 | |
2101 dc0=dc1=dc2=0; | |
2102 for(i=0;i<4; i++){ | |
2103 dc0+= src[-1+i*stride] + src[i-stride]; | |
2104 dc1+= src[4+i-stride]; | |
2105 dc2+= src[-1+(i+4)*stride]; | |
2106 } | |
2107 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2108 dc0= 0x01010101*((dc0 + 4)>>3); | |
2109 dc1= 0x01010101*((dc1 + 2)>>2); | |
2110 dc2= 0x01010101*((dc2 + 2)>>2); | |
2111 | |
2112 for(i=0; i<4; i++){ | |
2113 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2114 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2115 } | |
2116 for(i=4; i<8; i++){ | |
2117 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2118 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2119 } | |
2120 } | |
2121 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2122 void ff_pred8x8_plane_c(uint8_t *src, int stride){ |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2123 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2124 int a; |
4176 | 2125 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2126 const uint8_t * const src0 = src+3-stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2127 const uint8_t *src1 = src+4*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2128 const uint8_t *src2 = src1-2*stride; // == src+2*stride-1; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2129 int H = src0[1] - src0[-1]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2130 int V = src1[0] - src2[ 0]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2131 for(k=2; k<=4; ++k) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2132 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2133 H += k*(src0[k] - src0[-k]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2134 V += k*(src1[0] - src2[ 0]); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2135 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2136 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2137 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2138 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2139 a = 16*(src1[0] + src2[8]+1) - 3*(V+H); |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2140 for(j=8; j>0; --j) { |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2141 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2142 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2143 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2144 src[1] = cm[ (b+ H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2145 src[2] = cm[ (b+2*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2146 src[3] = cm[ (b+3*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2147 src[4] = cm[ (b+4*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2148 src[5] = cm[ (b+5*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2149 src[6] = cm[ (b+6*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2150 src[7] = cm[ (b+7*H) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2151 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2152 } |
1168 | 2153 } |
2154 | |
2755 | 2155 #define SRC(x,y) src[(x)+(y)*stride] |
2156 #define PL(y) \ | |
2157 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2158 #define PREDICT_8x8_LOAD_LEFT \ | |
2159 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2160 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2161 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2162 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2163 |
2164 #define PT(x) \ | |
2165 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2166 #define PREDICT_8x8_LOAD_TOP \ | |
2167 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2168 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2169 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2170 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2171 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2172 |
2173 #define PTR(x) \ | |
2174 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2175 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2176 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2177 if(has_topright) { \ | |
2178 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2179 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2180 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2181 | |
2182 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2183 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2184 |
2185 #define PREDICT_8x8_DC(v) \ | |
2186 int y; \ | |
2187 for( y = 0; y < 8; y++ ) { \ | |
2188 ((uint32_t*)src)[0] = \ | |
2189 ((uint32_t*)src)[1] = v; \ | |
2190 src += stride; \ | |
2191 } | |
2192 | |
2193 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2194 { | |
2195 PREDICT_8x8_DC(0x80808080); | |
2196 } | |
2197 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2198 { | |
2199 PREDICT_8x8_LOAD_LEFT; | |
2200 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2201 PREDICT_8x8_DC(dc); | |
2202 } | |
2203 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2204 { | |
2205 PREDICT_8x8_LOAD_TOP; | |
2206 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2207 PREDICT_8x8_DC(dc); | |
2208 } | |
2209 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2210 { | |
2211 PREDICT_8x8_LOAD_LEFT; | |
2212 PREDICT_8x8_LOAD_TOP; | |
2213 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2214 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2215 PREDICT_8x8_DC(dc); | |
2216 } | |
2217 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2218 { | |
2219 PREDICT_8x8_LOAD_LEFT; | |
2220 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2221 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2222 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2223 #undef ROW | |
2224 } | |
2225 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2226 { | |
2227 int y; | |
2228 PREDICT_8x8_LOAD_TOP; | |
2229 src[0] = t0; | |
2230 src[1] = t1; | |
2231 src[2] = t2; | |
2232 src[3] = t3; | |
2233 src[4] = t4; | |
2234 src[5] = t5; | |
2235 src[6] = t6; | |
2236 src[7] = t7; | |
2237 for( y = 1; y < 8; y++ ) | |
2238 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2239 } | |
2240 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2241 { | |
2242 PREDICT_8x8_LOAD_TOP; | |
2243 PREDICT_8x8_LOAD_TOPRIGHT; | |
2244 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2245 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2246 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2247 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2248 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2249 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2250 SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2251 SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2252 SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2253 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2254 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2255 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2256 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2257 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2258 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2259 } | |
2260 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2261 { | |
2262 PREDICT_8x8_LOAD_TOP; | |
2263 PREDICT_8x8_LOAD_LEFT; | |
2264 PREDICT_8x8_LOAD_TOPLEFT; | |
2265 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2266 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2267 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2268 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2269 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2270 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2271 SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2; | |
2272 SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2273 SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2; | |
2274 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2275 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2276 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2277 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2278 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2279 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2280 |
2755 | 2281 } |
2282 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2283 { | |
2284 PREDICT_8x8_LOAD_TOP; | |
2285 PREDICT_8x8_LOAD_LEFT; | |
2286 PREDICT_8x8_LOAD_TOPLEFT; | |
2287 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2288 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2289 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2290 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2291 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2292 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2293 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2294 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2295 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2296 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2297 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2298 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2299 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2300 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2301 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2302 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2303 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2304 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2305 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2306 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2307 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2308 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2309 } | |
2310 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2311 { | |
2312 PREDICT_8x8_LOAD_TOP; | |
2313 PREDICT_8x8_LOAD_LEFT; | |
2314 PREDICT_8x8_LOAD_TOPLEFT; | |
2315 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2316 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2317 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2318 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2319 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2320 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2321 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2322 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2323 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2324 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2325 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2326 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2327 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2328 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2329 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2330 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2331 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2332 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2333 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2334 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2335 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2336 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2337 } | |
2338 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2339 { | |
2340 PREDICT_8x8_LOAD_TOP; | |
2341 PREDICT_8x8_LOAD_TOPRIGHT; | |
2342 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2343 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2344 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2345 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2346 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2347 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2348 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2349 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2350 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2351 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2352 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2353 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2354 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2355 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2356 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2357 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2358 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2359 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2360 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2361 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2362 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2363 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2364 } | |
2365 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2366 { | |
2367 PREDICT_8x8_LOAD_LEFT; | |
2368 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2369 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2370 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2371 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2372 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2373 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2374 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2375 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2376 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2377 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2378 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2379 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2380 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2381 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2382 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2383 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2384 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2385 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2386 } | |
2387 #undef PREDICT_8x8_LOAD_LEFT | |
2388 #undef PREDICT_8x8_LOAD_TOP | |
2389 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2390 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2391 #undef PREDICT_8x8_DC | |
2392 #undef PTR | |
2393 #undef PT | |
2394 #undef PL | |
2395 #undef SRC | |
2396 | |
1168 | 2397 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2398 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2399 int src_x_offset, int src_y_offset, | |
2400 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2401 MpegEncContext * const s = &h->s; | |
2402 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2403 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2404 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2405 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2406 uint8_t * src_cb, * src_cr; | |
2407 int extra_width= h->emu_edge_width; | |
2408 int extra_height= h->emu_edge_height; | |
1168 | 2409 int emu=0; |
2410 const int full_mx= mx>>2; | |
2411 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2412 const int pic_width = 16*s->mb_width; |
3316 | 2413 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2414 |
4390 | 2415 if(!pic->data[0]) //FIXME this is unacceptable, some senseable error concealment must be done for missing reference frames |
3125 | 2416 return; |
2967 | 2417 |
1168 | 2418 if(mx&7) extra_width -= 3; |
2419 if(my&7) extra_height -= 3; | |
2967 | 2420 |
2421 if( full_mx < 0-extra_width | |
2422 || full_my < 0-extra_height | |
2423 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2424 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2425 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); |
2426 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2427 emu=1; |
2428 } | |
2967 | 2429 |
3316 | 2430 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2431 if(!square){ |
3316 | 2432 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2433 } |
2967 | 2434 |
1168 | 2435 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2436 |
3316 | 2437 if(MB_MBAFF){ |
2438 // chroma offset when predicting from a field of opposite parity | |
2439 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2440 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2441 } | |
2442 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2443 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2444 |
2445 if(emu){ | |
3316 | 2446 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); |
2447 src_cb= s->edge_emu_buffer; | |
2448 } | |
2449 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2450 | |
2451 if(emu){ | |
2452 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 | 2453 src_cr= s->edge_emu_buffer; |
2454 } | |
3316 | 2455 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2456 } |
2457 | |
2415 | 2458 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2459 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2460 int x_offset, int y_offset, | |
2461 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2462 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2463 int list0, int list1){ | |
2464 MpegEncContext * const s = &h->s; | |
2465 qpel_mc_func *qpix_op= qpix_put; | |
2466 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2467 |
3316 | 2468 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2469 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2470 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2471 x_offset += 8*s->mb_x; |
3316 | 2472 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2473 |
1168 | 2474 if(list0){ |
1169 | 2475 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2476 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2477 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2478 qpix_op, chroma_op); | |
2479 | |
2480 qpix_op= qpix_avg; | |
2481 chroma_op= chroma_avg; | |
2482 } | |
2483 | |
2484 if(list1){ | |
1169 | 2485 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2486 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2487 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2488 qpix_op, chroma_op); | |
2489 } | |
2490 } | |
2491 | |
2415 | 2492 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2493 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2494 int x_offset, int y_offset, | |
2495 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2496 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2497 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2498 int list0, int list1){ | |
2499 MpegEncContext * const s = &h->s; | |
2500 | |
3316 | 2501 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2502 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2503 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2504 x_offset += 8*s->mb_x; |
3316 | 2505 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2506 |
2415 | 2507 if(list0 && list1){ |
2508 /* don't optimize for luma-only case, since B-frames usually | |
2509 * use implicit weights => chroma too. */ | |
2510 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2511 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2512 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2513 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2514 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2515 | |
2516 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2517 dest_y, dest_cb, dest_cr, | |
2518 x_offset, y_offset, qpix_put, chroma_put); | |
2519 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2520 tmp_y, tmp_cb, tmp_cr, | |
2521 x_offset, y_offset, qpix_put, chroma_put); | |
2522 | |
2523 if(h->use_weight == 2){ | |
2524 int weight0 = h->implicit_weight[refn0][refn1]; | |
2525 int weight1 = 64 - weight0; | |
3316 | 2526 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2527 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2528 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 2529 }else{ |
3316 | 2530 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 2531 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 2532 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 2533 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2534 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 2535 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 2536 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2537 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 2538 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 2539 } |
2540 }else{ | |
2541 int list = list1 ? 1 : 0; | |
2542 int refn = h->ref_cache[list][ scan8[n] ]; | |
2543 Picture *ref= &h->ref_list[list][refn]; | |
2544 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2545 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2546 qpix_put, chroma_put); | |
2547 | |
3316 | 2548 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 2549 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
2550 if(h->use_weight_chroma){ | |
3316 | 2551 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2552 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 2553 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2554 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
2555 } | |
2556 } | |
2557 } | |
2558 | |
2559 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2560 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2561 int x_offset, int y_offset, | |
2562 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2563 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 2564 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 2565 int list0, int list1){ |
2566 if((h->use_weight==2 && list0 && list1 | |
2567 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2568 || h->use_weight==1) | |
2569 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2570 x_offset, y_offset, qpix_put, chroma_put, | |
2571 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2572 else | |
2573 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2574 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2575 } | |
2576 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2577 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
|
2578 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2579 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2580 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2581 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
|
2582 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2583 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
|
2584 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
|
2585 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 2586 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
|
2587 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
|
2588 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
|
2589 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
|
2590 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2591 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2592 |
1168 | 2593 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2594 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2595 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2596 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2597 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
|
2598 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2599 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 2600 |
1168 | 2601 assert(IS_INTER(mb_type)); |
2967 | 2602 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2603 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2604 |
1168 | 2605 if(IS_16X16(mb_type)){ |
2606 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2607 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2608 &weight_op[0], &weight_avg[0], |
1168 | 2609 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2610 }else if(IS_16X8(mb_type)){ | |
2611 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2612 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2613 &weight_op[1], &weight_avg[1], |
1168 | 2614 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2615 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
2616 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2617 &weight_op[1], &weight_avg[1], |
1168 | 2618 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2619 }else if(IS_8X16(mb_type)){ | |
3316 | 2620 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 2621 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2622 &weight_op[2], &weight_avg[2], |
1168 | 2623 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 2624 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 2625 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2626 &weight_op[2], &weight_avg[2], |
1168 | 2627 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2628 }else{ | |
2629 int i; | |
2967 | 2630 |
1168 | 2631 assert(IS_8X8(mb_type)); |
2632 | |
2633 for(i=0; i<4; i++){ | |
2634 const int sub_mb_type= h->sub_mb_type[i]; | |
2635 const int n= 4*i; | |
2636 int x_offset= (i&1)<<2; | |
2637 int y_offset= (i&2)<<1; | |
2638 | |
2639 if(IS_SUB_8X8(sub_mb_type)){ | |
2640 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2641 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 2642 &weight_op[3], &weight_avg[3], |
1168 | 2643 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2644 }else if(IS_SUB_8X4(sub_mb_type)){ | |
2645 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2646 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 2647 &weight_op[4], &weight_avg[4], |
1168 | 2648 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2649 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
2650 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 2651 &weight_op[4], &weight_avg[4], |
1168 | 2652 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2653 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 2654 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 2655 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 2656 &weight_op[5], &weight_avg[5], |
1168 | 2657 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 2658 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 2659 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 2660 &weight_op[5], &weight_avg[5], |
1168 | 2661 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2662 }else{ | |
2663 int j; | |
2664 assert(IS_SUB_4X4(sub_mb_type)); | |
2665 for(j=0; j<4; j++){ | |
2666 int sub_x_offset= x_offset + 2*(j&1); | |
2667 int sub_y_offset= y_offset + (j&2); | |
2668 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
2669 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 2670 &weight_op[6], &weight_avg[6], |
1168 | 2671 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
2672 } | |
2673 } | |
2674 } | |
2675 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2676 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2677 prefetch_motion(h, 1); |
1168 | 2678 } |
2679 | |
4783
011fb289e3b0
changes some function declarations from () to (void) as per ansi c.
gpoirier
parents:
4745
diff
changeset
|
2680 static void decode_init_vlc(void){ |
1168 | 2681 static int done = 0; |
2682 | |
2683 if (!done) { | |
2684 int i; | |
2685 done = 1; | |
2686 | |
2967 | 2687 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 2688 &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
|
2689 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 2690 |
2691 for(i=0; i<4; i++){ | |
2967 | 2692 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 2693 &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
|
2694 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 2695 } |
2696 | |
2697 for(i=0; i<3; i++){ | |
2698 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
2699 &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
|
2700 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 2701 } |
2702 for(i=0; i<15; i++){ | |
2967 | 2703 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 2704 &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
|
2705 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 2706 } |
2707 | |
2708 for(i=0; i<6; i++){ | |
2967 | 2709 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 2710 &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
|
2711 &run_bits[i][0], 1, 1, 1); |
1168 | 2712 } |
2967 | 2713 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 2714 &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
|
2715 &run_bits[6][0], 1, 1, 1); |
1168 | 2716 } |
2717 } | |
2718 | |
2719 /** | |
2720 * Sets the intra prediction function pointers. | |
2721 */ | |
2722 static void init_pred_ptrs(H264Context *h){ | |
2723 // MpegEncContext * const s = &h->s; | |
2724 | |
2725 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
2726 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
2727 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
2728 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
2729 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
2730 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
2731 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
2732 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
2733 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
2734 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
2735 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
2736 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
2737 | |
2755 | 2738 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
2739 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
2740 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
2741 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
2742 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
2743 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
2744 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
2745 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
2746 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
2747 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
2748 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
2749 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
2750 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2751 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2752 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2753 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2754 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c; |
1168 | 2755 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; |
2756 h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c; | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2757 h->pred8x8[DC_128_PRED8x8 ]= ff_pred8x8_128_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2758 |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2759 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2760 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2761 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2762 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c; |
1168 | 2763 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; |
2764 h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c; | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2765 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c; |
1168 | 2766 } |
2767 | |
2768 static void free_tables(H264Context *h){ | |
2769 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
|
2770 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
|
2771 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
|
2772 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
|
2773 av_freep(&h->mvd_table[1]); |
2396 | 2774 av_freep(&h->direct_table); |
1168 | 2775 av_freep(&h->non_zero_count); |
2776 av_freep(&h->slice_table_base); | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2777 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2778 av_freep(&h->top_borders[0]); |
1168 | 2779 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
|
2780 |
1168 | 2781 av_freep(&h->mb2b_xy); |
2782 av_freep(&h->mb2b8_xy); | |
2415 | 2783 |
2784 av_freep(&h->s.obmc_scratchpad); | |
1168 | 2785 } |
2786 | |
2919 | 2787 static void init_dequant8_coeff_table(H264Context *h){ |
2788 int i,q,x; | |
3174 | 2789 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 2790 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
2791 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
2792 | |
2793 for(i=0; i<2; i++ ){ | |
2794 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
2795 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
2796 break; | |
2797 } | |
2798 | |
2799 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2800 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2801 int idx = ff_rem6[q]; |
2919 | 2802 for(x=0; x<64; x++) |
3174 | 2803 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
2804 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
2805 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 2806 } |
2807 } | |
2808 } | |
2809 | |
2810 static void init_dequant4_coeff_table(H264Context *h){ | |
2811 int i,j,q,x; | |
3005 | 2812 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 2813 for(i=0; i<6; i++ ){ |
2814 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
2815 for(j=0; j<i; j++){ | |
2816 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
2817 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
2818 break; | |
2819 } | |
2820 } | |
2821 if(j<i) | |
2822 continue; | |
2823 | |
2824 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2825 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
2826 int idx = ff_rem6[q]; |
2919 | 2827 for(x=0; x<16; x++) |
3005 | 2828 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
2829 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 2830 h->pps.scaling_matrix4[i][x]) << shift; |
2831 } | |
2832 } | |
2833 } | |
2834 | |
2835 static void init_dequant_tables(H264Context *h){ | |
2836 int i,x; | |
2837 init_dequant4_coeff_table(h); | |
2838 if(h->pps.transform_8x8_mode) | |
2839 init_dequant8_coeff_table(h); | |
2840 if(h->sps.transform_bypass){ | |
2841 for(i=0; i<6; i++) | |
2842 for(x=0; x<16; x++) | |
2843 h->dequant4_coeff[i][0][x] = 1<<6; | |
2844 if(h->pps.transform_8x8_mode) | |
2845 for(i=0; i<2; i++) | |
2846 for(x=0; x<64; x++) | |
2847 h->dequant8_coeff[i][0][x] = 1<<6; | |
2848 } | |
2849 } | |
2850 | |
2851 | |
1168 | 2852 /** |
2853 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2854 * needs width/height |
1168 | 2855 */ |
2856 static int alloc_tables(H264Context *h){ | |
2857 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
|
2858 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 2859 int x,y; |
1168 | 2860 |
2861 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
|
2862 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2863 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 2864 CHECKED_ALLOCZ(h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(uint8_t)) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2865 CHECKED_ALLOCZ(h->top_borders[0] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2866 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 2867 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 2868 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2869 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
|
2870 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
|
2871 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
|
2872 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 2873 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
|
2874 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
2875 |
3316 | 2876 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
2877 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 2878 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
2879 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
|
2880 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 2881 for(y=0; y<s->mb_height; y++){ |
2882 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
|
2883 const int mb_xy= x + y*s->mb_stride; |
1168 | 2884 const int b_xy = 4*x + 4*y*h->b_stride; |
2885 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 2886 |
1168 | 2887 h->mb2b_xy [mb_xy]= b_xy; |
2888 h->mb2b8_xy[mb_xy]= b8_xy; | |
2889 } | |
2890 } | |
2415 | 2891 |
2417 | 2892 s->obmc_scratchpad = NULL; |
2893 | |
2920 | 2894 if(!h->dequant4_coeff[0]) |
2895 init_dequant_tables(h); | |
2896 | |
1168 | 2897 return 0; |
2898 fail: | |
2899 free_tables(h); | |
2900 return -1; | |
2901 } | |
2902 | |
2903 static void common_init(H264Context *h){ | |
2904 MpegEncContext * const s = &h->s; | |
2905 | |
2906 s->width = s->avctx->width; | |
2907 s->height = s->avctx->height; | |
2908 s->codec_id= s->avctx->codec->id; | |
2967 | 2909 |
1168 | 2910 init_pred_ptrs(h); |
2911 | |
2919 | 2912 h->dequant_coeff_pps= -1; |
1698 | 2913 s->unrestricted_mv=1; |
1168 | 2914 s->decode=1; //FIXME |
2920 | 2915 |
2916 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
2917 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 2918 } |
2919 | |
2920 static int decode_init(AVCodecContext *avctx){ | |
2921 H264Context *h= avctx->priv_data; | |
2922 MpegEncContext * const s = &h->s; | |
2923 | |
1892 | 2924 MPV_decode_defaults(s); |
2967 | 2925 |
1168 | 2926 s->avctx = avctx; |
2927 common_init(h); | |
2928 | |
2929 s->out_format = FMT_H264; | |
2930 s->workaround_bugs= avctx->workaround_bugs; | |
2931 | |
2932 // set defaults | |
2933 // s->decode_mb= ff_h263_decode_mb; | |
2934 s->low_delay= 1; | |
2935 avctx->pix_fmt= PIX_FMT_YUV420P; | |
2936 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
2937 decode_init_vlc(); |
2967 | 2938 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
2939 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
|
2940 *(char *)avctx->extradata == 1){ |
2227 | 2941 h->is_avc = 1; |
2942 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
|
2943 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
2944 h->is_avc = 0; |
2227 | 2945 } |
2946 | |
1168 | 2947 return 0; |
2948 } | |
2949 | |
2935 | 2950 static int frame_start(H264Context *h){ |
1168 | 2951 MpegEncContext * const s = &h->s; |
2952 int i; | |
2953 | |
2935 | 2954 if(MPV_frame_start(s, s->avctx) < 0) |
2955 return -1; | |
1168 | 2956 ff_er_frame_start(s); |
2957 | |
2958 assert(s->linesize && s->uvlinesize); | |
2959 | |
2960 for(i=0; i<16; i++){ | |
2961 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
|
2962 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 2963 } |
2964 for(i=0; i<4; i++){ | |
2965 h->block_offset[16+i]= | |
2966 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
|
2967 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
2968 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 2969 } |
2970 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2971 /* 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
|
2972 * FIXME: redo bipred weight to not require extra buffer? */ |
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
2973 if(!s->obmc_scratchpad) |
3316 | 2974 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
2975 | |
2976 /* some macroblocks will be accessed before they're available */ | |
2977 if(FRAME_MBAFF) | |
2978 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
|
2979 |
1168 | 2980 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 2981 return 0; |
1168 | 2982 } |
2983 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2984 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2985 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
|
2986 int i; |
2967 | 2987 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
2988 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
|
2989 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
|
2990 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
|
2991 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
2992 // 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
|
2993 // 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
|
2994 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
|
2995 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
|
2996 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
|
2997 } |
2967 | 2998 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
2999 *(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
|
3000 *(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
|
3001 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3002 if(!(s->flags&CODEC_FLAG_GRAY)){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3003 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
|
3004 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
|
3005 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
|
3006 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
|
3007 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
|
3008 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3009 *(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
|
3010 *(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
|
3011 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3012 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3013 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3014 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){ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3015 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
|
3016 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
|
3017 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3018 int deblock_left = (s->mb_x > 0); |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3019 int deblock_top = (s->mb_y > 0); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3020 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3021 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
|
3022 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
|
3023 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
|
3024 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3025 #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
|
3026 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3027 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3028 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3029 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3030 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3031 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3032 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
|
3033 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
|
3034 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3035 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3036 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3037 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3038 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
|
3039 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3040 if(s->mb_x+1 < s->mb_width){ |
2755 | 3041 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3042 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3043 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3044 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3045 if(!(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
|
3046 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3047 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
|
3048 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
|
3049 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
|
3050 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3051 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3052 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3053 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
|
3054 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
|
3055 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3056 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3057 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3058 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3059 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
|
3060 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3061 int i; |
2967 | 3062 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3063 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3064 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3065 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3066 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3067 // 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
|
3068 // 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
|
3069 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
|
3070 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
|
3071 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3072 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
|
3073 } |
2967 | 3074 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3075 *(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
|
3076 *(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
|
3077 *(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
|
3078 *(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
|
3079 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3080 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3081 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
|
3082 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
|
3083 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
|
3084 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
|
3085 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3086 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
|
3087 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
|
3088 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3089 *(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
|
3090 *(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
|
3091 *(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
|
3092 *(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
|
3093 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3094 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3095 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3096 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
|
3097 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3098 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3099 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3100 int deblock_left = (s->mb_x > 0); |
3316 | 3101 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
|
3102 |
4600 | 3103 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
|
3104 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3105 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3106 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3107 src_cr -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3108 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3109 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3110 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3111 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3112 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3113 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3114 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3115 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3116 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
|
3117 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
|
3118 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3119 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3120 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3121 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3122 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
|
3123 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
|
3124 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
|
3125 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3126 if(s->mb_x+1 < s->mb_width){ |
3127 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3128 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3129 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3130 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3131 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3132 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3133 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3134 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
|
3135 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
|
3136 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
|
3137 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3138 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3139 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3140 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
|
3141 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
|
3142 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
|
3143 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
|
3144 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3145 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3146 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3147 |
4908
777f250df232
Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents:
4896
diff
changeset
|
3148 static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){ |
1168 | 3149 MpegEncContext * const s = &h->s; |
3150 const int mb_x= s->mb_x; | |
3151 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
|
3152 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3153 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3154 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3155 int linesize, uvlinesize /*dct_offset*/; | |
3156 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3157 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
|
3158 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
|
3159 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass), is_h264 = (simple || s->codec_id == CODEC_ID_H264); |
2763 | 3160 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
|
3161 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3162 |
3163 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3164 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3165 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3166 | |
4000 | 3167 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3168 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3169 | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3170 if (!simple && MB_FIELD) { |
3316 | 3171 linesize = h->mb_linesize = s->linesize * 2; |
3172 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
|
3173 block_offset = &h->block_offset[24]; |
1168 | 3174 if(mb_y&1){ //FIXME move out of this func? |
3175 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3176 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3177 dest_cr-= s->uvlinesize*7; |
1168 | 3178 } |
3316 | 3179 if(FRAME_MBAFF) { |
3180 int list; | |
4533 | 3181 for(list=0; list<h->list_count; list++){ |
3316 | 3182 if(!USES_LIST(mb_type, list)) |
3183 continue; | |
3184 if(IS_16X16(mb_type)){ | |
3185 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3186 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3187 }else{ | |
3188 for(i=0; i<16; i+=4){ | |
3189 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3190 int ref = h->ref_cache[list][scan8[i]]; | |
3191 if(ref >= 0) | |
3192 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3193 } | |
3194 } | |
3195 } | |
3196 } | |
1168 | 3197 } else { |
3316 | 3198 linesize = h->mb_linesize = s->linesize; |
3199 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3200 // dct_offset = s->linesize * 16; |
3201 } | |
2967 | 3202 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3203 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3204 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3205 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
|
3206 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3207 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3208 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3209 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3210 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3211 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3212 } |
1168 | 3213 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3214 if(!simple && FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3316 | 3215 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ |
3216 int mbt_y = mb_y&~1; | |
3217 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3218 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3219 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3220 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3221 } | |
3222 | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3223 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
|
3224 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3225 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3226 // 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
|
3227 // 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
|
3228 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3229 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3230 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
|
3231 *(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
|
3232 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3233 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3234 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3235 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3236 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3237 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
|
3238 *(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
|
3239 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3240 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3241 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3242 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3243 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3244 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
|
3245 *(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
|
3246 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3247 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3248 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3249 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3250 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
|
3251 if(h->deblocking_filter && (simple || !FRAME_MBAFF)) |
3316 | 3252 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1); |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3253 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3254 if(simple || !(s->flags&CODEC_FLAG_GRAY)){ |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3255 h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize); |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3256 h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize); |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3257 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3258 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3259 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
|
3260 if(simple || !s->encoding){ |
2755 | 3261 if(IS_8x8DCT(mb_type)){ |
3262 for(i=0; i<16; i+=4){ | |
3263 uint8_t * const ptr= dest_y + block_offset[i]; | |
3264 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
|
3265 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3266 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
4546 | 3267 (h->topright_samples_available<<i)&0x4000, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3268 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3269 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3270 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3271 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3272 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3273 } |
2755 | 3274 } |
3275 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3276 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
|
3277 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
|
3278 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3279 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
|
3280 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3281 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3282 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
|
3283 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
|
3284 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
|
3285 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3286 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3287 topright= (uint8_t*) &tr; |
2967 | 3288 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3289 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3290 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3291 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3292 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3293 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3294 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3295 if(nnz){ |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3296 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3297 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3298 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3299 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3300 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3301 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3302 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
|
3303 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3304 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3305 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3306 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3307 h->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
|
3308 if(is_h264){ |
2763 | 3309 if(!transform_bypass) |
2919 | 3310 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3311 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3312 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
|
3313 } |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3314 if(h->deblocking_filter && (simple || !FRAME_MBAFF)) |
3316 | 3315 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3316 }else if(is_h264){ |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3317 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
|
3318 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
|
3319 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
|
3320 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
|
3321 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3322 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3323 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3324 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
|
3325 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3326 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3327 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3328 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3329 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
|
3330 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3331 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
|
3332 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3333 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3334 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3335 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3336 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3337 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3338 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3339 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
|
3340 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3341 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
|
3342 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3343 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3344 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3345 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3346 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
|
3347 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
|
3348 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
|
3349 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3350 } |
1168 | 3351 } |
3352 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3353 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3354 |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3355 if(simple || !(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3356 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3357 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3358 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3359 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3360 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3361 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3362 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp][0]); |
3363 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp][0]); | |
2763 | 3364 } |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3365 if(is_h264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3366 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3367 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3368 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
|
3369 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3370 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
|
3371 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3372 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3373 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
|
3374 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
|
3375 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
|
3376 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
|
3377 } |
1250 | 3378 } |
1168 | 3379 } |
3380 } | |
3381 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3382 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
|
3383 if (!simple && FRAME_MBAFF) { |
3316 | 3384 //FIXME try deblocking one mb at a time? |
3385 // 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
|
3386 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
|
3387 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
|
3388 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
|
3389 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
|
3390 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
|
3391 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3392 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
|
3393 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
|
3394 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
|
3395 |
3316 | 3396 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3397 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3398 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3399 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3400 // deblock a pair |
2967 | 3401 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3402 s->mb_y--; |
4600 | 3403 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
|
3404 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3405 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 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
|
3406 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
|
3407 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3408 s->mb_y++; |
4600 | 3409 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
|
3410 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3411 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 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
|
3412 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
|
3413 } else { |
4600 | 3414 tprintf(h->s.avctx, "call filter_mb\n"); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3415 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3416 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
|
3417 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
|
3418 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3419 } |
1168 | 3420 } |
3421 | |
3422 /** | |
4587
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3423 * 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
|
3424 */ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3425 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
|
3426 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
|
3427 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3428 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3429 /** |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3430 * 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
|
3431 */ |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3432 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
|
3433 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
|
3434 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3435 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3436 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
|
3437 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
|
3438 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
|
3439 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
|
3440 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
|
3441 const int mb_type= s->current_picture.mb_type[mb_xy]; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3442 int is_complex = FRAME_MBAFF || MB_FIELD || IS_INTRA_PCM(mb_type) || s->codec_id != CODEC_ID_H264 || (s->flags&CODEC_FLAG_GRAY) || s->encoding; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3443 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3444 if(!s->decode) |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3445 return; |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3446 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3447 if (is_complex) |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3448 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
|
3449 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
|
3450 } |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3451 |
644687c58928
h264 optimization: common case hl_decode_mb patch by (Alexander Strange astrange ithinksw com)
michael
parents:
4556
diff
changeset
|
3452 /** |
1168 | 3453 * fills the default_ref_list. |
3454 */ | |
3455 static int fill_default_ref_list(H264Context *h){ | |
3456 MpegEncContext * const s = &h->s; | |
3457 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
|
3458 int smallest_poc_greater_than_current = -1; |
2582 | 3459 Picture sorted_short_ref[32]; |
2967 | 3460 |
1168 | 3461 if(h->slice_type==B_TYPE){ |
3462 int out_i; | |
2713 | 3463 int limit= INT_MIN; |
1168 | 3464 |
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
|
3465 /* sort frame according to poc in B slice */ |
1168 | 3466 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3467 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
|
3468 int best_poc=INT_MAX; |
1168 | 3469 |
3470 for(i=0; i<h->short_ref_count; i++){ | |
3471 const int poc= h->short_ref[i]->poc; | |
3472 if(poc > limit && poc < best_poc){ | |
3473 best_poc= poc; | |
3474 best_i= i; | |
3475 } | |
3476 } | |
2967 | 3477 |
2713 | 3478 assert(best_i != INT_MIN); |
2967 | 3479 |
1168 | 3480 limit= best_poc; |
3481 sorted_short_ref[out_i]= *h->short_ref[best_i]; | |
4600 | 3482 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
|
3483 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
|
3484 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
|
3485 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
|
3486 } |
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
|
3487 } |
1168 | 3488 } |
3489 } | |
3490 | |
3491 if(s->picture_structure == PICT_FRAME){ | |
3492 if(h->slice_type==B_TYPE){ | |
3493 int list; | |
4600 | 3494 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
|
3495 |
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
|
3496 // find the largest poc |
1168 | 3497 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
|
3498 int index = 0; |
2447 | 3499 int j= -99; |
3500 int step= list ? -1 : 1; | |
3501 | |
3502 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3503 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
|
3504 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3505 return -1; |
2447 | 3506 step = -step; |
3507 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
|
3508 } |
2447 | 3509 if(sorted_short_ref[j].reference != 3) continue; |
3510 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3511 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3512 } |
3513 | |
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
|
3514 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
|
3515 if(h->long_ref[i] == NULL) continue; |
1168 | 3516 if(h->long_ref[i]->reference != 3) continue; |
3517 | |
3518 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3519 h->default_ref_list[ list ][index++].pic_id= i;; | |
3520 } | |
2967 | 3521 |
2447 | 3522 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
|
3523 // 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
|
3524 // L0 and L1 are identical |
1168 | 3525 Picture temp= h->default_ref_list[1][0]; |
3526 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3527 h->default_ref_list[1][1] = temp; |
1168 | 3528 } |
3529 | |
3530 if(index < h->ref_count[ list ]) | |
3531 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3532 } | |
3533 }else{ | |
3534 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3535 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3536 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3537 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3538 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3539 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3540 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
|
3541 if(h->long_ref[i] == NULL) continue; |
1168 | 3542 if(h->long_ref[i]->reference != 3) continue; |
3543 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3544 h->default_ref_list[0][index++].pic_id= i;; | |
3545 } | |
3546 if(index < h->ref_count[0]) | |
3547 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3548 } | |
3549 }else{ //FIELD | |
3550 if(h->slice_type==B_TYPE){ | |
3551 }else{ | |
3552 //FIXME second field balh | |
3553 } | |
3554 } | |
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
|
3555 #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
|
3556 for (i=0; i<h->ref_count[0]; i++) { |
4600 | 3557 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
|
3558 } |
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
|
3559 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
|
3560 for (i=0; i<h->ref_count[1]; i++) { |
4600 | 3561 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
|
3562 } |
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
|
3563 } |
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
|
3564 #endif |
1168 | 3565 return 0; |
3566 } | |
3567 | |
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
|
3568 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
|
3569 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
|
3570 |
1168 | 3571 static int decode_ref_pic_list_reordering(H264Context *h){ |
3572 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3573 int list, index; |
2967 | 3574 |
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
|
3575 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
|
3576 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3577 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 3578 |
4533 | 3579 for(list=0; list<h->list_count; list++){ |
1168 | 3580 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); |
3581 | |
3582 if(get_bits1(&s->gb)){ | |
3583 int pred= h->curr_pic_num; | |
3584 | |
3585 for(index=0; ; index++){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3586 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
|
3587 unsigned int pic_id; |
1168 | 3588 int i; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3589 Picture *ref = NULL; |
2967 | 3590 |
3591 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
|
3592 break; |
2967 | 3593 |
1168 | 3594 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3595 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3596 return -1; |
3597 } | |
2967 | 3598 |
1168 | 3599 if(reordering_of_pic_nums_idc<3){ |
3600 if(reordering_of_pic_nums_idc<2){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3601 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; |
1168 | 3602 |
3603 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
|
3604 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3605 return -1; |
3606 } | |
3607 | |
3608 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3609 else pred+= abs_diff_pic_num; | |
3610 pred &= h->max_pic_num - 1; | |
2967 | 3611 |
2683 | 3612 for(i= h->short_ref_count-1; i>=0; i--){ |
3613 ref = h->short_ref[i]; | |
3614 assert(ref->reference == 3); | |
3615 assert(!ref->long_ref); | |
3616 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 3617 break; |
3618 } | |
2683 | 3619 if(i>=0) |
3620 ref->pic_id= ref->frame_num; | |
1168 | 3621 }else{ |
3622 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
|
3623 if(pic_id>31){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3624 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
|
3625 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3626 } |
2683 | 3627 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
|
3628 if(ref){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3629 ref->pic_id= pic_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3630 assert(ref->reference == 3); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3631 assert(ref->long_ref); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3632 i=0; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3633 }else{ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3634 i=-1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3635 } |
1168 | 3636 } |
3637 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3638 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3639 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3640 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 3641 } else { |
3642 for(i=index; i+1<h->ref_count[list]; i++){ | |
3643 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
3644 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
|
3645 } |
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
|
3646 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
|
3647 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
|
3648 } |
2683 | 3649 h->ref_list[list][index]= *ref; |
1168 | 3650 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3651 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3652 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3653 return -1; |
3654 } | |
3655 } | |
3656 } | |
4533 | 3657 } |
3658 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
|
3659 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
|
3660 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3661 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3662 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3663 } |
2967 | 3664 |
2396 | 3665 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
3666 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3667 direct_ref_list_init(h); |
2967 | 3668 return 0; |
1168 | 3669 } |
3670 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
3671 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 3672 int list, i, j; |
4533 | 3673 for(list=0; list<2; list++){ //FIXME try list_count |
3316 | 3674 for(i=0; i<h->ref_count[list]; i++){ |
3675 Picture *frame = &h->ref_list[list][i]; | |
3676 Picture *field = &h->ref_list[list][16+2*i]; | |
3677 field[0] = *frame; | |
3678 for(j=0; j<3; j++) | |
3679 field[0].linesize[j] <<= 1; | |
3680 field[1] = field[0]; | |
3681 for(j=0; j<3; j++) | |
3682 field[1].data[j] += frame->linesize[j]; | |
3683 | |
3684 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
3685 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
3686 for(j=0; j<2; j++){ | |
3687 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
3688 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
3689 } | |
3690 } | |
3691 } | |
3692 for(j=0; j<h->ref_count[1]; j++){ | |
3693 for(i=0; i<h->ref_count[0]; i++) | |
3694 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
3695 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
3696 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
3697 } | |
3698 } | |
3699 | |
1168 | 3700 static int pred_weight_table(H264Context *h){ |
3701 MpegEncContext * const s = &h->s; | |
3702 int list, i; | |
2415 | 3703 int luma_def, chroma_def; |
2967 | 3704 |
2415 | 3705 h->use_weight= 0; |
3706 h->use_weight_chroma= 0; | |
1168 | 3707 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
3708 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 3709 luma_def = 1<<h->luma_log2_weight_denom; |
3710 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 3711 |
3712 for(list=0; list<2; list++){ | |
3713 for(i=0; i<h->ref_count[list]; i++){ | |
3714 int luma_weight_flag, chroma_weight_flag; | |
2967 | 3715 |
1168 | 3716 luma_weight_flag= get_bits1(&s->gb); |
3717 if(luma_weight_flag){ | |
3718 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
3719 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 3720 if( h->luma_weight[list][i] != luma_def |
3721 || h->luma_offset[list][i] != 0) | |
3722 h->use_weight= 1; | |
3723 }else{ | |
3724 h->luma_weight[list][i]= luma_def; | |
3725 h->luma_offset[list][i]= 0; | |
1168 | 3726 } |
3727 | |
3728 chroma_weight_flag= get_bits1(&s->gb); | |
3729 if(chroma_weight_flag){ | |
3730 int j; | |
3731 for(j=0; j<2; j++){ | |
3732 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
3733 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 3734 if( h->chroma_weight[list][i][j] != chroma_def |
3735 || h->chroma_offset[list][i][j] != 0) | |
3736 h->use_weight_chroma= 1; | |
3737 } | |
3738 }else{ | |
3739 int j; | |
3740 for(j=0; j<2; j++){ | |
3741 h->chroma_weight[list][i][j]= chroma_def; | |
3742 h->chroma_offset[list][i][j]= 0; | |
1168 | 3743 } |
3744 } | |
3745 } | |
3746 if(h->slice_type != B_TYPE) break; | |
3747 } | |
2415 | 3748 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 3749 return 0; |
3750 } | |
3751 | |
2415 | 3752 static void implicit_weight_table(H264Context *h){ |
3753 MpegEncContext * const s = &h->s; | |
3754 int ref0, ref1; | |
3755 int cur_poc = s->current_picture_ptr->poc; | |
3756 | |
3757 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
3758 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
3759 h->use_weight= 0; | |
3760 h->use_weight_chroma= 0; | |
3761 return; | |
3762 } | |
3763 | |
3764 h->use_weight= 2; | |
3765 h->use_weight_chroma= 2; | |
3766 h->luma_log2_weight_denom= 5; | |
3767 h->chroma_log2_weight_denom= 5; | |
3768 | |
3769 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
3770 int poc0 = h->ref_list[0][ref0].poc; | |
3771 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 3772 int poc1 = h->ref_list[1][ref1].poc; |
4594 | 3773 int td = av_clip(poc1 - poc0, -128, 127); |
2415 | 3774 if(td){ |
4594 | 3775 int tb = av_clip(cur_poc - poc0, -128, 127); |
4001 | 3776 int tx = (16384 + (FFABS(td) >> 1)) / td; |
4594 | 3777 int dist_scale_factor = av_clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
2415 | 3778 if(dist_scale_factor < -64 || dist_scale_factor > 128) |
3779 h->implicit_weight[ref0][ref1] = 32; | |
3780 else | |
3781 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
3782 }else | |
3783 h->implicit_weight[ref0][ref1] = 32; | |
3784 } | |
3785 } | |
3786 } | |
3787 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3788 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
|
3789 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3790 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3791 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
|
3792 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3793 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3794 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
|
3795 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
|
3796 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3797 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3798 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3799 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3800 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3801 |
1168 | 3802 /** |
2392 | 3803 * instantaneous decoder refresh. |
1168 | 3804 */ |
3805 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
|
3806 int i; |
1168 | 3807 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3808 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3809 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
|
3810 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
|
3811 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
3812 } |
1168 | 3813 } |
3814 h->long_ref_count=0; | |
3815 | |
3816 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
|
3817 unreference_pic(h, h->short_ref[i]); |
1168 | 3818 h->short_ref[i]= NULL; |
3819 } | |
3820 h->short_ref_count=0; | |
3821 } | |
3822 | |
2640 | 3823 /* forget old pics after a seek */ |
3824 static void flush_dpb(AVCodecContext *avctx){ | |
3825 H264Context *h= avctx->priv_data; | |
3826 int i; | |
3144 | 3827 for(i=0; i<16; i++) { |
3828 if(h->delayed_pic[i]) | |
3829 h->delayed_pic[i]->reference= 0; | |
2640 | 3830 h->delayed_pic[i]= NULL; |
3144 | 3831 } |
3832 if(h->delayed_output_pic) | |
3833 h->delayed_output_pic->reference= 0; | |
2640 | 3834 h->delayed_output_pic= NULL; |
3835 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
3836 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
3837 h->s.current_picture_ptr->reference= 0; |
2640 | 3838 } |
3839 | |
1168 | 3840 /** |
3841 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3842 * @return the removed picture or NULL if an error occurs |
1168 | 3843 */ |
3844 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 3845 MpegEncContext * const s = &h->s; |
1168 | 3846 int i; |
2967 | 3847 |
1169 | 3848 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
|
3849 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 3850 |
1168 | 3851 for(i=0; i<h->short_ref_count; i++){ |
3852 Picture *pic= h->short_ref[i]; | |
1169 | 3853 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
|
3854 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 3855 if(pic->frame_num == frame_num){ |
3856 h->short_ref[i]= NULL; | |
3857 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
3858 h->short_ref_count--; | |
3859 return pic; | |
3860 } | |
3861 } | |
3862 return NULL; | |
3863 } | |
3864 | |
3865 /** | |
3866 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3867 * @return the removed picture or NULL if an error occurs |
1168 | 3868 */ |
3869 static Picture * remove_long(H264Context *h, int i){ | |
3870 Picture *pic; | |
3871 | |
3872 pic= h->long_ref[i]; | |
3873 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
|
3874 if(pic) h->long_ref_count--; |
1168 | 3875 |
3876 return pic; | |
3877 } | |
3878 | |
3879 /** | |
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
|
3880 * 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
|
3881 */ |
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
|
3882 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
|
3883 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
|
3884 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
|
3885 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
|
3886 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
|
3887 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
|
3888 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
|
3889 } |
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
|
3890 } |
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
|
3891 } |
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
|
3892 |
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
|
3893 /** |
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
|
3894 * 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
|
3895 */ |
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
|
3896 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
|
3897 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
|
3898 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
|
3899 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
|
3900 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
|
3901 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
|
3902 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
|
3903 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
|
3904 } |
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
|
3905 } |
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
|
3906 } |
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
|
3907 } |
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
|
3908 |
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
|
3909 /** |
1168 | 3910 * Executes the reference picture marking (memory management control operations). |
3911 */ | |
3912 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
3913 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
|
3914 int i, j; |
1168 | 3915 int current_is_long=0; |
3916 Picture *pic; | |
2967 | 3917 |
1168 | 3918 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
|
3919 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 3920 |
1168 | 3921 for(i=0; i<mmco_count; i++){ |
3922 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
|
3923 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 | 3924 |
3925 switch(mmco[i].opcode){ | |
3926 case MMCO_SHORT2UNUSED: | |
3927 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
|
3928 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3929 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3930 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
|
3931 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 3932 break; |
3933 case MMCO_SHORT2LONG: | |
3934 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
|
3935 if(pic) unreference_pic(h, pic); |
2967 | 3936 |
1168 | 3937 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
|
3938 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
|
3939 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
|
3940 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3941 } |
1168 | 3942 break; |
3943 case MMCO_LONG2UNUSED: | |
3944 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
|
3945 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3946 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
3947 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
|
3948 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 3949 break; |
3950 case MMCO_LONG: | |
3951 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
|
3952 if(pic) unreference_pic(h, pic); |
2967 | 3953 |
1168 | 3954 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
3955 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
3956 h->long_ref_count++; | |
2967 | 3957 |
1168 | 3958 current_is_long=1; |
3959 break; | |
3960 case MMCO_SET_MAX_LONG: | |
3961 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
|
3962 // 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
|
3963 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
|
3964 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
|
3965 if (pic) unreference_pic(h, pic); |
1168 | 3966 } |
3967 break; | |
3968 case MMCO_RESET: | |
3969 while(h->short_ref_count){ | |
3970 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
|
3971 if(pic) unreference_pic(h, pic); |
1168 | 3972 } |
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
|
3973 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
|
3974 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
|
3975 if(pic) unreference_pic(h, pic); |
1168 | 3976 } |
3977 break; | |
3978 default: assert(0); | |
3979 } | |
3980 } | |
2967 | 3981 |
1168 | 3982 if(!current_is_long){ |
3983 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
3984 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
3985 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3986 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 3987 } |
2967 | 3988 |
1168 | 3989 if(h->short_ref_count) |
1169 | 3990 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
3991 | |
3992 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 3993 h->short_ref[0]->long_ref=0; |
3994 h->short_ref_count++; | |
3995 } | |
2967 | 3996 |
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
|
3997 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
|
3998 print_long_term(h); |
2967 | 3999 return 0; |
1168 | 4000 } |
4001 | |
4002 static int decode_ref_pic_marking(H264Context *h){ | |
4003 MpegEncContext * const s = &h->s; | |
4004 int i; | |
2967 | 4005 |
1168 | 4006 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4007 s->broken_link= get_bits1(&s->gb) -1; | |
4008 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4009 if(h->mmco[0].long_index == -1) | |
4010 h->mmco_index= 0; | |
4011 else{ | |
4012 h->mmco[0].opcode= MMCO_LONG; | |
4013 h->mmco_index= 1; | |
2967 | 4014 } |
1168 | 4015 }else{ |
4016 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4017 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4018 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4019 | |
4020 h->mmco[i].opcode= opcode; | |
4021 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4022 h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(&s->gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields | |
4023 /* 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
|
4024 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4025 return -1; |
4026 }*/ | |
4027 } | |
4028 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4029 unsigned int long_index= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4030 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
|
4031 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4032 return -1; |
4033 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4034 h->mmco[i].long_index= long_index; |
1168 | 4035 } |
2967 | 4036 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4037 if(opcode > (unsigned)MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4038 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4039 return -1; |
4040 } | |
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
|
4041 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
|
4042 break; |
1168 | 4043 } |
4044 h->mmco_index= i; | |
4045 }else{ | |
4046 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4047 | |
4048 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4049 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4050 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4051 h->mmco_index= 1; | |
4052 }else | |
4053 h->mmco_index= 0; | |
4054 } | |
4055 } | |
2967 | 4056 |
4057 return 0; | |
1168 | 4058 } |
4059 | |
4060 static int init_poc(H264Context *h){ | |
4061 MpegEncContext * const s = &h->s; | |
4062 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4063 int field_poc[2]; | |
4064 | |
4065 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4066 h->frame_num_offset= 0; | |
4067 }else{ | |
4068 if(h->frame_num < h->prev_frame_num) | |
4069 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4070 else | |
4071 h->frame_num_offset= h->prev_frame_num_offset; | |
4072 } | |
4073 | |
4074 if(h->sps.poc_type==0){ | |
4075 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4076 | |
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
|
4077 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
|
4078 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
|
4079 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
|
4080 } |
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
|
4081 |
1168 | 4082 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4083 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4084 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4085 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4086 else | |
4087 h->poc_msb = h->prev_poc_msb; | |
4088 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4089 field_poc[0] = |
1168 | 4090 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4091 if(s->picture_structure == PICT_FRAME) |
1168 | 4092 field_poc[1] += h->delta_poc_bottom; |
4093 }else if(h->sps.poc_type==1){ | |
4094 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4095 int i; | |
4096 | |
4097 if(h->sps.poc_cycle_length != 0) | |
4098 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4099 else | |
4100 abs_frame_num = 0; | |
4101 | |
4102 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4103 abs_frame_num--; | |
2967 | 4104 |
1168 | 4105 expected_delta_per_poc_cycle = 0; |
4106 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4107 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4108 | |
4109 if(abs_frame_num > 0){ | |
4110 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4111 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4112 | |
4113 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4114 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4115 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4116 } else | |
4117 expectedpoc = 0; | |
4118 | |
2967 | 4119 if(h->nal_ref_idc == 0) |
1168 | 4120 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4121 |
1168 | 4122 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4123 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4124 | |
4125 if(s->picture_structure == PICT_FRAME) | |
4126 field_poc[1] += h->delta_poc[1]; | |
4127 }else{ | |
4128 int poc; | |
4129 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4130 poc= 0; | |
4131 }else{ | |
4132 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4133 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4134 } | |
4135 field_poc[0]= poc; | |
4136 field_poc[1]= poc; | |
4137 } | |
2967 | 4138 |
1168 | 4139 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4140 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4141 if(s->picture_structure != PICT_TOP_FIELD) | |
4142 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4143 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4144 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4145 | |
4146 return 0; | |
4147 } | |
4148 | |
4149 /** | |
4150 * decodes a slice header. | |
4151 * this will allso call MPV_common_init() and frame_start() as needed | |
4152 */ | |
4153 static int decode_slice_header(H264Context *h){ | |
4154 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4155 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
|
4156 unsigned int pps_id; |
1168 | 4157 int num_ref_idx_active_override_flag; |
4158 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4159 unsigned int slice_type, tmp; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4160 int default_ref_list_done = 0; |
1168 | 4161 |
4162 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
|
4163 s->dropable= h->nal_ref_idc == 0; |
1168 | 4164 |
4165 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4166 | |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
4167 if((s->flags2 & CODEC_FLAG2_CHUNKS) && first_mb_in_slice == 0){ |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
4168 h->slice_num = 0; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
4169 s->current_picture_ptr= NULL; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
4170 } |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
4171 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4172 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
|
4173 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4174 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 | 4175 return -1; |
1168 | 4176 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4177 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4178 slice_type -= 5; |
1168 | 4179 h->slice_type_fixed=1; |
4180 }else | |
4181 h->slice_type_fixed=0; | |
2967 | 4182 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4183 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
|
4184 if (slice_type == I_TYPE |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4185 || (h->slice_num != 0 && slice_type == h->slice_type) ) { |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4186 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
|
4187 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4188 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
|
4189 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4190 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4191 |
1168 | 4192 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
|
4193 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4194 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4195 return -1; |
4196 } | |
4197 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4198 if(h->pps.slice_group_count == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4199 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4200 return -1; |
4201 } | |
4202 | |
1168 | 4203 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4204 if(h->sps.log2_max_frame_num == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4205 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4206 return -1; |
4207 } | |
2919 | 4208 |
4363 | 4209 if(h->dequant_coeff_pps != pps_id){ |
4210 h->dequant_coeff_pps = pps_id; | |
2919 | 4211 init_dequant_tables(h); |
4212 } | |
2967 | 4213 |
1168 | 4214 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
|
4215 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4216 |
3178 | 4217 h->b_stride= s->mb_width*4; |
4218 h->b8_stride= s->mb_width*2; | |
1168 | 4219 |
1371 | 4220 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4221 if(h->sps.frame_mbs_only_flag) |
1371 | 4222 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4223 else |
1371 | 4224 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4225 |
4226 if (s->context_initialized | |
1548 | 4227 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4228 free_tables(h); |
4229 MPV_common_end(s); | |
4230 } | |
4231 if (!s->context_initialized) { | |
4232 if (MPV_common_init(s) < 0) | |
4233 return -1; | |
2967 | 4234 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4235 if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4236 memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t)); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4237 memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t)); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4238 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4239 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4240 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4241 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4242 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4243 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4244 #undef T |
4245 } | |
4246 } | |
4247 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4248 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4249 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4250 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4251 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4252 }else{ |
4253 int i; | |
4254 for(i=0; i<64; i++){ | |
4255 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4256 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4257 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4258 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4259 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4260 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4261 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4262 } |
2763 | 4263 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4264 h->zigzag_scan_q0 = zigzag_scan; |
4265 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4266 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4267 h->field_scan_q0 = field_scan; |
4268 h->field_scan8x8_q0 = field_scan8x8; | |
4269 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4270 }else{ |
3316 | 4271 h->zigzag_scan_q0 = h->zigzag_scan; |
4272 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4273 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4274 h->field_scan_q0 = h->field_scan; |
4275 h->field_scan8x8_q0 = h->field_scan8x8; | |
4276 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4277 } |
1168 | 4278 |
4279 alloc_tables(h); | |
4280 | |
4281 s->avctx->width = s->width; | |
4282 s->avctx->height = s->height; | |
1548 | 4283 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4284 if(!s->avctx->sample_aspect_ratio.den) |
4285 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
|
4286 |
2648 | 4287 if(h->sps.timing_info_present_flag){ |
3052 | 4288 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
|
4289 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
|
4290 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4291 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
|
4292 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
|
4293 } |
1168 | 4294 } |
4295 | |
2392 | 4296 if(h->slice_num == 0){ |
2935 | 4297 if(frame_start(h) < 0) |
4298 return -1; | |
1168 | 4299 } |
4300 | |
1169 | 4301 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4302 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4303 | |
3316 | 4304 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4305 h->mb_aff_frame = 0; |
1168 | 4306 if(h->sps.frame_mbs_only_flag){ |
4307 s->picture_structure= PICT_FRAME; | |
4308 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4309 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4310 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4311 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
|
4312 } else { |
1168 | 4313 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4314 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
|
4315 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4316 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4317 assert(s->mb_num == s->mb_width * s->mb_height); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4318 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
|
4319 first_mb_in_slice >= s->mb_num){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4320 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
|
4321 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4322 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4323 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4324 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
|
4325 assert(s->mb_y < s->mb_height); |
2967 | 4326 |
1168 | 4327 if(s->picture_structure==PICT_FRAME){ |
4328 h->curr_pic_num= h->frame_num; | |
4329 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4330 }else{ | |
4331 h->curr_pic_num= 2*h->frame_num; | |
4332 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4333 } | |
2967 | 4334 |
1168 | 4335 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4336 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4337 } |
2967 | 4338 |
1168 | 4339 if(h->sps.poc_type==0){ |
4340 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4341 |
1168 | 4342 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4343 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4344 } | |
4345 } | |
2967 | 4346 |
1168 | 4347 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4348 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4349 |
1168 | 4350 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4351 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4352 } | |
2967 | 4353 |
1168 | 4354 init_poc(h); |
2967 | 4355 |
1168 | 4356 if(h->pps.redundant_pic_cnt_present){ |
4357 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4358 } | |
4359 | |
4360 //set defaults, might be overriden a few line later | |
4361 h->ref_count[0]= h->pps.ref_count[0]; | |
4362 h->ref_count[1]= h->pps.ref_count[1]; | |
4363 | |
4364 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4365 if(h->slice_type == B_TYPE){ | |
4366 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4367 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4368 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4369 } |
4370 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4371 |
1168 | 4372 if(num_ref_idx_active_override_flag){ |
4373 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4374 if(h->slice_type==B_TYPE) | |
4375 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4376 | |
4532 | 4377 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
|
4378 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
|
4379 h->ref_count[0]= h->ref_count[1]= 1; |
1168 | 4380 return -1; |
4381 } | |
4382 } | |
4532 | 4383 if(h->slice_type == B_TYPE) |
4384 h->list_count= 2; | |
4385 else | |
4386 h->list_count= 1; | |
4387 }else | |
4388 h->list_count= 0; | |
1168 | 4389 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4390 if(!default_ref_list_done){ |
1168 | 4391 fill_default_ref_list(h); |
4392 } | |
4393 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4394 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
|
4395 return -1; |
1168 | 4396 |
2967 | 4397 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4398 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4399 pred_weight_table(h); | |
2415 | 4400 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4401 implicit_weight_table(h); | |
4402 else | |
4403 h->use_weight = 0; | |
2967 | 4404 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4405 if(s->current_picture.reference) |
1168 | 4406 decode_ref_pic_marking(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
|
4407 |
3316 | 4408 if(FRAME_MBAFF) |
4409 fill_mbaff_ref_list(h); | |
4410 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4411 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
|
4412 tmp = get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4413 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4414 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
|
4415 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4416 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4417 h->cabac_init_idc= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4418 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4419 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4420 h->last_qscale_diff = 0; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4421 tmp = h->pps.init_qp + get_se_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4422 if(tmp>51){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4423 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); |
1898 | 4424 return -1; |
4425 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4426 s->qscale= tmp; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4427 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4428 //FIXME qscale / qp ... stuff |
4429 if(h->slice_type == SP_TYPE){ | |
1453 | 4430 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4431 } |
4432 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4433 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4434 } |
4435 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4436 h->deblocking_filter = 1; |
1898 | 4437 h->slice_alpha_c0_offset = 0; |
4438 h->slice_beta_offset = 0; | |
1168 | 4439 if( h->pps.deblocking_filter_parameters_present ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4440 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4441 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4442 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
|
4443 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4444 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4445 h->deblocking_filter= tmp; |
2967 | 4446 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
|
4447 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
|
4448 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4449 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
|
4450 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
|
4451 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4452 } |
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
|
4453 } |
2792 | 4454 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4455 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4456 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4457 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4458 h->deblocking_filter= 0; | |
1168 | 4459 |
4460 #if 0 //FMO | |
4461 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4462 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4463 #endif | |
4464 | |
2392 | 4465 h->slice_num++; |
4466 | |
3316 | 4467 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4468 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4469 | |
1168 | 4470 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
|
4471 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
|
4472 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4473 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4474 first_mb_in_slice, |
1264 | 4475 av_get_pict_type_char(h->slice_type), |
1168 | 4476 pps_id, h->frame_num, |
4477 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4478 h->ref_count[0], h->ref_count[1], | |
4479 s->qscale, | |
2583 | 4480 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4481 h->use_weight, |
4482 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4483 ); |
4484 } | |
4485 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4486 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
|
4487 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
|
4488 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
|
4489 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4490 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
|
4491 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
|
4492 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4493 |
1168 | 4494 return 0; |
4495 } | |
4496 | |
4497 /** | |
4498 * | |
4499 */ | |
4500 static inline int get_level_prefix(GetBitContext *gb){ | |
4501 unsigned int buf; | |
4502 int log; | |
2967 | 4503 |
1168 | 4504 OPEN_READER(re, gb); |
4505 UPDATE_CACHE(re, gb); | |
4506 buf=GET_CACHE(re, gb); | |
2967 | 4507 |
1168 | 4508 log= 32 - av_log2(buf); |
4509 #ifdef TRACE | |
4510 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
|
4511 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 | 4512 #endif |
4513 | |
4514 LAST_SKIP_BITS(re, gb, log); | |
4515 CLOSE_READER(re, gb); | |
4516 | |
4517 return log-1; | |
4518 } | |
4519 | |
2755 | 4520 static inline int get_dct8x8_allowed(H264Context *h){ |
4521 int i; | |
4522 for(i=0; i<4; i++){ | |
4523 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
|
4524 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4525 return 0; |
4526 } | |
4527 return 1; | |
4528 } | |
4529 | |
1168 | 4530 /** |
4531 * decodes a residual block. | |
4532 * @param n block index | |
4533 * @param scantable scantable | |
4534 * @param max_coeff number of coefficients in the block | |
4535 * @return <0 if an error occured | |
4536 */ | |
2919 | 4537 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4538 MpegEncContext * const s = &h->s; |
4539 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 | 4540 int level[16]; |
4541 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4542 |
4543 //FIXME put trailing_onex into the context | |
4544 | |
4545 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4546 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4547 total_coeff= coeff_token>>2; | |
2967 | 4548 }else{ |
1168 | 4549 if(n == LUMA_DC_BLOCK_INDEX){ |
4550 total_coeff= pred_non_zero_count(h, 0); | |
4551 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4552 total_coeff= coeff_token>>2; | |
4553 }else{ | |
4554 total_coeff= pred_non_zero_count(h, n); | |
4555 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4556 total_coeff= coeff_token>>2; | |
4557 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4558 } | |
4559 } | |
4560 | |
4561 //FIXME set last_non_zero? | |
4562 | |
4563 if(total_coeff==0) | |
4564 return 0; | |
4391
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4565 if(total_coeff > (unsigned)max_coeff) { |
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4566 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 | 4567 return -1; |
4568 } | |
2967 | 4569 |
1168 | 4570 trailing_ones= coeff_token&3; |
4600 | 4571 tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4572 assert(total_coeff<=16); |
2967 | 4573 |
1168 | 4574 for(i=0; i<trailing_ones; i++){ |
4575 level[i]= 1 - 2*get_bits1(gb); | |
4576 } | |
4577 | |
2897 | 4578 if(i<total_coeff) { |
1168 | 4579 int level_code, mask; |
2897 | 4580 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4581 int prefix= get_level_prefix(gb); | |
4582 | |
4583 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4584 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4585 if(suffix_length) | |
4586 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4587 else | |
4588 level_code= (prefix<<suffix_length); //part | |
4589 }else if(prefix==14){ | |
4590 if(suffix_length) | |
4591 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4592 else | |
4593 level_code= prefix + get_bits(gb, 4); //part | |
4594 }else if(prefix==15){ | |
4595 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
|
4596 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4597 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4598 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4599 return -1; |
4600 } | |
4601 | |
2897 | 4602 if(trailing_ones < 3) level_code += 2; |
4603 | |
4604 suffix_length = 1; | |
4605 if(level_code > 5) | |
4606 suffix_length++; | |
1168 | 4607 mask= -(level_code&1); |
4608 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4609 i++; |
4610 | |
4611 //remaining coefficients have suffix_length > 0 | |
4612 for(;i<total_coeff;i++) { | |
4613 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4614 prefix = get_level_prefix(gb); | |
4615 if(prefix<15){ | |
4616 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4617 }else if(prefix==15){ | |
4618 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4619 }else{ | |
4620 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4621 return -1; | |
4622 } | |
4623 mask= -(level_code&1); | |
4624 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4625 if(level_code > suffix_limit[suffix_length]) | |
4626 suffix_length++; | |
4627 } | |
1168 | 4628 } |
4629 | |
4630 if(total_coeff == max_coeff) | |
4631 zeros_left=0; | |
4632 else{ | |
4633 if(n == CHROMA_DC_BLOCK_INDEX) | |
4634 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4635 else | |
4636 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4637 } | |
2897 | 4638 |
4639 coeff_num = zeros_left + total_coeff - 1; | |
4640 j = scantable[coeff_num]; | |
4641 if(n > 24){ | |
4642 block[j] = level[0]; | |
4643 for(i=1;i<total_coeff;i++) { | |
4644 if(zeros_left <= 0) | |
4645 run_before = 0; | |
4646 else if(zeros_left < 7){ | |
4647 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4648 }else{ | |
4649 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4650 } | |
4651 zeros_left -= run_before; | |
4652 coeff_num -= 1 + run_before; | |
4653 j= scantable[ coeff_num ]; | |
4654 | |
4655 block[j]= level[i]; | |
4656 } | |
4657 }else{ | |
2919 | 4658 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4659 for(i=1;i<total_coeff;i++) { |
4660 if(zeros_left <= 0) | |
4661 run_before = 0; | |
4662 else if(zeros_left < 7){ | |
4663 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4664 }else{ | |
4665 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4666 } | |
4667 zeros_left -= run_before; | |
4668 coeff_num -= 1 + run_before; | |
4669 j= scantable[ coeff_num ]; | |
4670 | |
2919 | 4671 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 4672 } |
1168 | 4673 } |
4674 | |
4675 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4676 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4677 return -1; |
4678 } | |
2897 | 4679 |
1168 | 4680 return 0; |
4681 } | |
4682 | |
3316 | 4683 static void predict_field_decoding_flag(H264Context *h){ |
4684 MpegEncContext * const s = &h->s; | |
4685 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
4686 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
4687 ? s->current_picture.mb_type[mb_xy-1] | |
4688 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
4689 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
4690 : 0; | |
4691 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
4692 } | |
4693 | |
1168 | 4694 /** |
2396 | 4695 * decodes a P_SKIP or B_SKIP macroblock |
4696 */ | |
4697 static void decode_mb_skip(H264Context *h){ | |
4698 MpegEncContext * const s = &h->s; | |
4699 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
|
4700 int mb_type=0; |
2967 | 4701 |
2396 | 4702 memset(h->non_zero_count[mb_xy], 0, 16); |
4703 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
4704 | |
3316 | 4705 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4706 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
4707 |
2396 | 4708 if( h->slice_type == B_TYPE ) |
4709 { | |
4710 // 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
|
4711 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 4712 |
2449 | 4713 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 4714 pred_direct_motion(h, &mb_type); |
3927 | 4715 mb_type|= MB_TYPE_SKIP; |
2396 | 4716 } |
4717 else | |
4718 { | |
4719 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
4720 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 4721 |
2449 | 4722 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 4723 pred_pskip_motion(h, &mx, &my); |
4724 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
4725 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
4726 } | |
4727 | |
4728 write_back_motion(h, mb_type); | |
3927 | 4729 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 4730 s->current_picture.qscale_table[mb_xy]= s->qscale; |
4731 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
|
4732 h->prev_mb_skipped= 1; |
2396 | 4733 } |
4734 | |
4735 /** | |
1168 | 4736 * decodes a macroblock |
4737 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
4738 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4739 static int decode_mb_cavlc(H264Context *h){ |
1168 | 4740 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
|
4741 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
|
4742 int partition_count; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4743 unsigned int mb_type, cbp; |
2755 | 4744 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 4745 |
2967 | 4746 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 4747 |
4600 | 4748 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 4749 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
4750 down the code */ | |
1168 | 4751 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
4752 if(s->mb_skip_run==-1) | |
4753 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 4754 |
1168 | 4755 if (s->mb_skip_run--) { |
3316 | 4756 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
4757 if(s->mb_skip_run==0) | |
4758 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
4759 else | |
4760 predict_field_decoding_flag(h); | |
4761 } | |
2396 | 4762 decode_mb_skip(h); |
1168 | 4763 return 0; |
4764 } | |
4765 } | |
3316 | 4766 if(FRAME_MBAFF){ |
4767 if( (s->mb_y&1) == 0 ) | |
4768 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 4769 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4770 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 4771 |
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
|
4772 h->prev_mb_skipped= 0; |
2967 | 4773 |
1168 | 4774 mb_type= get_ue_golomb(&s->gb); |
4775 if(h->slice_type == B_TYPE){ | |
4776 if(mb_type < 23){ | |
4777 partition_count= b_mb_type_info[mb_type].partition_count; | |
4778 mb_type= b_mb_type_info[mb_type].type; | |
4779 }else{ | |
4780 mb_type -= 23; | |
4781 goto decode_intra_mb; | |
4782 } | |
4783 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
4784 if(mb_type < 5){ | |
4785 partition_count= p_mb_type_info[mb_type].partition_count; | |
4786 mb_type= p_mb_type_info[mb_type].type; | |
4787 }else{ | |
4788 mb_type -= 5; | |
4789 goto decode_intra_mb; | |
4790 } | |
4791 }else{ | |
4792 assert(h->slice_type == I_TYPE); | |
4793 decode_intra_mb: | |
4794 if(mb_type > 25){ | |
3954 | 4795 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 | 4796 return -1; |
4797 } | |
4798 partition_count=0; | |
4799 cbp= i_mb_type_info[mb_type].cbp; | |
4800 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
4801 mb_type= i_mb_type_info[mb_type].type; | |
4802 } | |
4803 | |
3316 | 4804 if(MB_FIELD) |
1168 | 4805 mb_type |= MB_TYPE_INTERLACED; |
4806 | |
4807 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 4808 |
1168 | 4809 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4810 unsigned int x, y; |
2967 | 4811 |
1168 | 4812 // we assume these blocks are very rare so we dont optimize it |
4813 align_get_bits(&s->gb); | |
2967 | 4814 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4815 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 4816 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4817 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 4818 for(x=0; x<16; x++){ |
4600 | 4819 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
|
4820 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 4821 } |
4822 } | |
4823 for(y=0; y<8; y++){ | |
4824 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
4825 for(x=0; x<8; x++){ | |
4600 | 4826 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
|
4827 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 4828 } |
4829 } | |
4830 for(y=0; y<8; y++){ | |
4831 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
4832 for(x=0; x<8; x++){ | |
4600 | 4833 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
|
4834 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 4835 } |
4836 } | |
2967 | 4837 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4838 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
4839 s->current_picture.qscale_table[mb_xy]= 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4840 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4841 // 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
|
4842 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 4843 |
2755 | 4844 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 4845 return 0; |
4846 } | |
2967 | 4847 |
3316 | 4848 if(MB_MBAFF){ |
4849 h->ref_count[0] <<= 1; | |
4850 h->ref_count[1] <<= 1; | |
4851 } | |
4852 | |
2449 | 4853 fill_caches(h, mb_type, 0); |
1168 | 4854 |
4855 //mb_pred | |
4856 if(IS_INTRA(mb_type)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4857 int pred_mode; |
1168 | 4858 // init_top_left_availability(h); |
4859 if(IS_INTRA4x4(mb_type)){ | |
4860 int i; | |
2755 | 4861 int di = 1; |
4862 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
4863 mb_type |= MB_TYPE_8x8DCT; | |
4864 di = 4; | |
4865 } | |
1168 | 4866 |
4867 // fill_intra4x4_pred_table(h); | |
2755 | 4868 for(i=0; i<16; i+=di){ |
3409 | 4869 int mode= pred_intra_mode(h, i); |
4870 | |
4871 if(!get_bits1(&s->gb)){ | |
1168 | 4872 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 4873 mode = rem_mode + (rem_mode >= mode); |
1168 | 4874 } |
2967 | 4875 |
2755 | 4876 if(di==4) |
4877 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
4878 else | |
4879 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 4880 } |
4881 write_back_intra_pred_mode(h); | |
4882 if( check_intra4x4_pred_mode(h) < 0) | |
4883 return -1; | |
4884 }else{ | |
4885 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
4886 if(h->intra16x16_pred_mode < 0) | |
4887 return -1; | |
4888 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4889 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4890 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
|
4891 if(pred_mode < 0) |
1168 | 4892 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4893 h->chroma_pred_mode= pred_mode; |
1168 | 4894 }else if(partition_count==4){ |
4895 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 4896 |
1168 | 4897 if(h->slice_type == B_TYPE){ |
4898 for(i=0; i<4; i++){ | |
4899 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4900 if(h->sub_mb_type[i] >=13){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4901 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 | 4902 return -1; |
4903 } | |
4904 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4905 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4906 } | |
2396 | 4907 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 4908 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 4909 pred_direct_motion(h, &mb_type); |
3003 | 4910 h->ref_cache[0][scan8[4]] = |
4911 h->ref_cache[1][scan8[4]] = | |
4912 h->ref_cache[0][scan8[12]] = | |
4913 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
4914 } | |
1168 | 4915 }else{ |
4916 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
4917 for(i=0; i<4; i++){ | |
4918 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
4919 if(h->sub_mb_type[i] >=4){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4920 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 | 4921 return -1; |
4922 } | |
4923 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
4924 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
4925 } | |
4926 } | |
2967 | 4927 |
4533 | 4928 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
|
4929 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 4930 for(i=0; i<4; i++){ |
2396 | 4931 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
4932 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4933 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
|
4934 if(tmp>=ref_count){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4935 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
|
4936 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4937 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4938 ref[list][i]= tmp; |
1168 | 4939 }else{ |
4940 //FIXME | |
4941 ref[list][i] = -1; | |
4942 } | |
4943 } | |
4944 } | |
2967 | 4945 |
2755 | 4946 if(dct8x8_allowed) |
4947 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 4948 |
4533 | 4949 for(list=0; list<h->list_count; list++){ |
1168 | 4950 for(i=0; i<4; i++){ |
3003 | 4951 if(IS_DIRECT(h->sub_mb_type[i])) { |
4952 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
4953 continue; | |
4954 } | |
1168 | 4955 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
4956 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
4957 | |
2396 | 4958 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 4959 const int sub_mb_type= h->sub_mb_type[i]; |
4960 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
4961 for(j=0; j<sub_partition_count[i]; j++){ | |
4962 int mx, my; | |
4963 const int index= 4*i + block_width*j; | |
4964 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
4965 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
4966 mx += get_se_golomb(&s->gb); | |
4967 my += get_se_golomb(&s->gb); | |
4600 | 4968 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 4969 |
1168 | 4970 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 4971 mv_cache[ 1 ][0]= |
1168 | 4972 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 4973 mv_cache[ 1 ][1]= |
1168 | 4974 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
4975 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4530 | 4976 mv_cache[ 1 ][0]= mx; |
4977 mv_cache[ 1 ][1]= my; | |
1168 | 4978 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 4979 mv_cache[ 8 ][0]= mx; |
4980 mv_cache[ 8 ][1]= my; | |
1168 | 4981 } |
4530 | 4982 mv_cache[ 0 ][0]= mx; |
4983 mv_cache[ 0 ][1]= my; | |
1168 | 4984 } |
4985 }else{ | |
4986 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
4987 p[0] = p[1]= | |
4988 p[8] = p[9]= 0; | |
4989 } | |
4990 } | |
4991 } | |
2396 | 4992 }else if(IS_DIRECT(mb_type)){ |
4993 pred_direct_motion(h, &mb_type); | |
2755 | 4994 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 4995 }else{ |
1168 | 4996 int list, mx, my, i; |
4997 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
4998 if(IS_16X16(mb_type)){ | |
4534 | 4999 for(list=0; list<h->list_count; list++){ |
5000 unsigned int val; | |
1168 | 5001 if(IS_DIR(mb_type, 0, list)){ |
4534 | 5002 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5003 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5004 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
|
5005 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5006 } |
2523 | 5007 }else |
4534 | 5008 val= LIST_NOT_USED&0xFF; |
5009 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
5010 } | |
5011 for(list=0; list<h->list_count; list++){ | |
5012 unsigned int val; | |
1168 | 5013 if(IS_DIR(mb_type, 0, list)){ |
5014 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5015 mx += get_se_golomb(&s->gb); | |
5016 my += get_se_golomb(&s->gb); | |
4600 | 5017 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 5018 |
4534 | 5019 val= pack16to32(mx,my); |
2523 | 5020 }else |
4534 | 5021 val=0; |
5022 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4); | |
1168 | 5023 } |
5024 } | |
5025 else if(IS_16X8(mb_type)){ | |
4534 | 5026 for(list=0; list<h->list_count; list++){ |
1168 | 5027 for(i=0; i<2; i++){ |
4534 | 5028 unsigned int val; |
1168 | 5029 if(IS_DIR(mb_type, i, list)){ |
4534 | 5030 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5031 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5032 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
|
5033 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5034 } |
2523 | 5035 }else |
4534 | 5036 val= LIST_NOT_USED&0xFF; |
5037 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
1168 | 5038 } |
4534 | 5039 } |
5040 for(list=0; list<h->list_count; list++){ | |
1168 | 5041 for(i=0; i<2; i++){ |
4534 | 5042 unsigned int val; |
1168 | 5043 if(IS_DIR(mb_type, i, list)){ |
5044 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5045 mx += get_se_golomb(&s->gb); | |
5046 my += get_se_golomb(&s->gb); | |
4600 | 5047 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 5048 |
4534 | 5049 val= pack16to32(mx,my); |
2396 | 5050 }else |
4534 | 5051 val=0; |
5052 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4); | |
1168 | 5053 } |
5054 } | |
5055 }else{ | |
5056 assert(IS_8X16(mb_type)); | |
4534 | 5057 for(list=0; list<h->list_count; list++){ |
1168 | 5058 for(i=0; i<2; i++){ |
4534 | 5059 unsigned int val; |
1168 | 5060 if(IS_DIR(mb_type, i, list)){ //FIXME optimize |
4534 | 5061 val= get_te0_golomb(&s->gb, h->ref_count[list]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5062 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5063 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
|
5064 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5065 } |
2523 | 5066 }else |
4534 | 5067 val= LIST_NOT_USED&0xFF; |
5068 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
1168 | 5069 } |
4534 | 5070 } |
5071 for(list=0; list<h->list_count; list++){ | |
1168 | 5072 for(i=0; i<2; i++){ |
4534 | 5073 unsigned int val; |
1168 | 5074 if(IS_DIR(mb_type, i, list)){ |
5075 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5076 mx += get_se_golomb(&s->gb); | |
5077 my += get_se_golomb(&s->gb); | |
4600 | 5078 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1170 | 5079 |
4534 | 5080 val= pack16to32(mx,my); |
2396 | 5081 }else |
4534 | 5082 val=0; |
5083 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4); | |
1168 | 5084 } |
5085 } | |
5086 } | |
5087 } | |
2967 | 5088 |
1168 | 5089 if(IS_INTER(mb_type)) |
5090 write_back_motion(h, mb_type); | |
2967 | 5091 |
1168 | 5092 if(!IS_INTRA16x16(mb_type)){ |
5093 cbp= get_ue_golomb(&s->gb); | |
5094 if(cbp > 47){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5095 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5096 return -1; |
5097 } | |
2967 | 5098 |
1168 | 5099 if(IS_INTRA4x4(mb_type)) |
5100 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5101 else | |
5102 cbp= golomb_to_inter_cbp[cbp]; | |
5103 } | |
3651 | 5104 h->cbp = cbp; |
1168 | 5105 |
2755 | 5106 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5107 if(get_bits1(&s->gb)) | |
5108 mb_type |= MB_TYPE_8x8DCT; | |
5109 } | |
5110 s->current_picture.mb_type[mb_xy]= mb_type; | |
5111 | |
1168 | 5112 if(cbp || IS_INTRA16x16(mb_type)){ |
5113 int i8x8, i4x4, chroma_idx; | |
5114 int chroma_qp, dquant; | |
5115 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5116 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5117 |
1168 | 5118 // fill_non_zero_count_cache(h); |
5119 | |
5120 if(IS_INTERLACED(mb_type)){ | |
3316 | 5121 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5122 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5123 dc_scan= luma_dc_field_scan; |
5124 }else{ | |
3316 | 5125 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5126 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5127 dc_scan= luma_dc_zigzag_scan; |
5128 } | |
5129 | |
5130 dquant= get_se_golomb(&s->gb); | |
5131 | |
5132 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5133 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 | 5134 return -1; |
5135 } | |
2967 | 5136 |
1168 | 5137 s->qscale += dquant; |
5138 if(((unsigned)s->qscale) > 51){ | |
5139 if(s->qscale<0) s->qscale+= 52; | |
5140 else s->qscale-= 52; | |
5141 } | |
2967 | 5142 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5143 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5144 if(IS_INTRA16x16(mb_type)){ |
2919 | 5145 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
|
5146 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5147 } |
5148 | |
5149 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5150 | |
5151 if(cbp&15){ | |
5152 for(i8x8=0; i8x8<4; i8x8++){ | |
5153 for(i4x4=0; i4x4<4; i4x4++){ | |
5154 const int index= i4x4 + 4*i8x8; | |
2919 | 5155 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5156 return -1; |
5157 } | |
5158 } | |
5159 } | |
5160 }else{ | |
1636 | 5161 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5162 } |
5163 }else{ | |
5164 for(i8x8=0; i8x8<4; i8x8++){ | |
5165 if(cbp & (1<<i8x8)){ | |
2755 | 5166 if(IS_8x8DCT(mb_type)){ |
5167 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5168 uint8_t *nnz; |
2755 | 5169 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5170 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5171 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5172 return -1; |
5173 } | |
2757 | 5174 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
|
5175 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5176 }else{ |
5177 for(i4x4=0; i4x4<4; i4x4++){ | |
5178 const int index= i4x4 + 4*i8x8; | |
2967 | 5179 |
2919 | 5180 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 | 5181 return -1; |
5182 } | |
1168 | 5183 } |
5184 } | |
5185 }else{ | |
5186 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5187 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5188 } | |
5189 } | |
5190 } | |
2967 | 5191 |
1168 | 5192 if(cbp&0x30){ |
5193 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5194 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5195 return -1; |
5196 } | |
5197 } | |
5198 | |
5199 if(cbp&0x20){ | |
5200 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5201 for(i4x4=0; i4x4<4; i4x4++){ | |
5202 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5203 if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][chroma_qp], 15) < 0){ |
1168 | 5204 return -1; |
5205 } | |
5206 } | |
5207 } | |
5208 }else{ | |
5209 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5210 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5211 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5212 } | |
5213 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5214 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
|
5215 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
|
5216 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
|
5217 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5218 } |
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
|
5219 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5220 write_back_non_zero_count(h); |
5221 | |
3316 | 5222 if(MB_MBAFF){ |
5223 h->ref_count[0] >>= 1; | |
5224 h->ref_count[1] >>= 1; | |
5225 } | |
5226 | |
1168 | 5227 return 0; |
5228 } | |
5229 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5230 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
|
5231 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
|
5232 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
|
5233 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
|
5234 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
|
5235 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
|
5236 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5237 unsigned int ctx = 0; |
2967 | 5238 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5239 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
|
5240 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5241 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5242 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
|
5243 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5244 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5245 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5246 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
|
5247 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5248 |
2312 | 5249 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5250 uint8_t *state= &h->cabac_state[ctx_base]; | |
5251 int mb_type; | |
2967 | 5252 |
2312 | 5253 if(intra_slice){ |
5254 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
|
5255 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
|
5256 const int mbb_xy = h->top_mb_xy; |
2312 | 5257 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5258 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
|
5259 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5260 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
|
5261 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5262 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5263 return 0; /* I4x4 */ |
5264 state += 2; | |
5265 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5266 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
|
5267 return 0; /* I4x4 */ |
2312 | 5268 } |
5269 | |
5270 if( get_cabac_terminate( &h->cabac ) ) | |
5271 return 25; /* PCM */ | |
5272 | |
5273 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
|
5274 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
|
5275 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
|
5276 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
|
5277 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
|
5278 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5279 return mb_type; |
5280 } | |
5281 | |
5282 static int decode_cabac_mb_type( H264Context *h ) { | |
5283 MpegEncContext * const s = &h->s; | |
5284 | |
5285 if( h->slice_type == I_TYPE ) { | |
5286 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
|
5287 } 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
|
5288 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
|
5289 /* 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
|
5290 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5291 /* 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
|
5292 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
|
5293 } else { |
3138 | 5294 /* 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
|
5295 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
|
5296 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5297 } else { |
2312 | 5298 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
|
5299 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5300 } 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
|
5301 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
|
5302 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
|
5303 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
|
5304 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5305 |
3138 | 5306 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
|
5307 ctx++; |
3138 | 5308 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
|
5309 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5310 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5311 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
|
5312 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
|
5313 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5314 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
|
5315 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
|
5316 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5317 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5318 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
|
5319 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
|
5320 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
|
5321 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
|
5322 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
|
5323 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
|
5324 else if( bits == 13 ) { |
2312 | 5325 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
|
5326 } 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
|
5327 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
|
5328 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
|
5329 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
|
5330 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5331 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
|
5332 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
|
5333 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5334 /* 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
|
5335 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5338 |
3316 | 5339 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
|
5340 MpegEncContext * const s = &h->s; |
3316 | 5341 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
|
5342 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
|
5343 |
3316 | 5344 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5345 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5346 mba_xy = mb_xy - 1; | |
5347 if( (mb_y&1) | |
5348 && h->slice_table[mba_xy] == h->slice_num | |
5349 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5350 mba_xy += s->mb_stride; | |
5351 if( MB_FIELD ){ | |
5352 mbb_xy = mb_xy - s->mb_stride; | |
5353 if( !(mb_y&1) | |
5354 && h->slice_table[mbb_xy] == h->slice_num | |
5355 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5356 mbb_xy -= s->mb_stride; | |
5357 }else | |
5358 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5359 }else{ | |
5360 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5361 mba_xy = mb_xy - 1; | |
5362 mbb_xy = mb_xy - s->mb_stride; | |
5363 } | |
5364 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5365 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
|
5366 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5367 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
|
5368 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5369 |
3138 | 5370 if( h->slice_type == B_TYPE ) |
5371 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
|
5372 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
|
5373 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5374 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5375 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
|
5376 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
|
5377 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5378 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
|
5379 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
|
5380 |
2928 | 5381 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5382 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5383 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5384 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5385 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
|
5386 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
|
5387 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5388 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
|
5389 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5390 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5391 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
|
5392 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
|
5393 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
|
5394 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5395 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
|
5396 |
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
|
5397 /* 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
|
5398 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
|
5399 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
|
5400 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5401 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
|
5402 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5403 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5404 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
|
5405 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
|
5406 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5407 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
|
5408 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
|
5409 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
|
5410 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
|
5411 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5412 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
|
5413 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5414 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5415 static const uint8_t block_idx_x[16] = { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5416 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5417 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5418 static const uint8_t block_idx_y[16] = { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5419 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5420 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5421 static const uint8_t block_idx_xy[4][4] = { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5422 { 0, 2, 8, 10}, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5423 { 1, 3, 9, 11}, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5424 { 4, 6, 12, 14}, |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5425 { 5, 7, 13, 15} |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5426 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5427 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5428 static int decode_cabac_mb_cbp_luma( 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
|
5429 int cbp = 0; |
3138 | 5430 int cbp_b = -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
|
5431 int i8x8; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5432 |
3138 | 5433 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5434 cbp_b = h->top_cbp; | |
4600 | 5435 tprintf(h->s.avctx, "cbp_b = top_cbp = %x\n", cbp_b); |
3138 | 5436 } |
5437 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5438 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5439 int cbp_a = -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
|
5440 int x, y; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5441 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
|
5442 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5443 x = block_idx_x[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
|
5444 y = block_idx_y[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
|
5445 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5446 if( x > 0 ) |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5447 cbp_a = cbp; |
3138 | 5448 else if( h->slice_table[h->left_mb_xy[0]] == h->slice_num ) { |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5449 cbp_a = h->left_cbp; |
4600 | 5450 tprintf(h->s.avctx, "cbp_a = left_cbp = %x\n", cbp_a); |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5451 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5452 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5453 if( y > 0 ) |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5454 cbp_b = 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
|
5455 |
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
|
5456 /* No need to test for skip as we put 0 for skip block */ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5457 /* No need to test for IPCM as we put 1 for IPCM block */ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5458 if( cbp_a >= 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
|
5459 int i8x8a = block_idx_xy[(x-1)&0x03][y]/4; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5460 if( ((cbp_a >> i8x8a)&0x01) == 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
|
5461 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5462 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5463 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5464 if( cbp_b >= 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
|
5465 int i8x8b = block_idx_xy[x][(y-1)&0x03]/4; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5466 if( ((cbp_b >> i8x8b)&0x01) == 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
|
5467 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
|
5468 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5469 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5470 if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5471 cbp |= 1 << i8x8; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5472 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5473 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5474 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
|
5475 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5476 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
|
5477 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
|
5478 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
|
5479 |
2314 | 5480 cbp_a = (h->left_cbp>>4)&0x03; |
5481 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
|
5482 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5483 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
|
5484 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
|
5485 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
|
5486 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
|
5487 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
|
5488 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5489 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
|
5490 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
|
5491 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
|
5492 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
|
5493 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5494 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
|
5495 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
|
5496 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
|
5497 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
|
5498 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
|
5499 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5500 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
|
5501 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
|
5502 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5503 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
|
5504 |
3316 | 5505 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
|
5506 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5507 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5508 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
|
5509 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
|
5510 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
|
5511 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5512 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
|
5513 val++; |
3128 | 5514 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5515 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
|
5516 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5517 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5518 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
|
5519 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
|
5520 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5521 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
|
5522 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5523 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
|
5524 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
|
5525 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
|
5526 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
|
5527 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
|
5528 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
|
5529 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
|
5530 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
|
5531 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5532 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
|
5533 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5534 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
|
5535 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
|
5536 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
|
5537 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
|
5538 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5539 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
|
5540 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
|
5541 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
|
5542 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5543 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5544 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
|
5545 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
|
5546 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5547 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5548 |
2755 | 5549 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
|
5550 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5551 } |
5552 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5553 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
|
5554 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
|
5555 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
|
5556 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
|
5557 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
|
5558 |
2396 | 5559 if( h->slice_type == B_TYPE) { |
5560 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5561 ctx++; | |
5562 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5563 ctx += 2; | |
5564 } else { | |
5565 if( refa > 0 ) | |
5566 ctx++; | |
5567 if( refb > 0 ) | |
5568 ctx += 2; | |
5569 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5570 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5571 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
|
5572 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5573 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
|
5574 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5575 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5576 ctx = 5; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5577 if(ref >= 32 /*h->ref_list[list]*/){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5578 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
|
5579 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
|
5580 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5581 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5582 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5583 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5584 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5585 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
|
5586 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
|
5587 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
|
5588 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5589 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
|
5590 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5591 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
|
5592 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5593 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
|
5594 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5595 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5596 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5597 |
2317 | 5598 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5599 return 0; | |
5600 | |
5601 mvd= 1; | |
5602 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
|
5603 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
|
5604 mvd++; |
2317 | 5605 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
|
5606 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5607 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5608 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5609 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
|
5610 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
|
5611 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
|
5612 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
|
5613 k++; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5614 if(k>24){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5615 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
|
5616 return INT_MIN; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5617 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5618 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5619 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5620 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
|
5621 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
|
5622 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5623 } |
4042 | 5624 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
|
5625 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5626 |
4908
777f250df232
Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents:
4896
diff
changeset
|
5627 static inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5628 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
|
5629 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
|
5630 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5631 if( cat == 0 ) { |
2314 | 5632 nza = h->left_cbp&0x100; |
5633 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
|
5634 } else if( cat == 1 || cat == 2 ) { |
2314 | 5635 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5636 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
|
5637 } else if( cat == 3 ) { |
2314 | 5638 nza = (h->left_cbp>>(6+idx))&0x01; |
5639 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5640 } else { | |
5641 assert(cat == 4); | |
5642 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5643 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5644 } | |
5645 | |
5646 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
|
5647 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5648 |
2314 | 5649 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
|
5650 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
|
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 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
|
5653 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5654 |
5006
28ebdd244a07
Change some leftover __attribute__((unused)) and __attribute__((used)) to
reimar
parents:
4984
diff
changeset
|
5655 static const attribute_used uint8_t last_coeff_flag_offset_8x8[63] = { |
4051 | 5656 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
5657 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
5658 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
5659 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
5660 }; | |
5661 | |
3028 | 5662 static int 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
|
5663 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5664 static const int significant_coeff_flag_offset[2][6] = { |
5665 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
5666 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
5667 }; | |
5668 static const int last_coeff_flag_offset[2][6] = { | |
5669 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
5670 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
5671 }; | |
5672 static const int coeff_abs_level_m1_offset[6] = { | |
5673 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
5674 }; | |
4007 | 5675 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 5676 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 5677 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
5678 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 5679 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
5680 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
5681 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
5682 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
5683 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 5684 }; |
5685 | |
5686 int index[64]; | |
2313 | 5687 |
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
|
5688 int 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
|
5689 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
|
5690 |
2316 | 5691 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
|
5692 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
|
5693 |
2898 | 5694 uint8_t *significant_coeff_ctx_base; |
5695 uint8_t *last_coeff_ctx_base; | |
5696 uint8_t *abs_level_m1_ctx_base; | |
2755 | 5697 |
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
|
5698 #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
|
5699 #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
|
5700 #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
|
5701 #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
|
5702 #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
|
5703 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
|
5704 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
|
5705 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
|
5706 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
|
5707 #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
|
5708 #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
|
5709 #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
|
5710 |
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
|
5711 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5712 /* 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
|
5713 * 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
|
5714 * 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
|
5715 * 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
|
5716 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 5717 * 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
|
5718 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5719 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5720 /* read coded block flag */ |
2898 | 5721 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
|
5722 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 5723 if( cat == 1 || cat == 2 ) |
5724 h->non_zero_count_cache[scan8[n]] = 0; | |
5725 else if( cat == 4 ) | |
5726 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
|
5727 #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
|
5728 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
|
5729 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
|
5730 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
|
5731 #endif |
2755 | 5732 return 0; |
5733 } | |
2898 | 5734 } |
5735 | |
5736 significant_coeff_ctx_base = h->cabac_state | |
3316 | 5737 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 5738 last_coeff_ctx_base = h->cabac_state |
3316 | 5739 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 5740 abs_level_m1_ctx_base = h->cabac_state |
5741 + coeff_abs_level_m1_offset[cat]; | |
5742 | |
5743 if( cat == 5 ) { | |
5744 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
5745 for(last= 0; last < coefs; last++) { \ | |
5746 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
|
5747 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 5748 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
5749 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
|
5750 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 5751 last= max_coeff; \ |
5752 break; \ | |
5753 } \ | |
5754 } \ | |
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
|
5755 }\ |
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
|
5756 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
|
5757 index[coeff_count++] = last;\ |
2898 | 5758 } |
4009 | 5759 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; |
4882
8131ccb4ea72
Mark code parts that cannot work on AMD64 due to broken relocations as such.
diego
parents:
4881
diff
changeset
|
5760 #if defined(ARCH_X86) && defined(CONFIG_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) |
4051 | 5761 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
5762 } else { | |
5763 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
5764 #else | |
3316 | 5765 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 5766 } else { |
5767 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
|
5768 #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
|
5769 } |
2316 | 5770 assert(coeff_count > 0); |
5771 | |
5772 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
|
5773 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
|
5774 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
|
5775 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 5776 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
|
5777 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 5778 else if( cat == 4 ) |
5779 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 5780 else { |
2755 | 5781 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
5782 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 5783 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5784 |
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
|
5785 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 5786 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
|
5787 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
|
5788 |
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
|
5789 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 5790 if( !qmul ) { |
4040 | 5791 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 5792 }else{ |
4040 | 5793 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 5794 } |
2967 | 5795 |
2313 | 5796 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
|
5797 } else { |
2313 | 5798 int coeff_abs = 2; |
2898 | 5799 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
|
5800 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 5801 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
|
5802 } |
2313 | 5803 |
5804 if( coeff_abs >= 15 ) { | |
5805 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
|
5806 while( get_cabac_bypass( CC ) ) { |
2313 | 5807 j++; |
5808 } | |
2967 | 5809 |
4016 | 5810 coeff_abs=1; |
2313 | 5811 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
|
5812 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 5813 } |
4016 | 5814 coeff_abs+= 14; |
2313 | 5815 } |
5816 | |
2898 | 5817 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
|
5818 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 5819 else block[j] = coeff_abs; |
5820 }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
|
5821 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 5822 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 5823 } |
2967 | 5824 |
2313 | 5825 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
|
5826 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5827 } |
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
|
5828 #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
|
5829 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
|
5830 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
|
5831 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
|
5832 #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
|
5833 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
|
5834 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5835 |
4908
777f250df232
Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents:
4896
diff
changeset
|
5836 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
|
5837 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5838 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
|
5839 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
|
5840 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
|
5841 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 5842 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
|
5843 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
|
5844 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
|
5845 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
|
5846 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 5847 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
|
5848 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
|
5849 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5850 ? !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
|
5851 : (!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
|
5852 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5853 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
|
5854 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5855 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
|
5856 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
|
5857 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5858 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5859 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5860 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5861 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5862 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5863 * 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
|
5864 * @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
|
5865 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5866 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
|
5867 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
|
5868 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
|
5869 int mb_type, partition_count, cbp = 0; |
2755 | 5870 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
|
5871 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5872 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
|
5873 |
4600 | 5874 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
|
5875 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 5876 int skip; |
5877 /* a skipped mb needs the aff flag from the following mb */ | |
5878 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
5879 predict_field_decoding_flag(h); | |
5880 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
5881 skip = h->next_mb_skipped; | |
5882 else | |
5883 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
|
5884 /* read skip flags */ |
3316 | 5885 if( skip ) { |
5886 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
5887 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
5888 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
5889 if(h->next_mb_skipped) | |
5890 predict_field_decoding_flag(h); | |
5891 else | |
5892 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
5893 } | |
5894 | |
2396 | 5895 decode_mb_skip(h); |
5896 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5897 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
|
5898 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
|
5899 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
|
5900 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5901 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
|
5902 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5903 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5904 } |
3316 | 5905 if(FRAME_MBAFF){ |
5906 if( (s->mb_y&1) == 0 ) | |
5907 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
|
5908 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
|
5909 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Lo«Ác Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5910 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
|
5911 |
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
|
5912 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
|
5913 |
3077 | 5914 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
|
5915 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
|
5916 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
|
5917 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
|
5918 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5919 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5920 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
|
5921 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
|
5922 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
|
5923 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
|
5924 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5925 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
|
5926 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
|
5927 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5928 } 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
|
5929 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
|
5930 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
|
5931 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
|
5932 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5933 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
|
5934 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
|
5935 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5936 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5937 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
|
5938 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
|
5939 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
|
5940 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
|
5941 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
|
5942 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
|
5943 } |
3316 | 5944 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
|
5945 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
|
5946 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5947 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
|
5948 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5949 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5950 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5951 unsigned int x, y; |
2967 | 5952 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5953 // We assume these blocks are very rare so we dont optimize it. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5954 // 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
|
5955 // 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
|
5956 ptr= h->cabac.bytestream; |
4344 | 5957 if(h->cabac.low&0x1) ptr--; |
5958 if(CABAC_BITS==16){ | |
5959 if(h->cabac.low&0x1FF) ptr--; | |
5960 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5961 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5962 // 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
|
5963 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5964 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
|
5965 for(x=0; x<16; x++){ |
4600 | 5966 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
|
5967 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
|
5968 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5969 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5970 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5971 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
|
5972 for(x=0; x<8; x++){ |
4600 | 5973 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
|
5974 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
|
5975 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5976 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5977 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5978 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
|
5979 for(x=0; x<8; x++){ |
4600 | 5980 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
|
5981 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
|
5982 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5983 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5984 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5985 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
|
5986 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5987 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5988 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
|
5989 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
|
5990 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5991 s->current_picture.qscale_table[mb_xy]= 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5992 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5993 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5994 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 5995 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
|
5996 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
|
5997 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5998 |
3316 | 5999 if(MB_MBAFF){ |
6000 h->ref_count[0] <<= 1; | |
6001 h->ref_count[1] <<= 1; | |
6002 } | |
6003 | |
2449 | 6004 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
|
6005 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6006 if( IS_INTRA( mb_type ) ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6007 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
|
6008 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6009 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6010 mb_type |= MB_TYPE_8x8DCT; | |
6011 for( i = 0; i < 16; i+=4 ) { | |
6012 int pred = pred_intra_mode( h, i ); | |
6013 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6014 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6015 } | |
6016 } else { | |
6017 for( i = 0; i < 16; i++ ) { | |
6018 int pred = pred_intra_mode( h, i ); | |
6019 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
|
6020 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6021 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6022 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6023 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6024 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
|
6025 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
|
6026 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6027 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
|
6028 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
|
6029 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6030 h->chroma_pred_mode_table[mb_xy] = |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6031 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6032 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6033 pred_mode= check_intra_pred_mode( h, pred_mode ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6034 if( pred_mode < 0 ) return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6035 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
|
6036 } 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
|
6037 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
|
6038 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6039 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
|
6040 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
|
6041 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
|
6042 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
|
6043 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
|
6044 } |
3482 | 6045 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6046 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6047 pred_direct_motion(h, &mb_type); |
6048 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6049 for( i = 0; i < 4; i++ ) | |
6050 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6051 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6052 } | |
6053 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6054 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6055 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
|
6056 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
|
6057 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
|
6058 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
|
6059 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6060 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6061 |
4533 | 6062 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
|
6063 for( i = 0; i < 4; i++ ) { |
2396 | 6064 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6065 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
|
6066 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
|
6067 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
|
6068 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6069 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
|
6070 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6071 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
|
6072 } |
2110 | 6073 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
|
6074 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
|
6075 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6076 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6077 |
2755 | 6078 if(dct8x8_allowed) |
6079 dct8x8_allowed = get_dct8x8_allowed(h); | |
6080 | |
4533 | 6081 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
|
6082 for(i=0; i<4; i++){ |
2396 | 6083 if(IS_DIRECT(h->sub_mb_type[i])){ |
6084 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6085 continue; | |
6086 } | |
2110 | 6087 h->ref_cache[list][ scan8[4*i] ]=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
|
6088 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6089 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
|
6090 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
|
6091 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
|
6092 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
|
6093 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
|
6094 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
|
6095 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
|
6096 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
|
6097 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
|
6098 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
|
6099 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6100 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
|
6101 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 ); |
4600 | 6102 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
|
6103 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6104 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 6105 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
|
6106 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 6107 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
|
6108 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
|
6109 |
4530 | 6110 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
|
6111 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
4530 | 6112 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
|
6113 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
|
6114 }else if(IS_SUB_8X4(sub_mb_type)){ |
4530 | 6115 mv_cache[ 1 ][0]= mx; |
6116 mv_cache[ 1 ][1]= my; | |
6117 | |
6118 mvd_cache[ 1 ][0]= mx - mpx; | |
6119 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
|
6120 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 6121 mv_cache[ 8 ][0]= mx; |
6122 mv_cache[ 8 ][1]= my; | |
6123 | |
6124 mvd_cache[ 8 ][0]= mx - mpx; | |
6125 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
|
6126 } |
4530 | 6127 mv_cache[ 0 ][0]= mx; |
6128 mv_cache[ 0 ][1]= my; | |
6129 | |
6130 mvd_cache[ 0 ][0]= mx - mpx; | |
6131 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
|
6132 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6133 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6134 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
|
6135 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
|
6136 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
|
6137 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
|
6138 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6139 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6140 } |
2396 | 6141 } else if( IS_DIRECT(mb_type) ) { |
6142 pred_direct_motion(h, &mb_type); | |
6143 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6144 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6145 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6146 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6147 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
|
6148 if(IS_16X16(mb_type)){ |
4534 | 6149 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
|
6150 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
|
6151 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
|
6152 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); |
2523 | 6153 }else |
4534 | 6154 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 |
6155 } | |
6156 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
|
6157 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
|
6158 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
|
6159 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6160 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
|
6161 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 ); |
4600 | 6162 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
|
6163 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6164 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
|
6165 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6166 }else |
6167 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
|
6168 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6169 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6170 else if(IS_16X8(mb_type)){ |
4533 | 6171 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
|
6172 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
|
6173 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
|
6174 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
|
6175 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6176 }else |
6177 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
|
6178 } |
4533 | 6179 } |
6180 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
|
6181 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
|
6182 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
|
6183 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
|
6184 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
|
6185 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 ); |
4600 | 6186 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
|
6187 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6188 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
|
6189 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6190 }else{ |
2396 | 6191 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6192 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
|
6193 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6194 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6195 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6196 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6197 assert(IS_8X16(mb_type)); |
4533 | 6198 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
|
6199 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
|
6200 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
|
6201 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
|
6202 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6203 }else |
6204 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
|
6205 } |
4533 | 6206 } |
6207 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
|
6208 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
|
6209 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
|
6210 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
|
6211 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
|
6212 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
|
6213 |
4600 | 6214 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
|
6215 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
|
6216 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6217 }else{ |
2396 | 6218 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6219 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
|
6220 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6221 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6222 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6223 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6224 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6225 |
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
|
6226 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
|
6227 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
|
6228 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
|
6229 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6230 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6231 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
|
6232 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
|
6233 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
|
6234 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6235 |
3651 | 6236 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
|
6237 |
2755 | 6238 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6239 if( decode_cabac_mb_transform_size( h ) ) | |
6240 mb_type |= MB_TYPE_8x8DCT; | |
6241 } | |
6242 s->current_picture.mb_type[mb_xy]= mb_type; | |
6243 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6244 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6245 const uint8_t *scan, *scan8x8, *dc_scan; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6246 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
|
6247 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6248 if(IS_INTERLACED(mb_type)){ |
3316 | 6249 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6250 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
|
6251 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
|
6252 }else{ |
3316 | 6253 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6254 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
|
6255 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
|
6256 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6257 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6258 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
|
6259 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6260 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
|
6261 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6262 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6263 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
|
6264 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
|
6265 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
|
6266 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
|
6267 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6268 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 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
|
6269 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6270 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
|
6271 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
|
6272 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6273 if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16) < 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
|
6274 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
|
6275 if( cbp&15 ) { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6276 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
|
6277 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6278 if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 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
|
6279 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
|
6280 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6281 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6282 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
|
6283 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6284 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6285 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
|
6286 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
|
6287 if( cbp & (1<<i8x8) ) { |
2755 | 6288 if( IS_8x8DCT(mb_type) ) { |
6289 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6290 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6291 return -1; |
6292 } 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
|
6293 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
|
6294 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
|
6295 //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
|
6296 //START_TIMER |
2919 | 6297 if( decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) < 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
|
6298 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6299 //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
|
6300 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6301 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6302 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
|
6303 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
|
6304 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6305 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6306 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6307 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6308 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
|
6309 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
|
6310 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
|
6311 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6312 if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4) < 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
|
6313 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
|
6314 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6315 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6316 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6317 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
|
6318 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
|
6319 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
|
6320 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
|
6321 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
|
6322 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6323 if( decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp], 15) < 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
|
6324 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
|
6325 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6326 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6327 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6328 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
|
6329 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
|
6330 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
|
6331 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6332 } else { |
2315 | 6333 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6334 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6335 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6336 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6337 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
|
6338 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6339 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6340 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
|
6341 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
|
6342 |
3316 | 6343 if(MB_MBAFF){ |
6344 h->ref_count[0] >>= 1; | |
6345 h->ref_count[1] >>= 1; | |
6346 } | |
6347 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6348 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
|
6349 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6350 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6351 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6352 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
|
6353 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
|
6354 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
|
6355 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
|
6356 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
|
6357 |
2633 | 6358 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
|
6359 int8_t tc[4]; |
2633 | 6360 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
|
6361 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6362 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6363 } else { | |
6364 /* 16px edge length, because bS=4 is triggered by being at | |
6365 * the edge of an intra MB, so all 4 bS are the same */ | |
6366 for( d = 0; d < 16; d++ ) { | |
1898 | 6367 const int p0 = pix[-1]; |
6368 const int p1 = pix[-2]; | |
6369 const int p2 = pix[-3]; | |
6370 | |
6371 const int q0 = pix[0]; | |
6372 const int q1 = pix[1]; | |
6373 const int q2 = pix[2]; | |
6374 | |
4001 | 6375 if( FFABS( p0 - q0 ) < alpha && |
6376 FFABS( p1 - p0 ) < beta && | |
6377 FFABS( q1 - q0 ) < beta ) { | |
6378 | |
6379 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6380 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6381 { |
6382 const int p3 = pix[-4]; | |
6383 /* p0', p1', p2' */ | |
6384 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6385 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6386 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6387 } else { | |
6388 /* p0' */ | |
6389 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6390 } | |
4001 | 6391 if( FFABS( q2 - q0 ) < beta) |
1898 | 6392 { |
6393 const int q3 = pix[3]; | |
6394 /* q0', q1', q2' */ | |
6395 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6396 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6397 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6398 } else { | |
6399 /* q0' */ | |
6400 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6401 } | |
6402 }else{ | |
6403 /* p0', q0' */ | |
6404 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6405 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6406 } | |
4600 | 6407 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
|
6408 } |
1898 | 6409 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
|
6410 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6411 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6412 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6413 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6414 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6415 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
|
6416 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
|
6417 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
|
6418 |
2633 | 6419 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
|
6420 int8_t tc[4]; |
2633 | 6421 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
|
6422 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6423 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6424 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6425 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
|
6426 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6427 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6428 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6429 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
|
6430 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6431 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
|
6432 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6433 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6434 int beta; |
2967 | 6435 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6436 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6437 int bS_index = (i >> 1); |
3316 | 6438 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6439 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6440 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6441 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6442 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6443 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6444 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6445 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6446 |
3316 | 6447 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
|
6448 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
|
6449 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
|
6450 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
|
6451 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6452 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
|
6453 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
|
6454 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6455 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6456 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6457 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6458 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6459 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6460 |
4001 | 6461 if( FFABS( p0 - q0 ) < alpha && |
6462 FFABS( p1 - p0 ) < beta && | |
6463 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6464 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6465 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6466 |
4001 | 6467 if( FFABS( p2 - p0 ) < beta ) { |
4594 | 6468 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
|
6469 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6470 } |
4001 | 6471 if( FFABS( q2 - q0 ) < beta ) { |
4594 | 6472 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
|
6473 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6474 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6475 |
4594 | 6476 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
6477 pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ | |
6478 pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ | |
4600 | 6479 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
|
6480 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6481 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6482 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6483 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6484 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6485 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6486 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6487 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6488 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6489 |
4001 | 6490 if( FFABS( p0 - q0 ) < alpha && |
6491 FFABS( p1 - p0 ) < beta && | |
6492 FFABS( q1 - q0 ) < beta ) { | |
6493 | |
6494 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6495 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6496 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6497 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6498 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6499 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
|
6500 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
|
6501 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
|
6502 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6503 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6504 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
|
6505 } |
4001 | 6506 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6507 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6508 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6509 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6510 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
|
6511 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
|
6512 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
|
6513 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6514 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6515 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
|
6516 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6517 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6518 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6519 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
|
6520 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
|
6521 } |
4600 | 6522 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
|
6523 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6524 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6525 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6526 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6527 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
|
6528 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6529 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
|
6530 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6531 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6532 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6533 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6534 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6535 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6536 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6537 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6538 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6539 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6540 |
3316 | 6541 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
|
6542 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
|
6543 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
|
6544 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6545 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6546 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
|
6547 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
|
6548 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6549 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6550 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6551 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6552 |
4001 | 6553 if( FFABS( p0 - q0 ) < alpha && |
6554 FFABS( p1 - p0 ) < beta && | |
6555 FFABS( q1 - q0 ) < beta ) { | |
4594 | 6556 const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
6557 | |
6558 pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */ | |
6559 pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */ | |
4600 | 6560 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
|
6561 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6562 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6563 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6564 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6565 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6566 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6567 |
4001 | 6568 if( FFABS( p0 - q0 ) < alpha && |
6569 FFABS( p1 - p0 ) < beta && | |
6570 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6571 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6572 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
|
6573 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ |
4600 | 6574 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
|
6575 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6576 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6577 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6578 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6579 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6580 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
|
6581 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
|
6582 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
|
6583 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
|
6584 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
|
6585 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
|
6586 |
2633 | 6587 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
|
6588 int8_t tc[4]; |
2633 | 6589 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
|
6590 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6591 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6592 } else { | |
6593 /* 16px edge length, see filter_mb_edgev */ | |
6594 for( d = 0; d < 16; d++ ) { | |
1898 | 6595 const int p0 = pix[-1*pix_next]; |
6596 const int p1 = pix[-2*pix_next]; | |
6597 const int p2 = pix[-3*pix_next]; | |
6598 const int q0 = pix[0]; | |
6599 const int q1 = pix[1*pix_next]; | |
6600 const int q2 = pix[2*pix_next]; | |
6601 | |
4001 | 6602 if( FFABS( p0 - q0 ) < alpha && |
6603 FFABS( p1 - p0 ) < beta && | |
6604 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6605 |
6606 const int p3 = pix[-4*pix_next]; | |
6607 const int q3 = pix[ 3*pix_next]; | |
6608 | |
4001 | 6609 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6610 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6611 /* p0', p1', p2' */ |
6612 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6613 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6614 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6615 } else { | |
6616 /* p0' */ | |
6617 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6618 } | |
4001 | 6619 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6620 /* q0', q1', q2' */ |
6621 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6622 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6623 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6624 } else { | |
6625 /* q0' */ | |
6626 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6627 } | |
6628 }else{ | |
6629 /* p0', q0' */ | |
6630 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6631 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6632 } | |
4600 | 6633 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
|
6634 } |
1898 | 6635 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
|
6636 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6637 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6638 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6639 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6640 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6641 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6642 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
|
6643 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
|
6644 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
|
6645 |
2633 | 6646 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
|
6647 int8_t tc[4]; |
2633 | 6648 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
|
6649 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6650 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6651 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6652 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
|
6653 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6654 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6655 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6656 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
|
6657 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6658 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6659 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6660 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6661 if(mb_x==0 || mb_y==0 || !s->dsp.h264_loop_filter_strength) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6662 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
|
6663 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6664 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6665 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6666 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6667 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6668 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6669 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6670 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6671 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6672 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6673 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6674 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6675 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6676 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6677 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6678 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 6679 qp_thresh = 15 - h->slice_alpha_c0_offset; |
6680 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
6681 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
6682 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6683 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6684 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6685 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6686 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6687 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6688 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6689 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6690 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6691 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6692 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6693 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6694 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6695 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6696 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6697 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6698 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6699 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6700 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6701 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6702 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6703 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6704 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6705 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6706 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6707 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6708 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6709 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6710 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6711 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6712 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6713 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 6714 int edges; |
6715 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
6716 edges = 4; | |
6717 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
6718 } else { | |
6719 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
6720 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
6721 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
6722 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
6723 ? 3 : 0; | |
6724 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
6725 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
6726 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
6727 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
6728 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6729 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6730 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6731 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6732 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6733 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6734 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6735 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6736 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
|
6737 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6738 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
|
6739 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
|
6740 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6741 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6742 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6743 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6744 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6745 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6746 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6747 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6748 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6749 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6750 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6751 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6752 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6753 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6754 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6755 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6756 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6757 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6758 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6759 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6760 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6761 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6762 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6763 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6764 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
|
6765 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
|
6766 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 6767 const int mb_type = s->current_picture.mb_type[mb_xy]; |
6768 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
|
6769 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
|
6770 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
6771 /* 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
|
6772 * 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
|
6773 * frame numbers, not indices. */ |
3316 | 6774 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
6775 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
|
6776 |
3101 | 6777 //for sufficiently low qp, filtering wouldn't do anything |
6778 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 6779 if(!FRAME_MBAFF){ |
3101 | 6780 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
6781 int qp = s->current_picture.qscale_table[mb_xy]; | |
6782 if(qp <= qp_thresh | |
6783 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
6784 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
6785 return; | |
6786 } | |
6787 } | |
6788 | |
3316 | 6789 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6790 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6791 && 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
|
6792 // and current and left pair do not have the same interlaced type |
3316 | 6793 && (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
|
6794 // 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
|
6795 && (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
|
6796 /* 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
|
6797 * 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
|
6798 */ |
3316 | 6799 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
6800 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
|
6801 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6802 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6803 int chroma_qp[2]; |
3316 | 6804 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
|
6805 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6806 first_vertical_edge_done = 1; |
3316 | 6807 |
6808 if( IS_INTRA(mb_type) ) | |
6809 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
6810 else { | |
6811 for( i = 0; i < 8; i++ ) { | |
6812 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
6813 | |
6814 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
6815 bS[i] = 4; | |
6816 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
6817 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
6818 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
6819 bS[i] = 2; | |
6820 else | |
6821 bS[i] = 1; | |
6822 } | |
6823 } | |
6824 | |
6825 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
6826 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
6827 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
6828 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
6829 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
6830 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
6831 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
6832 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
6833 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
6834 | |
6835 /* Filter edge */ | |
4600 | 6836 tprintf(s->avctx, "filter mb:%d/%d MBAFF, QPy:%d/%d, QPc:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], chroma_qp[0], chroma_qp[1], linesize, uvlinesize); |
6837 { int i; for (i = 0; i < 8; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); } | |
3316 | 6838 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); |
6839 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
6840 filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, chroma_qp ); | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6841 } |
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
|
6842 /* 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
|
6843 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
|
6844 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6845 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 6847 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 6848 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
6849 | |
3101 | 6850 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
6851 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 6852 // how often to recheck mv-based bS when iterating between edges |
6853 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
6854 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
6855 // how often to recheck mv-based bS when iterating along each edge | |
6856 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
6857 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6858 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6859 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6860 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6861 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6862 |
2454 | 6863 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
|
6864 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
|
6865 |
3316 | 6866 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
6867 && !IS_INTERLACED(mb_type) | |
6868 && IS_INTERLACED(mbm_type) | |
6869 ) { | |
6870 // This is a special case in the norm where the filtering must | |
6871 // be done twice (one each of the field) even if we are in a | |
6872 // frame macroblock. | |
6873 // | |
6874 static const int nnz_idx[4] = {4,5,6,3}; | |
6875 unsigned int tmp_linesize = 2 * linesize; | |
6876 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
6877 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
6878 int qp, chroma_qp; | |
6879 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6880 int16_t bS[4]; |
3316 | 6881 |
6882 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
6883 if( IS_INTRA(mb_type) || | |
6884 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
6885 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
6886 } else { | |
6887 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
6888 for( i = 0; i < 4; i++ ) { | |
6889 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
6890 mbn_nnz[nnz_idx[i]] != 0 ) | |
6891 bS[i] = 2; | |
6892 else | |
6893 bS[i] = 1; | |
6894 } | |
6895 } | |
6896 // Do not use s->qscale as luma quantizer because it has not the same | |
6897 // value in IPCM macroblocks. | |
6898 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
4600 | 6899 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); |
6900 { int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); } | |
3316 | 6901 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); |
6902 chroma_qp = ( h->chroma_qp + | |
6903 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
6904 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
6905 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
6906 } | |
6907 | |
6908 start = 1; | |
6909 } | |
6910 | |
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
|
6911 /* Calculate bS */ |
2924 | 6912 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6913 /* mbn_xy: neighbor macroblock */ |
2924 | 6914 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
6915 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6916 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
|
6917 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
|
6918 |
2924 | 6919 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 6920 continue; |
6921 | |
2924 | 6922 if( IS_INTRA(mb_type) || |
6923 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6924 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6925 if (edge == 0) { |
2924 | 6926 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 6927 || ((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
|
6928 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6929 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6930 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6931 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6932 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6933 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6934 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6935 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6936 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
|
6937 } else { |
2924 | 6938 int i, l; |
6939 int mv_done; | |
6940 | |
6941 if( edge & mask_edge ) { | |
6942 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
6943 mv_done = 1; | |
6944 } | |
3316 | 6945 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
6946 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
6947 mv_done = 1; | |
6948 } | |
2924 | 6949 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
6950 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
6951 int bn_idx= b_idx - (dir ? 8:1); | |
6952 int v = 0; | |
6953 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
6954 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 6955 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
6956 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 6957 } |
6958 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
6959 mv_done = 1; | |
6960 } | |
6961 else | |
6962 mv_done = 0; | |
6963 | |
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
|
6964 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
|
6965 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
|
6966 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
|
6967 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
|
6968 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
|
6969 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6970 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 6971 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
|
6972 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
|
6973 } |
2924 | 6974 else if(!mv_done) |
2523 | 6975 { |
6976 bS[i] = 0; | |
6977 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
|
6978 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 6979 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
6980 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 6981 bS[i] = 1; |
6982 break; | |
6983 } | |
6984 } | |
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
|
6985 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6986 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6987 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
6988 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
|
6989 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
|
6990 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6991 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6992 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6993 // 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
|
6994 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6995 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; |
4600 | 6996 //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]); |
6997 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); | |
6998 { 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
|
6999 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
|
7000 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7001 if( (edge&1) == 0 ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7002 int chroma_qp = ( h->chroma_qp + |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7003 get_chroma_qp( h->pps.chroma_qp_index_offset, 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
|
7004 filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_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
|
7005 filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_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
|
7006 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7007 } 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
|
7008 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7009 if( (edge&1) == 0 ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7010 int chroma_qp = ( h->chroma_qp + |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7011 get_chroma_qp( h->pps.chroma_qp_index_offset, 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
|
7012 filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_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
|
7013 filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_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
|
7014 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7015 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7016 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7017 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7018 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7019 |
1168 | 7020 static int decode_slice(H264Context *h){ |
7021 MpegEncContext * const s = &h->s; | |
7022 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7023 | |
7024 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
|
7025 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7026 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
|
7027 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
|
7028 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7029 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7030 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
|
7031 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7032 /* 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
|
7033 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
|
7034 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
|
7035 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7036 ( 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
|
7037 /* calculate pre-state */ |
2755 | 7038 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
|
7039 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
|
7040 if( h->slice_type == I_TYPE ) |
4594 | 7041 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
|
7042 else |
4594 | 7043 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
|
7044 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7045 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7046 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
|
7047 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7048 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7049 } |
7050 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7051 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7052 //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
|
7053 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
|
7054 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
|
7055 //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
|
7056 |
2163 | 7057 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
|
7058 |
3316 | 7059 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
|
7060 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
|
7061 |
2163 | 7062 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
|
7063 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7064 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
|
7065 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
|
7066 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7067 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
|
7068 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7069 if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) { |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
7070 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%d)\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
|
7071 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
|
7072 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
|
7073 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7074 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7075 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
|
7076 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
|
7077 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7078 ++s->mb_y; |
3316 | 7079 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7080 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7081 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7082 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7083 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7084 if( eos || s->mb_y >= s->mb_height ) { |
4600 | 7085 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
|
7086 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
|
7087 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
|
7088 } |
1168 | 7089 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7090 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7091 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7092 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7093 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
|
7094 |
2163 | 7095 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
|
7096 |
3316 | 7097 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
|
7098 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
|
7099 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
|
7100 |
2163 | 7101 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
|
7102 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
|
7103 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7104 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7105 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
|
7106 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
|
7107 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
|
7108 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7109 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
|
7110 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7111 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7112 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
|
7113 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
|
7114 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
|
7115 ++s->mb_y; |
3316 | 7116 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7117 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7118 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7119 if(s->mb_y >= s->mb_height){ |
4600 | 7120 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
|
7121 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7122 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
|
7123 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
|
7124 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7125 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
|
7126 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7127 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
|
7128 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7129 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
|
7130 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7131 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7132 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7133 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7134 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
4600 | 7135 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
|
7136 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7137 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); |
7138 | |
7139 return 0; | |
7140 }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
|
7141 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 | 7142 |
7143 return -1; | |
7144 } | |
7145 } | |
7146 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7147 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7148 |
1168 | 7149 #if 0 |
7150 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7151 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7152 int ret= decode_mb(h); | |
2967 | 7153 |
1168 | 7154 hl_decode_mb(h); |
7155 | |
7156 if(ret<0){ | |
3177 | 7157 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7158 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); |
7159 | |
7160 return -1; | |
7161 } | |
2967 | 7162 |
1168 | 7163 if(++s->mb_x >= s->mb_width){ |
7164 s->mb_x=0; | |
7165 if(++s->mb_y >= s->mb_height){ | |
7166 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7167 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); | |
7168 | |
7169 return 0; | |
7170 }else{ | |
7171 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); | |
7172 | |
7173 return -1; | |
7174 } | |
7175 } | |
7176 } | |
2967 | 7177 |
1168 | 7178 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7179 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7180 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); | |
7181 | |
7182 return 0; | |
7183 }else{ | |
7184 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); | |
7185 | |
7186 return -1; | |
7187 } | |
7188 } | |
7189 } | |
7190 s->mb_x=0; | |
7191 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7192 } | |
7193 #endif | |
7194 return -1; //not reached | |
7195 } | |
7196 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7197 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
|
7198 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7199 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7200 int e, build, i; |
2967 | 7201 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7202 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7203 return -1; |
2967 | 7204 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7205 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
|
7206 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
|
7207 } |
2967 | 7208 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7209 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7210 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
|
7211 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7212 h->x264_build= build; |
2967 | 7213 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7214 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
|
7215 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
|
7216 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7217 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7218 skip_bits(&s->gb, 8); |
2967 | 7219 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7220 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7221 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7222 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7223 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7224 MpegEncContext * const s = &h->s; |
2967 | 7225 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7226 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
|
7227 int size, type; |
2967 | 7228 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7229 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7230 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7231 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7232 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7233 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7234 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7235 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7236 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7237 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7238 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7239 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7240 case 5: |
3318 | 7241 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
|
7242 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7243 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7244 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7245 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7246 } |
2967 | 7247 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7248 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7249 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7250 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7251 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7252 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7253 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7254 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7255 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
|
7256 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7257 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7258 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
|
7259 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
|
7260 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
|
7261 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
|
7262 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
|
7263 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
|
7264 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
|
7265 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7266 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
|
7267 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
|
7268 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
|
7269 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
|
7270 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7271 |
1168 | 7272 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7273 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7274 int aspect_ratio_info_present_flag; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7275 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
|
7276 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7277 |
7278 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7279 |
1168 | 7280 if( aspect_ratio_info_present_flag ) { |
7281 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7282 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7283 sps->sar.num= get_bits(&s->gb, 16); |
7284 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
|
7285 }else if(aspect_ratio_idc < 14){ |
1548 | 7286 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7287 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7288 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7289 return -1; |
7290 } | |
7291 }else{ | |
2967 | 7292 sps->sar.num= |
1548 | 7293 sps->sar.den= 0; |
1168 | 7294 } |
7295 // 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
|
7296 |
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
|
7297 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
|
7298 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
|
7299 } |
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
|
7300 |
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
|
7301 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
|
7302 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
|
7303 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
|
7304 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
|
7305 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
|
7306 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
|
7307 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
|
7308 } |
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
|
7309 } |
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
|
7310 |
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
|
7311 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
|
7312 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
|
7313 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
|
7314 } |
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
|
7315 |
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
|
7316 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
|
7317 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
|
7318 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
|
7319 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
|
7320 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
|
7321 } |
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
|
7322 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7323 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
|
7324 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
|
7325 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7326 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
|
7327 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
|
7328 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7329 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
|
7330 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
|
7331 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
|
7332 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7333 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
|
7334 if(sps->bitstream_restriction_flag){ |
4389 | 7335 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
|
7336 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
|
7337 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
|
7338 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
|
7339 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
|
7340 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
4389 | 7341 num_reorder_frames= get_ue_golomb(&s->gb); |
7342 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/ | |
7343 | |
7344 if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){ | |
7345 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames); | |
7346 return -1; | |
7347 } | |
7348 | |
7349 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
|
7350 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7351 |
1168 | 7352 return 0; |
7353 } | |
7354 | |
3004 | 7355 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7356 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7357 MpegEncContext * const s = &h->s; |
7358 int i, last = 8, next = 8; | |
7359 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7360 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7361 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7362 else |
7363 for(i=0;i<size;i++){ | |
7364 if(next) | |
7365 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7366 if(!i && !next){ /* matrix not written, we use the preset one */ |
7367 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7368 break; |
7369 } | |
7370 last = factors[scan[i]] = next ? next : last; | |
7371 } | |
7372 } | |
7373 | |
7374 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7375 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7376 MpegEncContext * const s = &h->s; | |
7377 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7378 const uint8_t *fallback[4] = { | |
7379 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7380 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7381 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7382 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7383 }; | |
7384 if(get_bits1(&s->gb)){ | |
7385 sps->scaling_matrix_present |= is_sps; | |
3004 | 7386 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7387 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7388 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7389 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7390 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7391 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7392 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7393 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7394 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7395 } |
7396 } else if(fallback_sps) { | |
7397 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7398 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7399 } | |
7400 } | |
7401 | |
1168 | 7402 static inline int decode_seq_parameter_set(H264Context *h){ |
7403 MpegEncContext * const s = &h->s; | |
1371 | 7404 int profile_idc, level_idc; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7405 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
|
7406 int i; |
1168 | 7407 SPS *sps; |
2967 | 7408 |
1168 | 7409 profile_idc= get_bits(&s->gb, 8); |
1371 | 7410 get_bits1(&s->gb); //constraint_set0_flag |
7411 get_bits1(&s->gb); //constraint_set1_flag | |
7412 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7413 get_bits1(&s->gb); //constraint_set3_flag |
7414 get_bits(&s->gb, 4); // reserved | |
1168 | 7415 level_idc= get_bits(&s->gb, 8); |
7416 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7417 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7418 if (sps_id >= MAX_SPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7419 // ok it has gone out of hand, someone is sending us bad stuff. |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7420 av_log(h->s.avctx, AV_LOG_ERROR, "illegal sps_id (%d)\n", sps_id); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7421 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7422 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7423 |
1168 | 7424 sps= &h->sps_buffer[ sps_id ]; |
7425 sps->profile_idc= profile_idc; | |
7426 sps->level_idc= level_idc; | |
2312 | 7427 |
2755 | 7428 if(sps->profile_idc >= 100){ //high profile |
7429 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7430 get_bits1(&s->gb); //residual_color_transform_flag | |
7431 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7432 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7433 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7434 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7435 }else | |
7436 sps->scaling_matrix_present = 0; | |
2755 | 7437 |
1168 | 7438 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7439 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7440 |
1168 | 7441 if(sps->poc_type == 0){ //FIXME #define |
7442 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7443 } else if(sps->poc_type == 1){//FIXME #define | |
7444 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7445 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7446 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
|
7447 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7448 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7449 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
|
7450 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
|
7451 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7452 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7453 sps->poc_cycle_length= tmp; |
2967 | 7454 |
1168 | 7455 for(i=0; i<sps->poc_cycle_length; i++) |
7456 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
|
7457 }else if(sps->poc_type != 2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7458 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7459 return -1; |
7460 } | |
7461 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7462 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7463 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
|
7464 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
|
7465 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7466 sps->ref_frame_count= tmp; |
1371 | 7467 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
|
7468 mb_width= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7469 mb_height= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7470 if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7471 avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7472 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n"); |
2422 | 7473 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7474 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7475 sps->mb_width = mb_width; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7476 sps->mb_height= mb_height; |
2422 | 7477 |
1168 | 7478 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7479 if(!sps->frame_mbs_only_flag) | |
7480 sps->mb_aff= get_bits1(&s->gb); | |
7481 else | |
7482 sps->mb_aff= 0; | |
7483 | |
7484 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7485 | |
3316 | 7486 #ifndef ALLOW_INTERLACE |
7487 if(sps->mb_aff) | |
3954 | 7488 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7489 #endif |
7490 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7491 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7492 | |
1371 | 7493 sps->crop= get_bits1(&s->gb); |
7494 if(sps->crop){ | |
7495 sps->crop_left = get_ue_golomb(&s->gb); | |
7496 sps->crop_right = get_ue_golomb(&s->gb); | |
7497 sps->crop_top = get_ue_golomb(&s->gb); | |
7498 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7499 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
|
7500 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7501 } |
7502 }else{ | |
2967 | 7503 sps->crop_left = |
7504 sps->crop_right = | |
7505 sps->crop_top = | |
1371 | 7506 sps->crop_bottom= 0; |
7507 } | |
7508 | |
1168 | 7509 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7510 if( sps->vui_parameters_present_flag ) | |
7511 decode_vui_parameters(h, sps); | |
2967 | 7512 |
1168 | 7513 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
|
7514 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 | 7515 sps_id, sps->profile_idc, sps->level_idc, |
7516 sps->poc_type, | |
7517 sps->ref_frame_count, | |
7518 sps->mb_width, sps->mb_height, | |
7519 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7520 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7521 sps->crop_left, sps->crop_right, |
7522 sps->crop_top, sps->crop_bottom, | |
1168 | 7523 sps->vui_parameters_present_flag ? "VUI" : "" |
7524 ); | |
7525 } | |
7526 return 0; | |
7527 } | |
7528 | |
2755 | 7529 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7530 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7531 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
|
7532 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7533 |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7534 if(pps_id>=MAX_PPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7535 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7536 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7537 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7538 pps = &h->pps_buffer[pps_id]; |
2967 | 7539 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7540 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7541 if(tmp>=MAX_SPS_COUNT){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7542 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
|
7543 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7544 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7545 pps->sps_id= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7546 |
1168 | 7547 pps->cabac= get_bits1(&s->gb); |
7548 pps->pic_order_present= get_bits1(&s->gb); | |
7549 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7550 if(pps->slice_group_count > 1 ){ | |
7551 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
|
7552 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7553 switch(pps->mb_slice_group_map_type){ |
7554 case 0: | |
7555 #if 0 | |
7556 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7557 | run_length[ i ] |1 |ue(v) | | |
7558 #endif | |
7559 break; | |
7560 case 2: | |
7561 #if 0 | |
7562 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7563 |{ | | | | |
7564 | top_left_mb[ i ] |1 |ue(v) | | |
7565 | bottom_right_mb[ i ] |1 |ue(v) | | |
7566 | } | | | | |
7567 #endif | |
7568 break; | |
7569 case 3: | |
7570 case 4: | |
7571 case 5: | |
7572 #if 0 | |
7573 | slice_group_change_direction_flag |1 |u(1) | | |
7574 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7575 #endif | |
7576 break; | |
7577 case 6: | |
7578 #if 0 | |
7579 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7580 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7581 |) | | | | |
7582 | slice_group_id[ i ] |1 |u(v) | | |
7583 #endif | |
1214 | 7584 break; |
1168 | 7585 } |
7586 } | |
7587 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7588 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4531 | 7589 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
|
7590 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
|
7591 pps->ref_count[0]= pps->ref_count[1]= 1; |
1168 | 7592 return -1; |
7593 } | |
2967 | 7594 |
1168 | 7595 pps->weighted_pred= get_bits1(&s->gb); |
7596 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7597 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7598 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7599 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7600 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7601 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7602 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7603 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7604 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
|
7605 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7606 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7607 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7608 |
7609 if(get_bits_count(&s->gb) < bit_length){ | |
7610 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7611 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7612 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7613 } | |
2967 | 7614 |
1168 | 7615 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
|
7616 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n", |
1168 | 7617 pps_id, pps->sps_id, |
7618 pps->cabac ? "CABAC" : "CAVLC", | |
7619 pps->slice_group_count, | |
7620 pps->ref_count[0], pps->ref_count[1], | |
7621 pps->weighted_pred ? "weighted" : "", | |
7622 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7623 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7624 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7625 pps->redundant_pic_cnt_present ? "REDU" : "", |
7626 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7627 ); |
7628 } | |
2967 | 7629 |
1168 | 7630 return 0; |
7631 } | |
7632 | |
7633 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ | |
7634 MpegEncContext * const s = &h->s; | |
7635 AVCodecContext * const avctx= s->avctx; | |
7636 int buf_index=0; | |
1322 | 7637 #if 0 |
1168 | 7638 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7639 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7640 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 7641 } |
7642 #endif | |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7643 if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){ |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7644 h->slice_num = 0; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7645 s->current_picture_ptr= NULL; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7646 } |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7647 |
1168 | 7648 for(;;){ |
7649 int consumed; | |
7650 int dst_length; | |
7651 int bit_length; | |
7652 uint8_t *ptr; | |
2227 | 7653 int i, nalsize = 0; |
2967 | 7654 |
2227 | 7655 if(h->is_avc) { |
7656 if(buf_index >= buf_size) break; | |
7657 nalsize = 0; | |
7658 for(i = 0; i < h->nal_length_size; i++) | |
7659 nalsize = (nalsize << 8) | buf[buf_index++]; | |
4886
7eba8b456a3f
prevent going out of the buffer if the nal size does not fit in the buffer.
gpoirier
parents:
4882
diff
changeset
|
7660 if(nalsize <= 1 || (nalsize+buf_index > buf_size)){ |
3126 | 7661 if(nalsize == 1){ |
7662 buf_index++; | |
7663 continue; | |
7664 }else{ | |
7665 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
7666 break; | |
7667 } | |
7668 } | |
2227 | 7669 } else { |
1168 | 7670 // start code prefix search |
7671 for(; buf_index + 3 < buf_size; buf_index++){ | |
4795 | 7672 // This should always succeed in the first iteration. |
1168 | 7673 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) |
7674 break; | |
7675 } | |
2967 | 7676 |
1168 | 7677 if(buf_index+3 >= buf_size) break; |
2967 | 7678 |
1168 | 7679 buf_index+=3; |
2967 | 7680 } |
7681 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
7682 ptr= decode_nal(h, 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
|
7683 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
|
7684 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7685 } |
4829
e3161603a048
Remove a NAL unit's trailing zero bytes even when dst_length is 1.
diego
parents:
4828
diff
changeset
|
7686 while(ptr[dst_length - 1] == 0 && dst_length > 0) |
3341 | 7687 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
|
7688 bit_length= !dst_length ? 0 : (8*dst_length - decode_rbsp_trailing(h, ptr + dst_length - 1)); |
1168 | 7689 |
7690 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
7691 av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", h->nal_unit_type, buf_index, buf_size, dst_length); |
1168 | 7692 } |
2967 | 7693 |
2227 | 7694 if (h->is_avc && (nalsize != consumed)) |
7695 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
7696 | |
1168 | 7697 buf_index += consumed; |
7698 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7699 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 7700 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 7701 continue; |
2967 | 7702 |
1168 | 7703 switch(h->nal_unit_type){ |
7704 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7705 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 7706 case NAL_SLICE: |
7707 init_get_bits(&s->gb, ptr, bit_length); | |
7708 h->intra_gb_ptr= | |
7709 h->inter_gb_ptr= &s->gb; | |
7710 s->data_partitioning = 0; | |
2967 | 7711 |
2771 | 7712 if(decode_slice_header(h) < 0){ |
7713 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
7714 break; | |
7715 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
7716 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 7717 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 7718 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
7719 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
7720 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
7721 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 7722 decode_slice(h); |
7723 break; | |
7724 case NAL_DPA: | |
7725 init_get_bits(&s->gb, ptr, bit_length); | |
7726 h->intra_gb_ptr= | |
7727 h->inter_gb_ptr= NULL; | |
7728 s->data_partitioning = 1; | |
2967 | 7729 |
2771 | 7730 if(decode_slice_header(h) < 0){ |
7731 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
7732 } | |
1168 | 7733 break; |
7734 case NAL_DPB: | |
7735 init_get_bits(&h->intra_gb, ptr, bit_length); | |
7736 h->intra_gb_ptr= &h->intra_gb; | |
7737 break; | |
7738 case NAL_DPC: | |
7739 init_get_bits(&h->inter_gb, ptr, bit_length); | |
7740 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 7741 |
2967 | 7742 if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning |
4354
d18568fb0187
Avoid calling decode_slice when context_initialized is not set.
reimar
parents:
4344
diff
changeset
|
7743 && s->context_initialized |
2793 | 7744 && s->hurry_up < 5 |
7745 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
7746 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
7747 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
7748 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 7749 decode_slice(h); |
7750 break; | |
7751 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7752 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
|
7753 decode_sei(h); |
1168 | 7754 break; |
7755 case NAL_SPS: | |
7756 init_get_bits(&s->gb, ptr, bit_length); | |
7757 decode_seq_parameter_set(h); | |
2967 | 7758 |
1168 | 7759 if(s->flags& CODEC_FLAG_LOW_DELAY) |
7760 s->low_delay=1; | |
2967 | 7761 |
2538 | 7762 if(avctx->has_b_frames < 2) |
7763 avctx->has_b_frames= !s->low_delay; | |
1168 | 7764 break; |
7765 case NAL_PPS: | |
7766 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 7767 |
2755 | 7768 decode_picture_parameter_set(h, bit_length); |
1168 | 7769 |
7770 break; | |
2960 | 7771 case NAL_AUD: |
7772 case NAL_END_SEQUENCE: | |
7773 case NAL_END_STREAM: | |
7774 case NAL_FILLER_DATA: | |
7775 case NAL_SPS_EXT: | |
7776 case NAL_AUXILIARY_SLICE: | |
1168 | 7777 break; |
2979 | 7778 default: |
7779 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 7780 } |
7781 } | |
7782 | |
1168 | 7783 return buf_index; |
7784 } | |
7785 | |
7786 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7787 * returns the number of bytes consumed for building the current frame |
1168 | 7788 */ |
7789 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
7790 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
7791 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7792 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 7793 |
1168 | 7794 return pos; |
7795 }else{ | |
7796 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
7797 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
7798 | |
7799 return pos; | |
7800 } | |
7801 } | |
7802 | |
2967 | 7803 static int decode_frame(AVCodecContext *avctx, |
1168 | 7804 void *data, int *data_size, |
7805 uint8_t *buf, int buf_size) | |
7806 { | |
7807 H264Context *h = avctx->priv_data; | |
7808 MpegEncContext *s = &h->s; | |
2967 | 7809 AVFrame *pict = data; |
1168 | 7810 int buf_index; |
2967 | 7811 |
1168 | 7812 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
7813 s->flags2= avctx->flags2; |
1168 | 7814 |
7815 /* no supplementary picture */ | |
7816 if (buf_size == 0) { | |
4556 | 7817 Picture *out; |
7818 int i, out_idx; | |
7819 | |
7820 //FIXME factorize this with the output code below | |
7821 out = h->delayed_pic[0]; | |
7822 out_idx = 0; | |
7823 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++) | |
7824 if(h->delayed_pic[i]->poc < out->poc){ | |
7825 out = h->delayed_pic[i]; | |
7826 out_idx = i; | |
7827 } | |
7828 | |
7829 for(i=out_idx; h->delayed_pic[i]; i++) | |
7830 h->delayed_pic[i] = h->delayed_pic[i+1]; | |
7831 | |
7832 if(out){ | |
7833 *data_size = sizeof(AVFrame); | |
7834 *pict= *(AVFrame*)out; | |
7835 } | |
7836 | |
1168 | 7837 return 0; |
7838 } | |
2967 | 7839 |
1168 | 7840 if(s->flags&CODEC_FLAG_TRUNCATED){ |
4975 | 7841 int next= ff_h264_find_frame_end(h, buf, buf_size); |
2967 | 7842 |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4908
diff
changeset
|
7843 if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 ) |
1168 | 7844 return buf_size; |
7845 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
7846 } | |
7847 | |
2227 | 7848 if(h->is_avc && !h->got_avcC) { |
7849 int i, cnt, nalsize; | |
7850 unsigned char *p = avctx->extradata; | |
7851 if(avctx->extradata_size < 7) { | |
7852 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
7853 return -1; | |
7854 } | |
7855 if(*p != 1) { | |
7856 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
7857 return -1; | |
7858 } | |
7859 /* sps and pps in the avcC always have length coded with 2 bytes, | |
7860 so put a fake nal_length_size = 2 while parsing them */ | |
7861 h->nal_length_size = 2; | |
7862 // Decode sps from avcC | |
7863 cnt = *(p+5) & 0x1f; // Number of sps | |
7864 p += 6; | |
7865 for (i = 0; i < cnt; i++) { | |
4364 | 7866 nalsize = AV_RB16(p) + 2; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7867 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 7868 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
7869 return -1; | |
7870 } | |
7871 p += nalsize; | |
2967 | 7872 } |
2227 | 7873 // Decode pps from avcC |
7874 cnt = *(p++); // Number of pps | |
7875 for (i = 0; i < cnt; i++) { | |
4364 | 7876 nalsize = AV_RB16(p) + 2; |
2227 | 7877 if(decode_nal_units(h, p, nalsize) != nalsize) { |
7878 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
7879 return -1; | |
7880 } | |
7881 p += nalsize; | |
2967 | 7882 } |
2227 | 7883 // Now store right nal length size, that will be use to parse all other nals |
7884 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
7885 // Do not reparse avcC | |
7886 h->got_avcC = 1; | |
7887 } | |
7888 | |
4507
b80c704183e9
always decode extradata when of non-avc stream (like RTSP)
gpoirier
parents:
4391
diff
changeset
|
7889 if(avctx->frame_number==0 && !h->is_avc && s->avctx->extradata_size){ |
2967 | 7890 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 7891 return -1; |
7892 } | |
7893 | |
7894 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 7895 if(buf_index < 0) |
1168 | 7896 return -1; |
7897 | |
4620 | 7898 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){ |
7899 av_log(avctx, AV_LOG_ERROR, "no frame!\n"); | |
7900 return -1; | |
7901 } | |
7902 | |
4616
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7903 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
|
7904 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
|
7905 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
|
7906 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
|
7907 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
|
7908 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7909 s->mb_y= 0; |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7910 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7911 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
|
7912 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
|
7913 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7914 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
|
7915 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
|
7916 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
|
7917 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
|
7918 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
|
7919 } |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7920 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
|
7921 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
|
7922 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7923 ff_er_frame_end(s); |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7924 |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7925 MPV_frame_end(s); |
8036b117ae26
support feeding individual NAL units to the decoder instead of just complete frames
michael
parents:
4600
diff
changeset
|
7926 |
2967 | 7927 //FIXME do something with unavailable reference frames |
7928 | |
2561 | 7929 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7930 *data_size = sizeof(AVFrame); |
2561 | 7931 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7932 /* 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
|
7933 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7934 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
|
7935 && 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
|
7936 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
|
7937 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7938 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7939 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
7940 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7941 while(h->delayed_pic[pics]) pics++; |
4388 | 7942 |
7943 assert(pics+1 < sizeof(h->delayed_pic) / sizeof(h->delayed_pic[0])); | |
7944 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7945 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
|
7946 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7947 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7948 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
7949 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7950 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
|
7951 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
|
7952 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7953 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7954 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
7955 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7956 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
|
7957 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
|
7958 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7959 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7960 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7961 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7962 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 7963 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
7964 { } | |
7965 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
|
7966 out = prev; |
2923 | 7967 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 7968 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7969 ((!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
|
7970 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7971 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7972 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7973 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7974 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7975 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7976 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7977 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7978 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7979 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
|
7980 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
|
7981 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
|
7982 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
7983 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
7984 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7985 *data_size = 0; |
2561 | 7986 else |
7987 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7988 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
|
7989 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7990 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
|
7991 #endif |
2409 | 7992 |
2937 | 7993 if(out) |
7994 *pict= *(AVFrame*)out; | |
7995 else | |
7996 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
7997 } | |
7998 | |
7999 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
|
8000 ff_print_debug_info(s, pict); |
1168 | 8001 //printf("out %d\n", (int)pict->data[0]); |
8002 #if 0 //? | |
8003 | |
8004 /* Return the Picture timestamp as the frame number */ | |
8005 /* we substract 1 because it is added on utils.c */ | |
8006 avctx->frame_number = s->picture_number - 1; | |
8007 #endif | |
8008 return get_consumed_bytes(s, buf_index, buf_size); | |
8009 } | |
8010 #if 0 | |
8011 static inline void fill_mb_avail(H264Context *h){ | |
8012 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
|
8013 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8014 |
8015 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
|
8016 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
|
8017 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
|
8018 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8019 }else{ |
8020 h->mb_avail[0]= | |
8021 h->mb_avail[1]= | |
8022 h->mb_avail[2]= 0; | |
8023 } | |
8024 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8025 h->mb_avail[4]= 1; //FIXME move out | |
8026 h->mb_avail[5]= 0; //FIXME move out | |
8027 } | |
8028 #endif | |
8029 | |
8030 #if 0 //selftest | |
8031 #define COUNT 8000 | |
8032 #define SIZE (COUNT*40) | |
8033 int main(){ | |
8034 int i; | |
8035 uint8_t temp[SIZE]; | |
8036 PutBitContext pb; | |
8037 GetBitContext gb; | |
8038 // int int_temp[10000]; | |
8039 DSPContext dsp; | |
8040 AVCodecContext avctx; | |
2967 | 8041 |
1168 | 8042 dsputil_init(&dsp, &avctx); |
8043 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8044 init_put_bits(&pb, temp, SIZE); |
1168 | 8045 printf("testing unsigned exp golomb\n"); |
8046 for(i=0; i<COUNT; i++){ | |
8047 START_TIMER | |
8048 set_ue_golomb(&pb, i); | |
8049 STOP_TIMER("set_ue_golomb"); | |
8050 } | |
8051 flush_put_bits(&pb); | |
2967 | 8052 |
1168 | 8053 init_get_bits(&gb, temp, 8*SIZE); |
8054 for(i=0; i<COUNT; i++){ | |
8055 int j, s; | |
2967 | 8056 |
1168 | 8057 s= show_bits(&gb, 24); |
2967 | 8058 |
1168 | 8059 START_TIMER |
8060 j= get_ue_golomb(&gb); | |
8061 if(j != i){ | |
8062 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8063 // return -1; | |
8064 } | |
8065 STOP_TIMER("get_ue_golomb"); | |
8066 } | |
2967 | 8067 |
8068 | |
1524 | 8069 init_put_bits(&pb, temp, SIZE); |
1168 | 8070 printf("testing signed exp golomb\n"); |
8071 for(i=0; i<COUNT; i++){ | |
8072 START_TIMER | |
8073 set_se_golomb(&pb, i - COUNT/2); | |
8074 STOP_TIMER("set_se_golomb"); | |
8075 } | |
8076 flush_put_bits(&pb); | |
2967 | 8077 |
1168 | 8078 init_get_bits(&gb, temp, 8*SIZE); |
8079 for(i=0; i<COUNT; i++){ | |
8080 int j, s; | |
2967 | 8081 |
1168 | 8082 s= show_bits(&gb, 24); |
2967 | 8083 |
1168 | 8084 START_TIMER |
8085 j= get_se_golomb(&gb); | |
8086 if(j != i - COUNT/2){ | |
8087 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8088 // return -1; | |
8089 } | |
8090 STOP_TIMER("get_se_golomb"); | |
8091 } | |
8092 | |
8093 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8094 |
1168 | 8095 DCTELEM block[16]; |
8096 uint8_t src[16], ref[16]; | |
8097 uint64_t error= 0, max_error=0; | |
8098 | |
8099 for(i=0; i<COUNT; i++){ | |
8100 int j; | |
8101 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8102 for(j=0; j<16; j++){ | |
8103 ref[j]= random()%255; | |
8104 src[j]= random()%255; | |
8105 } | |
8106 | |
8107 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8108 |
1168 | 8109 //normalize |
8110 for(j=0; j<16; j++){ | |
8111 // printf("%d ", block[j]); | |
8112 block[j]= block[j]*4; | |
8113 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8114 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8115 } | |
8116 // printf("\n"); | |
2967 | 8117 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8118 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8119 /* for(j=0; j<16; j++){ |
8120 printf("%d ", ref[j]); | |
8121 } | |
8122 printf("\n");*/ | |
2967 | 8123 |
1168 | 8124 for(j=0; j<16; j++){ |
4001 | 8125 int diff= FFABS(src[j] - ref[j]); |
2967 | 8126 |
1168 | 8127 error+= diff*diff; |
8128 max_error= FFMAX(max_error, diff); | |
8129 } | |
8130 } | |
8131 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8132 #if 0 | |
8133 printf("testing quantizer\n"); | |
8134 for(qp=0; qp<52; qp++){ | |
8135 for(i=0; i<16; i++) | |
8136 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8137 |
1168 | 8138 } |
8139 #endif | |
8140 printf("Testing NAL layer\n"); | |
2967 | 8141 |
1168 | 8142 uint8_t bitstream[COUNT]; |
8143 uint8_t nal[COUNT*2]; | |
8144 H264Context h; | |
8145 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8146 |
1168 | 8147 for(i=0; i<COUNT; i++){ |
8148 int zeros= i; | |
8149 int nal_length; | |
8150 int consumed; | |
8151 int out_length; | |
8152 uint8_t *out; | |
8153 int j; | |
2967 | 8154 |
1168 | 8155 for(j=0; j<COUNT; j++){ |
8156 bitstream[j]= (random() % 255) + 1; | |
8157 } | |
2967 | 8158 |
1168 | 8159 for(j=0; j<zeros; j++){ |
8160 int pos= random() % COUNT; | |
8161 while(bitstream[pos] == 0){ | |
8162 pos++; | |
8163 pos %= COUNT; | |
8164 } | |
8165 bitstream[pos]=0; | |
8166 } | |
2967 | 8167 |
1168 | 8168 START_TIMER |
2967 | 8169 |
1168 | 8170 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8171 if(nal_length<0){ | |
8172 printf("encoding failed\n"); | |
8173 return -1; | |
8174 } | |
2967 | 8175 |
1168 | 8176 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8177 | |
8178 STOP_TIMER("NAL") | |
2967 | 8179 |
1168 | 8180 if(out_length != COUNT){ |
8181 printf("incorrect length %d %d\n", out_length, COUNT); | |
8182 return -1; | |
8183 } | |
2967 | 8184 |
1168 | 8185 if(consumed != nal_length){ |
8186 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8187 return -1; | |
8188 } | |
2967 | 8189 |
1168 | 8190 if(memcmp(bitstream, out, COUNT)){ |
8191 printf("missmatch\n"); | |
8192 return -1; | |
8193 } | |
8194 } | |
2967 | 8195 |
1168 | 8196 printf("Testing RBSP\n"); |
2967 | 8197 |
8198 | |
1168 | 8199 return 0; |
8200 } | |
8201 #endif | |
8202 | |
8203 | |
8204 static int decode_end(AVCodecContext *avctx) | |
8205 { | |
8206 H264Context *h = avctx->priv_data; | |
8207 MpegEncContext *s = &h->s; | |
2967 | 8208 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8209 av_freep(&h->rbsp_buffer); |
1168 | 8210 free_tables(h); //FIXME cleanup init stuff perhaps |
8211 MPV_common_end(s); | |
8212 | |
8213 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8214 |
1168 | 8215 return 0; |
8216 } | |
8217 | |
8218 | |
8219 AVCodec h264_decoder = { | |
8220 "h264", | |
8221 CODEC_TYPE_VIDEO, | |
8222 CODEC_ID_H264, | |
8223 sizeof(H264Context), | |
8224 decode_init, | |
8225 NULL, | |
8226 decode_end, | |
8227 decode_frame, | |
2453 | 8228 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8229 .flush= flush_dpb, |
1168 | 8230 }; |
8231 | |
1234 | 8232 #include "svq3.c" |