Mercurial > libavcodec.hg
annotate h264.c @ 4533:dca590e16c43 libavcodec
replace list<2 checks by list<list_count
remove silly ref_count<0 and ref_count==0 checks its impossible for this variable to have such a value
author | michael |
---|---|
date | Fri, 16 Feb 2007 21:42:01 +0000 |
parents | c296efb7575e |
children | a856fe4b80f0 |
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 "common.h" | |
30 #include "dsputil.h" | |
31 #include "avcodec.h" | |
32 #include "mpegvideo.h" | |
33 #include "h264data.h" | |
34 #include "golomb.h" | |
35 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
36 #include "cabac.h" |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
37 |
3284
a224d9752912
don't force asserts in release builds. 2% faster h264.
lorenm
parents:
3219
diff
changeset
|
38 //#undef NDEBUG |
1168 | 39 #include <assert.h> |
40 | |
41 #define interlaced_dct interlaced_dct_is_a_bad_name | |
42 #define mb_intra mb_intra_isnt_initalized_see_mb_type | |
43 | |
44 #define LUMA_DC_BLOCK_INDEX 25 | |
45 #define CHROMA_DC_BLOCK_INDEX 26 | |
46 | |
47 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 | |
48 #define COEFF_TOKEN_VLC_BITS 8 | |
49 #define TOTAL_ZEROS_VLC_BITS 9 | |
50 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 | |
51 #define RUN_VLC_BITS 3 | |
52 #define RUN7_VLC_BITS 6 | |
53 | |
54 #define MAX_SPS_COUNT 32 | |
55 #define MAX_PPS_COUNT 256 | |
56 | |
57 #define MAX_MMCO_COUNT 66 | |
58 | |
3316 | 59 /* Compiling in interlaced support reduces the speed |
60 * of progressive decoding by about 2%. */ | |
61 #define ALLOW_INTERLACE | |
62 | |
63 #ifdef ALLOW_INTERLACE | |
64 #define MB_MBAFF h->mb_mbaff | |
65 #define MB_FIELD h->mb_field_decoding_flag | |
66 #define FRAME_MBAFF h->mb_aff_frame | |
67 #else | |
68 #define MB_MBAFF 0 | |
69 #define MB_FIELD 0 | |
70 #define FRAME_MBAFF 0 | |
71 #undef IS_INTERLACED | |
72 #define IS_INTERLACED(mb_type) 0 | |
73 #endif | |
74 | |
1168 | 75 /** |
76 * Sequence parameter set | |
77 */ | |
78 typedef struct SPS{ | |
2967 | 79 |
1168 | 80 int profile_idc; |
81 int level_idc; | |
2763 | 82 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag |
1168 | 83 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 |
84 int poc_type; ///< pic_order_cnt_type | |
85 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 | |
86 int delta_pic_order_always_zero_flag; | |
87 int offset_for_non_ref_pic; | |
88 int offset_for_top_to_bottom_field; | |
89 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle | |
90 int ref_frame_count; ///< num_ref_frames | |
1371 | 91 int gaps_in_frame_num_allowed_flag; |
1168 | 92 int mb_width; ///< frame_width_in_mbs_minus1 + 1 |
93 int mb_height; ///< frame_height_in_mbs_minus1 + 1 | |
94 int frame_mbs_only_flag; | |
95 int mb_aff; ///<mb_adaptive_frame_field_flag | |
96 int direct_8x8_inference_flag; | |
1371 | 97 int crop; ///< frame_cropping_flag |
98 int crop_left; ///< frame_cropping_rect_left_offset | |
99 int crop_right; ///< frame_cropping_rect_right_offset | |
100 int crop_top; ///< frame_cropping_rect_top_offset | |
101 int crop_bottom; ///< frame_cropping_rect_bottom_offset | |
1168 | 102 int vui_parameters_present_flag; |
1548 | 103 AVRational sar; |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
104 int timing_info_present_flag; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
105 uint32_t num_units_in_tick; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
106 uint32_t time_scale; |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
107 int fixed_frame_rate_flag; |
1168 | 108 short offset_for_ref_frame[256]; //FIXME dyn aloc? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
109 int bitstream_restriction_flag; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
110 int num_reorder_frames; |
2919 | 111 int scaling_matrix_present; |
112 uint8_t scaling_matrix4[6][16]; | |
113 uint8_t scaling_matrix8[2][64]; | |
1168 | 114 }SPS; |
115 | |
116 /** | |
117 * Picture parameter set | |
118 */ | |
119 typedef struct PPS{ | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
120 unsigned int sps_id; |
1168 | 121 int cabac; ///< entropy_coding_mode_flag |
122 int pic_order_present; ///< pic_order_present_flag | |
123 int slice_group_count; ///< num_slice_groups_minus1 + 1 | |
124 int mb_slice_group_map_type; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
125 unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 |
1168 | 126 int weighted_pred; ///< weighted_pred_flag |
127 int weighted_bipred_idc; | |
128 int init_qp; ///< pic_init_qp_minus26 + 26 | |
129 int init_qs; ///< pic_init_qs_minus26 + 26 | |
130 int chroma_qp_index_offset; | |
131 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag | |
132 int constrained_intra_pred; ///< constrained_intra_pred_flag | |
133 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag | |
2755 | 134 int transform_8x8_mode; ///< transform_8x8_mode_flag |
2919 | 135 uint8_t scaling_matrix4[6][16]; |
136 uint8_t scaling_matrix8[2][64]; | |
1168 | 137 }PPS; |
138 | |
139 /** | |
140 * Memory management control operation opcode. | |
141 */ | |
142 typedef enum MMCOOpcode{ | |
143 MMCO_END=0, | |
144 MMCO_SHORT2UNUSED, | |
145 MMCO_LONG2UNUSED, | |
146 MMCO_SHORT2LONG, | |
147 MMCO_SET_MAX_LONG, | |
2967 | 148 MMCO_RESET, |
1168 | 149 MMCO_LONG, |
150 } MMCOOpcode; | |
151 | |
152 /** | |
153 * Memory management control operation. | |
154 */ | |
155 typedef struct MMCO{ | |
156 MMCOOpcode opcode; | |
157 int short_frame_num; | |
158 int long_index; | |
159 } MMCO; | |
160 | |
161 /** | |
162 * H264Context | |
163 */ | |
164 typedef struct H264Context{ | |
165 MpegEncContext s; | |
2967 | 166 int nal_ref_idc; |
1168 | 167 int nal_unit_type; |
168 uint8_t *rbsp_buffer; | |
3066
04b924f8f5a5
warning fixes by Luca Abeni, lucabe72 ##@## email ##.## it
diego
parents:
3063
diff
changeset
|
169 unsigned int rbsp_buffer_size; |
1168 | 170 |
2227 | 171 /** |
172 * Used to parse AVC variant of h264 | |
173 */ | |
174 int is_avc; ///< this flag is != 0 if codec is avc1 | |
175 int got_avcC; ///< flag used to parse avcC data only once | |
176 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) | |
177 | |
1168 | 178 int chroma_qp; //QPc |
179 | |
3316 | 180 int prev_mb_skipped; |
181 int next_mb_skipped; | |
1168 | 182 |
183 //prediction stuff | |
184 int chroma_pred_mode; | |
185 int intra16x16_pred_mode; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
186 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
187 int top_mb_xy; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
188 int left_mb_xy[2]; |
2967 | 189 |
1168 | 190 int8_t intra4x4_pred_mode_cache[5*8]; |
191 int8_t (*intra4x4_pred_mode)[8]; | |
192 void (*pred4x4 [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp? | |
2755 | 193 void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride); |
1168 | 194 void (*pred8x8 [4+3])(uint8_t *src, int stride); |
195 void (*pred16x16[4+3])(uint8_t *src, int stride); | |
196 unsigned int topleft_samples_available; | |
197 unsigned int top_samples_available; | |
198 unsigned int topright_samples_available; | |
199 unsigned int left_samples_available; | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
200 uint8_t (*top_borders[2])[16+2*8]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
201 uint8_t left_border[2*(17+2*9)]; |
1168 | 202 |
203 /** | |
204 * non zero coeff count cache. | |
205 * is 64 if not available. | |
206 */ | |
3089 | 207 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]); |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
208 uint8_t (*non_zero_count)[16]; |
1168 | 209 |
210 /** | |
211 * Motion vector cache. | |
212 */ | |
3089 | 213 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); |
214 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); | |
1168 | 215 #define LIST_NOT_USED -1 //FIXME rename? |
216 #define PART_NOT_AVAILABLE -2 | |
2967 | 217 |
1168 | 218 /** |
219 * is 1 if the specific list MV&references are set to 0,0,-2. | |
220 */ | |
221 int mv_cache_clean[2]; | |
222 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
223 /** |
2755 | 224 * number of neighbors (top and/or left) that used 8x8 dct |
225 */ | |
226 int neighbor_transform_size; | |
227 | |
228 /** | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
229 * block_offset[ 0..23] for frame macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
230 * block_offset[24..47] for field macroblocks |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
231 */ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
232 int block_offset[2*(16+8)]; |
2967 | 233 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
234 uint32_t *mb2b_xy; //FIXME are these 4 a good idea? |
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
235 uint32_t *mb2b8_xy; |
2395 | 236 int b_stride; //FIXME use s->b4_stride |
1168 | 237 int b8_stride; |
238 | |
3316 | 239 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff |
240 int mb_uvlinesize; | |
241 | |
242 int emu_edge_width; | |
243 int emu_edge_height; | |
244 | |
1234 | 245 int halfpel_flag; |
246 int thirdpel_flag; | |
247 | |
1319 | 248 int unknown_svq3_flag; |
249 int next_slice_index; | |
250 | |
1168 | 251 SPS sps_buffer[MAX_SPS_COUNT]; |
252 SPS sps; ///< current sps | |
2967 | 253 |
1168 | 254 PPS pps_buffer[MAX_PPS_COUNT]; |
255 /** | |
256 * current pps | |
257 */ | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
258 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? |
1168 | 259 |
2919 | 260 uint32_t dequant4_buffer[6][52][16]; |
261 uint32_t dequant8_buffer[2][52][64]; | |
262 uint32_t (*dequant4_coeff[6])[16]; | |
263 uint32_t (*dequant8_coeff[2])[64]; | |
264 int dequant_coeff_pps; ///< reinit tables when pps changes | |
2755 | 265 |
1168 | 266 int slice_num; |
267 uint8_t *slice_table_base; | |
3316 | 268 uint8_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 |
1168 | 269 int slice_type; |
270 int slice_type_fixed; | |
2967 | 271 |
1168 | 272 //interlacing specific flags |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
273 int mb_aff_frame; |
1168 | 274 int mb_field_decoding_flag; |
3316 | 275 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag |
2967 | 276 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
277 unsigned int sub_mb_type[4]; |
2967 | 278 |
1168 | 279 //POC stuff |
280 int poc_lsb; | |
281 int poc_msb; | |
282 int delta_poc_bottom; | |
283 int delta_poc[2]; | |
284 int frame_num; | |
285 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 | |
286 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 | |
287 int frame_num_offset; ///< for POC type 2 | |
288 int prev_frame_num_offset; ///< for POC type 2 | |
289 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 | |
290 | |
291 /** | |
292 * frame_num for frames or 2*frame_num for field pics. | |
293 */ | |
294 int curr_pic_num; | |
2967 | 295 |
1168 | 296 /** |
297 * max_frame_num or 2*max_frame_num for field pics. | |
298 */ | |
299 int max_pic_num; | |
300 | |
301 //Weighted pred stuff | |
2415 | 302 int use_weight; |
303 int use_weight_chroma; | |
1168 | 304 int luma_log2_weight_denom; |
305 int chroma_log2_weight_denom; | |
3316 | 306 int luma_weight[2][48]; |
307 int luma_offset[2][48]; | |
308 int chroma_weight[2][48][2]; | |
309 int chroma_offset[2][48][2]; | |
310 int implicit_weight[48][48]; | |
2967 | 311 |
1168 | 312 //deblock |
2967 | 313 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->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
|
314 int slice_alpha_c0_offset; |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
315 int slice_beta_offset; |
2967 | 316 |
1168 | 317 int redundant_pic_count; |
2967 | 318 |
1168 | 319 int direct_spatial_mv_pred; |
2396 | 320 int dist_scale_factor[16]; |
3316 | 321 int dist_scale_factor_field[32]; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
322 int map_col_to_list0[2][16]; |
3316 | 323 int map_col_to_list0_field[2][32]; |
1168 | 324 |
325 /** | |
326 * num_ref_idx_l0/1_active_minus1 + 1 | |
327 */ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
328 unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
4532 | 329 unsigned int list_count; |
2582 | 330 Picture *short_ref[32]; |
331 Picture *long_ref[32]; | |
1168 | 332 Picture default_ref_list[2][32]; |
3316 | 333 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs |
4389 | 334 Picture *delayed_pic[18]; //FIXME size? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
335 Picture *delayed_output_pic; |
2967 | 336 |
1168 | 337 /** |
338 * memory management control operations buffer. | |
339 */ | |
340 MMCO mmco[MAX_MMCO_COUNT]; | |
341 int mmco_index; | |
2967 | 342 |
1168 | 343 int long_ref_count; ///< number of actual long term references |
344 int short_ref_count; ///< number of actual short term references | |
2967 | 345 |
1168 | 346 //data partitioning |
347 GetBitContext intra_gb; | |
348 GetBitContext inter_gb; | |
349 GetBitContext *intra_gb_ptr; | |
350 GetBitContext *inter_gb_ptr; | |
2967 | 351 |
3089 | 352 DECLARE_ALIGNED_8(DCTELEM, mb[16*24]); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
353 DCTELEM mb_padding[256]; ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not to large or ensure that there is some unused stuff after mb |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
354 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
355 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
356 * Cabac |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
357 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
358 CABACContext cabac; |
2755 | 359 uint8_t cabac_state[460]; |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
360 int cabac_init_idc; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
361 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
362 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
363 uint16_t *cbp_table; |
3651 | 364 int cbp; |
2314 | 365 int top_cbp; |
366 int left_cbp; | |
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
|
367 /* chroma_pred_mode for i4x4 or i16x16, else 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
|
368 uint8_t *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
|
369 int last_qscale_diff; |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
370 int16_t (*mvd_table[2])[2]; |
3089 | 371 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); |
2396 | 372 uint8_t *direct_table; |
373 uint8_t direct_cache[5*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
|
374 |
2748
135aa7d0bd17
avoid one transpose (730->680 dezicycles on duron)
michael
parents:
2717
diff
changeset
|
375 uint8_t zigzag_scan[16]; |
3174 | 376 uint8_t zigzag_scan8x8[64]; |
377 uint8_t zigzag_scan8x8_cavlc[64]; | |
3316 | 378 uint8_t field_scan[16]; |
379 uint8_t field_scan8x8[64]; | |
380 uint8_t field_scan8x8_cavlc[64]; | |
2763 | 381 const uint8_t *zigzag_scan_q0; |
3174 | 382 const uint8_t *zigzag_scan8x8_q0; |
383 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
3316 | 384 const uint8_t *field_scan_q0; |
385 const uint8_t *field_scan8x8_q0; | |
386 const uint8_t *field_scan8x8_cavlc_q0; | |
2967 | 387 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
388 int x264_build; |
1168 | 389 }H264Context; |
390 | |
391 static VLC coeff_token_vlc[4]; | |
392 static VLC chroma_dc_coeff_token_vlc; | |
393 | |
394 static VLC total_zeros_vlc[15]; | |
395 static VLC chroma_dc_total_zeros_vlc[3]; | |
396 | |
397 static VLC run_vlc[6]; | |
398 static VLC run7_vlc; | |
399 | |
1234 | 400 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
401 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
|
402 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
|
403 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 | 404 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
405 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 406 #ifdef WORDS_BIGENDIAN |
407 return (b&0xFFFF) + (a<<16); | |
408 #else | |
409 return (a&0xFFFF) + (b<<16); | |
410 #endif | |
411 } | |
412 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
413 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
414 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
|
415 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
416 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
417 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
418 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
|
419 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
420 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
421 |
1168 | 422 /** |
423 * fill a rectangle. | |
2392 | 424 * @param h height of the rectangle, should be a constant |
425 * @param w width of the rectangle, should be a constant | |
1168 | 426 * @param size the size of val (1 or 4), should be a constant |
427 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
428 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 429 uint8_t *p= (uint8_t*)vp; |
1168 | 430 assert(size==1 || size==4); |
3315 | 431 assert(w<=4); |
2967 | 432 |
1168 | 433 w *= size; |
434 stride *= size; | |
2967 | 435 |
2962 | 436 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 437 assert((stride&(w-1))==0); |
3315 | 438 if(w==2){ |
439 const uint16_t v= size==4 ? val : val*0x0101; | |
440 *(uint16_t*)(p + 0*stride)= v; | |
441 if(h==1) return; | |
442 *(uint16_t*)(p + 1*stride)= v; | |
443 if(h==2) return; | |
1168 | 444 *(uint16_t*)(p + 2*stride)= |
3315 | 445 *(uint16_t*)(p + 3*stride)= v; |
446 }else if(w==4){ | |
447 const uint32_t v= size==4 ? val : val*0x01010101; | |
448 *(uint32_t*)(p + 0*stride)= v; | |
449 if(h==1) return; | |
450 *(uint32_t*)(p + 1*stride)= v; | |
451 if(h==2) return; | |
1168 | 452 *(uint32_t*)(p + 2*stride)= |
3315 | 453 *(uint32_t*)(p + 3*stride)= v; |
454 }else if(w==8){ | |
455 //gcc can't optimize 64bit math on x86_32 | |
456 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
457 const uint64_t v= val*0x0100000001ULL; | |
458 *(uint64_t*)(p + 0*stride)= v; | |
459 if(h==1) return; | |
460 *(uint64_t*)(p + 1*stride)= v; | |
461 if(h==2) return; | |
1168 | 462 *(uint64_t*)(p + 2*stride)= |
3315 | 463 *(uint64_t*)(p + 3*stride)= v; |
464 }else if(w==16){ | |
465 const uint64_t v= val*0x0100000001ULL; | |
1168 | 466 *(uint64_t*)(p + 0+0*stride)= |
467 *(uint64_t*)(p + 8+0*stride)= | |
468 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 469 *(uint64_t*)(p + 8+1*stride)= v; |
470 if(h==2) return; | |
1168 | 471 *(uint64_t*)(p + 0+2*stride)= |
472 *(uint64_t*)(p + 8+2*stride)= | |
473 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 474 *(uint64_t*)(p + 8+3*stride)= v; |
475 #else | |
476 *(uint32_t*)(p + 0+0*stride)= | |
477 *(uint32_t*)(p + 4+0*stride)= val; | |
478 if(h==1) return; | |
479 *(uint32_t*)(p + 0+1*stride)= | |
480 *(uint32_t*)(p + 4+1*stride)= val; | |
481 if(h==2) return; | |
482 *(uint32_t*)(p + 0+2*stride)= | |
483 *(uint32_t*)(p + 4+2*stride)= | |
484 *(uint32_t*)(p + 0+3*stride)= | |
485 *(uint32_t*)(p + 4+3*stride)= val; | |
486 }else if(w==16){ | |
487 *(uint32_t*)(p + 0+0*stride)= | |
488 *(uint32_t*)(p + 4+0*stride)= | |
489 *(uint32_t*)(p + 8+0*stride)= | |
490 *(uint32_t*)(p +12+0*stride)= | |
491 *(uint32_t*)(p + 0+1*stride)= | |
492 *(uint32_t*)(p + 4+1*stride)= | |
493 *(uint32_t*)(p + 8+1*stride)= | |
494 *(uint32_t*)(p +12+1*stride)= val; | |
495 if(h==2) return; | |
496 *(uint32_t*)(p + 0+2*stride)= | |
497 *(uint32_t*)(p + 4+2*stride)= | |
498 *(uint32_t*)(p + 8+2*stride)= | |
499 *(uint32_t*)(p +12+2*stride)= | |
500 *(uint32_t*)(p + 0+3*stride)= | |
501 *(uint32_t*)(p + 4+3*stride)= | |
502 *(uint32_t*)(p + 8+3*stride)= | |
503 *(uint32_t*)(p +12+3*stride)= val; | |
504 #endif | |
1168 | 505 }else |
506 assert(0); | |
3315 | 507 assert(h==4); |
1168 | 508 } |
509 | |
3028 | 510 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 511 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
|
512 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 513 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
514 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
|
515 int left_block[8]; |
1168 | 516 int i; |
517 | |
3482 | 518 //FIXME deblocking could skip the intra and nnz parts. |
519 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
|
520 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
521 |
2967 | 522 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
523 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
524 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
|
525 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
526 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
527 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
|
528 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
529 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
530 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
531 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
532 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
533 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
534 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
535 left_block[7]= 11; |
3316 | 536 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
537 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
|
538 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
|
539 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
|
540 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
|
541 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
|
542 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
|
543 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
|
544 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
|
545 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
|
546 const int bottom = (s->mb_y & 1); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
547 tprintf("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); |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
548 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
549 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
550 : (!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
|
551 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
552 top_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
553 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
554 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
555 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
556 : (!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
|
557 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
558 topleft_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
559 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
560 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
561 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
562 : (!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
|
563 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
564 topright_xy -= s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
565 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
566 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
|
567 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
|
568 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
569 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
570 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
571 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
572 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
573 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
574 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
575 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
576 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
577 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
578 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
579 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
580 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
581 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
582 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
583 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
584 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
585 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
586 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
587 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
588 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
589 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
590 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
591 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
592 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
593 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
594 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
595 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
596 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
597 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
598 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
599 } |
1168 | 600 } |
601 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
602 h->top_mb_xy = top_xy; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
603 h->left_mb_xy[0] = left_xy[0]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
604 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
|
605 if(for_deblock){ |
3482 | 606 topleft_type = 0; |
607 topright_type = 0; | |
2449 | 608 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
609 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
610 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 611 |
612 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
613 int list; | |
614 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
615 for(i=0; i<16; i++) | |
616 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
4533 | 617 for(list=0; list<h->list_count; list++){ |
3316 | 618 if(USES_LIST(mb_type,list)){ |
619 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
620 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 621 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 622 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
623 dst[0] = src[0]; | |
624 dst[1] = src[1]; | |
625 dst[2] = src[2]; | |
626 dst[3] = src[3]; | |
627 } | |
628 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
629 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
630 ref += h->b8_stride; | |
631 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
632 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
633 }else{ | |
634 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
635 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
636 } | |
637 } | |
638 } | |
2449 | 639 }else{ |
640 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
641 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
642 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
643 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
644 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
645 } | |
1168 | 646 |
647 if(IS_INTRA(mb_type)){ | |
2967 | 648 h->topleft_samples_available= |
649 h->top_samples_available= | |
1168 | 650 h->left_samples_available= 0xFFFF; |
651 h->topright_samples_available= 0xEEEA; | |
652 | |
653 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
654 h->topleft_samples_available= 0xB3FF; | |
655 h->top_samples_available= 0x33FF; | |
656 h->topright_samples_available= 0x26EA; | |
657 } | |
658 for(i=0; i<2; i++){ | |
659 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
660 h->topleft_samples_available&= 0xDF5F; | |
661 h->left_samples_available&= 0x5F5F; | |
662 } | |
663 } | |
2967 | 664 |
1168 | 665 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
666 h->topleft_samples_available&= 0x7FFF; | |
2967 | 667 |
1168 | 668 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
669 h->topright_samples_available&= 0xFBFF; | |
2967 | 670 |
1168 | 671 if(IS_INTRA4x4(mb_type)){ |
672 if(IS_INTRA4x4(top_type)){ | |
673 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
674 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
675 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
676 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
677 }else{ | |
678 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
679 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
|
680 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
681 else{ |
1168 | 682 pred= 2; |
683 } | |
684 h->intra4x4_pred_mode_cache[4+8*0]= | |
685 h->intra4x4_pred_mode_cache[5+8*0]= | |
686 h->intra4x4_pred_mode_cache[6+8*0]= | |
687 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
688 } | |
689 for(i=0; i<2; i++){ | |
690 if(IS_INTRA4x4(left_type[i])){ | |
691 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
692 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
693 }else{ | |
694 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
695 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
|
696 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
697 else{ |
1168 | 698 pred= 2; |
699 } | |
700 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
701 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
702 } | |
703 } | |
704 } | |
705 } | |
2967 | 706 |
707 | |
1168 | 708 /* |
2967 | 709 0 . T T. T T T T |
710 1 L . .L . . . . | |
711 2 L . .L . . . . | |
712 3 . T TL . . . . | |
713 4 L . .L . . . . | |
714 5 L . .. . . . . | |
1168 | 715 */ |
716 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
717 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
718 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
|
719 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
|
720 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
|
721 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 722 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
723 h->non_zero_count_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
|
724 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 725 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
726 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
|
727 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 728 |
1168 | 729 }else{ |
2967 | 730 h->non_zero_count_cache[4+8*0]= |
1168 | 731 h->non_zero_count_cache[5+8*0]= |
732 h->non_zero_count_cache[6+8*0]= | |
733 h->non_zero_count_cache[7+8*0]= | |
2967 | 734 |
1168 | 735 h->non_zero_count_cache[1+8*0]= |
736 h->non_zero_count_cache[2+8*0]= | |
2967 | 737 |
1168 | 738 h->non_zero_count_cache[1+8*3]= |
2314 | 739 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 740 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
741 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
742 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
743 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
744 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
745 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
|
746 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
|
747 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
|
748 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
|
749 }else{ |
2967 | 750 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
751 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
752 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
|
753 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 (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
754 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
755 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
756 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
757 if( h->pps.cabac ) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
758 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
759 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
760 h->top_cbp = h->cbp_table[top_xy]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
761 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
762 h->top_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
763 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
764 h->top_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
765 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
766 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
767 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
768 h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
769 } else if(IS_INTRA(mb_type)) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
770 h->left_cbp = 0x1C0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
771 } else { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
772 h->left_cbp = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
773 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
774 if (left_type[0]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
775 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 (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
776 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
777 if (left_type[1]) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
778 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
|
779 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
780 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
781 |
1168 | 782 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
783 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 784 int list; |
4533 | 785 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
|
786 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 787 /*if(!h->mv_cache_clean[list]){ |
788 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
789 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
790 h->mv_cache_clean[list]= 1; | |
791 }*/ | |
2396 | 792 continue; |
1168 | 793 } |
794 h->mv_cache_clean[list]= 0; | |
2967 | 795 |
3212 | 796 if(USES_LIST(top_type, list)){ |
1168 | 797 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
798 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
799 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
800 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
801 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
802 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
803 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
804 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
805 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
806 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
807 }else{ | |
2967 | 808 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
809 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
810 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 811 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
812 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
813 } | |
814 | |
815 //FIXME unify cleanup or sth | |
3212 | 816 if(USES_LIST(left_type[0], list)){ |
1168 | 817 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
818 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1; | |
819 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]]; | |
820 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1]]; | |
3316 | 821 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)]; |
822 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1]>>1)]; | |
1168 | 823 }else{ |
824 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]= | |
825 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0; | |
826 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
827 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
828 } | |
2967 | 829 |
3212 | 830 if(USES_LIST(left_type[1], list)){ |
1168 | 831 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
832 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1; | |
833 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[2]]; | |
834 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[3]]; | |
3316 | 835 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)]; |
836 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[3]>>1)]; | |
1168 | 837 }else{ |
838 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]= | |
839 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0; | |
840 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
841 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
2669 | 842 assert((!left_type[0]) == (!left_type[1])); |
1168 | 843 } |
844 | |
3519 | 845 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 846 continue; |
847 | |
3212 | 848 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
|
849 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
|
850 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
|
851 *(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
|
852 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
|
853 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
854 *(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
|
855 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
|
856 } |
2967 | 857 |
3212 | 858 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
|
859 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
|
860 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
|
861 *(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
|
862 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
|
863 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
864 *(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
|
865 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
|
866 } |
2967 | 867 |
3519 | 868 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 869 continue; |
2967 | 870 |
871 h->ref_cache[list][scan8[5 ]+1] = | |
872 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
873 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 874 h->ref_cache[list][scan8[4 ]] = |
1168 | 875 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
876 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
877 *(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
|
878 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 879 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
880 *(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
|
881 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
882 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
|
883 /* XXX beurk, Load mvd */ |
3212 | 884 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
|
885 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
|
886 *(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
|
887 *(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
|
888 *(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
|
889 *(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
|
890 }else{ |
2967 | 891 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
892 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
893 *(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
|
894 *(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
|
895 } |
3212 | 896 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
|
897 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
|
898 *(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
|
899 *(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
|
900 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
901 *(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
|
902 *(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
|
903 } |
3212 | 904 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
|
905 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
|
906 *(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
|
907 *(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
|
908 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
909 *(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
|
910 *(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
|
911 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
912 *(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
|
913 *(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
|
914 *(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
|
915 *(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
|
916 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 917 |
918 if(h->slice_type == B_TYPE){ | |
919 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
920 | |
921 if(IS_DIRECT(top_type)){ | |
922 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
923 }else if(IS_8X8(top_type)){ | |
924 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
925 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
926 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
927 }else{ | |
928 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
929 } | |
2967 | 930 |
3316 | 931 if(IS_DIRECT(left_type[0])) |
932 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
933 else if(IS_8X8(left_type[0])) | |
934 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)]; | |
935 else | |
936 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
937 | |
938 if(IS_DIRECT(left_type[1])) | |
2396 | 939 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 940 else if(IS_8X8(left_type[1])) |
941 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)]; | |
942 else | |
2396 | 943 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 944 } |
945 } | |
946 | |
947 if(FRAME_MBAFF){ | |
948 #define MAP_MVS\ | |
949 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
950 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
951 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
952 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
953 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
954 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
955 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
956 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
957 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
958 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
959 if(MB_FIELD){ | |
960 #define MAP_F2F(idx, mb_type)\ | |
961 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
962 h->ref_cache[list][idx] <<= 1;\ | |
963 h->mv_cache[list][idx][1] /= 2;\ | |
964 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 965 } |
3316 | 966 MAP_MVS |
967 #undef MAP_F2F | |
968 }else{ | |
969 #define MAP_F2F(idx, mb_type)\ | |
970 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
971 h->ref_cache[list][idx] >>= 1;\ | |
972 h->mv_cache[list][idx][1] <<= 1;\ | |
973 h->mvd_cache[list][idx][1] <<= 1;\ | |
974 } | |
975 MAP_MVS | |
976 #undef MAP_F2F | |
2396 | 977 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
978 } |
1168 | 979 } |
980 } | |
981 #endif | |
2755 | 982 |
983 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 984 } |
985 | |
986 static inline void write_back_intra_pred_mode(H264Context *h){ | |
987 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
|
988 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 989 |
990 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
991 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
992 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
993 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
994 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
995 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
996 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
997 } | |
998 | |
999 /** | |
1000 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1001 */ | |
1002 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
1003 MpegEncContext * const s = &h->s; | |
1004 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
1005 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
1006 int i; | |
2967 | 1007 |
1168 | 1008 if(!(h->top_samples_available&0x8000)){ |
1009 for(i=0; i<4; i++){ | |
1010 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
1011 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1012 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 | 1013 return -1; |
1014 } else if(status){ | |
1015 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
1016 } | |
1017 } | |
1018 } | |
2967 | 1019 |
1168 | 1020 if(!(h->left_samples_available&0x8000)){ |
1021 for(i=0; i<4; i++){ | |
1022 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
1023 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1024 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 | 1025 return -1; |
1026 } else if(status){ | |
1027 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
1028 } | |
1029 } | |
1030 } | |
1031 | |
1032 return 0; | |
1033 } //FIXME cleanup like next | |
1034 | |
1035 /** | |
1036 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1037 */ | |
1038 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
1039 MpegEncContext * const s = &h->s; | |
1040 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
1041 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 1042 |
4529 | 1043 if(mode > 6U) { |
2392 | 1044 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 | 1045 return -1; |
2392 | 1046 } |
2967 | 1047 |
1168 | 1048 if(!(h->top_samples_available&0x8000)){ |
1049 mode= top[ mode ]; | |
1050 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1051 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 | 1052 return -1; |
1053 } | |
1054 } | |
2967 | 1055 |
1168 | 1056 if(!(h->left_samples_available&0x8000)){ |
1057 mode= left[ mode ]; | |
1058 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1059 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 | 1060 return -1; |
2967 | 1061 } |
1168 | 1062 } |
1063 | |
1064 return mode; | |
1065 } | |
1066 | |
1067 /** | |
1068 * gets the predicted intra4x4 prediction mode. | |
1069 */ | |
1070 static inline int pred_intra_mode(H264Context *h, int n){ | |
1071 const int index8= scan8[n]; | |
1072 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1073 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1074 const int min= FFMIN(left, top); | |
1075 | |
1170 | 1076 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 1077 |
1078 if(min<0) return DC_PRED; | |
1079 else return min; | |
1080 } | |
1081 | |
1082 static inline void write_back_non_zero_count(H264Context *h){ | |
1083 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
|
1084 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
|
1085 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1086 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
|
1087 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
|
1088 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
|
1089 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
|
1090 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
|
1091 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
|
1092 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 1093 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1094 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
|
1095 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
|
1096 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
|
1097 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1098 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
|
1099 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
|
1100 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 1101 |
1102 if(FRAME_MBAFF){ | |
1103 // store all luma nnzs, for deblocking | |
1104 int v = 0, i; | |
1105 for(i=0; i<16; i++) | |
1106 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
1107 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
1108 } | |
1168 | 1109 } |
1110 | |
1111 /** | |
1112 * gets the predicted number of non zero coefficients. | |
1113 * @param n block index | |
1114 */ | |
1115 static inline int pred_non_zero_count(H264Context *h, int n){ | |
1116 const int index8= scan8[n]; | |
1117 const int left= h->non_zero_count_cache[index8 - 1]; | |
1118 const int top = h->non_zero_count_cache[index8 - 8]; | |
1119 int i= left + top; | |
2967 | 1120 |
1168 | 1121 if(i<64) i= (i+1)>>1; |
1122 | |
1170 | 1123 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 1124 |
1125 return i&31; | |
1126 } | |
1127 | |
1169 | 1128 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
1129 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
1130 | |
3316 | 1131 /* there is no consistent mapping of mvs to neighboring locations that will |
1132 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
1133 if(FRAME_MBAFF){ | |
1134 MpegEncContext *s = &h->s; | |
3776 | 1135 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 1136 const int16_t *mv; |
1137 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
1138 *C = h->mv_cache[list][scan8[0]-2]; | |
1139 | |
1140 if(!MB_FIELD | |
1141 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
1142 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
1143 if(IS_INTERLACED(mb_types[topright_xy])){ | |
1144 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
1145 const int x4 = X4, y4 = Y4;\ | |
1146 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
1147 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
1148 return LIST_NOT_USED;\ | |
1149 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
1150 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
1151 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
1152 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
1153 | |
1154 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
1155 } | |
1156 } | |
1157 if(topright_ref == PART_NOT_AVAILABLE | |
1158 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
1159 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
1160 if(!MB_FIELD | |
1161 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
1162 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
1163 } | |
1164 if(MB_FIELD | |
1165 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
1166 && i >= scan8[0]+8){ | |
1167 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
1168 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
1169 } | |
1170 } | |
1171 #undef SET_DIAG_MV | |
1172 } | |
1173 | |
1169 | 1174 if(topright_ref != PART_NOT_AVAILABLE){ |
1175 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
1176 return topright_ref; | |
1177 }else{ | |
1170 | 1178 tprintf("topright MV not available\n"); |
1179 | |
1169 | 1180 *C= h->mv_cache[list][ i - 8 - 1 ]; |
1181 return h->ref_cache[list][ i - 8 - 1 ]; | |
1182 } | |
1183 } | |
1184 | |
1168 | 1185 /** |
1186 * gets the predicted MV. | |
1187 * @param n the block index | |
1188 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
1189 * @param mx the x component of the predicted motion vector | |
1190 * @param my the y component of the predicted motion vector | |
1191 */ | |
1192 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
1193 const int index8= scan8[n]; | |
1194 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
1195 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
1196 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
1197 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 1198 const int16_t * C; |
1199 int diagonal_ref, match_count; | |
1200 | |
1168 | 1201 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 1202 |
1168 | 1203 /* mv_cache |
2967 | 1204 B . . A T T T T |
1168 | 1205 U . . L . . , . |
1206 U . . L . . . . | |
1207 U . . L . . , . | |
1208 . . . L . . . . | |
1209 */ | |
1169 | 1210 |
1211 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
1212 match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref); | |
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
|
1213 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 1214 if(match_count > 1){ //most common |
1215 *mx= mid_pred(A[0], B[0], C[0]); | |
1216 *my= mid_pred(A[1], B[1], C[1]); | |
1217 }else if(match_count==1){ | |
1218 if(left_ref==ref){ | |
1219 *mx= A[0]; | |
2967 | 1220 *my= A[1]; |
1169 | 1221 }else if(top_ref==ref){ |
1222 *mx= B[0]; | |
2967 | 1223 *my= B[1]; |
1169 | 1224 }else{ |
1225 *mx= C[0]; | |
2967 | 1226 *my= C[1]; |
1169 | 1227 } |
1228 }else{ | |
1229 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
1230 *mx= A[0]; | |
2967 | 1231 *my= A[1]; |
1168 | 1232 }else{ |
1233 *mx= mid_pred(A[0], B[0], C[0]); | |
1234 *my= mid_pred(A[1], B[1], C[1]); | |
1235 } | |
1169 | 1236 } |
2967 | 1237 |
1187 | 1238 tprintf("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 | 1239 } |
1240 | |
1241 /** | |
1242 * gets the directionally predicted 16x8 MV. | |
1243 * @param n the block index | |
1244 * @param mx the x component of the predicted motion vector | |
1245 * @param my the y component of the predicted motion vector | |
1246 */ | |
1247 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1248 if(n==0){ | |
1249 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
1250 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
1251 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1252 tprintf("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 | 1253 |
1168 | 1254 if(top_ref == ref){ |
1255 *mx= B[0]; | |
1256 *my= B[1]; | |
1257 return; | |
1258 } | |
1259 }else{ | |
1260 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
1261 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 1262 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1263 tprintf("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 | 1264 |
1265 if(left_ref == ref){ | |
1266 *mx= A[0]; | |
1267 *my= A[1]; | |
1268 return; | |
1269 } | |
1270 } | |
1271 | |
1272 //RARE | |
1273 pred_motion(h, n, 4, list, ref, mx, my); | |
1274 } | |
1275 | |
1276 /** | |
1277 * gets the directionally predicted 8x16 MV. | |
1278 * @param n the block index | |
1279 * @param mx the x component of the predicted motion vector | |
1280 * @param my the y component of the predicted motion vector | |
1281 */ | |
1282 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1283 if(n==0){ | |
1284 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1285 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 1286 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1287 tprintf("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 | 1288 |
1289 if(left_ref == ref){ | |
1290 *mx= A[0]; | |
1291 *my= A[1]; | |
1292 return; | |
1293 } | |
1294 }else{ | |
1169 | 1295 const int16_t * C; |
1296 int diagonal_ref; | |
1297 | |
1298 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 1299 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1300 tprintf("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 | 1301 |
2967 | 1302 if(diagonal_ref == ref){ |
1168 | 1303 *mx= C[0]; |
1304 *my= C[1]; | |
1305 return; | |
1306 } | |
1307 } | |
1308 | |
1309 //RARE | |
1310 pred_motion(h, n, 2, list, ref, mx, my); | |
1311 } | |
1312 | |
1313 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1314 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1315 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1316 | |
2392 | 1317 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1318 |
1319 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1320 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1321 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 1322 |
1168 | 1323 *mx = *my = 0; |
1324 return; | |
1325 } | |
2967 | 1326 |
1168 | 1327 pred_motion(h, 0, 4, 0, 0, mx, my); |
1328 | |
1329 return; | |
1330 } | |
1331 | |
2396 | 1332 static inline void direct_dist_scale_factor(H264Context * const h){ |
1333 const int poc = h->s.current_picture_ptr->poc; | |
1334 const int poc1 = h->ref_list[1][0].poc; | |
1335 int i; | |
1336 for(i=0; i<h->ref_count[0]; i++){ | |
1337 int poc0 = h->ref_list[0][i].poc; | |
1338 int td = clip(poc1 - poc0, -128, 127); | |
1339 if(td == 0 /* FIXME || pic0 is a long-term ref */){ | |
1340 h->dist_scale_factor[i] = 256; | |
1341 }else{ | |
1342 int tb = clip(poc - poc0, -128, 127); | |
4001 | 1343 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2396 | 1344 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023); |
1345 } | |
1346 } | |
3316 | 1347 if(FRAME_MBAFF){ |
1348 for(i=0; i<h->ref_count[0]; i++){ | |
1349 h->dist_scale_factor_field[2*i] = | |
1350 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
1351 } | |
1352 } | |
2396 | 1353 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1354 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
|
1355 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1356 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
|
1357 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
|
1358 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1359 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1360 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1361 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1362 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1363 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1364 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
|
1365 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
|
1366 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
|
1367 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1368 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
|
1369 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1370 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1371 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
|
1372 const int poc = ref1->ref_poc[list][i]; |
3125 | 1373 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
|
1374 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
|
1375 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
|
1376 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
|
1377 break; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1378 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1379 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1380 } |
3316 | 1381 if(FRAME_MBAFF){ |
1382 for(list=0; list<2; list++){ | |
1383 for(i=0; i<ref1->ref_count[list]; i++){ | |
1384 j = h->map_col_to_list0[list][i]; | |
1385 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1386 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1387 } | |
1388 } | |
1389 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1390 } |
2396 | 1391 |
1392 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1393 MpegEncContext * const s = &h->s; | |
1394 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1395 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1396 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1397 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1398 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
|
1399 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1400 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
|
1401 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1402 const int is_b8x8 = IS_8X8(*mb_type); |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
1403 unsigned int sub_mb_type; |
2396 | 1404 int i8, i4; |
1405 | |
3316 | 1406 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1407 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1408 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1409 * so we know exactly what block size to use */ | |
1410 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1411 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1412 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1413 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1414 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1415 }else{ | |
1416 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1417 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1418 } |
1419 if(!is_b8x8) | |
1420 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1421 if(MB_FIELD) |
1422 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1423 |
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
|
1424 tprintf("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 | 1425 |
2396 | 1426 if(h->direct_spatial_mv_pred){ |
1427 int ref[2]; | |
1428 int mv[2][2]; | |
1429 int list; | |
1430 | |
3316 | 1431 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1432 | |
2396 | 1433 /* ref = min(neighbors) */ |
1434 for(list=0; list<2; list++){ | |
1435 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1436 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1437 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1438 if(refc == -2) | |
1439 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1440 ref[list] = refa; | |
1441 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1442 ref[list] = refb; | |
1443 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1444 ref[list] = refc; | |
1445 if(ref[list] < 0) | |
1446 ref[list] = -1; | |
1447 } | |
1448 | |
1449 if(ref[0] < 0 && ref[1] < 0){ | |
1450 ref[0] = ref[1] = 0; | |
1451 mv[0][0] = mv[0][1] = | |
1452 mv[1][0] = mv[1][1] = 0; | |
1453 }else{ | |
1454 for(list=0; list<2; list++){ | |
1455 if(ref[list] >= 0) | |
1456 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1457 else | |
1458 mv[list][0] = mv[list][1] = 0; | |
1459 } | |
1460 } | |
1461 | |
1462 if(ref[1] < 0){ | |
1463 *mb_type &= ~MB_TYPE_P0L1; | |
1464 sub_mb_type &= ~MB_TYPE_P0L1; | |
1465 }else if(ref[0] < 0){ | |
1466 *mb_type &= ~MB_TYPE_P0L0; | |
1467 sub_mb_type &= ~MB_TYPE_P0L0; | |
1468 } | |
1469 | |
1470 if(IS_16X16(*mb_type)){ | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1471 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
|
1472 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1473 if(!IS_INTRA(mb_type_col) |
4001 | 1474 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1475 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1476 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1477 if(ref[0] > 0) |
1478 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1479 else | |
1480 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1481 if(ref[1] > 0) | |
1482 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1483 else | |
1484 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1485 }else{ | |
1486 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1487 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1488 } | |
1489 }else{ | |
1490 for(i8=0; i8<4; i8++){ | |
1491 const int x8 = i8&1; | |
1492 const int y8 = i8>>1; | |
2967 | 1493 |
2396 | 1494 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1495 continue; | |
1496 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1497 |
2396 | 1498 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1499 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
|
1500 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
|
1501 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1502 |
2396 | 1503 /* col_zero_flag */ |
2967 | 1504 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1505 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1506 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1507 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1508 if(IS_SUB_8X8(sub_mb_type)){ |
1509 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1510 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1511 if(ref[0] == 0) |
1512 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1513 if(ref[1] == 0) | |
1514 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1515 } | |
1516 }else | |
2396 | 1517 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1518 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1519 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1520 if(ref[0] == 0) |
1521 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1522 if(ref[1] == 0) | |
1523 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1524 } | |
1525 } | |
1526 } | |
1527 } | |
1528 } | |
1529 }else{ /* direct temporal mv pred */ | |
3316 | 1530 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1531 const int *dist_scale_factor = h->dist_scale_factor; | |
1532 | |
1533 if(FRAME_MBAFF){ | |
1534 if(IS_INTERLACED(*mb_type)){ | |
1535 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1536 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1537 dist_scale_factor = h->dist_scale_factor_field; | |
1538 } | |
1539 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1540 /* FIXME assumes direct_8x8_inference == 1 */ | |
1541 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1542 int mb_types_col[2]; | |
1543 int y_shift; | |
1544 | |
1545 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1546 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1547 | (*mb_type & MB_TYPE_INTERLACED); | |
1548 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1549 | |
1550 if(IS_INTERLACED(*mb_type)){ | |
1551 /* frame to field scaling */ | |
1552 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1553 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1554 if(s->mb_y&1){ | |
1555 l1ref0 -= 2*h->b8_stride; | |
1556 l1ref1 -= 2*h->b8_stride; | |
1557 l1mv0 -= 4*h->b_stride; | |
1558 l1mv1 -= 4*h->b_stride; | |
1559 } | |
1560 y_shift = 0; | |
1561 | |
1562 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1563 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1564 && !is_b8x8) | |
1565 *mb_type |= MB_TYPE_16x8; | |
1566 else | |
1567 *mb_type |= MB_TYPE_8x8; | |
1568 }else{ | |
1569 /* field to frame scaling */ | |
1570 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1571 * but in MBAFF, top and bottom POC are equal */ | |
1572 int dy = (s->mb_y&1) ? 1 : 2; | |
1573 mb_types_col[0] = | |
1574 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1575 l1ref0 += dy*h->b8_stride; | |
1576 l1ref1 += dy*h->b8_stride; | |
1577 l1mv0 += 2*dy*h->b_stride; | |
1578 l1mv1 += 2*dy*h->b_stride; | |
1579 y_shift = 2; | |
1580 | |
1581 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1582 && !is_b8x8) | |
1583 *mb_type |= MB_TYPE_16x16; | |
1584 else | |
1585 *mb_type |= MB_TYPE_8x8; | |
1586 } | |
1587 | |
1588 for(i8=0; i8<4; i8++){ | |
1589 const int x8 = i8&1; | |
1590 const int y8 = i8>>1; | |
1591 int ref0, scale; | |
1592 const int16_t (*l1mv)[2]= l1mv0; | |
1593 | |
1594 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1595 continue; | |
1596 h->sub_mb_type[i8] = sub_mb_type; | |
1597 | |
1598 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1599 if(IS_INTRA(mb_types_col[y8])){ | |
1600 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1601 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1602 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1603 continue; | |
1604 } | |
1605 | |
1606 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1607 if(ref0 >= 0) | |
1608 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1609 else{ | |
1610 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1611 l1mv= l1mv1; | |
1612 } | |
1613 scale = dist_scale_factor[ref0]; | |
1614 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1615 | |
1616 { | |
1617 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1618 int my_col = (mv_col[1]<<y_shift)/2; | |
1619 int mx = (scale * mv_col[0] + 128) >> 8; | |
1620 int my = (scale * my_col + 128) >> 8; | |
1621 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1622 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1623 } | |
1624 } | |
1625 return; | |
1626 } | |
1627 } | |
1628 | |
1629 /* one-to-one mv scaling */ | |
1630 | |
2396 | 1631 if(IS_16X16(*mb_type)){ |
1632 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); | |
1633 if(IS_INTRA(mb_type_col)){ | |
1634 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1635 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1636 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1637 }else{ | |
3316 | 1638 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1639 : map_col_to_list0[1][l1ref1[0]]; | |
1640 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
|
1641 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1642 int mv_l0[2]; |
3316 | 1643 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1644 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1645 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1); |
1646 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4); | |
1647 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]), 4); | |
1648 } | |
1649 }else{ | |
1650 for(i8=0; i8<4; i8++){ | |
1651 const int x8 = i8&1; | |
1652 const int y8 = i8>>1; | |
3316 | 1653 int ref0, scale; |
2834 | 1654 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
|
1655 |
2396 | 1656 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1657 continue; | |
1658 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1659 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1660 if(IS_INTRA(mb_type_col)){ |
1661 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1662 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1663 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1664 continue; | |
1665 } | |
2967 | 1666 |
2396 | 1667 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
|
1668 if(ref0 >= 0) |
3316 | 1669 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
|
1670 else{ |
3316 | 1671 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
|
1672 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1673 } |
3316 | 1674 scale = dist_scale_factor[ref0]; |
2967 | 1675 |
2396 | 1676 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1677 if(IS_SUB_8X8(sub_mb_type)){ |
1678 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1679 int mx = (scale * mv_col[0] + 128) >> 8; |
1680 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1681 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1682 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1683 }else | |
2396 | 1684 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
|
1685 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1686 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1687 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1688 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1689 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1690 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1691 } | |
1692 } | |
1693 } | |
1694 } | |
1695 } | |
1696 | |
1168 | 1697 static inline void write_back_motion(H264Context *h, int mb_type){ |
1698 MpegEncContext * const s = &h->s; | |
1699 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1700 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1701 int list; | |
1702 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1703 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1704 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
|
1705 |
4533 | 1706 for(list=0; list<h->list_count; list++){ |
1168 | 1707 int y; |
3212 | 1708 if(!USES_LIST(mb_type, list)) |
2396 | 1709 continue; |
2967 | 1710 |
1168 | 1711 for(y=0; y<4; y++){ |
1712 *(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]; | |
1713 *(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]; | |
1714 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1715 if( h->pps.cabac ) { |
3927 | 1716 if(IS_SKIP(mb_type)) |
1717 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1718 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1719 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
|
1720 *(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
|
1721 *(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
|
1722 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1723 } |
3212 | 1724 |
1725 { | |
3776 | 1726 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1727 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1728 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1729 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1730 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1731 } |
1732 } | |
2967 | 1733 |
2396 | 1734 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1735 if(IS_8X8(mb_type)){ | |
3212 | 1736 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1737 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1738 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1739 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1740 } |
1741 } | |
1168 | 1742 } |
1743 | |
1744 /** | |
1745 * Decodes a network abstraction layer unit. | |
1746 * @param consumed is the number of bytes used as input | |
1747 * @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
|
1748 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1749 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1750 */ |
1751 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1752 int i, si, di; | |
1753 uint8_t *dst; | |
1754 | |
2979 | 1755 // src[0]&0x80; //forbidden bit |
1168 | 1756 h->nal_ref_idc= src[0]>>5; |
1757 h->nal_unit_type= src[0]&0x1F; | |
1758 | |
1759 src++; length--; | |
2967 | 1760 #if 0 |
1168 | 1761 for(i=0; i<length; i++) |
1762 printf("%2X ", src[i]); | |
1763 #endif | |
1764 for(i=0; i+1<length; i+=2){ | |
1765 if(src[i]) continue; | |
1766 if(i>0 && src[i-1]==0) i--; | |
1767 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1768 if(src[i+2]!=3){ | |
1769 /* startcode, so we must be past the end */ | |
1770 length=i; | |
1771 } | |
1772 break; | |
1773 } | |
1774 } | |
1775 | |
1776 if(i>=length-1){ //no escaped 0 | |
1777 *dst_length= length; | |
1778 *consumed= length+1; //+1 for the header | |
2967 | 1779 return src; |
1168 | 1780 } |
1781 | |
1782 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1783 dst= h->rbsp_buffer; | |
1784 | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1785 if (dst == NULL){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1786 return NULL; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1787 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
1788 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1789 //printf("decoding esc\n"); |
1168 | 1790 si=di=0; |
2967 | 1791 while(si<length){ |
1168 | 1792 //remove escapes (very rare 1:2^22) |
1793 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1794 if(src[si+2]==3){ //escape | |
1795 dst[di++]= 0; | |
1796 dst[di++]= 0; | |
1797 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1798 continue; |
1168 | 1799 }else //next start code |
1800 break; | |
1801 } | |
1802 | |
1803 dst[di++]= src[si++]; | |
1804 } | |
1805 | |
1806 *dst_length= di; | |
1807 *consumed= si + 1;//+1 for the header | |
1808 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1809 return dst; | |
1810 } | |
1811 | |
1812 /** | |
1813 * identifies the exact end of the bitstream | |
1814 * @return the length of the trailing, or 0 if damaged | |
1815 */ | |
1816 static int decode_rbsp_trailing(uint8_t *src){ | |
1817 int v= *src; | |
1818 int r; | |
1819 | |
1170 | 1820 tprintf("rbsp trailing %X\n", v); |
1168 | 1821 |
1822 for(r=1; r<9; r++){ | |
1823 if(v&1) return r; | |
1824 v>>=1; | |
1825 } | |
1826 return 0; | |
1827 } | |
1828 | |
1829 /** | |
1830 * idct tranforms the 16 dc values and dequantize them. | |
1831 * @param qp quantization parameter | |
1832 */ | |
2919 | 1833 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1834 #define stride 16 |
1835 int i; | |
1836 int temp[16]; //FIXME check if this is a good idea | |
1837 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1838 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1839 | |
1840 //memset(block, 64, 2*256); | |
1841 //return; | |
1842 for(i=0; i<4; i++){ | |
1843 const int offset= y_offset[i]; | |
1844 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1845 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1846 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1847 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1848 | |
1849 temp[4*i+0]= z0+z3; | |
1850 temp[4*i+1]= z1+z2; | |
1851 temp[4*i+2]= z1-z2; | |
1852 temp[4*i+3]= z0-z3; | |
1853 } | |
1854 | |
1855 for(i=0; i<4; i++){ | |
1856 const int offset= x_offset[i]; | |
1857 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1858 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1859 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1860 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1861 | |
2919 | 1862 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1863 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1864 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1865 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1866 } |
1867 } | |
1868 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1869 #if 0 |
1168 | 1870 /** |
1871 * dct tranforms the 16 dc values. | |
1872 * @param qp quantization parameter ??? FIXME | |
1873 */ | |
1874 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1875 // const int qmul= dequant_coeff[qp][0]; | |
1876 int i; | |
1877 int temp[16]; //FIXME check if this is a good idea | |
1878 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1879 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1880 | |
1881 for(i=0; i<4; i++){ | |
1882 const int offset= y_offset[i]; | |
1883 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1884 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1885 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1886 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1887 | |
1888 temp[4*i+0]= z0+z3; | |
1889 temp[4*i+1]= z1+z2; | |
1890 temp[4*i+2]= z1-z2; | |
1891 temp[4*i+3]= z0-z3; | |
1892 } | |
1893 | |
1894 for(i=0; i<4; i++){ | |
1895 const int offset= x_offset[i]; | |
1896 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1897 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1898 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1899 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1900 | |
1901 block[stride*0 +offset]= (z0 + z3)>>1; | |
1902 block[stride*2 +offset]= (z1 + z2)>>1; | |
1903 block[stride*8 +offset]= (z1 - z2)>>1; | |
1904 block[stride*10+offset]= (z0 - z3)>>1; | |
1905 } | |
1906 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1907 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1908 |
1168 | 1909 #undef xStride |
1910 #undef stride | |
1911 | |
2919 | 1912 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1913 const int stride= 16*2; |
1914 const int xStride= 16; | |
1915 int a,b,c,d,e; | |
1916 | |
1917 a= block[stride*0 + xStride*0]; | |
1918 b= block[stride*0 + xStride*1]; | |
1919 c= block[stride*1 + xStride*0]; | |
1920 d= block[stride*1 + xStride*1]; | |
1921 | |
1922 e= a-b; | |
1923 a= a+b; | |
1924 b= c-d; | |
1925 c= c+d; | |
1926 | |
2919 | 1927 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1928 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1929 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1930 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1931 } |
1932 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1933 #if 0 |
1168 | 1934 static void chroma_dc_dct_c(DCTELEM *block){ |
1935 const int stride= 16*2; | |
1936 const int xStride= 16; | |
1937 int a,b,c,d,e; | |
1938 | |
1939 a= block[stride*0 + xStride*0]; | |
1940 b= block[stride*0 + xStride*1]; | |
1941 c= block[stride*1 + xStride*0]; | |
1942 d= block[stride*1 + xStride*1]; | |
1943 | |
1944 e= a-b; | |
1945 a= a+b; | |
1946 b= c-d; | |
1947 c= c+d; | |
1948 | |
1949 block[stride*0 + xStride*0]= (a+c); | |
1950 block[stride*0 + xStride*1]= (e+b); | |
1951 block[stride*1 + xStride*0]= (a-c); | |
1952 block[stride*1 + xStride*1]= (e-b); | |
1953 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1954 #endif |
1168 | 1955 |
1956 /** | |
1957 * gets the chroma qp. | |
1958 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1959 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 1960 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1961 return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 1962 } |
1963 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1964 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close |
1168 | 1965 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away) |
1966 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){ | |
1967 int i; | |
1968 const int * const quant_table= quant_coeff[qscale]; | |
1969 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1970 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1971 const unsigned int threshold2= (threshold1<<1); | |
1972 int last_non_zero; | |
1973 | |
1974 if(seperate_dc){ | |
1975 if(qscale<=18){ | |
1976 //avoid overflows | |
1977 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1978 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1979 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1980 | |
1981 int level= block[0]*quant_coeff[qscale+18][0]; | |
1982 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1983 if(level>0){ | |
1984 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1985 block[0]= level; | |
1986 }else{ | |
1987 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1988 block[0]= -level; | |
1989 } | |
1990 // last_non_zero = i; | |
1991 }else{ | |
1992 block[0]=0; | |
1993 } | |
1994 }else{ | |
1995 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1996 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1997 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1998 | |
1999 int level= block[0]*quant_table[0]; | |
2000 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
2001 if(level>0){ | |
2002 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
2003 block[0]= level; | |
2004 }else{ | |
2005 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
2006 block[0]= -level; | |
2007 } | |
2008 // last_non_zero = i; | |
2009 }else{ | |
2010 block[0]=0; | |
2011 } | |
2012 } | |
2013 last_non_zero= 0; | |
2014 i=1; | |
2015 }else{ | |
2016 last_non_zero= -1; | |
2017 i=0; | |
2018 } | |
2019 | |
2020 for(; i<16; i++){ | |
2021 const int j= scantable[i]; | |
2022 int level= block[j]*quant_table[j]; | |
2023 | |
2024 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
2025 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
2026 if(((unsigned)(level+threshold1))>threshold2){ | |
2027 if(level>0){ | |
2028 level= (bias + level)>>QUANT_SHIFT; | |
2029 block[j]= level; | |
2030 }else{ | |
2031 level= (bias - level)>>QUANT_SHIFT; | |
2032 block[j]= -level; | |
2033 } | |
2034 last_non_zero = i; | |
2035 }else{ | |
2036 block[j]=0; | |
2037 } | |
2038 } | |
2039 | |
2040 return last_non_zero; | |
2041 } | |
2042 | |
2043 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
2044 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2045 ((uint32_t*)(src+0*stride))[0]= a; | |
2046 ((uint32_t*)(src+1*stride))[0]= a; | |
2047 ((uint32_t*)(src+2*stride))[0]= a; | |
2048 ((uint32_t*)(src+3*stride))[0]= a; | |
2049 } | |
2050 | |
2051 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
2052 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
2053 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
2054 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
2055 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
2056 } | |
2057 | |
2058 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2059 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
2060 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 2061 |
2062 ((uint32_t*)(src+0*stride))[0]= | |
2063 ((uint32_t*)(src+1*stride))[0]= | |
2064 ((uint32_t*)(src+2*stride))[0]= | |
2065 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2066 } |
2067 | |
2068 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2069 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 2070 |
2071 ((uint32_t*)(src+0*stride))[0]= | |
2072 ((uint32_t*)(src+1*stride))[0]= | |
2073 ((uint32_t*)(src+2*stride))[0]= | |
2074 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2075 } |
2076 | |
2077 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2078 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 2079 |
2080 ((uint32_t*)(src+0*stride))[0]= | |
2081 ((uint32_t*)(src+1*stride))[0]= | |
2082 ((uint32_t*)(src+2*stride))[0]= | |
2083 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2084 } |
2085 | |
2086 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2087 ((uint32_t*)(src+0*stride))[0]= |
2088 ((uint32_t*)(src+1*stride))[0]= | |
2089 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 2090 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
2091 } | |
2092 | |
2093 | |
2094 #define LOAD_TOP_RIGHT_EDGE\ | |
2095 const int t4= topright[0];\ | |
2096 const int t5= topright[1];\ | |
2097 const int t6= topright[2];\ | |
2098 const int t7= topright[3];\ | |
2099 | |
2100 #define LOAD_LEFT_EDGE\ | |
2101 const int l0= src[-1+0*stride];\ | |
2102 const int l1= src[-1+1*stride];\ | |
2103 const int l2= src[-1+2*stride];\ | |
2104 const int l3= src[-1+3*stride];\ | |
2105 | |
2106 #define LOAD_TOP_EDGE\ | |
2107 const int t0= src[ 0-1*stride];\ | |
2108 const int t1= src[ 1-1*stride];\ | |
2109 const int t2= src[ 2-1*stride];\ | |
2110 const int t3= src[ 3-1*stride];\ | |
2111 | |
2112 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2113 const int lt= src[-1-1*stride]; | |
2114 LOAD_TOP_EDGE | |
2115 LOAD_LEFT_EDGE | |
2116 | |
2967 | 2117 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 2118 src[0+2*stride]= |
2967 | 2119 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 2120 src[0+1*stride]= |
2121 src[1+2*stride]= | |
2967 | 2122 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 2123 src[0+0*stride]= |
2124 src[1+1*stride]= | |
2125 src[2+2*stride]= | |
2967 | 2126 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 2127 src[1+0*stride]= |
2128 src[2+1*stride]= | |
2129 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2130 src[2+0*stride]= | |
2131 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2132 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 2133 } |
1168 | 2134 |
2135 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2136 LOAD_TOP_EDGE |
2137 LOAD_TOP_RIGHT_EDGE | |
2138 // LOAD_LEFT_EDGE | |
1168 | 2139 |
2140 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
2141 src[1+0*stride]= | |
2142 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
2143 src[2+0*stride]= | |
2144 src[1+1*stride]= | |
2145 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
2146 src[3+0*stride]= | |
2147 src[2+1*stride]= | |
2148 src[1+2*stride]= | |
2149 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
2150 src[3+1*stride]= | |
2151 src[2+2*stride]= | |
2152 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
2153 src[3+2*stride]= | |
2154 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
2155 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 2156 } |
1168 | 2157 |
2158 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2159 const int lt= src[-1-1*stride]; | |
2967 | 2160 LOAD_TOP_EDGE |
2161 LOAD_LEFT_EDGE | |
1168 | 2162 const __attribute__((unused)) int unu= l3; |
2163 | |
2164 src[0+0*stride]= | |
2165 src[1+2*stride]=(lt + t0 + 1)>>1; | |
2166 src[1+0*stride]= | |
2167 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
2168 src[2+0*stride]= | |
2169 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
2170 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
2171 src[0+1*stride]= | |
2172 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2173 src[1+1*stride]= | |
2174 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2175 src[2+1*stride]= | |
2176 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2177 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2178 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2179 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 2180 } |
1168 | 2181 |
2182 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2183 LOAD_TOP_EDGE |
2184 LOAD_TOP_RIGHT_EDGE | |
1168 | 2185 const __attribute__((unused)) int unu= t7; |
2186 | |
2187 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
2188 src[1+0*stride]= | |
2189 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
2190 src[2+0*stride]= | |
2191 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
2192 src[3+0*stride]= | |
2193 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
2194 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
2195 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2196 src[1+1*stride]= | |
2197 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2198 src[2+1*stride]= | |
2199 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
2200 src[3+1*stride]= | |
2201 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
2202 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 2203 } |
1168 | 2204 |
2205 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2206 LOAD_LEFT_EDGE |
1168 | 2207 |
2208 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
2209 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2210 src[2+0*stride]= | |
2211 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
2212 src[3+0*stride]= | |
2213 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
2214 src[2+1*stride]= | |
2215 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
2216 src[3+1*stride]= | |
2217 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
2218 src[3+2*stride]= | |
2219 src[1+3*stride]= | |
2220 src[0+3*stride]= | |
2221 src[2+2*stride]= | |
2222 src[2+3*stride]= | |
2223 src[3+3*stride]=l3; | |
1282 | 2224 } |
2967 | 2225 |
1168 | 2226 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
2227 const int lt= src[-1-1*stride]; | |
2967 | 2228 LOAD_TOP_EDGE |
2229 LOAD_LEFT_EDGE | |
1168 | 2230 const __attribute__((unused)) int unu= t3; |
2231 | |
2232 src[0+0*stride]= | |
2233 src[2+1*stride]=(lt + l0 + 1)>>1; | |
2234 src[1+0*stride]= | |
2235 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2236 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2237 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2238 src[0+1*stride]= | |
2239 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
2240 src[1+1*stride]= | |
2241 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2242 src[0+2*stride]= | |
2243 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
2244 src[1+2*stride]= | |
2245 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2246 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
2247 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 2248 } |
1168 | 2249 |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2250 void ff_pred16x16_vertical_c(uint8_t *src, int stride){ |
1168 | 2251 int i; |
2252 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2253 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2254 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
2255 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 2256 |
1168 | 2257 for(i=0; i<16; i++){ |
2258 ((uint32_t*)(src+i*stride))[0]= a; | |
2259 ((uint32_t*)(src+i*stride))[1]= b; | |
2260 ((uint32_t*)(src+i*stride))[2]= c; | |
2261 ((uint32_t*)(src+i*stride))[3]= d; | |
2262 } | |
2263 } | |
2264 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2265 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){ |
1168 | 2266 int i; |
2267 | |
2268 for(i=0; i<16; i++){ | |
2269 ((uint32_t*)(src+i*stride))[0]= | |
2270 ((uint32_t*)(src+i*stride))[1]= | |
2271 ((uint32_t*)(src+i*stride))[2]= | |
2272 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
2273 } | |
2274 } | |
2275 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2276 void ff_pred16x16_dc_c(uint8_t *src, int stride){ |
1168 | 2277 int i, dc=0; |
2278 | |
2279 for(i=0;i<16; i++){ | |
2280 dc+= src[-1+i*stride]; | |
2281 } | |
2967 | 2282 |
1168 | 2283 for(i=0;i<16; i++){ |
2284 dc+= src[i-stride]; | |
2285 } | |
2286 | |
2287 dc= 0x01010101*((dc + 16)>>5); | |
2288 | |
2289 for(i=0; i<16; i++){ | |
2290 ((uint32_t*)(src+i*stride))[0]= | |
2291 ((uint32_t*)(src+i*stride))[1]= | |
2292 ((uint32_t*)(src+i*stride))[2]= | |
2293 ((uint32_t*)(src+i*stride))[3]= dc; | |
2294 } | |
2295 } | |
2296 | |
2297 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
2298 int i, dc=0; | |
2299 | |
2300 for(i=0;i<16; i++){ | |
2301 dc+= src[-1+i*stride]; | |
2302 } | |
2967 | 2303 |
1168 | 2304 dc= 0x01010101*((dc + 8)>>4); |
2305 | |
2306 for(i=0; i<16; i++){ | |
2307 ((uint32_t*)(src+i*stride))[0]= | |
2308 ((uint32_t*)(src+i*stride))[1]= | |
2309 ((uint32_t*)(src+i*stride))[2]= | |
2310 ((uint32_t*)(src+i*stride))[3]= dc; | |
2311 } | |
2312 } | |
2313 | |
2314 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
2315 int i, dc=0; | |
2316 | |
2317 for(i=0;i<16; i++){ | |
2318 dc+= src[i-stride]; | |
2319 } | |
2320 dc= 0x01010101*((dc + 8)>>4); | |
2321 | |
2322 for(i=0; i<16; i++){ | |
2323 ((uint32_t*)(src+i*stride))[0]= | |
2324 ((uint32_t*)(src+i*stride))[1]= | |
2325 ((uint32_t*)(src+i*stride))[2]= | |
2326 ((uint32_t*)(src+i*stride))[3]= dc; | |
2327 } | |
2328 } | |
2329 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2330 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){ |
1168 | 2331 int i; |
2332 | |
2333 for(i=0; i<16; i++){ | |
2334 ((uint32_t*)(src+i*stride))[0]= | |
2335 ((uint32_t*)(src+i*stride))[1]= | |
2336 ((uint32_t*)(src+i*stride))[2]= | |
2337 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
2338 } | |
2339 } | |
2340 | |
1234 | 2341 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
|
2342 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2343 int a; |
4176 | 2344 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
|
2345 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
|
2346 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
|
2347 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
|
2348 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
|
2349 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
|
2350 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
|
2351 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2352 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
|
2353 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
|
2354 } |
1234 | 2355 if(svq3){ |
2356 H = ( 5*(H/4) ) / 16; | |
2357 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2358 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2359 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2360 i = H; H = V; V = i; |
1234 | 2361 }else{ |
2362 H = ( 5*H+32 ) >> 6; | |
2363 V = ( 5*V+32 ) >> 6; | |
2364 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2365 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2366 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
|
2367 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
|
2368 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2369 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2370 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
|
2371 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
|
2372 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
|
2373 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
|
2374 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
|
2375 b += 4*H; |
1168 | 2376 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2377 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2378 } |
1168 | 2379 } |
2380 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2381 void ff_pred16x16_plane_c(uint8_t *src, int stride){ |
1234 | 2382 pred16x16_plane_compat_c(src, stride, 0); |
2383 } | |
2384 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2385 void ff_pred8x8_vertical_c(uint8_t *src, int stride){ |
1168 | 2386 int i; |
2387 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2388 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2389 |
1168 | 2390 for(i=0; i<8; i++){ |
2391 ((uint32_t*)(src+i*stride))[0]= a; | |
2392 ((uint32_t*)(src+i*stride))[1]= b; | |
2393 } | |
2394 } | |
2395 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2396 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){ |
1168 | 2397 int i; |
2398 | |
2399 for(i=0; i<8; i++){ | |
2400 ((uint32_t*)(src+i*stride))[0]= | |
2401 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2402 } | |
2403 } | |
2404 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2405 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){ |
1168 | 2406 int i; |
2407 | |
2755 | 2408 for(i=0; i<8; i++){ |
2967 | 2409 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2410 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2411 } | |
2412 } | |
2413 | |
2414 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2415 int i; | |
2416 int dc0, dc2; | |
2417 | |
2418 dc0=dc2=0; | |
2419 for(i=0;i<4; i++){ | |
2420 dc0+= src[-1+i*stride]; | |
2421 dc2+= src[-1+(i+4)*stride]; | |
2422 } | |
2423 dc0= 0x01010101*((dc0 + 2)>>2); | |
2424 dc2= 0x01010101*((dc2 + 2)>>2); | |
2425 | |
2426 for(i=0; i<4; i++){ | |
2427 ((uint32_t*)(src+i*stride))[0]= | |
2428 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2429 } | |
2430 for(i=4; i<8; i++){ | |
2431 ((uint32_t*)(src+i*stride))[0]= | |
2432 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2433 } | |
2434 } | |
2435 | |
2436 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2437 int i; | |
2438 int dc0, dc1; | |
2439 | |
2440 dc0=dc1=0; | |
2441 for(i=0;i<4; i++){ | |
2442 dc0+= src[i-stride]; | |
2443 dc1+= src[4+i-stride]; | |
2444 } | |
2445 dc0= 0x01010101*((dc0 + 2)>>2); | |
2446 dc1= 0x01010101*((dc1 + 2)>>2); | |
2447 | |
2448 for(i=0; i<4; i++){ | |
2449 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2450 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2451 } | |
2452 for(i=4; i<8; i++){ | |
2453 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2454 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2455 } | |
2456 } | |
2457 | |
2458 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2459 void ff_pred8x8_dc_c(uint8_t *src, int stride){ |
1168 | 2460 int i; |
2461 int dc0, dc1, dc2, dc3; | |
2462 | |
2463 dc0=dc1=dc2=0; | |
2464 for(i=0;i<4; i++){ | |
2465 dc0+= src[-1+i*stride] + src[i-stride]; | |
2466 dc1+= src[4+i-stride]; | |
2467 dc2+= src[-1+(i+4)*stride]; | |
2468 } | |
2469 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2470 dc0= 0x01010101*((dc0 + 4)>>3); | |
2471 dc1= 0x01010101*((dc1 + 2)>>2); | |
2472 dc2= 0x01010101*((dc2 + 2)>>2); | |
2473 | |
2474 for(i=0; i<4; i++){ | |
2475 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2476 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2477 } | |
2478 for(i=4; i<8; i++){ | |
2479 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2480 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2481 } | |
2482 } | |
2483 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2484 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
|
2485 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2486 int a; |
4176 | 2487 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
|
2488 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
|
2489 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
|
2490 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
|
2491 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
|
2492 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
|
2493 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
|
2494 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2495 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
|
2496 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
|
2497 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2498 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2499 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2500 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2501 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
|
2502 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
|
2503 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2504 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2505 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2506 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
|
2507 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
|
2508 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
|
2509 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
|
2510 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
|
2511 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
|
2512 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
|
2513 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2514 } |
1168 | 2515 } |
2516 | |
2755 | 2517 #define SRC(x,y) src[(x)+(y)*stride] |
2518 #define PL(y) \ | |
2519 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2520 #define PREDICT_8x8_LOAD_LEFT \ | |
2521 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2522 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2523 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2524 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2525 |
2526 #define PT(x) \ | |
2527 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2528 #define PREDICT_8x8_LOAD_TOP \ | |
2529 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2530 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2531 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2532 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2533 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2534 |
2535 #define PTR(x) \ | |
2536 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2537 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2538 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2539 if(has_topright) { \ | |
2540 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2541 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2542 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2543 | |
2544 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2545 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2546 |
2547 #define PREDICT_8x8_DC(v) \ | |
2548 int y; \ | |
2549 for( y = 0; y < 8; y++ ) { \ | |
2550 ((uint32_t*)src)[0] = \ | |
2551 ((uint32_t*)src)[1] = v; \ | |
2552 src += stride; \ | |
2553 } | |
2554 | |
2555 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2556 { | |
2557 PREDICT_8x8_DC(0x80808080); | |
2558 } | |
2559 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2560 { | |
2561 PREDICT_8x8_LOAD_LEFT; | |
2562 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2563 PREDICT_8x8_DC(dc); | |
2564 } | |
2565 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2566 { | |
2567 PREDICT_8x8_LOAD_TOP; | |
2568 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2569 PREDICT_8x8_DC(dc); | |
2570 } | |
2571 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2572 { | |
2573 PREDICT_8x8_LOAD_LEFT; | |
2574 PREDICT_8x8_LOAD_TOP; | |
2575 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2576 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2577 PREDICT_8x8_DC(dc); | |
2578 } | |
2579 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2580 { | |
2581 PREDICT_8x8_LOAD_LEFT; | |
2582 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2583 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2584 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2585 #undef ROW | |
2586 } | |
2587 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2588 { | |
2589 int y; | |
2590 PREDICT_8x8_LOAD_TOP; | |
2591 src[0] = t0; | |
2592 src[1] = t1; | |
2593 src[2] = t2; | |
2594 src[3] = t3; | |
2595 src[4] = t4; | |
2596 src[5] = t5; | |
2597 src[6] = t6; | |
2598 src[7] = t7; | |
2599 for( y = 1; y < 8; y++ ) | |
2600 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2601 } | |
2602 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2603 { | |
2604 PREDICT_8x8_LOAD_TOP; | |
2605 PREDICT_8x8_LOAD_TOPRIGHT; | |
2606 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2607 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2608 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2609 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2610 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2611 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2612 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; | |
2613 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; | |
2614 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; | |
2615 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2616 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2617 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2618 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2619 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2620 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2621 } | |
2622 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2623 { | |
2624 PREDICT_8x8_LOAD_TOP; | |
2625 PREDICT_8x8_LOAD_LEFT; | |
2626 PREDICT_8x8_LOAD_TOPLEFT; | |
2627 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2628 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2629 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2630 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2631 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2632 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2633 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; | |
2634 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; | |
2635 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; | |
2636 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2637 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2638 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2639 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2640 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2641 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2642 |
2755 | 2643 } |
2644 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2645 { | |
2646 PREDICT_8x8_LOAD_TOP; | |
2647 PREDICT_8x8_LOAD_LEFT; | |
2648 PREDICT_8x8_LOAD_TOPLEFT; | |
2649 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2650 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2651 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2652 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2653 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2654 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2655 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2656 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2657 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2658 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2659 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2660 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2661 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2662 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2663 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2664 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2665 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2666 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2667 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2668 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2669 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2670 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2671 } | |
2672 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2673 { | |
2674 PREDICT_8x8_LOAD_TOP; | |
2675 PREDICT_8x8_LOAD_LEFT; | |
2676 PREDICT_8x8_LOAD_TOPLEFT; | |
2677 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2678 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2679 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2680 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2681 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2682 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2683 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2684 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2685 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2686 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2687 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2688 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2689 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2690 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2691 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2692 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2693 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2694 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2695 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2696 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2697 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2698 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2699 } | |
2700 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2701 { | |
2702 PREDICT_8x8_LOAD_TOP; | |
2703 PREDICT_8x8_LOAD_TOPRIGHT; | |
2704 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2705 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2706 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2707 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2708 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2709 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2710 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2711 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2712 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2713 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2714 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2715 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2716 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2717 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2718 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2719 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2720 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2721 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2722 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2723 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2724 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2725 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2726 } | |
2727 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2728 { | |
2729 PREDICT_8x8_LOAD_LEFT; | |
2730 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2731 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2732 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2733 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2734 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2735 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2736 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2737 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2738 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2739 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2740 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2741 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2742 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2743 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2744 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2745 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2746 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2747 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2748 } | |
2749 #undef PREDICT_8x8_LOAD_LEFT | |
2750 #undef PREDICT_8x8_LOAD_TOP | |
2751 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2752 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2753 #undef PREDICT_8x8_DC | |
2754 #undef PTR | |
2755 #undef PT | |
2756 #undef PL | |
2757 #undef SRC | |
2758 | |
1168 | 2759 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2760 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2761 int src_x_offset, int src_y_offset, | |
2762 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2763 MpegEncContext * const s = &h->s; | |
2764 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2765 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2766 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2767 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2768 uint8_t * src_cb, * src_cr; | |
2769 int extra_width= h->emu_edge_width; | |
2770 int extra_height= h->emu_edge_height; | |
1168 | 2771 int emu=0; |
2772 const int full_mx= mx>>2; | |
2773 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2774 const int pic_width = 16*s->mb_width; |
3316 | 2775 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2776 |
4390 | 2777 if(!pic->data[0]) //FIXME this is unacceptable, some senseable error concealment must be done for missing reference frames |
3125 | 2778 return; |
2967 | 2779 |
1168 | 2780 if(mx&7) extra_width -= 3; |
2781 if(my&7) extra_height -= 3; | |
2967 | 2782 |
2783 if( full_mx < 0-extra_width | |
2784 || full_my < 0-extra_height | |
2785 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2786 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2787 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); |
2788 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2789 emu=1; |
2790 } | |
2967 | 2791 |
3316 | 2792 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2793 if(!square){ |
3316 | 2794 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2795 } |
2967 | 2796 |
1168 | 2797 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2798 |
3316 | 2799 if(MB_MBAFF){ |
2800 // chroma offset when predicting from a field of opposite parity | |
2801 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2802 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2803 } | |
2804 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2805 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2806 |
2807 if(emu){ | |
3316 | 2808 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); |
2809 src_cb= s->edge_emu_buffer; | |
2810 } | |
2811 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2812 | |
2813 if(emu){ | |
2814 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 | 2815 src_cr= s->edge_emu_buffer; |
2816 } | |
3316 | 2817 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2818 } |
2819 | |
2415 | 2820 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2821 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2822 int x_offset, int y_offset, | |
2823 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2824 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2825 int list0, int list1){ | |
2826 MpegEncContext * const s = &h->s; | |
2827 qpel_mc_func *qpix_op= qpix_put; | |
2828 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2829 |
3316 | 2830 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2831 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2832 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2833 x_offset += 8*s->mb_x; |
3316 | 2834 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2835 |
1168 | 2836 if(list0){ |
1169 | 2837 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2838 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2839 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2840 qpix_op, chroma_op); | |
2841 | |
2842 qpix_op= qpix_avg; | |
2843 chroma_op= chroma_avg; | |
2844 } | |
2845 | |
2846 if(list1){ | |
1169 | 2847 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2848 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2849 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2850 qpix_op, chroma_op); | |
2851 } | |
2852 } | |
2853 | |
2415 | 2854 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2855 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2856 int x_offset, int y_offset, | |
2857 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2858 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2859 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2860 int list0, int list1){ | |
2861 MpegEncContext * const s = &h->s; | |
2862 | |
3316 | 2863 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2864 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2865 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2866 x_offset += 8*s->mb_x; |
3316 | 2867 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2868 |
2415 | 2869 if(list0 && list1){ |
2870 /* don't optimize for luma-only case, since B-frames usually | |
2871 * use implicit weights => chroma too. */ | |
2872 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2873 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2874 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2875 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2876 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2877 | |
2878 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2879 dest_y, dest_cb, dest_cr, | |
2880 x_offset, y_offset, qpix_put, chroma_put); | |
2881 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2882 tmp_y, tmp_cb, tmp_cr, | |
2883 x_offset, y_offset, qpix_put, chroma_put); | |
2884 | |
2885 if(h->use_weight == 2){ | |
2886 int weight0 = h->implicit_weight[refn0][refn1]; | |
2887 int weight1 = 64 - weight0; | |
3316 | 2888 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2889 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2890 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 2891 }else{ |
3316 | 2892 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 2893 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 2894 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 2895 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2896 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 2897 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 2898 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2899 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 2900 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 2901 } |
2902 }else{ | |
2903 int list = list1 ? 1 : 0; | |
2904 int refn = h->ref_cache[list][ scan8[n] ]; | |
2905 Picture *ref= &h->ref_list[list][refn]; | |
2906 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2907 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2908 qpix_put, chroma_put); | |
2909 | |
3316 | 2910 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 2911 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
2912 if(h->use_weight_chroma){ | |
3316 | 2913 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2914 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 2915 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2916 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
2917 } | |
2918 } | |
2919 } | |
2920 | |
2921 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2922 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2923 int x_offset, int y_offset, | |
2924 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2925 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 2926 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 2927 int list0, int list1){ |
2928 if((h->use_weight==2 && list0 && list1 | |
2929 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2930 || h->use_weight==1) | |
2931 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2932 x_offset, y_offset, qpix_put, chroma_put, | |
2933 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2934 else | |
2935 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2936 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2937 } | |
2938 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2939 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
|
2940 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2941 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2942 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2943 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
|
2944 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2945 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
|
2946 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
|
2947 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 2948 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
|
2949 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
|
2950 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
|
2951 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
|
2952 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2953 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2954 |
1168 | 2955 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2956 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2957 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2958 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2959 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
|
2960 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2961 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 2962 |
1168 | 2963 assert(IS_INTER(mb_type)); |
2967 | 2964 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2965 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2966 |
1168 | 2967 if(IS_16X16(mb_type)){ |
2968 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2969 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2970 &weight_op[0], &weight_avg[0], |
1168 | 2971 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2972 }else if(IS_16X8(mb_type)){ | |
2973 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2974 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2975 &weight_op[1], &weight_avg[1], |
1168 | 2976 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2977 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
2978 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2979 &weight_op[1], &weight_avg[1], |
1168 | 2980 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2981 }else if(IS_8X16(mb_type)){ | |
3316 | 2982 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 2983 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2984 &weight_op[2], &weight_avg[2], |
1168 | 2985 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 2986 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 2987 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2988 &weight_op[2], &weight_avg[2], |
1168 | 2989 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2990 }else{ | |
2991 int i; | |
2967 | 2992 |
1168 | 2993 assert(IS_8X8(mb_type)); |
2994 | |
2995 for(i=0; i<4; i++){ | |
2996 const int sub_mb_type= h->sub_mb_type[i]; | |
2997 const int n= 4*i; | |
2998 int x_offset= (i&1)<<2; | |
2999 int y_offset= (i&2)<<1; | |
3000 | |
3001 if(IS_SUB_8X8(sub_mb_type)){ | |
3002 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3003 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 3004 &weight_op[3], &weight_avg[3], |
1168 | 3005 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3006 }else if(IS_SUB_8X4(sub_mb_type)){ | |
3007 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3008 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3009 &weight_op[4], &weight_avg[4], |
1168 | 3010 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3011 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
3012 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3013 &weight_op[4], &weight_avg[4], |
1168 | 3014 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3015 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 3016 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 3017 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3018 &weight_op[5], &weight_avg[5], |
1168 | 3019 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 3020 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 3021 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3022 &weight_op[5], &weight_avg[5], |
1168 | 3023 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3024 }else{ | |
3025 int j; | |
3026 assert(IS_SUB_4X4(sub_mb_type)); | |
3027 for(j=0; j<4; j++){ | |
3028 int sub_x_offset= x_offset + 2*(j&1); | |
3029 int sub_y_offset= y_offset + (j&2); | |
3030 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
3031 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 3032 &weight_op[6], &weight_avg[6], |
1168 | 3033 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3034 } | |
3035 } | |
3036 } | |
3037 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3038 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3039 prefetch_motion(h, 1); |
1168 | 3040 } |
3041 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3042 static void decode_init_vlc(){ |
1168 | 3043 static int done = 0; |
3044 | |
3045 if (!done) { | |
3046 int i; | |
3047 done = 1; | |
3048 | |
2967 | 3049 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 3050 &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
|
3051 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 3052 |
3053 for(i=0; i<4; i++){ | |
2967 | 3054 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 3055 &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
|
3056 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 3057 } |
3058 | |
3059 for(i=0; i<3; i++){ | |
3060 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
3061 &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
|
3062 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3063 } |
3064 for(i=0; i<15; i++){ | |
2967 | 3065 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 3066 &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
|
3067 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3068 } |
3069 | |
3070 for(i=0; i<6; i++){ | |
2967 | 3071 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 3072 &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
|
3073 &run_bits[i][0], 1, 1, 1); |
1168 | 3074 } |
2967 | 3075 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 3076 &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
|
3077 &run_bits[6][0], 1, 1, 1); |
1168 | 3078 } |
3079 } | |
3080 | |
3081 /** | |
3082 * Sets the intra prediction function pointers. | |
3083 */ | |
3084 static void init_pred_ptrs(H264Context *h){ | |
3085 // MpegEncContext * const s = &h->s; | |
3086 | |
3087 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
3088 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
3089 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
3090 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
3091 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
3092 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
3093 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
3094 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
3095 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
3096 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
3097 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
3098 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
3099 | |
2755 | 3100 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
3101 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
3102 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
3103 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
3104 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
3105 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
3106 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
3107 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
3108 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
3109 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
3110 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
3111 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
3112 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3113 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3114 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3115 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3116 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c; |
1168 | 3117 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; |
3118 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
|
3119 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
|
3120 |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3121 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3122 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3123 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3124 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c; |
1168 | 3125 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; |
3126 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
|
3127 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c; |
1168 | 3128 } |
3129 | |
3130 static void free_tables(H264Context *h){ | |
3131 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
|
3132 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
|
3133 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
|
3134 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
|
3135 av_freep(&h->mvd_table[1]); |
2396 | 3136 av_freep(&h->direct_table); |
1168 | 3137 av_freep(&h->non_zero_count); |
3138 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
|
3139 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3140 av_freep(&h->top_borders[0]); |
1168 | 3141 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
|
3142 |
1168 | 3143 av_freep(&h->mb2b_xy); |
3144 av_freep(&h->mb2b8_xy); | |
2415 | 3145 |
3146 av_freep(&h->s.obmc_scratchpad); | |
1168 | 3147 } |
3148 | |
2919 | 3149 static void init_dequant8_coeff_table(H264Context *h){ |
3150 int i,q,x; | |
3174 | 3151 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 3152 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
3153 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
3154 | |
3155 for(i=0; i<2; i++ ){ | |
3156 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
3157 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
3158 break; | |
3159 } | |
3160 | |
3161 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3162 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3163 int idx = ff_rem6[q]; |
2919 | 3164 for(x=0; x<64; x++) |
3174 | 3165 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
3166 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
3167 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 3168 } |
3169 } | |
3170 } | |
3171 | |
3172 static void init_dequant4_coeff_table(H264Context *h){ | |
3173 int i,j,q,x; | |
3005 | 3174 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 3175 for(i=0; i<6; i++ ){ |
3176 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
3177 for(j=0; j<i; j++){ | |
3178 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
3179 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
3180 break; | |
3181 } | |
3182 } | |
3183 if(j<i) | |
3184 continue; | |
3185 | |
3186 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3187 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3188 int idx = ff_rem6[q]; |
2919 | 3189 for(x=0; x<16; x++) |
3005 | 3190 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
3191 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 3192 h->pps.scaling_matrix4[i][x]) << shift; |
3193 } | |
3194 } | |
3195 } | |
3196 | |
3197 static void init_dequant_tables(H264Context *h){ | |
3198 int i,x; | |
3199 init_dequant4_coeff_table(h); | |
3200 if(h->pps.transform_8x8_mode) | |
3201 init_dequant8_coeff_table(h); | |
3202 if(h->sps.transform_bypass){ | |
3203 for(i=0; i<6; i++) | |
3204 for(x=0; x<16; x++) | |
3205 h->dequant4_coeff[i][0][x] = 1<<6; | |
3206 if(h->pps.transform_8x8_mode) | |
3207 for(i=0; i<2; i++) | |
3208 for(x=0; x<64; x++) | |
3209 h->dequant8_coeff[i][0][x] = 1<<6; | |
3210 } | |
3211 } | |
3212 | |
3213 | |
1168 | 3214 /** |
3215 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3216 * needs width/height |
1168 | 3217 */ |
3218 static int alloc_tables(H264Context *h){ | |
3219 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
|
3220 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 3221 int x,y; |
1168 | 3222 |
3223 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
|
3224 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3225 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 3226 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
|
3227 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
|
3228 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 3229 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 3230 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3231 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
|
3232 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
|
3233 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
|
3234 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 3235 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
|
3236 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3237 |
3316 | 3238 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
3239 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 3240 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
3241 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
|
3242 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 3243 for(y=0; y<s->mb_height; y++){ |
3244 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
|
3245 const int mb_xy= x + y*s->mb_stride; |
1168 | 3246 const int b_xy = 4*x + 4*y*h->b_stride; |
3247 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 3248 |
1168 | 3249 h->mb2b_xy [mb_xy]= b_xy; |
3250 h->mb2b8_xy[mb_xy]= b8_xy; | |
3251 } | |
3252 } | |
2415 | 3253 |
2417 | 3254 s->obmc_scratchpad = NULL; |
3255 | |
2920 | 3256 if(!h->dequant4_coeff[0]) |
3257 init_dequant_tables(h); | |
3258 | |
1168 | 3259 return 0; |
3260 fail: | |
3261 free_tables(h); | |
3262 return -1; | |
3263 } | |
3264 | |
3265 static void common_init(H264Context *h){ | |
3266 MpegEncContext * const s = &h->s; | |
3267 | |
3268 s->width = s->avctx->width; | |
3269 s->height = s->avctx->height; | |
3270 s->codec_id= s->avctx->codec->id; | |
2967 | 3271 |
1168 | 3272 init_pred_ptrs(h); |
3273 | |
2919 | 3274 h->dequant_coeff_pps= -1; |
1698 | 3275 s->unrestricted_mv=1; |
1168 | 3276 s->decode=1; //FIXME |
2920 | 3277 |
3278 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
3279 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 3280 } |
3281 | |
3282 static int decode_init(AVCodecContext *avctx){ | |
3283 H264Context *h= avctx->priv_data; | |
3284 MpegEncContext * const s = &h->s; | |
3285 | |
1892 | 3286 MPV_decode_defaults(s); |
2967 | 3287 |
1168 | 3288 s->avctx = avctx; |
3289 common_init(h); | |
3290 | |
3291 s->out_format = FMT_H264; | |
3292 s->workaround_bugs= avctx->workaround_bugs; | |
3293 | |
3294 // set defaults | |
3295 // s->decode_mb= ff_h263_decode_mb; | |
3296 s->low_delay= 1; | |
3297 avctx->pix_fmt= PIX_FMT_YUV420P; | |
3298 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3299 decode_init_vlc(); |
2967 | 3300 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3301 if(avctx->extradata_size > 0 && avctx->extradata && |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3302 *(char *)avctx->extradata == 1){ |
2227 | 3303 h->is_avc = 1; |
3304 h->got_avcC = 0; | |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3305 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3306 h->is_avc = 0; |
2227 | 3307 } |
3308 | |
1168 | 3309 return 0; |
3310 } | |
3311 | |
2935 | 3312 static int frame_start(H264Context *h){ |
1168 | 3313 MpegEncContext * const s = &h->s; |
3314 int i; | |
3315 | |
2935 | 3316 if(MPV_frame_start(s, s->avctx) < 0) |
3317 return -1; | |
1168 | 3318 ff_er_frame_start(s); |
3319 | |
3320 assert(s->linesize && s->uvlinesize); | |
3321 | |
3322 for(i=0; i<16; i++){ | |
3323 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
|
3324 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 3325 } |
3326 for(i=0; i<4; i++){ | |
3327 h->block_offset[16+i]= | |
3328 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
|
3329 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3330 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 3331 } |
3332 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
3333 /* 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
|
3334 * 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
|
3335 if(!s->obmc_scratchpad) |
3316 | 3336 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
3337 | |
3338 /* some macroblocks will be accessed before they're available */ | |
3339 if(FRAME_MBAFF) | |
3340 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
|
3341 |
1168 | 3342 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 3343 return 0; |
1168 | 3344 } |
3345 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3346 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
|
3347 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
|
3348 int i; |
2967 | 3349 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3350 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
|
3351 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
|
3352 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
|
3353 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3354 // 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
|
3355 // 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
|
3356 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
|
3357 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
|
3358 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
|
3359 } |
2967 | 3360 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3361 *(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
|
3362 *(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
|
3363 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3364 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
|
3365 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
|
3366 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
|
3367 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
|
3368 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
|
3369 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
|
3370 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3371 *(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
|
3372 *(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
|
3373 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3374 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3375 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3376 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
|
3377 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
|
3378 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
|
3379 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3380 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
|
3381 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
|
3382 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3383 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
|
3384 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
|
3385 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
|
3386 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3387 #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
|
3388 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3389 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3390 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3391 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3392 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3393 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3394 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
|
3395 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
|
3396 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3397 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3398 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3399 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3400 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
|
3401 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3402 if(s->mb_x+1 < s->mb_width){ |
2755 | 3403 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3404 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3405 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3406 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3407 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
|
3408 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3409 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
|
3410 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
|
3411 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
|
3412 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3413 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3414 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3415 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
|
3416 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
|
3417 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3418 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3419 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3420 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3421 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
|
3422 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3423 int i; |
2967 | 3424 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3425 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3426 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3427 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3428 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3429 // 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
|
3430 // 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
|
3431 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
|
3432 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
|
3433 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3434 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
|
3435 } |
2967 | 3436 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3437 *(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
|
3438 *(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
|
3439 *(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
|
3440 *(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
|
3441 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3442 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3443 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
|
3444 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
|
3445 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
|
3446 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
|
3447 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3448 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
|
3449 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
|
3450 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3451 *(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
|
3452 *(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
|
3453 *(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
|
3454 *(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
|
3455 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3456 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3457 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3458 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
|
3459 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3460 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3461 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3462 int deblock_left = (s->mb_x > 0); |
3316 | 3463 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
|
3464 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3465 tprintf("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); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3466 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3467 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3468 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3469 src_cr -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3470 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3471 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3472 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3473 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3474 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3475 b= t; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3476 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3477 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3478 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
|
3479 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
|
3480 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3481 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3482 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3483 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3484 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
|
3485 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
|
3486 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
|
3487 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3488 if(s->mb_x+1 < s->mb_width){ |
3489 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3490 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3491 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3492 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3493 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3494 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3495 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3496 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
|
3497 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
|
3498 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
|
3499 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3500 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3501 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3502 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
|
3503 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
|
3504 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
|
3505 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
|
3506 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3507 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3508 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3509 |
1168 | 3510 static void hl_decode_mb(H264Context *h){ |
3511 MpegEncContext * const s = &h->s; | |
3512 const int mb_x= s->mb_x; | |
3513 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
|
3514 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3515 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3516 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3517 int linesize, uvlinesize /*dct_offset*/; | |
3518 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3519 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
|
3520 const unsigned int bottom = mb_y & 1; |
2763 | 3521 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass); |
3522 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
|
3523 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3524 |
3525 if(!s->decode) | |
3526 return; | |
3527 | |
3528 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3529 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3530 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3531 | |
4000 | 3532 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3533 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3534 | |
3316 | 3535 if (MB_FIELD) { |
3536 linesize = h->mb_linesize = s->linesize * 2; | |
3537 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
|
3538 block_offset = &h->block_offset[24]; |
1168 | 3539 if(mb_y&1){ //FIXME move out of this func? |
3540 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3541 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3542 dest_cr-= s->uvlinesize*7; |
1168 | 3543 } |
3316 | 3544 if(FRAME_MBAFF) { |
3545 int list; | |
4533 | 3546 for(list=0; list<h->list_count; list++){ |
3316 | 3547 if(!USES_LIST(mb_type, list)) |
3548 continue; | |
3549 if(IS_16X16(mb_type)){ | |
3550 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3551 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3552 }else{ | |
3553 for(i=0; i<16; i+=4){ | |
3554 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3555 int ref = h->ref_cache[list][scan8[i]]; | |
3556 if(ref >= 0) | |
3557 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3558 } | |
3559 } | |
3560 } | |
3561 } | |
1168 | 3562 } else { |
3316 | 3563 linesize = h->mb_linesize = s->linesize; |
3564 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3565 // dct_offset = s->linesize * 16; |
3566 } | |
2967 | 3567 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3568 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3569 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3570 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
|
3571 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3572 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3573 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3574 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3575 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3576 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3577 } |
1168 | 3578 |
3316 | 3579 if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3580 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ | |
3581 int mbt_y = mb_y&~1; | |
3582 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3583 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3584 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3585 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3586 } | |
3587 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3588 if (IS_INTRA_PCM(mb_type)) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3589 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3590 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3591 // 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
|
3592 // 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
|
3593 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3594 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3595 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
|
3596 *(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
|
3597 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3598 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3599 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3600 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3601 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3602 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
|
3603 *(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
|
3604 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3605 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3606 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3607 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3608 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3609 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
|
3610 *(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
|
3611 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3612 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3613 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3614 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3615 if(IS_INTRA(mb_type)){ |
3316 | 3616 if(h->deblocking_filter && !FRAME_MBAFF) |
3617 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
|
3618 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3619 if(!(s->flags&CODEC_FLAG_GRAY)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3620 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
|
3621 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
|
3622 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3623 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3624 if(IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3625 if(!s->encoding){ |
2755 | 3626 if(IS_8x8DCT(mb_type)){ |
3627 for(i=0; i<16; i+=4){ | |
3628 uint8_t * const ptr= dest_y + block_offset[i]; | |
3629 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
|
3630 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3631 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
3632 (h->topright_samples_available<<(i+1))&0x8000, linesize); | |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3633 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3634 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3635 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3636 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3637 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3638 } |
2755 | 3639 } |
3640 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3641 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
|
3642 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
|
3643 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3644 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
|
3645 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3646 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3647 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
|
3648 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
|
3649 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
|
3650 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3651 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3652 topright= (uint8_t*) &tr; |
2967 | 3653 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3654 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3655 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3656 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3657 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3658 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3659 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3660 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3661 if(s->codec_id == CODEC_ID_H264){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3662 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3663 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3664 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3665 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3666 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3667 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
|
3668 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3669 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3670 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3671 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3672 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
2763 | 3673 if(s->codec_id == CODEC_ID_H264){ |
3674 if(!transform_bypass) | |
2919 | 3675 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3676 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3677 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
|
3678 } |
3316 | 3679 if(h->deblocking_filter && !FRAME_MBAFF) |
3680 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3681 }else if(s->codec_id == CODEC_ID_H264){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3682 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
|
3683 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
|
3684 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
|
3685 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
|
3686 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3687 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3688 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3689 if(!IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3690 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3691 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3692 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3693 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3694 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
|
3695 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3696 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
|
3697 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3698 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3699 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3700 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3701 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3702 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3703 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3704 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
|
3705 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3706 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
|
3707 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3708 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3709 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3710 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3711 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
|
3712 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
|
3713 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
|
3714 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3715 } |
1168 | 3716 } |
3717 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3718 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3719 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3720 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3721 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3722 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3723 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3724 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3725 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3726 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3727 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]); |
3728 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 | 3729 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3730 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3731 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3732 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3733 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
|
3734 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3735 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
|
3736 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3737 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3738 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
|
3739 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
|
3740 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
|
3741 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
|
3742 } |
1250 | 3743 } |
1168 | 3744 } |
3745 } | |
3746 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3747 if(h->deblocking_filter) { |
3316 | 3748 if (FRAME_MBAFF) { |
3749 //FIXME try deblocking one mb at a time? | |
3750 // 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
|
3751 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
|
3752 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
|
3753 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
|
3754 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
|
3755 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
|
3756 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3757 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
|
3758 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
|
3759 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
|
3760 |
3316 | 3761 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3762 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3763 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3764 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3765 // deblock a pair |
2967 | 3766 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3767 s->mb_y--; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3768 tprintf("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
|
3769 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3770 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
|
3771 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
|
3772 // bottom |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3773 s->mb_y++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3774 tprintf("call mbaff filter_mb\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3775 fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3776 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
|
3777 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
|
3778 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3779 tprintf("call filter_mb\n"); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3780 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
|
3781 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
|
3782 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
|
3783 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3784 } |
1168 | 3785 } |
3786 | |
3787 /** | |
3788 * fills the default_ref_list. | |
3789 */ | |
3790 static int fill_default_ref_list(H264Context *h){ | |
3791 MpegEncContext * const s = &h->s; | |
3792 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
|
3793 int smallest_poc_greater_than_current = -1; |
2582 | 3794 Picture sorted_short_ref[32]; |
2967 | 3795 |
1168 | 3796 if(h->slice_type==B_TYPE){ |
3797 int out_i; | |
2713 | 3798 int limit= INT_MIN; |
1168 | 3799 |
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
|
3800 /* sort frame according to poc in B slice */ |
1168 | 3801 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3802 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
|
3803 int best_poc=INT_MAX; |
1168 | 3804 |
3805 for(i=0; i<h->short_ref_count; i++){ | |
3806 const int poc= h->short_ref[i]->poc; | |
3807 if(poc > limit && poc < best_poc){ | |
3808 best_poc= poc; | |
3809 best_i= i; | |
3810 } | |
3811 } | |
2967 | 3812 |
2713 | 3813 assert(best_i != INT_MIN); |
2967 | 3814 |
1168 | 3815 limit= best_poc; |
3816 sorted_short_ref[out_i]= *h->short_ref[best_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
|
3817 tprintf("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); |
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
|
3818 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
|
3819 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
|
3820 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
|
3821 } |
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
|
3822 } |
1168 | 3823 } |
3824 } | |
3825 | |
3826 if(s->picture_structure == PICT_FRAME){ | |
3827 if(h->slice_type==B_TYPE){ | |
3828 int 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
|
3829 tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, 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
|
3830 |
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
|
3831 // find the largest poc |
1168 | 3832 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
|
3833 int index = 0; |
2447 | 3834 int j= -99; |
3835 int step= list ? -1 : 1; | |
3836 | |
3837 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3838 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
|
3839 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3840 return -1; |
2447 | 3841 step = -step; |
3842 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
|
3843 } |
2447 | 3844 if(sorted_short_ref[j].reference != 3) continue; |
3845 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3846 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3847 } |
3848 | |
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
|
3849 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
|
3850 if(h->long_ref[i] == NULL) continue; |
1168 | 3851 if(h->long_ref[i]->reference != 3) continue; |
3852 | |
3853 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3854 h->default_ref_list[ list ][index++].pic_id= i;; | |
3855 } | |
2967 | 3856 |
2447 | 3857 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
|
3858 // 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
|
3859 // L0 and L1 are identical |
1168 | 3860 Picture temp= h->default_ref_list[1][0]; |
3861 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3862 h->default_ref_list[1][1] = temp; |
1168 | 3863 } |
3864 | |
3865 if(index < h->ref_count[ list ]) | |
3866 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3867 } | |
3868 }else{ | |
3869 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3870 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3871 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3872 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3873 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3874 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3875 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
|
3876 if(h->long_ref[i] == NULL) continue; |
1168 | 3877 if(h->long_ref[i]->reference != 3) continue; |
3878 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3879 h->default_ref_list[0][index++].pic_id= i;; | |
3880 } | |
3881 if(index < h->ref_count[0]) | |
3882 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3883 } | |
3884 }else{ //FIELD | |
3885 if(h->slice_type==B_TYPE){ | |
3886 }else{ | |
3887 //FIXME second field balh | |
3888 } | |
3889 } | |
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
|
3890 #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
|
3891 for (i=0; i<h->ref_count[0]; 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
|
3892 tprintf("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]); |
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 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
|
3895 for (i=0; i<h->ref_count[1]; 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
|
3896 tprintf("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]); |
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 } |
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 } |
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 #endif |
1168 | 3900 return 0; |
3901 } | |
3902 | |
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
|
3903 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
|
3904 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
|
3905 |
1168 | 3906 static int decode_ref_pic_list_reordering(H264Context *h){ |
3907 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3908 int list, index; |
2967 | 3909 |
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
|
3910 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
|
3911 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3912 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 3913 |
4533 | 3914 for(list=0; list<h->list_count; list++){ |
1168 | 3915 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); |
3916 | |
3917 if(get_bits1(&s->gb)){ | |
3918 int pred= h->curr_pic_num; | |
3919 | |
3920 for(index=0; ; index++){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3921 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
|
3922 unsigned int pic_id; |
1168 | 3923 int i; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3924 Picture *ref = NULL; |
2967 | 3925 |
3926 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
|
3927 break; |
2967 | 3928 |
1168 | 3929 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3930 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3931 return -1; |
3932 } | |
2967 | 3933 |
1168 | 3934 if(reordering_of_pic_nums_idc<3){ |
3935 if(reordering_of_pic_nums_idc<2){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3936 const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; |
1168 | 3937 |
3938 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
|
3939 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3940 return -1; |
3941 } | |
3942 | |
3943 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3944 else pred+= abs_diff_pic_num; | |
3945 pred &= h->max_pic_num - 1; | |
2967 | 3946 |
2683 | 3947 for(i= h->short_ref_count-1; i>=0; i--){ |
3948 ref = h->short_ref[i]; | |
3949 assert(ref->reference == 3); | |
3950 assert(!ref->long_ref); | |
3951 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 3952 break; |
3953 } | |
2683 | 3954 if(i>=0) |
3955 ref->pic_id= ref->frame_num; | |
1168 | 3956 }else{ |
3957 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
|
3958 if(pic_id>31){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3959 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
|
3960 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
3961 } |
2683 | 3962 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
|
3963 if(ref){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3964 ref->pic_id= pic_id; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3965 assert(ref->reference == 3); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3966 assert(ref->long_ref); |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3967 i=0; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3968 }else{ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3969 i=-1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
3970 } |
1168 | 3971 } |
3972 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3973 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3974 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3975 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 3976 } else { |
3977 for(i=index; i+1<h->ref_count[list]; i++){ | |
3978 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
3979 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
|
3980 } |
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
|
3981 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
|
3982 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
|
3983 } |
2683 | 3984 h->ref_list[list][index]= *ref; |
1168 | 3985 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3986 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3987 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3988 return -1; |
3989 } | |
3990 } | |
3991 } | |
4533 | 3992 } |
3993 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
|
3994 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
|
3995 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3996 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3997 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3998 } |
2967 | 3999 |
2396 | 4000 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
4001 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
4002 direct_ref_list_init(h); |
2967 | 4003 return 0; |
1168 | 4004 } |
4005 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
4006 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 4007 int list, i, j; |
4533 | 4008 for(list=0; list<2; list++){ //FIXME try list_count |
3316 | 4009 for(i=0; i<h->ref_count[list]; i++){ |
4010 Picture *frame = &h->ref_list[list][i]; | |
4011 Picture *field = &h->ref_list[list][16+2*i]; | |
4012 field[0] = *frame; | |
4013 for(j=0; j<3; j++) | |
4014 field[0].linesize[j] <<= 1; | |
4015 field[1] = field[0]; | |
4016 for(j=0; j<3; j++) | |
4017 field[1].data[j] += frame->linesize[j]; | |
4018 | |
4019 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4020 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4021 for(j=0; j<2; j++){ | |
4022 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4023 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4024 } | |
4025 } | |
4026 } | |
4027 for(j=0; j<h->ref_count[1]; j++){ | |
4028 for(i=0; i<h->ref_count[0]; i++) | |
4029 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4030 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4031 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4032 } | |
4033 } | |
4034 | |
1168 | 4035 static int pred_weight_table(H264Context *h){ |
4036 MpegEncContext * const s = &h->s; | |
4037 int list, i; | |
2415 | 4038 int luma_def, chroma_def; |
2967 | 4039 |
2415 | 4040 h->use_weight= 0; |
4041 h->use_weight_chroma= 0; | |
1168 | 4042 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4043 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4044 luma_def = 1<<h->luma_log2_weight_denom; |
4045 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4046 |
4047 for(list=0; list<2; list++){ | |
4048 for(i=0; i<h->ref_count[list]; i++){ | |
4049 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4050 |
1168 | 4051 luma_weight_flag= get_bits1(&s->gb); |
4052 if(luma_weight_flag){ | |
4053 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4054 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4055 if( h->luma_weight[list][i] != luma_def |
4056 || h->luma_offset[list][i] != 0) | |
4057 h->use_weight= 1; | |
4058 }else{ | |
4059 h->luma_weight[list][i]= luma_def; | |
4060 h->luma_offset[list][i]= 0; | |
1168 | 4061 } |
4062 | |
4063 chroma_weight_flag= get_bits1(&s->gb); | |
4064 if(chroma_weight_flag){ | |
4065 int j; | |
4066 for(j=0; j<2; j++){ | |
4067 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4068 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4069 if( h->chroma_weight[list][i][j] != chroma_def |
4070 || h->chroma_offset[list][i][j] != 0) | |
4071 h->use_weight_chroma= 1; | |
4072 } | |
4073 }else{ | |
4074 int j; | |
4075 for(j=0; j<2; j++){ | |
4076 h->chroma_weight[list][i][j]= chroma_def; | |
4077 h->chroma_offset[list][i][j]= 0; | |
1168 | 4078 } |
4079 } | |
4080 } | |
4081 if(h->slice_type != B_TYPE) break; | |
4082 } | |
2415 | 4083 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4084 return 0; |
4085 } | |
4086 | |
2415 | 4087 static void implicit_weight_table(H264Context *h){ |
4088 MpegEncContext * const s = &h->s; | |
4089 int ref0, ref1; | |
4090 int cur_poc = s->current_picture_ptr->poc; | |
4091 | |
4092 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4093 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4094 h->use_weight= 0; | |
4095 h->use_weight_chroma= 0; | |
4096 return; | |
4097 } | |
4098 | |
4099 h->use_weight= 2; | |
4100 h->use_weight_chroma= 2; | |
4101 h->luma_log2_weight_denom= 5; | |
4102 h->chroma_log2_weight_denom= 5; | |
4103 | |
4104 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4105 int poc0 = h->ref_list[0][ref0].poc; | |
4106 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4107 int poc1 = h->ref_list[1][ref1].poc; |
2415 | 4108 int td = clip(poc1 - poc0, -128, 127); |
4109 if(td){ | |
4110 int tb = clip(cur_poc - poc0, -128, 127); | |
4001 | 4111 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2415 | 4112 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
4113 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
4114 h->implicit_weight[ref0][ref1] = 32; | |
4115 else | |
4116 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4117 }else | |
4118 h->implicit_weight[ref0][ref1] = 32; | |
4119 } | |
4120 } | |
4121 } | |
4122 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4123 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
|
4124 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4125 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4126 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
|
4127 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4128 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4129 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
|
4130 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
|
4131 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4132 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4133 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4134 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4135 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4136 |
1168 | 4137 /** |
2392 | 4138 * instantaneous decoder refresh. |
1168 | 4139 */ |
4140 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
|
4141 int i; |
1168 | 4142 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4143 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4144 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
|
4145 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
|
4146 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4147 } |
1168 | 4148 } |
4149 h->long_ref_count=0; | |
4150 | |
4151 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
|
4152 unreference_pic(h, h->short_ref[i]); |
1168 | 4153 h->short_ref[i]= NULL; |
4154 } | |
4155 h->short_ref_count=0; | |
4156 } | |
4157 | |
2640 | 4158 /* forget old pics after a seek */ |
4159 static void flush_dpb(AVCodecContext *avctx){ | |
4160 H264Context *h= avctx->priv_data; | |
4161 int i; | |
3144 | 4162 for(i=0; i<16; i++) { |
4163 if(h->delayed_pic[i]) | |
4164 h->delayed_pic[i]->reference= 0; | |
2640 | 4165 h->delayed_pic[i]= NULL; |
3144 | 4166 } |
4167 if(h->delayed_output_pic) | |
4168 h->delayed_output_pic->reference= 0; | |
2640 | 4169 h->delayed_output_pic= NULL; |
4170 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4171 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4172 h->s.current_picture_ptr->reference= 0; |
2640 | 4173 } |
4174 | |
1168 | 4175 /** |
4176 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4177 * @return the removed picture or NULL if an error occurs |
1168 | 4178 */ |
4179 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4180 MpegEncContext * const s = &h->s; |
1168 | 4181 int i; |
2967 | 4182 |
1169 | 4183 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
|
4184 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4185 |
1168 | 4186 for(i=0; i<h->short_ref_count; i++){ |
4187 Picture *pic= h->short_ref[i]; | |
1169 | 4188 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
|
4189 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4190 if(pic->frame_num == frame_num){ |
4191 h->short_ref[i]= NULL; | |
4192 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4193 h->short_ref_count--; | |
4194 return pic; | |
4195 } | |
4196 } | |
4197 return NULL; | |
4198 } | |
4199 | |
4200 /** | |
4201 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4202 * @return the removed picture or NULL if an error occurs |
1168 | 4203 */ |
4204 static Picture * remove_long(H264Context *h, int i){ | |
4205 Picture *pic; | |
4206 | |
4207 pic= h->long_ref[i]; | |
4208 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
|
4209 if(pic) h->long_ref_count--; |
1168 | 4210 |
4211 return pic; | |
4212 } | |
4213 | |
4214 /** | |
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
|
4215 * 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
|
4216 */ |
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
|
4217 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
|
4218 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
|
4219 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
|
4220 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
|
4221 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
|
4222 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
|
4223 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
|
4224 } |
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
|
4225 } |
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
|
4226 } |
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
|
4227 |
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
|
4228 /** |
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
|
4229 * 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
|
4230 */ |
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
|
4231 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
|
4232 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
|
4233 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
|
4234 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
|
4235 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
|
4236 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
|
4237 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
|
4238 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
|
4239 } |
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
|
4240 } |
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
|
4241 } |
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
|
4242 } |
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
|
4243 |
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
|
4244 /** |
1168 | 4245 * Executes the reference picture marking (memory management control operations). |
4246 */ | |
4247 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4248 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
|
4249 int i, j; |
1168 | 4250 int current_is_long=0; |
4251 Picture *pic; | |
2967 | 4252 |
1168 | 4253 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
|
4254 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4255 |
1168 | 4256 for(i=0; i<mmco_count; i++){ |
4257 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
|
4258 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 | 4259 |
4260 switch(mmco[i].opcode){ | |
4261 case MMCO_SHORT2UNUSED: | |
4262 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
|
4263 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4264 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4265 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
|
4266 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4267 break; |
4268 case MMCO_SHORT2LONG: | |
4269 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
|
4270 if(pic) unreference_pic(h, pic); |
2967 | 4271 |
1168 | 4272 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
|
4273 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
|
4274 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
|
4275 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4276 } |
1168 | 4277 break; |
4278 case MMCO_LONG2UNUSED: | |
4279 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
|
4280 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4281 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4282 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
|
4283 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4284 break; |
4285 case MMCO_LONG: | |
4286 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
|
4287 if(pic) unreference_pic(h, pic); |
2967 | 4288 |
1168 | 4289 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4290 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4291 h->long_ref_count++; | |
2967 | 4292 |
1168 | 4293 current_is_long=1; |
4294 break; | |
4295 case MMCO_SET_MAX_LONG: | |
4296 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
|
4297 // 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
|
4298 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
|
4299 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
|
4300 if (pic) unreference_pic(h, pic); |
1168 | 4301 } |
4302 break; | |
4303 case MMCO_RESET: | |
4304 while(h->short_ref_count){ | |
4305 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
|
4306 if(pic) unreference_pic(h, pic); |
1168 | 4307 } |
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
|
4308 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
|
4309 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
|
4310 if(pic) unreference_pic(h, pic); |
1168 | 4311 } |
4312 break; | |
4313 default: assert(0); | |
4314 } | |
4315 } | |
2967 | 4316 |
1168 | 4317 if(!current_is_long){ |
4318 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4319 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4320 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4321 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4322 } |
2967 | 4323 |
1168 | 4324 if(h->short_ref_count) |
1169 | 4325 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4326 | |
4327 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4328 h->short_ref[0]->long_ref=0; |
4329 h->short_ref_count++; | |
4330 } | |
2967 | 4331 |
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
|
4332 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
|
4333 print_long_term(h); |
2967 | 4334 return 0; |
1168 | 4335 } |
4336 | |
4337 static int decode_ref_pic_marking(H264Context *h){ | |
4338 MpegEncContext * const s = &h->s; | |
4339 int i; | |
2967 | 4340 |
1168 | 4341 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4342 s->broken_link= get_bits1(&s->gb) -1; | |
4343 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4344 if(h->mmco[0].long_index == -1) | |
4345 h->mmco_index= 0; | |
4346 else{ | |
4347 h->mmco[0].opcode= MMCO_LONG; | |
4348 h->mmco_index= 1; | |
2967 | 4349 } |
1168 | 4350 }else{ |
4351 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4352 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4353 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4354 | |
4355 h->mmco[i].opcode= opcode; | |
4356 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4357 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 | |
4358 /* 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
|
4359 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4360 return -1; |
4361 }*/ | |
4362 } | |
4363 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
|
4364 unsigned int long_index= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4365 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
|
4366 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4367 return -1; |
4368 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4369 h->mmco[i].long_index= long_index; |
1168 | 4370 } |
2967 | 4371 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4372 if(opcode > (unsigned)MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4373 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4374 return -1; |
4375 } | |
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
|
4376 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
|
4377 break; |
1168 | 4378 } |
4379 h->mmco_index= i; | |
4380 }else{ | |
4381 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4382 | |
4383 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4384 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4385 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4386 h->mmco_index= 1; | |
4387 }else | |
4388 h->mmco_index= 0; | |
4389 } | |
4390 } | |
2967 | 4391 |
4392 return 0; | |
1168 | 4393 } |
4394 | |
4395 static int init_poc(H264Context *h){ | |
4396 MpegEncContext * const s = &h->s; | |
4397 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4398 int field_poc[2]; | |
4399 | |
4400 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4401 h->frame_num_offset= 0; | |
4402 }else{ | |
4403 if(h->frame_num < h->prev_frame_num) | |
4404 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4405 else | |
4406 h->frame_num_offset= h->prev_frame_num_offset; | |
4407 } | |
4408 | |
4409 if(h->sps.poc_type==0){ | |
4410 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4411 | |
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
|
4412 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
|
4413 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
|
4414 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
|
4415 } |
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
|
4416 |
1168 | 4417 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4418 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4419 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4420 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4421 else | |
4422 h->poc_msb = h->prev_poc_msb; | |
4423 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4424 field_poc[0] = |
1168 | 4425 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4426 if(s->picture_structure == PICT_FRAME) |
1168 | 4427 field_poc[1] += h->delta_poc_bottom; |
4428 }else if(h->sps.poc_type==1){ | |
4429 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4430 int i; | |
4431 | |
4432 if(h->sps.poc_cycle_length != 0) | |
4433 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4434 else | |
4435 abs_frame_num = 0; | |
4436 | |
4437 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4438 abs_frame_num--; | |
2967 | 4439 |
1168 | 4440 expected_delta_per_poc_cycle = 0; |
4441 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4442 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4443 | |
4444 if(abs_frame_num > 0){ | |
4445 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4446 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4447 | |
4448 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4449 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4450 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4451 } else | |
4452 expectedpoc = 0; | |
4453 | |
2967 | 4454 if(h->nal_ref_idc == 0) |
1168 | 4455 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4456 |
1168 | 4457 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4458 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4459 | |
4460 if(s->picture_structure == PICT_FRAME) | |
4461 field_poc[1] += h->delta_poc[1]; | |
4462 }else{ | |
4463 int poc; | |
4464 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4465 poc= 0; | |
4466 }else{ | |
4467 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4468 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4469 } | |
4470 field_poc[0]= poc; | |
4471 field_poc[1]= poc; | |
4472 } | |
2967 | 4473 |
1168 | 4474 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4475 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4476 if(s->picture_structure != PICT_TOP_FIELD) | |
4477 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4478 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4479 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4480 | |
4481 return 0; | |
4482 } | |
4483 | |
4484 /** | |
4485 * decodes a slice header. | |
4486 * this will allso call MPV_common_init() and frame_start() as needed | |
4487 */ | |
4488 static int decode_slice_header(H264Context *h){ | |
4489 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4490 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
|
4491 unsigned int pps_id; |
1168 | 4492 int num_ref_idx_active_override_flag; |
4493 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
|
4494 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
|
4495 int default_ref_list_done = 0; |
1168 | 4496 |
4497 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
|
4498 s->dropable= h->nal_ref_idc == 0; |
1168 | 4499 |
4500 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4501 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4502 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
|
4503 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4504 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 | 4505 return -1; |
1168 | 4506 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4507 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4508 slice_type -= 5; |
1168 | 4509 h->slice_type_fixed=1; |
4510 }else | |
4511 h->slice_type_fixed=0; | |
2967 | 4512 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4513 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
|
4514 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
|
4515 || (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
|
4516 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
|
4517 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4518 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
|
4519 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4520 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4521 |
1168 | 4522 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
|
4523 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4524 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4525 return -1; |
4526 } | |
4527 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4528 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
|
4529 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4530 return -1; |
4531 } | |
4532 | |
1168 | 4533 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4534 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
|
4535 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4536 return -1; |
4537 } | |
2919 | 4538 |
4363 | 4539 if(h->dequant_coeff_pps != pps_id){ |
4540 h->dequant_coeff_pps = pps_id; | |
2919 | 4541 init_dequant_tables(h); |
4542 } | |
2967 | 4543 |
1168 | 4544 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
|
4545 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4546 |
3178 | 4547 h->b_stride= s->mb_width*4; |
4548 h->b8_stride= s->mb_width*2; | |
1168 | 4549 |
1371 | 4550 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4551 if(h->sps.frame_mbs_only_flag) |
1371 | 4552 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4553 else |
1371 | 4554 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4555 |
4556 if (s->context_initialized | |
1548 | 4557 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4558 free_tables(h); |
4559 MPV_common_end(s); | |
4560 } | |
4561 if (!s->context_initialized) { | |
4562 if (MPV_common_init(s) < 0) | |
4563 return -1; | |
2967 | 4564 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4565 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
|
4566 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
|
4567 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
|
4568 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4569 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4570 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4571 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4572 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4573 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4574 #undef T |
4575 } | |
4576 } | |
4577 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4578 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4579 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4580 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4581 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4582 }else{ |
4583 int i; | |
4584 for(i=0; i<64; i++){ | |
4585 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4586 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4587 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4588 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4589 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4590 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4591 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4592 } |
2763 | 4593 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4594 h->zigzag_scan_q0 = zigzag_scan; |
4595 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4596 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4597 h->field_scan_q0 = field_scan; |
4598 h->field_scan8x8_q0 = field_scan8x8; | |
4599 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4600 }else{ |
3316 | 4601 h->zigzag_scan_q0 = h->zigzag_scan; |
4602 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4603 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4604 h->field_scan_q0 = h->field_scan; |
4605 h->field_scan8x8_q0 = h->field_scan8x8; | |
4606 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4607 } |
1168 | 4608 |
4609 alloc_tables(h); | |
4610 | |
4611 s->avctx->width = s->width; | |
4612 s->avctx->height = s->height; | |
1548 | 4613 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4614 if(!s->avctx->sample_aspect_ratio.den) |
4615 s->avctx->sample_aspect_ratio.den = 1; | |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
4616 |
2648 | 4617 if(h->sps.timing_info_present_flag){ |
3052 | 4618 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
|
4619 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
|
4620 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4621 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
|
4622 s->avctx->time_base.num, s->avctx->time_base.den, 1<<30); |
2174
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
4623 } |
1168 | 4624 } |
4625 | |
2392 | 4626 if(h->slice_num == 0){ |
2935 | 4627 if(frame_start(h) < 0) |
4628 return -1; | |
1168 | 4629 } |
4630 | |
1169 | 4631 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4632 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4633 | |
3316 | 4634 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4635 h->mb_aff_frame = 0; |
1168 | 4636 if(h->sps.frame_mbs_only_flag){ |
4637 s->picture_structure= PICT_FRAME; | |
4638 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4639 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4640 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4641 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
|
4642 } else { |
1168 | 4643 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4644 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
|
4645 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4646 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4647 assert(s->mb_num == s->mb_width * s->mb_height); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4648 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
|
4649 first_mb_in_slice >= s->mb_num){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4650 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
|
4651 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4652 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4653 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4654 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
|
4655 assert(s->mb_y < s->mb_height); |
2967 | 4656 |
1168 | 4657 if(s->picture_structure==PICT_FRAME){ |
4658 h->curr_pic_num= h->frame_num; | |
4659 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4660 }else{ | |
4661 h->curr_pic_num= 2*h->frame_num; | |
4662 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4663 } | |
2967 | 4664 |
1168 | 4665 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4666 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4667 } |
2967 | 4668 |
1168 | 4669 if(h->sps.poc_type==0){ |
4670 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4671 |
1168 | 4672 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4673 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4674 } | |
4675 } | |
2967 | 4676 |
1168 | 4677 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4678 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4679 |
1168 | 4680 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4681 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4682 } | |
2967 | 4683 |
1168 | 4684 init_poc(h); |
2967 | 4685 |
1168 | 4686 if(h->pps.redundant_pic_cnt_present){ |
4687 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4688 } | |
4689 | |
4690 //set defaults, might be overriden a few line later | |
4691 h->ref_count[0]= h->pps.ref_count[0]; | |
4692 h->ref_count[1]= h->pps.ref_count[1]; | |
4693 | |
4694 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4695 if(h->slice_type == B_TYPE){ | |
4696 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4697 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4698 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4699 } |
4700 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4701 |
1168 | 4702 if(num_ref_idx_active_override_flag){ |
4703 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4704 if(h->slice_type==B_TYPE) | |
4705 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4706 | |
4532 | 4707 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
|
4708 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
|
4709 h->ref_count[0]= h->ref_count[1]= 1; |
1168 | 4710 return -1; |
4711 } | |
4712 } | |
4532 | 4713 if(h->slice_type == B_TYPE) |
4714 h->list_count= 2; | |
4715 else | |
4716 h->list_count= 1; | |
4717 }else | |
4718 h->list_count= 0; | |
1168 | 4719 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4720 if(!default_ref_list_done){ |
1168 | 4721 fill_default_ref_list(h); |
4722 } | |
4723 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4724 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
|
4725 return -1; |
1168 | 4726 |
2967 | 4727 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4728 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4729 pred_weight_table(h); | |
2415 | 4730 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4731 implicit_weight_table(h); | |
4732 else | |
4733 h->use_weight = 0; | |
2967 | 4734 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4735 if(s->current_picture.reference) |
1168 | 4736 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
|
4737 |
3316 | 4738 if(FRAME_MBAFF) |
4739 fill_mbaff_ref_list(h); | |
4740 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4741 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
|
4742 tmp = get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4743 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4744 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
|
4745 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4746 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4747 h->cabac_init_idc= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4748 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4749 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4750 h->last_qscale_diff = 0; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4751 tmp = h->pps.init_qp + get_se_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4752 if(tmp>51){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4753 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); |
1898 | 4754 return -1; |
4755 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4756 s->qscale= tmp; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4757 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4758 //FIXME qscale / qp ... stuff |
4759 if(h->slice_type == SP_TYPE){ | |
1453 | 4760 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4761 } |
4762 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4763 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4764 } |
4765 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4766 h->deblocking_filter = 1; |
1898 | 4767 h->slice_alpha_c0_offset = 0; |
4768 h->slice_beta_offset = 0; | |
1168 | 4769 if( h->pps.deblocking_filter_parameters_present ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4770 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4771 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4772 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
|
4773 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4774 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4775 h->deblocking_filter= tmp; |
2967 | 4776 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
|
4777 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
|
4778 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4779 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
|
4780 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
|
4781 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4782 } |
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
|
4783 } |
2792 | 4784 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4785 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4786 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4787 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4788 h->deblocking_filter= 0; | |
1168 | 4789 |
4790 #if 0 //FMO | |
4791 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4792 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4793 #endif | |
4794 | |
2392 | 4795 h->slice_num++; |
4796 | |
3316 | 4797 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4798 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4799 | |
1168 | 4800 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
|
4801 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
|
4802 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4803 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4804 first_mb_in_slice, |
1264 | 4805 av_get_pict_type_char(h->slice_type), |
1168 | 4806 pps_id, h->frame_num, |
4807 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4808 h->ref_count[0], h->ref_count[1], | |
4809 s->qscale, | |
2583 | 4810 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4811 h->use_weight, |
4812 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4813 ); |
4814 } | |
4815 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4816 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
|
4817 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
|
4818 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
|
4819 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4820 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
|
4821 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
|
4822 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4823 |
1168 | 4824 return 0; |
4825 } | |
4826 | |
4827 /** | |
4828 * | |
4829 */ | |
4830 static inline int get_level_prefix(GetBitContext *gb){ | |
4831 unsigned int buf; | |
4832 int log; | |
2967 | 4833 |
1168 | 4834 OPEN_READER(re, gb); |
4835 UPDATE_CACHE(re, gb); | |
4836 buf=GET_CACHE(re, gb); | |
2967 | 4837 |
1168 | 4838 log= 32 - av_log2(buf); |
4839 #ifdef TRACE | |
4840 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
|
4841 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 | 4842 #endif |
4843 | |
4844 LAST_SKIP_BITS(re, gb, log); | |
4845 CLOSE_READER(re, gb); | |
4846 | |
4847 return log-1; | |
4848 } | |
4849 | |
2755 | 4850 static inline int get_dct8x8_allowed(H264Context *h){ |
4851 int i; | |
4852 for(i=0; i<4; i++){ | |
4853 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
|
4854 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4855 return 0; |
4856 } | |
4857 return 1; | |
4858 } | |
4859 | |
1168 | 4860 /** |
4861 * decodes a residual block. | |
4862 * @param n block index | |
4863 * @param scantable scantable | |
4864 * @param max_coeff number of coefficients in the block | |
4865 * @return <0 if an error occured | |
4866 */ | |
2919 | 4867 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4868 MpegEncContext * const s = &h->s; |
4869 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 | 4870 int level[16]; |
4871 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4872 |
4873 //FIXME put trailing_onex into the context | |
4874 | |
4875 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4876 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4877 total_coeff= coeff_token>>2; | |
2967 | 4878 }else{ |
1168 | 4879 if(n == LUMA_DC_BLOCK_INDEX){ |
4880 total_coeff= pred_non_zero_count(h, 0); | |
4881 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4882 total_coeff= coeff_token>>2; | |
4883 }else{ | |
4884 total_coeff= pred_non_zero_count(h, n); | |
4885 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4886 total_coeff= coeff_token>>2; | |
4887 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4888 } | |
4889 } | |
4890 | |
4891 //FIXME set last_non_zero? | |
4892 | |
4893 if(total_coeff==0) | |
4894 return 0; | |
4391
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4895 if(total_coeff > (unsigned)max_coeff) { |
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4896 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 | 4897 return -1; |
4898 } | |
2967 | 4899 |
1168 | 4900 trailing_ones= coeff_token&3; |
1170 | 4901 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4902 assert(total_coeff<=16); |
2967 | 4903 |
1168 | 4904 for(i=0; i<trailing_ones; i++){ |
4905 level[i]= 1 - 2*get_bits1(gb); | |
4906 } | |
4907 | |
2897 | 4908 if(i<total_coeff) { |
1168 | 4909 int level_code, mask; |
2897 | 4910 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4911 int prefix= get_level_prefix(gb); | |
4912 | |
4913 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4914 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4915 if(suffix_length) | |
4916 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4917 else | |
4918 level_code= (prefix<<suffix_length); //part | |
4919 }else if(prefix==14){ | |
4920 if(suffix_length) | |
4921 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4922 else | |
4923 level_code= prefix + get_bits(gb, 4); //part | |
4924 }else if(prefix==15){ | |
4925 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
|
4926 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4927 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4928 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4929 return -1; |
4930 } | |
4931 | |
2897 | 4932 if(trailing_ones < 3) level_code += 2; |
4933 | |
4934 suffix_length = 1; | |
4935 if(level_code > 5) | |
4936 suffix_length++; | |
1168 | 4937 mask= -(level_code&1); |
4938 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4939 i++; |
4940 | |
4941 //remaining coefficients have suffix_length > 0 | |
4942 for(;i<total_coeff;i++) { | |
4943 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4944 prefix = get_level_prefix(gb); | |
4945 if(prefix<15){ | |
4946 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4947 }else if(prefix==15){ | |
4948 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4949 }else{ | |
4950 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4951 return -1; | |
4952 } | |
4953 mask= -(level_code&1); | |
4954 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4955 if(level_code > suffix_limit[suffix_length]) | |
4956 suffix_length++; | |
4957 } | |
1168 | 4958 } |
4959 | |
4960 if(total_coeff == max_coeff) | |
4961 zeros_left=0; | |
4962 else{ | |
4963 if(n == CHROMA_DC_BLOCK_INDEX) | |
4964 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4965 else | |
4966 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4967 } | |
2897 | 4968 |
4969 coeff_num = zeros_left + total_coeff - 1; | |
4970 j = scantable[coeff_num]; | |
4971 if(n > 24){ | |
4972 block[j] = level[0]; | |
4973 for(i=1;i<total_coeff;i++) { | |
4974 if(zeros_left <= 0) | |
4975 run_before = 0; | |
4976 else if(zeros_left < 7){ | |
4977 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4978 }else{ | |
4979 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4980 } | |
4981 zeros_left -= run_before; | |
4982 coeff_num -= 1 + run_before; | |
4983 j= scantable[ coeff_num ]; | |
4984 | |
4985 block[j]= level[i]; | |
4986 } | |
4987 }else{ | |
2919 | 4988 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4989 for(i=1;i<total_coeff;i++) { |
4990 if(zeros_left <= 0) | |
4991 run_before = 0; | |
4992 else if(zeros_left < 7){ | |
4993 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4994 }else{ | |
4995 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4996 } | |
4997 zeros_left -= run_before; | |
4998 coeff_num -= 1 + run_before; | |
4999 j= scantable[ coeff_num ]; | |
5000 | |
2919 | 5001 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 5002 } |
1168 | 5003 } |
5004 | |
5005 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5006 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 5007 return -1; |
5008 } | |
2897 | 5009 |
1168 | 5010 return 0; |
5011 } | |
5012 | |
3316 | 5013 static void predict_field_decoding_flag(H264Context *h){ |
5014 MpegEncContext * const s = &h->s; | |
5015 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
5016 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
5017 ? s->current_picture.mb_type[mb_xy-1] | |
5018 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
5019 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
5020 : 0; | |
5021 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
5022 } | |
5023 | |
1168 | 5024 /** |
2396 | 5025 * decodes a P_SKIP or B_SKIP macroblock |
5026 */ | |
5027 static void decode_mb_skip(H264Context *h){ | |
5028 MpegEncContext * const s = &h->s; | |
5029 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
|
5030 int mb_type=0; |
2967 | 5031 |
2396 | 5032 memset(h->non_zero_count[mb_xy], 0, 16); |
5033 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
5034 | |
3316 | 5035 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5036 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5037 |
2396 | 5038 if( h->slice_type == B_TYPE ) |
5039 { | |
5040 // 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
|
5041 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5042 |
2449 | 5043 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5044 pred_direct_motion(h, &mb_type); |
3927 | 5045 mb_type|= MB_TYPE_SKIP; |
2396 | 5046 } |
5047 else | |
5048 { | |
5049 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5050 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5051 |
2449 | 5052 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5053 pred_pskip_motion(h, &mx, &my); |
5054 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5055 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5056 } | |
5057 | |
5058 write_back_motion(h, mb_type); | |
3927 | 5059 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5060 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5061 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
|
5062 h->prev_mb_skipped= 1; |
2396 | 5063 } |
5064 | |
5065 /** | |
1168 | 5066 * decodes a macroblock |
5067 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5068 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5069 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5070 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
|
5071 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
|
5072 int partition_count; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5073 unsigned int mb_type, cbp; |
2755 | 5074 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5075 |
2967 | 5076 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5077 |
1170 | 5078 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5079 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5080 down the code */ | |
1168 | 5081 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5082 if(s->mb_skip_run==-1) | |
5083 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5084 |
1168 | 5085 if (s->mb_skip_run--) { |
3316 | 5086 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5087 if(s->mb_skip_run==0) | |
5088 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5089 else | |
5090 predict_field_decoding_flag(h); | |
5091 } | |
2396 | 5092 decode_mb_skip(h); |
1168 | 5093 return 0; |
5094 } | |
5095 } | |
3316 | 5096 if(FRAME_MBAFF){ |
5097 if( (s->mb_y&1) == 0 ) | |
5098 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5099 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5100 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5101 |
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
|
5102 h->prev_mb_skipped= 0; |
2967 | 5103 |
1168 | 5104 mb_type= get_ue_golomb(&s->gb); |
5105 if(h->slice_type == B_TYPE){ | |
5106 if(mb_type < 23){ | |
5107 partition_count= b_mb_type_info[mb_type].partition_count; | |
5108 mb_type= b_mb_type_info[mb_type].type; | |
5109 }else{ | |
5110 mb_type -= 23; | |
5111 goto decode_intra_mb; | |
5112 } | |
5113 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5114 if(mb_type < 5){ | |
5115 partition_count= p_mb_type_info[mb_type].partition_count; | |
5116 mb_type= p_mb_type_info[mb_type].type; | |
5117 }else{ | |
5118 mb_type -= 5; | |
5119 goto decode_intra_mb; | |
5120 } | |
5121 }else{ | |
5122 assert(h->slice_type == I_TYPE); | |
5123 decode_intra_mb: | |
5124 if(mb_type > 25){ | |
3954 | 5125 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 | 5126 return -1; |
5127 } | |
5128 partition_count=0; | |
5129 cbp= i_mb_type_info[mb_type].cbp; | |
5130 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5131 mb_type= i_mb_type_info[mb_type].type; | |
5132 } | |
5133 | |
3316 | 5134 if(MB_FIELD) |
1168 | 5135 mb_type |= MB_TYPE_INTERLACED; |
5136 | |
5137 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5138 |
1168 | 5139 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5140 unsigned int x, y; |
2967 | 5141 |
1168 | 5142 // we assume these blocks are very rare so we dont optimize it |
5143 align_get_bits(&s->gb); | |
2967 | 5144 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5145 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5146 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5147 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5148 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5149 tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5150 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5151 } |
5152 } | |
5153 for(y=0; y<8; y++){ | |
5154 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5155 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5156 tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5157 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5158 } |
5159 } | |
5160 for(y=0; y<8; y++){ | |
5161 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5162 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5163 tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8)); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5164 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5165 } |
5166 } | |
2967 | 5167 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5168 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5169 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
|
5170 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
|
5171 // 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
|
5172 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5173 |
2755 | 5174 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5175 return 0; |
5176 } | |
2967 | 5177 |
3316 | 5178 if(MB_MBAFF){ |
5179 h->ref_count[0] <<= 1; | |
5180 h->ref_count[1] <<= 1; | |
5181 } | |
5182 | |
2449 | 5183 fill_caches(h, mb_type, 0); |
1168 | 5184 |
5185 //mb_pred | |
5186 if(IS_INTRA(mb_type)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5187 int pred_mode; |
1168 | 5188 // init_top_left_availability(h); |
5189 if(IS_INTRA4x4(mb_type)){ | |
5190 int i; | |
2755 | 5191 int di = 1; |
5192 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5193 mb_type |= MB_TYPE_8x8DCT; | |
5194 di = 4; | |
5195 } | |
1168 | 5196 |
5197 // fill_intra4x4_pred_table(h); | |
2755 | 5198 for(i=0; i<16; i+=di){ |
3409 | 5199 int mode= pred_intra_mode(h, i); |
5200 | |
5201 if(!get_bits1(&s->gb)){ | |
1168 | 5202 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5203 mode = rem_mode + (rem_mode >= mode); |
1168 | 5204 } |
2967 | 5205 |
2755 | 5206 if(di==4) |
5207 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5208 else | |
5209 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5210 } |
5211 write_back_intra_pred_mode(h); | |
5212 if( check_intra4x4_pred_mode(h) < 0) | |
5213 return -1; | |
5214 }else{ | |
5215 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5216 if(h->intra16x16_pred_mode < 0) | |
5217 return -1; | |
5218 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5219 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5220 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
|
5221 if(pred_mode < 0) |
1168 | 5222 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5223 h->chroma_pred_mode= pred_mode; |
1168 | 5224 }else if(partition_count==4){ |
5225 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5226 |
1168 | 5227 if(h->slice_type == B_TYPE){ |
5228 for(i=0; i<4; i++){ | |
5229 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5230 if(h->sub_mb_type[i] >=13){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5231 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 | 5232 return -1; |
5233 } | |
5234 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5235 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5236 } | |
2396 | 5237 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5238 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5239 pred_direct_motion(h, &mb_type); |
3003 | 5240 h->ref_cache[0][scan8[4]] = |
5241 h->ref_cache[1][scan8[4]] = | |
5242 h->ref_cache[0][scan8[12]] = | |
5243 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5244 } | |
1168 | 5245 }else{ |
5246 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5247 for(i=0; i<4; i++){ | |
5248 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5249 if(h->sub_mb_type[i] >=4){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5250 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 | 5251 return -1; |
5252 } | |
5253 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5254 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5255 } | |
5256 } | |
2967 | 5257 |
4533 | 5258 for(list=0; list<h->list_count; list++){ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5259 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5260 for(i=0; i<4; i++){ |
2396 | 5261 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5262 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5263 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
|
5264 if(tmp>=ref_count){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5265 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
|
5266 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5267 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5268 ref[list][i]= tmp; |
1168 | 5269 }else{ |
5270 //FIXME | |
5271 ref[list][i] = -1; | |
5272 } | |
5273 } | |
5274 } | |
2967 | 5275 |
2755 | 5276 if(dct8x8_allowed) |
5277 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5278 |
4533 | 5279 for(list=0; list<h->list_count; list++){ |
1168 | 5280 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
5281 | |
5282 for(i=0; i<4; i++){ | |
3003 | 5283 if(IS_DIRECT(h->sub_mb_type[i])) { |
5284 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5285 continue; | |
5286 } | |
1168 | 5287 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5288 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5289 | |
2396 | 5290 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5291 const int sub_mb_type= h->sub_mb_type[i]; |
5292 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5293 for(j=0; j<sub_partition_count[i]; j++){ | |
5294 int mx, my; | |
5295 const int index= 4*i + block_width*j; | |
5296 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5297 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5298 mx += get_se_golomb(&s->gb); | |
5299 my += get_se_golomb(&s->gb); | |
1170 | 5300 tprintf("final mv:%d %d\n", mx, my); |
5301 | |
1168 | 5302 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 5303 mv_cache[ 1 ][0]= |
1168 | 5304 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 5305 mv_cache[ 1 ][1]= |
1168 | 5306 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5307 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4530 | 5308 mv_cache[ 1 ][0]= mx; |
5309 mv_cache[ 1 ][1]= my; | |
1168 | 5310 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 5311 mv_cache[ 8 ][0]= mx; |
5312 mv_cache[ 8 ][1]= my; | |
1168 | 5313 } |
4530 | 5314 mv_cache[ 0 ][0]= mx; |
5315 mv_cache[ 0 ][1]= my; | |
1168 | 5316 } |
5317 }else{ | |
5318 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5319 p[0] = p[1]= | |
5320 p[8] = p[9]= 0; | |
5321 } | |
5322 } | |
5323 } | |
2396 | 5324 }else if(IS_DIRECT(mb_type)){ |
5325 pred_direct_motion(h, &mb_type); | |
2755 | 5326 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5327 }else{ |
1168 | 5328 int list, mx, my, i; |
5329 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5330 if(IS_16X16(mb_type)){ | |
5331 for(list=0; list<2; list++){ | |
2392 | 5332 if(h->ref_count[list]>0){ |
1168 | 5333 if(IS_DIR(mb_type, 0, list)){ |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5334 unsigned int val= get_te0_golomb(&s->gb, h->ref_count[list]); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5335 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5336 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
|
5337 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5338 } |
1168 | 5339 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); |
2523 | 5340 }else |
5341 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 5342 } |
5343 } | |
5344 for(list=0; list<2; list++){ | |
5345 if(IS_DIR(mb_type, 0, list)){ | |
5346 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5347 mx += get_se_golomb(&s->gb); | |
5348 my += get_se_golomb(&s->gb); | |
1170 | 5349 tprintf("final mv:%d %d\n", mx, my); |
5350 | |
1269 | 5351 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5352 }else |
5353 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1168 | 5354 } |
5355 } | |
5356 else if(IS_16X8(mb_type)){ | |
5357 for(list=0; list<2; list++){ | |
5358 if(h->ref_count[list]>0){ | |
5359 for(i=0; i<2; i++){ | |
5360 if(IS_DIR(mb_type, i, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5361 unsigned int val= get_te0_golomb(&s->gb, h->ref_count[list]); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5362 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5363 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
|
5364 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5365 } |
1168 | 5366 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); |
2523 | 5367 }else |
2396 | 5368 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5369 } |
5370 } | |
5371 } | |
5372 for(list=0; list<2; list++){ | |
5373 for(i=0; i<2; i++){ | |
5374 if(IS_DIR(mb_type, i, list)){ | |
5375 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5376 mx += get_se_golomb(&s->gb); | |
5377 my += get_se_golomb(&s->gb); | |
1170 | 5378 tprintf("final mv:%d %d\n", mx, my); |
5379 | |
1269 | 5380 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5381 }else |
5382 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 5383 } |
5384 } | |
5385 }else{ | |
5386 assert(IS_8X16(mb_type)); | |
5387 for(list=0; list<2; list++){ | |
5388 if(h->ref_count[list]>0){ | |
5389 for(i=0; i<2; i++){ | |
5390 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5391 unsigned int val= get_te0_golomb(&s->gb, h->ref_count[list]); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5392 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5393 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
|
5394 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5395 } |
1168 | 5396 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); |
2523 | 5397 }else |
2396 | 5398 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5399 } |
5400 } | |
5401 } | |
5402 for(list=0; list<2; list++){ | |
5403 for(i=0; i<2; i++){ | |
5404 if(IS_DIR(mb_type, i, list)){ | |
5405 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5406 mx += get_se_golomb(&s->gb); | |
5407 my += get_se_golomb(&s->gb); | |
1170 | 5408 tprintf("final mv:%d %d\n", mx, my); |
5409 | |
1269 | 5410 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5411 }else |
5412 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 5413 } |
5414 } | |
5415 } | |
5416 } | |
2967 | 5417 |
1168 | 5418 if(IS_INTER(mb_type)) |
5419 write_back_motion(h, mb_type); | |
2967 | 5420 |
1168 | 5421 if(!IS_INTRA16x16(mb_type)){ |
5422 cbp= get_ue_golomb(&s->gb); | |
5423 if(cbp > 47){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5424 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5425 return -1; |
5426 } | |
2967 | 5427 |
1168 | 5428 if(IS_INTRA4x4(mb_type)) |
5429 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5430 else | |
5431 cbp= golomb_to_inter_cbp[cbp]; | |
5432 } | |
3651 | 5433 h->cbp = cbp; |
1168 | 5434 |
2755 | 5435 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5436 if(get_bits1(&s->gb)) | |
5437 mb_type |= MB_TYPE_8x8DCT; | |
5438 } | |
5439 s->current_picture.mb_type[mb_xy]= mb_type; | |
5440 | |
1168 | 5441 if(cbp || IS_INTRA16x16(mb_type)){ |
5442 int i8x8, i4x4, chroma_idx; | |
5443 int chroma_qp, dquant; | |
5444 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5445 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5446 |
1168 | 5447 // fill_non_zero_count_cache(h); |
5448 | |
5449 if(IS_INTERLACED(mb_type)){ | |
3316 | 5450 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5451 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5452 dc_scan= luma_dc_field_scan; |
5453 }else{ | |
3316 | 5454 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5455 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5456 dc_scan= luma_dc_zigzag_scan; |
5457 } | |
5458 | |
5459 dquant= get_se_golomb(&s->gb); | |
5460 | |
5461 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5462 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 | 5463 return -1; |
5464 } | |
2967 | 5465 |
1168 | 5466 s->qscale += dquant; |
5467 if(((unsigned)s->qscale) > 51){ | |
5468 if(s->qscale<0) s->qscale+= 52; | |
5469 else s->qscale-= 52; | |
5470 } | |
2967 | 5471 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5472 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5473 if(IS_INTRA16x16(mb_type)){ |
2919 | 5474 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
|
5475 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5476 } |
5477 | |
5478 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5479 | |
5480 if(cbp&15){ | |
5481 for(i8x8=0; i8x8<4; i8x8++){ | |
5482 for(i4x4=0; i4x4<4; i4x4++){ | |
5483 const int index= i4x4 + 4*i8x8; | |
2919 | 5484 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5485 return -1; |
5486 } | |
5487 } | |
5488 } | |
5489 }else{ | |
1636 | 5490 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5491 } |
5492 }else{ | |
5493 for(i8x8=0; i8x8<4; i8x8++){ | |
5494 if(cbp & (1<<i8x8)){ | |
2755 | 5495 if(IS_8x8DCT(mb_type)){ |
5496 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5497 uint8_t *nnz; |
2755 | 5498 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5499 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5500 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5501 return -1; |
5502 } | |
2757 | 5503 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
|
5504 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5505 }else{ |
5506 for(i4x4=0; i4x4<4; i4x4++){ | |
5507 const int index= i4x4 + 4*i8x8; | |
2967 | 5508 |
2919 | 5509 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 | 5510 return -1; |
5511 } | |
1168 | 5512 } |
5513 } | |
5514 }else{ | |
5515 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5516 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5517 } | |
5518 } | |
5519 } | |
2967 | 5520 |
1168 | 5521 if(cbp&0x30){ |
5522 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5523 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5524 return -1; |
5525 } | |
5526 } | |
5527 | |
5528 if(cbp&0x20){ | |
5529 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5530 for(i4x4=0; i4x4<4; i4x4++){ | |
5531 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5532 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 | 5533 return -1; |
5534 } | |
5535 } | |
5536 } | |
5537 }else{ | |
5538 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5539 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5540 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5541 } | |
5542 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5543 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
|
5544 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
|
5545 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
|
5546 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5547 } |
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
|
5548 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5549 write_back_non_zero_count(h); |
5550 | |
3316 | 5551 if(MB_MBAFF){ |
5552 h->ref_count[0] >>= 1; | |
5553 h->ref_count[1] >>= 1; | |
5554 } | |
5555 | |
1168 | 5556 return 0; |
5557 } | |
5558 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5559 static int decode_cabac_field_decoding_flag(H264Context *h) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5560 MpegEncContext * const s = &h->s; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5561 const int mb_x = s->mb_x; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5562 const int mb_y = s->mb_y & ~1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5563 const int mba_xy = mb_x - 1 + mb_y *s->mb_stride; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5564 const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5565 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5566 unsigned int ctx = 0; |
2967 | 5567 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5568 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 (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5569 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5570 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5571 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 (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5572 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5573 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5574 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5575 return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] ); |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5576 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5577 |
2312 | 5578 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5579 uint8_t *state= &h->cabac_state[ctx_base]; | |
5580 int mb_type; | |
2967 | 5581 |
2312 | 5582 if(intra_slice){ |
5583 MpegEncContext * const s = &h->s; | |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5584 const int mba_xy = h->left_mb_xy[0]; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5585 const int mbb_xy = h->top_mb_xy; |
2312 | 5586 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5587 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
|
5588 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5589 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
|
5590 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5591 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5592 return 0; /* I4x4 */ |
5593 state += 2; | |
5594 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5595 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
|
5596 return 0; /* I4x4 */ |
2312 | 5597 } |
5598 | |
5599 if( get_cabac_terminate( &h->cabac ) ) | |
5600 return 25; /* PCM */ | |
5601 | |
5602 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
|
5603 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
|
5604 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
|
5605 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
|
5606 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
|
5607 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5608 return mb_type; |
5609 } | |
5610 | |
5611 static int decode_cabac_mb_type( H264Context *h ) { | |
5612 MpegEncContext * const s = &h->s; | |
5613 | |
5614 if( h->slice_type == I_TYPE ) { | |
5615 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
|
5616 } 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
|
5617 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
|
5618 /* 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
|
5619 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5620 /* 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
|
5621 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
|
5622 } else { |
3138 | 5623 /* 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
|
5624 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
|
5625 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5626 } else { |
2312 | 5627 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
|
5628 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5629 } else if( h->slice_type == B_TYPE ) { |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5630 const int mba_xy = h->left_mb_xy[0]; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
5631 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
|
5632 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
|
5633 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5634 |
3138 | 5635 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
|
5636 ctx++; |
3138 | 5637 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
|
5638 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5639 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5640 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
|
5641 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
|
5642 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5643 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
|
5644 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
|
5645 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5646 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5647 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
|
5648 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
|
5649 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
|
5650 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
|
5651 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
|
5652 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
|
5653 else if( bits == 13 ) { |
2312 | 5654 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
|
5655 } 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
|
5656 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
|
5657 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
|
5658 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
|
5659 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5660 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
|
5661 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
|
5662 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5663 /* 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
|
5664 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
|
5665 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5666 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5667 |
3316 | 5668 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
|
5669 MpegEncContext * const s = &h->s; |
3316 | 5670 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
|
5671 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
|
5672 |
3316 | 5673 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5674 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5675 mba_xy = mb_xy - 1; | |
5676 if( (mb_y&1) | |
5677 && h->slice_table[mba_xy] == h->slice_num | |
5678 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5679 mba_xy += s->mb_stride; | |
5680 if( MB_FIELD ){ | |
5681 mbb_xy = mb_xy - s->mb_stride; | |
5682 if( !(mb_y&1) | |
5683 && h->slice_table[mbb_xy] == h->slice_num | |
5684 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5685 mbb_xy -= s->mb_stride; | |
5686 }else | |
5687 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5688 }else{ | |
5689 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5690 mba_xy = mb_xy - 1; | |
5691 mbb_xy = mb_xy - s->mb_stride; | |
5692 } | |
5693 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5694 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
|
5695 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5696 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
|
5697 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5698 |
3138 | 5699 if( h->slice_type == B_TYPE ) |
5700 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
|
5701 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
|
5702 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5703 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5704 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
|
5705 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
|
5706 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5707 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
|
5708 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
|
5709 |
2928 | 5710 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5711 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5712 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5713 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5714 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
|
5715 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
|
5716 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5717 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
|
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 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5721 const int mba_xy = h->left_mb_xy[0]; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5722 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
|
5723 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5724 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
|
5725 |
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
|
5726 /* 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
|
5727 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
|
5728 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
|
5729 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5730 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
|
5731 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5732 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5733 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
|
5734 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
|
5735 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5736 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
|
5737 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
|
5738 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
|
5739 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
|
5740 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5741 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
|
5742 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5743 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5744 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
|
5745 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
|
5746 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5747 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
|
5748 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
|
5749 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5750 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
|
5751 { 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
|
5752 { 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
|
5753 { 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
|
5754 { 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
|
5755 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5756 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5757 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
|
5758 int cbp = 0; |
3138 | 5759 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
|
5760 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
|
5761 |
3138 | 5762 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5763 cbp_b = h->top_cbp; | |
5764 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5765 } | |
5766 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5767 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5768 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
|
5769 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
|
5770 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
|
5771 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5772 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
|
5773 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
|
5774 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5775 if( x > 0 ) |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5776 cbp_a = cbp; |
3138 | 5777 else if( h->slice_table[h->left_mb_xy[0]] == h->slice_num ) { |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5778 cbp_a = h->left_cbp; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5779 tprintf("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
|
5780 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5781 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5782 if( y > 0 ) |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5783 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
|
5784 |
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
|
5785 /* 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
|
5786 /* No need to test for IPCM as we put 1 for IPCM block */ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5787 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
|
5788 int i8x8a = block_idx_xy[(x-1)&0x03][y]/4; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5789 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
|
5790 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5791 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5792 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5793 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
|
5794 int i8x8b = block_idx_xy[x][(y-1)&0x03]/4; |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5795 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
|
5796 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
|
5797 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5798 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5799 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
|
5800 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
|
5801 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5802 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5803 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
|
5804 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5805 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
|
5806 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
|
5807 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
|
5808 |
2314 | 5809 cbp_a = (h->left_cbp>>4)&0x03; |
5810 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
|
5811 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5812 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
|
5813 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
|
5814 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
|
5815 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
|
5816 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
|
5817 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5818 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
|
5819 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
|
5820 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
|
5821 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
|
5822 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5823 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
|
5824 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
|
5825 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
|
5826 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
|
5827 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
|
5828 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5829 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
|
5830 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
|
5831 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5832 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
|
5833 |
3316 | 5834 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
|
5835 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5836 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5837 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
|
5838 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
|
5839 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
|
5840 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5841 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
|
5842 val++; |
3128 | 5843 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5844 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
|
5845 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5846 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5847 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
|
5848 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
|
5849 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5850 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
|
5851 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5852 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
|
5853 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
|
5854 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
|
5855 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
|
5856 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
|
5857 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
|
5858 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
|
5859 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
|
5860 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5861 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
|
5862 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5863 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
|
5864 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
|
5865 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
|
5866 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
|
5867 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5868 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
|
5869 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
|
5870 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
|
5871 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5872 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5873 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
|
5874 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
|
5875 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5876 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5877 |
2755 | 5878 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
|
5879 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5880 } |
5881 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5882 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
|
5883 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
|
5884 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
|
5885 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
|
5886 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
|
5887 |
2396 | 5888 if( h->slice_type == B_TYPE) { |
5889 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5890 ctx++; | |
5891 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5892 ctx += 2; | |
5893 } else { | |
5894 if( refa > 0 ) | |
5895 ctx++; | |
5896 if( refb > 0 ) | |
5897 ctx += 2; | |
5898 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5899 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5900 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
|
5901 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5902 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
|
5903 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5904 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5905 ctx = 5; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5906 if(ref >= 32 /*h->ref_list[list]*/){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5907 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
|
5908 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
|
5909 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5910 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5911 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5912 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5913 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5914 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
|
5915 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
|
5916 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
|
5917 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5918 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
|
5919 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5920 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
|
5921 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5922 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
|
5923 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5924 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5925 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5926 |
2317 | 5927 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5928 return 0; | |
5929 | |
5930 mvd= 1; | |
5931 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
|
5932 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
|
5933 mvd++; |
2317 | 5934 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
|
5935 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5936 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5937 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5938 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
|
5939 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
|
5940 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
|
5941 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
|
5942 k++; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5943 if(k>24){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5944 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
|
5945 return INT_MIN; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5946 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5947 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5948 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5949 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
|
5950 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
|
5951 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5952 } |
4042 | 5953 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
|
5954 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5955 |
2316 | 5956 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5957 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
|
5958 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
|
5959 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5960 if( cat == 0 ) { |
2314 | 5961 nza = h->left_cbp&0x100; |
5962 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
|
5963 } else if( cat == 1 || cat == 2 ) { |
2314 | 5964 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5965 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
|
5966 } else if( cat == 3 ) { |
2314 | 5967 nza = (h->left_cbp>>(6+idx))&0x01; |
5968 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5969 } else { | |
5970 assert(cat == 4); | |
5971 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5972 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5973 } | |
5974 | |
5975 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
|
5976 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5977 |
2314 | 5978 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
|
5979 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
|
5980 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5981 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
|
5982 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5983 |
4051 | 5984 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
5985 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
5986 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
5987 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
5988 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
5989 }; | |
5990 | |
3028 | 5991 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
|
5992 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5993 static const int significant_coeff_flag_offset[2][6] = { |
5994 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
5995 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
5996 }; | |
5997 static const int last_coeff_flag_offset[2][6] = { | |
5998 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
5999 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
6000 }; | |
6001 static const int coeff_abs_level_m1_offset[6] = { | |
6002 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
6003 }; | |
4007 | 6004 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 6005 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 6006 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
6007 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 6008 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
6009 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
6010 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
6011 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
6012 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 6013 }; |
6014 | |
6015 int index[64]; | |
2313 | 6016 |
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
|
6017 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
|
6018 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
|
6019 |
2316 | 6020 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
|
6021 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
|
6022 |
2898 | 6023 uint8_t *significant_coeff_ctx_base; |
6024 uint8_t *last_coeff_ctx_base; | |
6025 uint8_t *abs_level_m1_ctx_base; | |
2755 | 6026 |
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
|
6027 #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
|
6028 #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
|
6029 #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
|
6030 #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
|
6031 #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
|
6032 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
|
6033 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
|
6034 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
|
6035 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
|
6036 #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
|
6037 #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
|
6038 #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
|
6039 |
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
|
6040 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6041 /* 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
|
6042 * 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
|
6043 * 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
|
6044 * 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
|
6045 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 6046 * 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
|
6047 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6048 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6049 /* read coded block flag */ |
2898 | 6050 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
|
6051 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 6052 if( cat == 1 || cat == 2 ) |
6053 h->non_zero_count_cache[scan8[n]] = 0; | |
6054 else if( cat == 4 ) | |
6055 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
|
6056 #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
|
6057 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
|
6058 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
|
6059 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
|
6060 #endif |
2755 | 6061 return 0; |
6062 } | |
2898 | 6063 } |
6064 | |
6065 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6066 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6067 last_coeff_ctx_base = h->cabac_state |
3316 | 6068 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6069 abs_level_m1_ctx_base = h->cabac_state |
6070 + coeff_abs_level_m1_offset[cat]; | |
6071 | |
6072 if( cat == 5 ) { | |
6073 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6074 for(last= 0; last < coefs; last++) { \ | |
6075 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
|
6076 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6077 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6078 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
|
6079 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6080 last= max_coeff; \ |
6081 break; \ | |
6082 } \ | |
6083 } \ | |
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
|
6084 }\ |
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
|
6085 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
|
6086 index[coeff_count++] = last;\ |
2898 | 6087 } |
4009 | 6088 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; |
4113
4ce3923d5806
Reenable AMD64 optimizations for cabac accidentially disabled in r6852
reimar
parents:
4112
diff
changeset
|
6089 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6090 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6091 } else { | |
6092 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6093 #else | |
3316 | 6094 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6095 } else { |
6096 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
|
6097 #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
|
6098 } |
2316 | 6099 assert(coeff_count > 0); |
6100 | |
6101 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
|
6102 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
|
6103 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
|
6104 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6105 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
|
6106 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6107 else if( cat == 4 ) |
6108 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6109 else { |
2755 | 6110 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6111 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6112 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6113 |
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
|
6114 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6115 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
|
6116 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
|
6117 |
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
|
6118 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6119 if( !qmul ) { |
4040 | 6120 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6121 }else{ |
4040 | 6122 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6123 } |
2967 | 6124 |
2313 | 6125 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
|
6126 } else { |
2313 | 6127 int coeff_abs = 2; |
2898 | 6128 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
|
6129 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6130 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
|
6131 } |
2313 | 6132 |
6133 if( coeff_abs >= 15 ) { | |
6134 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
|
6135 while( get_cabac_bypass( CC ) ) { |
2313 | 6136 j++; |
6137 } | |
2967 | 6138 |
4016 | 6139 coeff_abs=1; |
2313 | 6140 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
|
6141 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6142 } |
4016 | 6143 coeff_abs+= 14; |
2313 | 6144 } |
6145 | |
2898 | 6146 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
|
6147 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6148 else block[j] = coeff_abs; |
6149 }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
|
6150 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6151 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6152 } |
2967 | 6153 |
2313 | 6154 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
|
6155 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6156 } |
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
|
6157 #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
|
6158 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
|
6159 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
|
6160 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
|
6161 #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
|
6162 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
|
6163 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6164 |
3077 | 6165 static void inline compute_mb_neighbors(H264Context *h) |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6166 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6167 MpegEncContext * const s = &h->s; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6168 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6169 h->top_mb_xy = mb_xy - s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6170 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6171 if(FRAME_MBAFF){ |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6172 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6173 const int top_pair_xy = pair_xy - s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6174 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 (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6175 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6176 const int curr_mb_frame_flag = !MB_FIELD; |
2597
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6177 const int bottom = (s->mb_y & 1); |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6178 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6179 ? !curr_mb_frame_flag // bottom macroblock |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6180 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6181 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6182 h->top_mb_xy -= s->mb_stride; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6183 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6184 if (left_mb_frame_flag != curr_mb_frame_flag) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6185 h->left_mb_xy[0] = pair_xy - 1; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6186 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6187 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6188 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6189 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6190 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6191 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6192 * 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
|
6193 * @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
|
6194 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6195 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
|
6196 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
|
6197 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
|
6198 int mb_type, partition_count, cbp = 0; |
2755 | 6199 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
|
6200 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6201 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
|
6202 |
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
|
6203 tprintf("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
|
6204 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6205 int skip; |
6206 /* a skipped mb needs the aff flag from the following mb */ | |
6207 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6208 predict_field_decoding_flag(h); | |
6209 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6210 skip = h->next_mb_skipped; | |
6211 else | |
6212 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
|
6213 /* read skip flags */ |
3316 | 6214 if( skip ) { |
6215 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6216 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6217 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6218 if(h->next_mb_skipped) | |
6219 predict_field_decoding_flag(h); | |
6220 else | |
6221 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6222 } | |
6223 | |
2396 | 6224 decode_mb_skip(h); |
6225 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6226 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
|
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 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
|
6229 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6230 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
|
6231 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6232 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6233 } |
3316 | 6234 if(FRAME_MBAFF){ |
6235 if( (s->mb_y&1) == 0 ) | |
6236 h->mb_mbaff = | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6237 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6238 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6239 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6240 |
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
|
6241 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
|
6242 |
3077 | 6243 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
|
6244 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
|
6245 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
|
6246 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
|
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 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6249 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
|
6250 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
|
6251 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
|
6252 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
|
6253 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6254 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
|
6255 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
|
6256 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6257 } 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
|
6258 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
|
6259 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
|
6260 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
|
6261 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6262 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
|
6263 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
|
6264 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6265 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6266 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
|
6267 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
|
6268 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
|
6269 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
|
6270 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
|
6271 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
|
6272 } |
3316 | 6273 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
|
6274 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
|
6275 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6276 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
|
6277 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6278 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6279 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6280 unsigned int x, y; |
2967 | 6281 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6282 // 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
|
6283 // 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
|
6284 // 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
|
6285 ptr= h->cabac.bytestream; |
4344 | 6286 if(h->cabac.low&0x1) ptr--; |
6287 if(CABAC_BITS==16){ | |
6288 if(h->cabac.low&0x1FF) ptr--; | |
6289 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6290 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6291 // 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
|
6292 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6293 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
|
6294 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6295 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6296 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
|
6297 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6298 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6299 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6300 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
|
6301 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6302 tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6303 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
|
6304 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6305 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6306 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6307 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
|
6308 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6309 tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6310 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
|
6311 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6312 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6313 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6314 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
|
6315 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6316 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6317 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
|
6318 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
|
6319 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6320 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
|
6321 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
|
6322 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6323 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6324 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
|
6325 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
|
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 |
3316 | 6328 if(MB_MBAFF){ |
6329 h->ref_count[0] <<= 1; | |
6330 h->ref_count[1] <<= 1; | |
6331 } | |
6332 | |
2449 | 6333 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
|
6334 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6335 if( IS_INTRA( mb_type ) ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6336 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
|
6337 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6338 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6339 mb_type |= MB_TYPE_8x8DCT; | |
6340 for( i = 0; i < 16; i+=4 ) { | |
6341 int pred = pred_intra_mode( h, i ); | |
6342 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6343 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6344 } | |
6345 } else { | |
6346 for( i = 0; i < 16; i++ ) { | |
6347 int pred = pred_intra_mode( h, i ); | |
6348 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
|
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 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6351 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6352 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6353 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
|
6354 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
|
6355 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6356 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
|
6357 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
|
6358 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6359 h->chroma_pred_mode_table[mb_xy] = |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6360 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6361 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6362 pred_mode= check_intra_pred_mode( h, pred_mode ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6363 if( pred_mode < 0 ) return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6364 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
|
6365 } 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
|
6366 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
|
6367 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6368 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
|
6369 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
|
6370 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
|
6371 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
|
6372 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
|
6373 } |
3482 | 6374 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6375 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6376 pred_direct_motion(h, &mb_type); |
6377 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6378 for( i = 0; i < 4; i++ ) | |
6379 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6380 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6381 } | |
6382 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6383 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6384 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
|
6385 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
|
6386 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
|
6387 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
|
6388 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6389 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6390 |
4533 | 6391 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
|
6392 for( i = 0; i < 4; i++ ) { |
2396 | 6393 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6394 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
|
6395 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
|
6396 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
|
6397 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6398 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
|
6399 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6400 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
|
6401 } |
2110 | 6402 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
|
6403 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
|
6404 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6405 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6406 |
2755 | 6407 if(dct8x8_allowed) |
6408 dct8x8_allowed = get_dct8x8_allowed(h); | |
6409 | |
4533 | 6410 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
|
6411 for(i=0; i<4; i++){ |
2396 | 6412 if(IS_DIRECT(h->sub_mb_type[i])){ |
6413 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6414 continue; | |
6415 } | |
2110 | 6416 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
|
6417 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6418 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
|
6419 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
|
6420 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
|
6421 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
|
6422 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
|
6423 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
|
6424 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
|
6425 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
|
6426 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
|
6427 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
|
6428 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6429 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
|
6430 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6431 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6432 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6433 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 6434 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
|
6435 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 6436 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
|
6437 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
|
6438 |
4530 | 6439 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
|
6440 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
4530 | 6441 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
|
6442 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
|
6443 }else if(IS_SUB_8X4(sub_mb_type)){ |
4530 | 6444 mv_cache[ 1 ][0]= mx; |
6445 mv_cache[ 1 ][1]= my; | |
6446 | |
6447 mvd_cache[ 1 ][0]= mx - mpx; | |
6448 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
|
6449 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 6450 mv_cache[ 8 ][0]= mx; |
6451 mv_cache[ 8 ][1]= my; | |
6452 | |
6453 mvd_cache[ 8 ][0]= mx - mpx; | |
6454 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
|
6455 } |
4530 | 6456 mv_cache[ 0 ][0]= mx; |
6457 mv_cache[ 0 ][1]= my; | |
6458 | |
6459 mvd_cache[ 0 ][0]= mx - mpx; | |
6460 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
|
6461 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6462 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6463 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
|
6464 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
|
6465 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
|
6466 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
|
6467 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6468 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6469 } |
2396 | 6470 } else if( IS_DIRECT(mb_type) ) { |
6471 pred_direct_motion(h, &mb_type); | |
6472 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6473 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6474 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6475 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6476 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
|
6477 if(IS_16X16(mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6478 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6479 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
|
6480 if(h->ref_count[list] > 0 ){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6481 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
|
6482 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6483 } |
2523 | 6484 }else |
6485 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6486 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6487 for(list=0; list<2; list++){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6488 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
|
6489 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
|
6490 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6491 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
|
6492 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6493 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6494 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6495 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
|
6496 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6497 }else |
6498 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
|
6499 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6500 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6501 else if(IS_16X8(mb_type)){ |
4533 | 6502 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
|
6503 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
|
6504 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
|
6505 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
|
6506 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6507 }else |
6508 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
|
6509 } |
4533 | 6510 } |
6511 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
|
6512 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
|
6513 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
|
6514 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
|
6515 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
|
6516 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 ); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6517 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6518 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6519 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
|
6520 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6521 }else{ |
2396 | 6522 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6523 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
|
6524 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6525 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6526 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6527 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6528 assert(IS_8X16(mb_type)); |
4533 | 6529 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
|
6530 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
|
6531 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
|
6532 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
|
6533 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6534 }else |
6535 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
|
6536 } |
4533 | 6537 } |
6538 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
|
6539 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
|
6540 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
|
6541 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
|
6542 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
|
6543 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
|
6544 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6545 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6546 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
|
6547 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6548 }else{ |
2396 | 6549 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6550 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
|
6551 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6552 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6553 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6554 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6555 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6556 |
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
|
6557 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
|
6558 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
|
6559 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
|
6560 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6561 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6562 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
|
6563 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
|
6564 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
|
6565 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6566 |
3651 | 6567 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
|
6568 |
2755 | 6569 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6570 if( decode_cabac_mb_transform_size( h ) ) | |
6571 mb_type |= MB_TYPE_8x8DCT; | |
6572 } | |
6573 s->current_picture.mb_type[mb_xy]= mb_type; | |
6574 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6575 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6576 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
|
6577 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
|
6578 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6579 if(IS_INTERLACED(mb_type)){ |
3316 | 6580 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6581 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
|
6582 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
|
6583 }else{ |
3316 | 6584 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6585 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
|
6586 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
|
6587 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6588 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6589 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
|
6590 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6591 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
|
6592 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6593 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6594 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
|
6595 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
|
6596 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
|
6597 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
|
6598 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6599 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
|
6600 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6601 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
|
6602 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
|
6603 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6604 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
|
6605 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
|
6606 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
|
6607 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
|
6608 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6609 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
|
6610 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
|
6611 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6612 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6613 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
|
6614 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6615 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6616 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
|
6617 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
|
6618 if( cbp & (1<<i8x8) ) { |
2755 | 6619 if( IS_8x8DCT(mb_type) ) { |
6620 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6621 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6622 return -1; |
6623 } 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
|
6624 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
|
6625 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
|
6626 //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
|
6627 //START_TIMER |
2919 | 6628 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
|
6629 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6630 //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
|
6631 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6632 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6633 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
|
6634 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
|
6635 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6636 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6637 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6638 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6639 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
|
6640 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
|
6641 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
|
6642 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6643 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
|
6644 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
|
6645 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6646 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6647 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6648 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
|
6649 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
|
6650 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
|
6651 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
|
6652 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
|
6653 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6654 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
|
6655 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
|
6656 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6657 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6658 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6659 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
|
6660 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
|
6661 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
|
6662 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6663 } else { |
2315 | 6664 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6665 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6666 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6667 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6668 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
|
6669 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6670 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6671 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
|
6672 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
|
6673 |
3316 | 6674 if(MB_MBAFF){ |
6675 h->ref_count[0] >>= 1; | |
6676 h->ref_count[1] >>= 1; | |
6677 } | |
6678 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6679 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
|
6680 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6681 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6682 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6683 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
|
6684 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
|
6685 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
|
6686 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
|
6687 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
|
6688 |
2633 | 6689 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
|
6690 int8_t tc[4]; |
2633 | 6691 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
|
6692 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6693 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6694 } else { | |
6695 /* 16px edge length, because bS=4 is triggered by being at | |
6696 * the edge of an intra MB, so all 4 bS are the same */ | |
6697 for( d = 0; d < 16; d++ ) { | |
1898 | 6698 const int p0 = pix[-1]; |
6699 const int p1 = pix[-2]; | |
6700 const int p2 = pix[-3]; | |
6701 | |
6702 const int q0 = pix[0]; | |
6703 const int q1 = pix[1]; | |
6704 const int q2 = pix[2]; | |
6705 | |
4001 | 6706 if( FFABS( p0 - q0 ) < alpha && |
6707 FFABS( p1 - p0 ) < beta && | |
6708 FFABS( q1 - q0 ) < beta ) { | |
6709 | |
6710 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6711 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6712 { |
6713 const int p3 = pix[-4]; | |
6714 /* p0', p1', p2' */ | |
6715 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6716 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6717 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6718 } else { | |
6719 /* p0' */ | |
6720 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6721 } | |
4001 | 6722 if( FFABS( q2 - q0 ) < beta) |
1898 | 6723 { |
6724 const int q3 = pix[3]; | |
6725 /* q0', q1', q2' */ | |
6726 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6727 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6728 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6729 } else { | |
6730 /* q0' */ | |
6731 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6732 } | |
6733 }else{ | |
6734 /* p0', q0' */ | |
6735 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6736 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6737 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6738 tprintf("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
|
6739 } |
1898 | 6740 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
|
6741 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6742 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6743 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6744 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6745 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6746 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
|
6747 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
|
6748 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
|
6749 |
2633 | 6750 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
|
6751 int8_t tc[4]; |
2633 | 6752 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
|
6753 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6754 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6755 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6756 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
|
6757 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6758 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6759 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6760 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
|
6761 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6762 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
|
6763 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6764 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6765 int beta; |
2967 | 6766 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6767 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6768 int bS_index = (i >> 1); |
3316 | 6769 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6770 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6771 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6772 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6773 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6774 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6775 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6776 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6777 |
3316 | 6778 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
|
6779 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
|
6780 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
|
6781 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
|
6782 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6783 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
|
6784 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
|
6785 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6786 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6787 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6788 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6789 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6790 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6791 |
4001 | 6792 if( FFABS( p0 - q0 ) < alpha && |
6793 FFABS( p1 - p0 ) < beta && | |
6794 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6795 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6796 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6797 |
4001 | 6798 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6799 pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6800 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6801 } |
4001 | 6802 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6803 pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6804 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6805 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6806 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6807 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6808 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6809 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6810 tprintf("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); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6811 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6812 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6813 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6814 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6815 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6816 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6817 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6818 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6819 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6820 |
4001 | 6821 if( FFABS( p0 - q0 ) < alpha && |
6822 FFABS( p1 - p0 ) < beta && | |
6823 FFABS( q1 - q0 ) < beta ) { | |
6824 | |
6825 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6826 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6827 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6829 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6830 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
|
6831 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
|
6832 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
|
6833 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6834 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6835 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
|
6836 } |
4001 | 6837 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6838 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6839 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6840 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6841 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
|
6842 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
|
6843 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
|
6844 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6845 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 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
|
6847 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6848 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6849 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6850 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
|
6851 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
|
6852 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6853 tprintf("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]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6854 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6855 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6856 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6857 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6858 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
|
6859 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6860 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
|
6861 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6862 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6863 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6864 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6865 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6866 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6867 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6868 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6869 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6870 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6871 |
3316 | 6872 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
|
6873 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
|
6874 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
|
6875 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6876 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6877 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
|
6878 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
|
6879 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6880 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6881 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6882 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6883 |
4001 | 6884 if( FFABS( p0 - q0 ) < alpha && |
6885 FFABS( p1 - p0 ) < beta && | |
6886 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6887 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc ); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6888 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6889 pix[-1] = clip_uint8( p0 + i_delta ); /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6890 pix[0] = clip_uint8( q0 - i_delta ); /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6891 tprintf("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); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6892 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6893 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6894 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6895 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6896 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6897 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6898 |
4001 | 6899 if( FFABS( p0 - q0 ) < alpha && |
6900 FFABS( p1 - p0 ) < beta && | |
6901 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6902 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6903 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
|
6904 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6905 tprintf("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]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6906 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6907 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6908 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6909 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6910 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6911 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
|
6912 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
|
6913 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
|
6914 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
|
6915 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
|
6916 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
|
6917 |
2633 | 6918 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
|
6919 int8_t tc[4]; |
2633 | 6920 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
|
6921 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6922 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6923 } else { | |
6924 /* 16px edge length, see filter_mb_edgev */ | |
6925 for( d = 0; d < 16; d++ ) { | |
1898 | 6926 const int p0 = pix[-1*pix_next]; |
6927 const int p1 = pix[-2*pix_next]; | |
6928 const int p2 = pix[-3*pix_next]; | |
6929 const int q0 = pix[0]; | |
6930 const int q1 = pix[1*pix_next]; | |
6931 const int q2 = pix[2*pix_next]; | |
6932 | |
4001 | 6933 if( FFABS( p0 - q0 ) < alpha && |
6934 FFABS( p1 - p0 ) < beta && | |
6935 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6936 |
6937 const int p3 = pix[-4*pix_next]; | |
6938 const int q3 = pix[ 3*pix_next]; | |
6939 | |
4001 | 6940 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6941 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6942 /* p0', p1', p2' */ |
6943 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6944 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6945 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6946 } else { | |
6947 /* p0' */ | |
6948 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6949 } | |
4001 | 6950 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6951 /* q0', q1', q2' */ |
6952 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6953 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6954 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6955 } else { | |
6956 /* q0' */ | |
6957 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6958 } | |
6959 }else{ | |
6960 /* p0', q0' */ | |
6961 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6962 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6963 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6964 tprintf("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
|
6965 } |
1898 | 6966 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
|
6967 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6968 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6969 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6970 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6971 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6972 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6973 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
|
6974 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
|
6975 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
|
6976 |
2633 | 6977 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
|
6978 int8_t tc[4]; |
2633 | 6979 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
|
6980 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6981 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6982 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6983 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
|
6984 } |
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 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6987 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
|
6988 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6989 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6990 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6991 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6992 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
|
6993 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
|
6994 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6995 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6996 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6997 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6998 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6999 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7000 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7001 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7002 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7003 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7004 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7005 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7006 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7007 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7008 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7009 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 7010 qp_thresh = 15 - h->slice_alpha_c0_offset; |
7011 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
7012 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
7013 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7014 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7015 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7016 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7017 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7018 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7019 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7020 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7021 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7022 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7023 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7024 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7025 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7027 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7028 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7029 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7030 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7031 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7032 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7033 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7034 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7035 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7036 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7037 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7038 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7039 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7040 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7041 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7043 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7045 int edges; |
7046 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7047 edges = 4; | |
7048 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7049 } else { | |
7050 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7051 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7052 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7053 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7054 ? 3 : 0; | |
7055 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7056 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7057 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7058 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7059 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7060 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7061 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7062 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7063 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7064 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7065 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7066 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7067 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
|
7068 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7069 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
|
7070 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
|
7071 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7072 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7073 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7074 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7075 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7076 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7077 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7078 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7079 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7080 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7081 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7082 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7083 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7084 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7085 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7086 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7087 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7088 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7089 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7090 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7091 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7092 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7093 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7094 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7095 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
|
7096 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
|
7097 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7098 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7099 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
|
7100 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
|
7101 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7102 /* 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
|
7103 * 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
|
7104 * frame numbers, not indices. */ |
3316 | 7105 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7106 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
|
7107 |
3101 | 7108 //for sufficiently low qp, filtering wouldn't do anything |
7109 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7110 if(!FRAME_MBAFF){ |
3101 | 7111 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7112 int qp = s->current_picture.qscale_table[mb_xy]; | |
7113 if(qp <= qp_thresh | |
7114 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7115 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7116 return; | |
7117 } | |
7118 } | |
7119 | |
3316 | 7120 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7121 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7122 && 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
|
7123 // and current and left pair do not have the same interlaced type |
3316 | 7124 && (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
|
7125 // 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
|
7126 && (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
|
7127 /* 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
|
7128 * 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
|
7129 */ |
3316 | 7130 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7131 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
|
7132 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7133 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7134 int chroma_qp[2]; |
3316 | 7135 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
|
7136 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7137 first_vertical_edge_done = 1; |
3316 | 7138 |
7139 if( IS_INTRA(mb_type) ) | |
7140 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7141 else { | |
7142 for( i = 0; i < 8; i++ ) { | |
7143 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7144 | |
7145 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7146 bS[i] = 4; | |
7147 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7148 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7149 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7150 bS[i] = 2; | |
7151 else | |
7152 bS[i] = 1; | |
7153 } | |
7154 } | |
7155 | |
7156 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7157 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7158 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7159 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7160 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7161 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7162 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7163 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7164 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7165 | |
7166 /* Filter edge */ | |
7167 tprintf("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); | |
7168 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7169 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7170 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7171 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
|
7172 } |
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
|
7173 /* 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
|
7174 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
|
7175 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7176 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7177 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7178 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7179 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7180 | |
3101 | 7181 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7182 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7183 // how often to recheck mv-based bS when iterating between edges |
7184 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7185 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7186 // how often to recheck mv-based bS when iterating along each edge | |
7187 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7188 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7189 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7190 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7191 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7192 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7193 |
2454 | 7194 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
|
7195 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
|
7196 |
3316 | 7197 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7198 && !IS_INTERLACED(mb_type) | |
7199 && IS_INTERLACED(mbm_type) | |
7200 ) { | |
7201 // This is a special case in the norm where the filtering must | |
7202 // be done twice (one each of the field) even if we are in a | |
7203 // frame macroblock. | |
7204 // | |
7205 static const int nnz_idx[4] = {4,5,6,3}; | |
7206 unsigned int tmp_linesize = 2 * linesize; | |
7207 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7208 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7209 int qp, chroma_qp; | |
7210 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7211 int16_t bS[4]; |
3316 | 7212 |
7213 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7214 if( IS_INTRA(mb_type) || | |
7215 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7216 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7217 } else { | |
7218 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7219 for( i = 0; i < 4; i++ ) { | |
7220 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7221 mbn_nnz[nnz_idx[i]] != 0 ) | |
7222 bS[i] = 2; | |
7223 else | |
7224 bS[i] = 1; | |
7225 } | |
7226 } | |
7227 // Do not use s->qscale as luma quantizer because it has not the same | |
7228 // value in IPCM macroblocks. | |
7229 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7230 tprintf("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); | |
7231 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7232 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7233 chroma_qp = ( h->chroma_qp + | |
7234 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7235 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7236 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7237 } | |
7238 | |
7239 start = 1; | |
7240 } | |
7241 | |
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
|
7242 /* Calculate bS */ |
2924 | 7243 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7244 /* mbn_xy: neighbor macroblock */ |
2924 | 7245 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7246 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7247 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
|
7248 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
|
7249 |
2924 | 7250 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7251 continue; |
7252 | |
2924 | 7253 if( IS_INTRA(mb_type) || |
7254 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7255 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7256 if (edge == 0) { |
2924 | 7257 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7258 || ((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
|
7259 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7260 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7261 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7262 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7263 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7264 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7265 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7266 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7267 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
|
7268 } else { |
2924 | 7269 int i, l; |
7270 int mv_done; | |
7271 | |
7272 if( edge & mask_edge ) { | |
7273 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7274 mv_done = 1; | |
7275 } | |
3316 | 7276 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7277 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7278 mv_done = 1; | |
7279 } | |
2924 | 7280 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7281 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7282 int bn_idx= b_idx - (dir ? 8:1); | |
7283 int v = 0; | |
7284 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7285 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7286 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7287 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7288 } |
7289 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7290 mv_done = 1; | |
7291 } | |
7292 else | |
7293 mv_done = 0; | |
7294 | |
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
|
7295 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
|
7296 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
|
7297 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
|
7298 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
|
7299 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
|
7300 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7301 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7302 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
|
7303 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
|
7304 } |
2924 | 7305 else if(!mv_done) |
2523 | 7306 { |
7307 bS[i] = 0; | |
7308 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
|
7309 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7310 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7311 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7312 bS[i] = 1; |
7313 break; | |
7314 } | |
7315 } | |
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
|
7316 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7317 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7318 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7319 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
|
7320 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
|
7321 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7322 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7323 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7324 // 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
|
7325 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7326 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 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
|
7327 //tprintf("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]); |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7328 tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7329 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\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
|
7330 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
|
7331 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7332 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
|
7333 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
|
7334 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
|
7335 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
|
7336 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
|
7337 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7338 } 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
|
7339 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7340 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
|
7341 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
|
7342 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
|
7343 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
|
7344 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
|
7345 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7346 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7347 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7348 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7349 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7350 |
1168 | 7351 static int decode_slice(H264Context *h){ |
7352 MpegEncContext * const s = &h->s; | |
7353 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7354 | |
7355 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
|
7356 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7357 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
|
7358 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
|
7359 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7360 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7361 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
|
7362 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7363 /* 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
|
7364 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
|
7365 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
|
7366 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7367 ( 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
|
7368 /* calculate pre-state */ |
2755 | 7369 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
|
7370 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
|
7371 if( 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
|
7372 pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7373 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7374 pre = 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 ); |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7375 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7376 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7377 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
|
7378 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7379 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7380 } |
7381 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7382 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7383 //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
|
7384 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
|
7385 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
|
7386 //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
|
7387 |
2163 | 7388 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
|
7389 |
3316 | 7390 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
|
7391 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
|
7392 |
2163 | 7393 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
|
7394 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7395 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
|
7396 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
|
7397 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7398 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
|
7399 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7400 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
|
7401 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
|
7402 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
|
7403 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
|
7404 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7405 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7406 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
|
7407 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
|
7408 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7409 ++s->mb_y; |
3316 | 7410 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7411 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7412 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7413 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7414 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7415 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7416 tprintf("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
|
7417 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
|
7418 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
|
7419 } |
1168 | 7420 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7421 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7422 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7423 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7424 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
|
7425 |
2163 | 7426 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
|
7427 |
3316 | 7428 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
|
7429 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
|
7430 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
|
7431 |
2163 | 7432 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
|
7433 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
|
7434 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7435 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7436 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
|
7437 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
|
7438 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
|
7439 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7440 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
|
7441 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7442 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7443 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
|
7444 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
|
7445 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
|
7446 ++s->mb_y; |
3316 | 7447 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7448 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7449 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7450 if(s->mb_y >= s->mb_height){ |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7451 tprintf("slice end %d %d\n", 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
|
7452 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7453 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
|
7454 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
|
7455 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7456 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
|
7457 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7458 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
|
7459 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7460 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
|
7461 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7462 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7463 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7464 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7465 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7466 tprintf("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
|
7467 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7468 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); |
7469 | |
7470 return 0; | |
7471 }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
|
7472 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 | 7473 |
7474 return -1; | |
7475 } | |
7476 } | |
7477 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7478 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7479 |
1168 | 7480 #if 0 |
7481 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7482 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7483 int ret= decode_mb(h); | |
2967 | 7484 |
1168 | 7485 hl_decode_mb(h); |
7486 | |
7487 if(ret<0){ | |
3177 | 7488 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7489 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); |
7490 | |
7491 return -1; | |
7492 } | |
2967 | 7493 |
1168 | 7494 if(++s->mb_x >= s->mb_width){ |
7495 s->mb_x=0; | |
7496 if(++s->mb_y >= s->mb_height){ | |
7497 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7498 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); | |
7499 | |
7500 return 0; | |
7501 }else{ | |
7502 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); | |
7503 | |
7504 return -1; | |
7505 } | |
7506 } | |
7507 } | |
2967 | 7508 |
1168 | 7509 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7510 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7511 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); | |
7512 | |
7513 return 0; | |
7514 }else{ | |
7515 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); | |
7516 | |
7517 return -1; | |
7518 } | |
7519 } | |
7520 } | |
7521 s->mb_x=0; | |
7522 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7523 } | |
7524 #endif | |
7525 return -1; //not reached | |
7526 } | |
7527 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7528 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
|
7529 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7530 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7531 int e, build, i; |
2967 | 7532 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7533 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7534 return -1; |
2967 | 7535 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7536 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
|
7537 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
|
7538 } |
2967 | 7539 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7540 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7541 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
|
7542 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7543 h->x264_build= build; |
2967 | 7544 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7545 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
|
7546 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
|
7547 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7548 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7549 skip_bits(&s->gb, 8); |
2967 | 7550 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7551 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7552 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7553 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7554 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7555 MpegEncContext * const s = &h->s; |
2967 | 7556 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7557 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
|
7558 int size, type; |
2967 | 7559 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7560 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7561 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7562 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7563 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7564 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7565 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7566 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7567 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7568 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7569 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7570 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7571 case 5: |
3318 | 7572 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
|
7573 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7574 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7575 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7576 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7577 } |
2967 | 7578 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7579 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7580 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7581 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7582 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7583 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7584 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7585 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7586 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
|
7587 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7588 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7589 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
|
7590 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
|
7591 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
|
7592 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
|
7593 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
|
7594 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
|
7595 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
|
7596 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7597 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
|
7598 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
|
7599 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
|
7600 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
|
7601 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7602 |
1168 | 7603 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7604 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7605 int aspect_ratio_info_present_flag; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7606 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
|
7607 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7608 |
7609 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7610 |
1168 | 7611 if( aspect_ratio_info_present_flag ) { |
7612 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7613 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7614 sps->sar.num= get_bits(&s->gb, 16); |
7615 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
|
7616 }else if(aspect_ratio_idc < 14){ |
1548 | 7617 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7618 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7619 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7620 return -1; |
7621 } | |
7622 }else{ | |
2967 | 7623 sps->sar.num= |
1548 | 7624 sps->sar.den= 0; |
1168 | 7625 } |
7626 // 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 (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7627 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7628 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7629 get_bits1(&s->gb); /* overscan_appropriate_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7630 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7631 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7632 if(get_bits1(&s->gb)){ /* video_signal_type_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7633 get_bits(&s->gb, 3); /* video_format */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7634 get_bits1(&s->gb); /* video_full_range_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7635 if(get_bits1(&s->gb)){ /* colour_description_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7636 get_bits(&s->gb, 8); /* colour_primaries */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7637 get_bits(&s->gb, 8); /* transfer_characteristics */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7638 get_bits(&s->gb, 8); /* matrix_coefficients */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7639 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7640 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7641 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7642 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7643 get_ue_golomb(&s->gb); /* chroma_sample_location_type_top_field */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7644 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7645 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7646 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7647 sps->timing_info_present_flag = get_bits1(&s->gb); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7648 if(sps->timing_info_present_flag){ |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7649 sps->num_units_in_tick = get_bits_long(&s->gb, 32); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7650 sps->time_scale = get_bits_long(&s->gb, 32); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7651 sps->fixed_frame_rate_flag = get_bits1(&s->gb); |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7652 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7653 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7654 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
|
7655 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
|
7656 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7657 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
|
7658 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
|
7659 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7660 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
|
7661 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
|
7662 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
|
7663 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7664 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
|
7665 if(sps->bitstream_restriction_flag){ |
4389 | 7666 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
|
7667 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
|
7668 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
|
7669 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
|
7670 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
|
7671 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
4389 | 7672 num_reorder_frames= get_ue_golomb(&s->gb); |
7673 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/ | |
7674 | |
7675 if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){ | |
7676 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames); | |
7677 return -1; | |
7678 } | |
7679 | |
7680 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
|
7681 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7682 |
1168 | 7683 return 0; |
7684 } | |
7685 | |
3004 | 7686 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7687 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7688 MpegEncContext * const s = &h->s; |
7689 int i, last = 8, next = 8; | |
7690 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7691 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7692 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7693 else |
7694 for(i=0;i<size;i++){ | |
7695 if(next) | |
7696 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7697 if(!i && !next){ /* matrix not written, we use the preset one */ |
7698 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7699 break; |
7700 } | |
7701 last = factors[scan[i]] = next ? next : last; | |
7702 } | |
7703 } | |
7704 | |
7705 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7706 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7707 MpegEncContext * const s = &h->s; | |
7708 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7709 const uint8_t *fallback[4] = { | |
7710 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7711 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7712 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7713 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7714 }; | |
7715 if(get_bits1(&s->gb)){ | |
7716 sps->scaling_matrix_present |= is_sps; | |
3004 | 7717 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7718 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7719 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7720 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7721 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7722 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7723 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7724 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7725 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7726 } |
7727 } else if(fallback_sps) { | |
7728 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7729 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7730 } | |
7731 } | |
7732 | |
1168 | 7733 static inline int decode_seq_parameter_set(H264Context *h){ |
7734 MpegEncContext * const s = &h->s; | |
1371 | 7735 int profile_idc, level_idc; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7736 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
|
7737 int i; |
1168 | 7738 SPS *sps; |
2967 | 7739 |
1168 | 7740 profile_idc= get_bits(&s->gb, 8); |
1371 | 7741 get_bits1(&s->gb); //constraint_set0_flag |
7742 get_bits1(&s->gb); //constraint_set1_flag | |
7743 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7744 get_bits1(&s->gb); //constraint_set3_flag |
7745 get_bits(&s->gb, 4); // reserved | |
1168 | 7746 level_idc= get_bits(&s->gb, 8); |
7747 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7748 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7749 if (sps_id >= MAX_SPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7750 // 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
|
7751 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
|
7752 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7753 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7754 |
1168 | 7755 sps= &h->sps_buffer[ sps_id ]; |
7756 sps->profile_idc= profile_idc; | |
7757 sps->level_idc= level_idc; | |
2312 | 7758 |
2755 | 7759 if(sps->profile_idc >= 100){ //high profile |
7760 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7761 get_bits1(&s->gb); //residual_color_transform_flag | |
7762 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7763 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7764 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7765 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7766 }else | |
7767 sps->scaling_matrix_present = 0; | |
2755 | 7768 |
1168 | 7769 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7770 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7771 |
1168 | 7772 if(sps->poc_type == 0){ //FIXME #define |
7773 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7774 } else if(sps->poc_type == 1){//FIXME #define | |
7775 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7776 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7777 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
|
7778 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7779 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7780 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
|
7781 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
|
7782 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7783 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7784 sps->poc_cycle_length= tmp; |
2967 | 7785 |
1168 | 7786 for(i=0; i<sps->poc_cycle_length; i++) |
7787 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
|
7788 }else if(sps->poc_type != 2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7789 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7790 return -1; |
7791 } | |
7792 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7793 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7794 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
|
7795 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
|
7796 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7797 sps->ref_frame_count= tmp; |
1371 | 7798 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
|
7799 mb_width= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7800 mb_height= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7801 if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7802 avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7803 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n"); |
2422 | 7804 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7805 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7806 sps->mb_width = mb_width; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7807 sps->mb_height= mb_height; |
2422 | 7808 |
1168 | 7809 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7810 if(!sps->frame_mbs_only_flag) | |
7811 sps->mb_aff= get_bits1(&s->gb); | |
7812 else | |
7813 sps->mb_aff= 0; | |
7814 | |
7815 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7816 | |
3316 | 7817 #ifndef ALLOW_INTERLACE |
7818 if(sps->mb_aff) | |
3954 | 7819 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7820 #endif |
7821 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7822 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7823 | |
1371 | 7824 sps->crop= get_bits1(&s->gb); |
7825 if(sps->crop){ | |
7826 sps->crop_left = get_ue_golomb(&s->gb); | |
7827 sps->crop_right = get_ue_golomb(&s->gb); | |
7828 sps->crop_top = get_ue_golomb(&s->gb); | |
7829 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7830 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
|
7831 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7832 } |
7833 }else{ | |
2967 | 7834 sps->crop_left = |
7835 sps->crop_right = | |
7836 sps->crop_top = | |
1371 | 7837 sps->crop_bottom= 0; |
7838 } | |
7839 | |
1168 | 7840 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7841 if( sps->vui_parameters_present_flag ) | |
7842 decode_vui_parameters(h, sps); | |
2967 | 7843 |
1168 | 7844 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
|
7845 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 | 7846 sps_id, sps->profile_idc, sps->level_idc, |
7847 sps->poc_type, | |
7848 sps->ref_frame_count, | |
7849 sps->mb_width, sps->mb_height, | |
7850 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7851 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7852 sps->crop_left, sps->crop_right, |
7853 sps->crop_top, sps->crop_bottom, | |
1168 | 7854 sps->vui_parameters_present_flag ? "VUI" : "" |
7855 ); | |
7856 } | |
7857 return 0; | |
7858 } | |
7859 | |
2755 | 7860 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7861 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7862 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
|
7863 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7864 |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7865 if(pps_id>=MAX_PPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7866 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
|
7867 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7868 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7869 pps = &h->pps_buffer[pps_id]; |
2967 | 7870 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7871 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7872 if(tmp>=MAX_SPS_COUNT){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7873 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
|
7874 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7875 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7876 pps->sps_id= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7877 |
1168 | 7878 pps->cabac= get_bits1(&s->gb); |
7879 pps->pic_order_present= get_bits1(&s->gb); | |
7880 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7881 if(pps->slice_group_count > 1 ){ | |
7882 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
|
7883 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7884 switch(pps->mb_slice_group_map_type){ |
7885 case 0: | |
7886 #if 0 | |
7887 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7888 | run_length[ i ] |1 |ue(v) | | |
7889 #endif | |
7890 break; | |
7891 case 2: | |
7892 #if 0 | |
7893 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7894 |{ | | | | |
7895 | top_left_mb[ i ] |1 |ue(v) | | |
7896 | bottom_right_mb[ i ] |1 |ue(v) | | |
7897 | } | | | | |
7898 #endif | |
7899 break; | |
7900 case 3: | |
7901 case 4: | |
7902 case 5: | |
7903 #if 0 | |
7904 | slice_group_change_direction_flag |1 |u(1) | | |
7905 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7906 #endif | |
7907 break; | |
7908 case 6: | |
7909 #if 0 | |
7910 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7911 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7912 |) | | | | |
7913 | slice_group_id[ i ] |1 |u(v) | | |
7914 #endif | |
1214 | 7915 break; |
1168 | 7916 } |
7917 } | |
7918 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7919 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4531 | 7920 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
|
7921 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
|
7922 pps->ref_count[0]= pps->ref_count[1]= 1; |
1168 | 7923 return -1; |
7924 } | |
2967 | 7925 |
1168 | 7926 pps->weighted_pred= get_bits1(&s->gb); |
7927 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7928 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7929 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7930 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7931 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7932 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7933 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7934 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7935 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
|
7936 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7937 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7938 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7939 |
7940 if(get_bits_count(&s->gb) < bit_length){ | |
7941 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7942 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7943 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7944 } | |
2967 | 7945 |
1168 | 7946 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
|
7947 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 | 7948 pps_id, pps->sps_id, |
7949 pps->cabac ? "CABAC" : "CAVLC", | |
7950 pps->slice_group_count, | |
7951 pps->ref_count[0], pps->ref_count[1], | |
7952 pps->weighted_pred ? "weighted" : "", | |
7953 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7954 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7955 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7956 pps->redundant_pic_cnt_present ? "REDU" : "", |
7957 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7958 ); |
7959 } | |
2967 | 7960 |
1168 | 7961 return 0; |
7962 } | |
7963 | |
7964 /** | |
7965 * finds the end of the current frame in the bitstream. | |
7966 * @return the position of the first byte of the next frame, or -1 | |
7967 */ | |
2392 | 7968 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7969 int i; |
1168 | 7970 uint32_t state; |
2392 | 7971 ParseContext *pc = &(h->s.parse_context); |
1168 | 7972 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7973 // mb_addr= pc->mb_addr - 1; | |
7974 state= pc->state; | |
2392 | 7975 for(i=0; i<=buf_size; i++){ |
1168 | 7976 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7977 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7978 if(pc->frame_start_found){ |
2392 | 7979 // If there isn't one more byte in the buffer |
7980 // the test on first_mb_in_slice cannot be done yet | |
7981 // do it at next call. | |
7982 if (i >= buf_size) break; | |
7983 if (buf[i] & 0x80) { | |
7984 // first_mb_in_slice is 0, probably the first nal of a new | |
7985 // slice | |
7986 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 7987 pc->state=-1; |
2392 | 7988 pc->frame_start_found= 0; |
7989 return i-4; | |
7990 } | |
1168 | 7991 } |
2392 | 7992 pc->frame_start_found = 1; |
1168 | 7993 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7994 if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7995 if(pc->frame_start_found){ |
2967 | 7996 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7997 pc->frame_start_found= 0; |
2967 | 7998 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7999 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8000 } |
2392 | 8001 if (i<buf_size) |
8002 state= (state<<8) | buf[i]; | |
1168 | 8003 } |
2967 | 8004 |
1168 | 8005 pc->state= state; |
1219 | 8006 return END_NOT_FOUND; |
1168 | 8007 } |
8008 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8009 #ifdef CONFIG_H264_PARSER |
1988 | 8010 static int h264_parse(AVCodecParserContext *s, |
8011 AVCodecContext *avctx, | |
2967 | 8012 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 8013 const uint8_t *buf, int buf_size) |
8014 { | |
2392 | 8015 H264Context *h = s->priv_data; |
8016 ParseContext *pc = &h->s.parse_context; | |
1988 | 8017 int next; |
2967 | 8018 |
2392 | 8019 next= find_frame_end(h, buf, buf_size); |
1988 | 8020 |
8021 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
8022 *poutbuf = NULL; | |
8023 *poutbuf_size = 0; | |
8024 return buf_size; | |
8025 } | |
8026 | |
8027 *poutbuf = (uint8_t *)buf; | |
8028 *poutbuf_size = buf_size; | |
8029 return next; | |
8030 } | |
8031 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8032 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8033 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8034 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8035 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8036 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8037 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8038 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8039 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8040 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8041 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8042 /* if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8043 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8044 if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8045 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8046 while(i>4 && buf[i-5]==0) i--; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8047 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8048 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8049 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8050 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8051 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8052 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8053 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8054 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8055 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8056 |
1168 | 8057 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
8058 MpegEncContext * const s = &h->s; | |
8059 AVCodecContext * const avctx= s->avctx; | |
8060 int buf_index=0; | |
1322 | 8061 #if 0 |
1168 | 8062 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8063 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8064 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 8065 } |
8066 #endif | |
2392 | 8067 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8068 s->current_picture_ptr= NULL; |
1168 | 8069 for(;;){ |
8070 int consumed; | |
8071 int dst_length; | |
8072 int bit_length; | |
8073 uint8_t *ptr; | |
2227 | 8074 int i, nalsize = 0; |
2967 | 8075 |
2227 | 8076 if(h->is_avc) { |
8077 if(buf_index >= buf_size) break; | |
8078 nalsize = 0; | |
8079 for(i = 0; i < h->nal_length_size; i++) | |
8080 nalsize = (nalsize << 8) | buf[buf_index++]; | |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8081 if(nalsize <= 1 || nalsize > buf_size){ |
3126 | 8082 if(nalsize == 1){ |
8083 buf_index++; | |
8084 continue; | |
8085 }else{ | |
8086 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8087 break; | |
8088 } | |
8089 } | |
2227 | 8090 } else { |
1168 | 8091 // start code prefix search |
8092 for(; buf_index + 3 < buf_size; buf_index++){ | |
8093 // this should allways succeed in the first iteration | |
8094 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8095 break; | |
8096 } | |
2967 | 8097 |
1168 | 8098 if(buf_index+3 >= buf_size) break; |
2967 | 8099 |
1168 | 8100 buf_index+=3; |
2967 | 8101 } |
8102 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8103 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8104 if (ptr==NULL || dst_length <= 0){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8105 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8106 } |
3341 | 8107 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8108 dst_length--; | |
1168 | 8109 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8110 | |
8111 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8112 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 | 8113 } |
2967 | 8114 |
2227 | 8115 if (h->is_avc && (nalsize != consumed)) |
8116 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8117 | |
1168 | 8118 buf_index += consumed; |
8119 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8120 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8121 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8122 continue; |
2967 | 8123 |
1168 | 8124 switch(h->nal_unit_type){ |
8125 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8126 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8127 case NAL_SLICE: |
8128 init_get_bits(&s->gb, ptr, bit_length); | |
8129 h->intra_gb_ptr= | |
8130 h->inter_gb_ptr= &s->gb; | |
8131 s->data_partitioning = 0; | |
2967 | 8132 |
2771 | 8133 if(decode_slice_header(h) < 0){ |
8134 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8135 break; | |
8136 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8137 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8138 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8139 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8140 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8141 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8142 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8143 decode_slice(h); |
8144 break; | |
8145 case NAL_DPA: | |
8146 init_get_bits(&s->gb, ptr, bit_length); | |
8147 h->intra_gb_ptr= | |
8148 h->inter_gb_ptr= NULL; | |
8149 s->data_partitioning = 1; | |
2967 | 8150 |
2771 | 8151 if(decode_slice_header(h) < 0){ |
8152 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8153 } | |
1168 | 8154 break; |
8155 case NAL_DPB: | |
8156 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8157 h->intra_gb_ptr= &h->intra_gb; | |
8158 break; | |
8159 case NAL_DPC: | |
8160 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8161 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8162 |
2967 | 8163 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
|
8164 && s->context_initialized |
2793 | 8165 && s->hurry_up < 5 |
8166 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8167 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8168 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8169 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8170 decode_slice(h); |
8171 break; | |
8172 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8173 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
|
8174 decode_sei(h); |
1168 | 8175 break; |
8176 case NAL_SPS: | |
8177 init_get_bits(&s->gb, ptr, bit_length); | |
8178 decode_seq_parameter_set(h); | |
2967 | 8179 |
1168 | 8180 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8181 s->low_delay=1; | |
2967 | 8182 |
2538 | 8183 if(avctx->has_b_frames < 2) |
8184 avctx->has_b_frames= !s->low_delay; | |
1168 | 8185 break; |
8186 case NAL_PPS: | |
8187 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8188 |
2755 | 8189 decode_picture_parameter_set(h, bit_length); |
1168 | 8190 |
8191 break; | |
2960 | 8192 case NAL_AUD: |
8193 case NAL_END_SEQUENCE: | |
8194 case NAL_END_STREAM: | |
8195 case NAL_FILLER_DATA: | |
8196 case NAL_SPS_EXT: | |
8197 case NAL_AUXILIARY_SLICE: | |
1168 | 8198 break; |
2979 | 8199 default: |
8200 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8201 } |
8202 } | |
8203 | |
1174 | 8204 if(!s->current_picture_ptr) return buf_index; //no frame |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8205 |
2971 | 8206 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8207 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8208 |
1168 | 8209 h->prev_frame_num_offset= h->frame_num_offset; |
8210 h->prev_frame_num= h->frame_num; | |
8211 if(s->current_picture_ptr->reference){ | |
8212 h->prev_poc_msb= h->poc_msb; | |
8213 h->prev_poc_lsb= h->poc_lsb; | |
8214 } | |
8215 if(s->current_picture_ptr->reference) | |
8216 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8217 | |
8218 ff_er_frame_end(s); | |
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
|
8219 |
1168 | 8220 MPV_frame_end(s); |
8221 | |
8222 return buf_index; | |
8223 } | |
8224 | |
8225 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8226 * returns the number of bytes consumed for building the current frame |
1168 | 8227 */ |
8228 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8229 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8230 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8231 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8232 |
1168 | 8233 return pos; |
8234 }else{ | |
8235 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8236 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8237 | |
8238 return pos; | |
8239 } | |
8240 } | |
8241 | |
2967 | 8242 static int decode_frame(AVCodecContext *avctx, |
1168 | 8243 void *data, int *data_size, |
8244 uint8_t *buf, int buf_size) | |
8245 { | |
8246 H264Context *h = avctx->priv_data; | |
8247 MpegEncContext *s = &h->s; | |
2967 | 8248 AVFrame *pict = data; |
1168 | 8249 int buf_index; |
2967 | 8250 |
1168 | 8251 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8252 s->flags2= avctx->flags2; |
1168 | 8253 |
8254 /* no supplementary picture */ | |
8255 if (buf_size == 0) { | |
8256 return 0; | |
8257 } | |
2967 | 8258 |
1168 | 8259 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8260 int next= find_frame_end(h, buf, buf_size); |
2967 | 8261 |
1988 | 8262 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8263 return buf_size; |
8264 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8265 } | |
8266 | |
2227 | 8267 if(h->is_avc && !h->got_avcC) { |
8268 int i, cnt, nalsize; | |
8269 unsigned char *p = avctx->extradata; | |
8270 if(avctx->extradata_size < 7) { | |
8271 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8272 return -1; | |
8273 } | |
8274 if(*p != 1) { | |
8275 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8276 return -1; | |
8277 } | |
8278 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8279 so put a fake nal_length_size = 2 while parsing them */ | |
8280 h->nal_length_size = 2; | |
8281 // Decode sps from avcC | |
8282 cnt = *(p+5) & 0x1f; // Number of sps | |
8283 p += 6; | |
8284 for (i = 0; i < cnt; i++) { | |
4364 | 8285 nalsize = AV_RB16(p) + 2; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8286 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8287 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8288 return -1; | |
8289 } | |
8290 p += nalsize; | |
2967 | 8291 } |
2227 | 8292 // Decode pps from avcC |
8293 cnt = *(p++); // Number of pps | |
8294 for (i = 0; i < cnt; i++) { | |
4364 | 8295 nalsize = AV_RB16(p) + 2; |
2227 | 8296 if(decode_nal_units(h, p, nalsize) != nalsize) { |
8297 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8298 return -1; | |
8299 } | |
8300 p += nalsize; | |
2967 | 8301 } |
2227 | 8302 // Now store right nal length size, that will be use to parse all other nals |
8303 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8304 // Do not reparse avcC | |
8305 h->got_avcC = 1; | |
8306 } | |
8307 | |
4507
b80c704183e9
always decode extradata when of non-avc stream (like RTSP)
gpoirier
parents:
4391
diff
changeset
|
8308 if(avctx->frame_number==0 && !h->is_avc && s->avctx->extradata_size){ |
2967 | 8309 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8310 return -1; |
8311 } | |
8312 | |
8313 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8314 if(buf_index < 0) |
1168 | 8315 return -1; |
8316 | |
2967 | 8317 //FIXME do something with unavailable reference frames |
8318 | |
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
|
8319 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8320 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8321 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8322 return -1; |
8323 } | |
8324 | |
2409 | 8325 { |
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
|
8326 Picture *out = s->current_picture_ptr; |
2561 | 8327 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8328 *data_size = sizeof(AVFrame); |
2561 | 8329 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8330 /* Sort B-frames into display order */ |
2409 | 8331 Picture *cur = s->current_picture_ptr; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8332 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8333 int i, pics, cross_idr, out_of_order, out_idx; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8334 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8335 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
|
8336 && 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
|
8337 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
|
8338 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8339 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8340 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8341 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8342 while(h->delayed_pic[pics]) pics++; |
4388 | 8343 |
8344 assert(pics+1 < sizeof(h->delayed_pic) / sizeof(h->delayed_pic[0])); | |
8345 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8346 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
|
8347 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8348 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8349 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8350 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8351 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
|
8352 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
|
8353 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8354 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8355 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8356 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8357 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
|
8358 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
|
8359 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8360 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8361 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8362 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8363 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8364 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8365 { } | |
8366 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
|
8367 out = prev; |
2923 | 8368 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8369 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8370 ((!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
|
8371 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8372 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8373 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8374 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8375 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8376 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8377 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8378 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8379 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8380 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
|
8381 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
|
8382 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
|
8383 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8384 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8385 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8386 *data_size = 0; |
2561 | 8387 else |
8388 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8389 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
|
8390 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8391 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
|
8392 #endif |
2409 | 8393 |
2937 | 8394 if(out) |
8395 *pict= *(AVFrame*)out; | |
8396 else | |
8397 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8398 } | |
8399 | |
8400 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
|
8401 ff_print_debug_info(s, pict); |
1168 | 8402 //printf("out %d\n", (int)pict->data[0]); |
8403 #if 0 //? | |
8404 | |
8405 /* Return the Picture timestamp as the frame number */ | |
8406 /* we substract 1 because it is added on utils.c */ | |
8407 avctx->frame_number = s->picture_number - 1; | |
8408 #endif | |
8409 return get_consumed_bytes(s, buf_index, buf_size); | |
8410 } | |
8411 #if 0 | |
8412 static inline void fill_mb_avail(H264Context *h){ | |
8413 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
|
8414 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8415 |
8416 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
|
8417 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
|
8418 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
|
8419 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8420 }else{ |
8421 h->mb_avail[0]= | |
8422 h->mb_avail[1]= | |
8423 h->mb_avail[2]= 0; | |
8424 } | |
8425 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8426 h->mb_avail[4]= 1; //FIXME move out | |
8427 h->mb_avail[5]= 0; //FIXME move out | |
8428 } | |
8429 #endif | |
8430 | |
8431 #if 0 //selftest | |
8432 #define COUNT 8000 | |
8433 #define SIZE (COUNT*40) | |
8434 int main(){ | |
8435 int i; | |
8436 uint8_t temp[SIZE]; | |
8437 PutBitContext pb; | |
8438 GetBitContext gb; | |
8439 // int int_temp[10000]; | |
8440 DSPContext dsp; | |
8441 AVCodecContext avctx; | |
2967 | 8442 |
1168 | 8443 dsputil_init(&dsp, &avctx); |
8444 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8445 init_put_bits(&pb, temp, SIZE); |
1168 | 8446 printf("testing unsigned exp golomb\n"); |
8447 for(i=0; i<COUNT; i++){ | |
8448 START_TIMER | |
8449 set_ue_golomb(&pb, i); | |
8450 STOP_TIMER("set_ue_golomb"); | |
8451 } | |
8452 flush_put_bits(&pb); | |
2967 | 8453 |
1168 | 8454 init_get_bits(&gb, temp, 8*SIZE); |
8455 for(i=0; i<COUNT; i++){ | |
8456 int j, s; | |
2967 | 8457 |
1168 | 8458 s= show_bits(&gb, 24); |
2967 | 8459 |
1168 | 8460 START_TIMER |
8461 j= get_ue_golomb(&gb); | |
8462 if(j != i){ | |
8463 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8464 // return -1; | |
8465 } | |
8466 STOP_TIMER("get_ue_golomb"); | |
8467 } | |
2967 | 8468 |
8469 | |
1524 | 8470 init_put_bits(&pb, temp, SIZE); |
1168 | 8471 printf("testing signed exp golomb\n"); |
8472 for(i=0; i<COUNT; i++){ | |
8473 START_TIMER | |
8474 set_se_golomb(&pb, i - COUNT/2); | |
8475 STOP_TIMER("set_se_golomb"); | |
8476 } | |
8477 flush_put_bits(&pb); | |
2967 | 8478 |
1168 | 8479 init_get_bits(&gb, temp, 8*SIZE); |
8480 for(i=0; i<COUNT; i++){ | |
8481 int j, s; | |
2967 | 8482 |
1168 | 8483 s= show_bits(&gb, 24); |
2967 | 8484 |
1168 | 8485 START_TIMER |
8486 j= get_se_golomb(&gb); | |
8487 if(j != i - COUNT/2){ | |
8488 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8489 // return -1; | |
8490 } | |
8491 STOP_TIMER("get_se_golomb"); | |
8492 } | |
8493 | |
8494 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8495 |
1168 | 8496 DCTELEM block[16]; |
8497 uint8_t src[16], ref[16]; | |
8498 uint64_t error= 0, max_error=0; | |
8499 | |
8500 for(i=0; i<COUNT; i++){ | |
8501 int j; | |
8502 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8503 for(j=0; j<16; j++){ | |
8504 ref[j]= random()%255; | |
8505 src[j]= random()%255; | |
8506 } | |
8507 | |
8508 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8509 |
1168 | 8510 //normalize |
8511 for(j=0; j<16; j++){ | |
8512 // printf("%d ", block[j]); | |
8513 block[j]= block[j]*4; | |
8514 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8515 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8516 } | |
8517 // printf("\n"); | |
2967 | 8518 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8519 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8520 /* for(j=0; j<16; j++){ |
8521 printf("%d ", ref[j]); | |
8522 } | |
8523 printf("\n");*/ | |
2967 | 8524 |
1168 | 8525 for(j=0; j<16; j++){ |
4001 | 8526 int diff= FFABS(src[j] - ref[j]); |
2967 | 8527 |
1168 | 8528 error+= diff*diff; |
8529 max_error= FFMAX(max_error, diff); | |
8530 } | |
8531 } | |
8532 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8533 #if 0 | |
8534 printf("testing quantizer\n"); | |
8535 for(qp=0; qp<52; qp++){ | |
8536 for(i=0; i<16; i++) | |
8537 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8538 |
1168 | 8539 } |
8540 #endif | |
8541 printf("Testing NAL layer\n"); | |
2967 | 8542 |
1168 | 8543 uint8_t bitstream[COUNT]; |
8544 uint8_t nal[COUNT*2]; | |
8545 H264Context h; | |
8546 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8547 |
1168 | 8548 for(i=0; i<COUNT; i++){ |
8549 int zeros= i; | |
8550 int nal_length; | |
8551 int consumed; | |
8552 int out_length; | |
8553 uint8_t *out; | |
8554 int j; | |
2967 | 8555 |
1168 | 8556 for(j=0; j<COUNT; j++){ |
8557 bitstream[j]= (random() % 255) + 1; | |
8558 } | |
2967 | 8559 |
1168 | 8560 for(j=0; j<zeros; j++){ |
8561 int pos= random() % COUNT; | |
8562 while(bitstream[pos] == 0){ | |
8563 pos++; | |
8564 pos %= COUNT; | |
8565 } | |
8566 bitstream[pos]=0; | |
8567 } | |
2967 | 8568 |
1168 | 8569 START_TIMER |
2967 | 8570 |
1168 | 8571 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8572 if(nal_length<0){ | |
8573 printf("encoding failed\n"); | |
8574 return -1; | |
8575 } | |
2967 | 8576 |
1168 | 8577 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8578 | |
8579 STOP_TIMER("NAL") | |
2967 | 8580 |
1168 | 8581 if(out_length != COUNT){ |
8582 printf("incorrect length %d %d\n", out_length, COUNT); | |
8583 return -1; | |
8584 } | |
2967 | 8585 |
1168 | 8586 if(consumed != nal_length){ |
8587 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8588 return -1; | |
8589 } | |
2967 | 8590 |
1168 | 8591 if(memcmp(bitstream, out, COUNT)){ |
8592 printf("missmatch\n"); | |
8593 return -1; | |
8594 } | |
8595 } | |
2967 | 8596 |
1168 | 8597 printf("Testing RBSP\n"); |
2967 | 8598 |
8599 | |
1168 | 8600 return 0; |
8601 } | |
8602 #endif | |
8603 | |
8604 | |
8605 static int decode_end(AVCodecContext *avctx) | |
8606 { | |
8607 H264Context *h = avctx->priv_data; | |
8608 MpegEncContext *s = &h->s; | |
2967 | 8609 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8610 av_freep(&h->rbsp_buffer); |
1168 | 8611 free_tables(h); //FIXME cleanup init stuff perhaps |
8612 MPV_common_end(s); | |
8613 | |
8614 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8615 |
1168 | 8616 return 0; |
8617 } | |
8618 | |
8619 | |
8620 AVCodec h264_decoder = { | |
8621 "h264", | |
8622 CODEC_TYPE_VIDEO, | |
8623 CODEC_ID_H264, | |
8624 sizeof(H264Context), | |
8625 decode_init, | |
8626 NULL, | |
8627 decode_end, | |
8628 decode_frame, | |
2453 | 8629 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8630 .flush= flush_dpb, |
1168 | 8631 }; |
8632 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8633 #ifdef CONFIG_H264_PARSER |
1988 | 8634 AVCodecParser h264_parser = { |
8635 { CODEC_ID_H264 }, | |
2392 | 8636 sizeof(H264Context), |
1988 | 8637 NULL, |
8638 h264_parse, | |
8639 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8640 h264_split, |
1988 | 8641 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8642 #endif |
1988 | 8643 |
1234 | 8644 #include "svq3.c" |