Mercurial > libavcodec.hg
annotate h264.c @ 4532:c296efb7575e libavcodec
fix 2nd ref_count check
add list_count
author | michael |
---|---|
date | Fri, 16 Feb 2007 21:34:21 +0000 |
parents | 8a5a3dd25390 |
children | dca590e16c43 |
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; | |
617 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ | |
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; |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
785 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ |
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 |
1168 | 1706 for(list=0; list<2; list++){ |
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; | |
3546 for(list=0; list<2; list++){ | |
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 |
1168 | 3914 for(list=0; list<2; list++){ |
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 } | |
3992 | |
3993 if(h->slice_type!=B_TYPE) break; | |
3994 } | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3995 for(list=0; list<2; list++){ |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3996 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
|
3997 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3998 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3999 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4000 if(h->slice_type!=B_TYPE) break; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
4001 } |
2967 | 4002 |
2396 | 4003 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
4004 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
4005 direct_ref_list_init(h); |
2967 | 4006 return 0; |
1168 | 4007 } |
4008 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
4009 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 4010 int list, i, j; |
4011 for(list=0; list<2; list++){ | |
4012 for(i=0; i<h->ref_count[list]; i++){ | |
4013 Picture *frame = &h->ref_list[list][i]; | |
4014 Picture *field = &h->ref_list[list][16+2*i]; | |
4015 field[0] = *frame; | |
4016 for(j=0; j<3; j++) | |
4017 field[0].linesize[j] <<= 1; | |
4018 field[1] = field[0]; | |
4019 for(j=0; j<3; j++) | |
4020 field[1].data[j] += frame->linesize[j]; | |
4021 | |
4022 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4023 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4024 for(j=0; j<2; j++){ | |
4025 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4026 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4027 } | |
4028 } | |
4029 } | |
4030 for(j=0; j<h->ref_count[1]; j++){ | |
4031 for(i=0; i<h->ref_count[0]; i++) | |
4032 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4033 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4034 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4035 } | |
4036 } | |
4037 | |
1168 | 4038 static int pred_weight_table(H264Context *h){ |
4039 MpegEncContext * const s = &h->s; | |
4040 int list, i; | |
2415 | 4041 int luma_def, chroma_def; |
2967 | 4042 |
2415 | 4043 h->use_weight= 0; |
4044 h->use_weight_chroma= 0; | |
1168 | 4045 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4046 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4047 luma_def = 1<<h->luma_log2_weight_denom; |
4048 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4049 |
4050 for(list=0; list<2; list++){ | |
4051 for(i=0; i<h->ref_count[list]; i++){ | |
4052 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4053 |
1168 | 4054 luma_weight_flag= get_bits1(&s->gb); |
4055 if(luma_weight_flag){ | |
4056 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4057 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4058 if( h->luma_weight[list][i] != luma_def |
4059 || h->luma_offset[list][i] != 0) | |
4060 h->use_weight= 1; | |
4061 }else{ | |
4062 h->luma_weight[list][i]= luma_def; | |
4063 h->luma_offset[list][i]= 0; | |
1168 | 4064 } |
4065 | |
4066 chroma_weight_flag= get_bits1(&s->gb); | |
4067 if(chroma_weight_flag){ | |
4068 int j; | |
4069 for(j=0; j<2; j++){ | |
4070 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4071 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4072 if( h->chroma_weight[list][i][j] != chroma_def |
4073 || h->chroma_offset[list][i][j] != 0) | |
4074 h->use_weight_chroma= 1; | |
4075 } | |
4076 }else{ | |
4077 int j; | |
4078 for(j=0; j<2; j++){ | |
4079 h->chroma_weight[list][i][j]= chroma_def; | |
4080 h->chroma_offset[list][i][j]= 0; | |
1168 | 4081 } |
4082 } | |
4083 } | |
4084 if(h->slice_type != B_TYPE) break; | |
4085 } | |
2415 | 4086 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4087 return 0; |
4088 } | |
4089 | |
2415 | 4090 static void implicit_weight_table(H264Context *h){ |
4091 MpegEncContext * const s = &h->s; | |
4092 int ref0, ref1; | |
4093 int cur_poc = s->current_picture_ptr->poc; | |
4094 | |
4095 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4096 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4097 h->use_weight= 0; | |
4098 h->use_weight_chroma= 0; | |
4099 return; | |
4100 } | |
4101 | |
4102 h->use_weight= 2; | |
4103 h->use_weight_chroma= 2; | |
4104 h->luma_log2_weight_denom= 5; | |
4105 h->chroma_log2_weight_denom= 5; | |
4106 | |
4107 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4108 int poc0 = h->ref_list[0][ref0].poc; | |
4109 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4110 int poc1 = h->ref_list[1][ref1].poc; |
2415 | 4111 int td = clip(poc1 - poc0, -128, 127); |
4112 if(td){ | |
4113 int tb = clip(cur_poc - poc0, -128, 127); | |
4001 | 4114 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2415 | 4115 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
4116 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
4117 h->implicit_weight[ref0][ref1] = 32; | |
4118 else | |
4119 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4120 }else | |
4121 h->implicit_weight[ref0][ref1] = 32; | |
4122 } | |
4123 } | |
4124 } | |
4125 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4126 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
|
4127 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4128 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4129 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
|
4130 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4131 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4132 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
|
4133 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
|
4134 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4135 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4136 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4137 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4138 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4139 |
1168 | 4140 /** |
2392 | 4141 * instantaneous decoder refresh. |
1168 | 4142 */ |
4143 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
|
4144 int i; |
1168 | 4145 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4146 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4147 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
|
4148 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
|
4149 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4150 } |
1168 | 4151 } |
4152 h->long_ref_count=0; | |
4153 | |
4154 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
|
4155 unreference_pic(h, h->short_ref[i]); |
1168 | 4156 h->short_ref[i]= NULL; |
4157 } | |
4158 h->short_ref_count=0; | |
4159 } | |
4160 | |
2640 | 4161 /* forget old pics after a seek */ |
4162 static void flush_dpb(AVCodecContext *avctx){ | |
4163 H264Context *h= avctx->priv_data; | |
4164 int i; | |
3144 | 4165 for(i=0; i<16; i++) { |
4166 if(h->delayed_pic[i]) | |
4167 h->delayed_pic[i]->reference= 0; | |
2640 | 4168 h->delayed_pic[i]= NULL; |
3144 | 4169 } |
4170 if(h->delayed_output_pic) | |
4171 h->delayed_output_pic->reference= 0; | |
2640 | 4172 h->delayed_output_pic= NULL; |
4173 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4174 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4175 h->s.current_picture_ptr->reference= 0; |
2640 | 4176 } |
4177 | |
1168 | 4178 /** |
4179 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4180 * @return the removed picture or NULL if an error occurs |
1168 | 4181 */ |
4182 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4183 MpegEncContext * const s = &h->s; |
1168 | 4184 int i; |
2967 | 4185 |
1169 | 4186 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
|
4187 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4188 |
1168 | 4189 for(i=0; i<h->short_ref_count; i++){ |
4190 Picture *pic= h->short_ref[i]; | |
1169 | 4191 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
|
4192 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4193 if(pic->frame_num == frame_num){ |
4194 h->short_ref[i]= NULL; | |
4195 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4196 h->short_ref_count--; | |
4197 return pic; | |
4198 } | |
4199 } | |
4200 return NULL; | |
4201 } | |
4202 | |
4203 /** | |
4204 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4205 * @return the removed picture or NULL if an error occurs |
1168 | 4206 */ |
4207 static Picture * remove_long(H264Context *h, int i){ | |
4208 Picture *pic; | |
4209 | |
4210 pic= h->long_ref[i]; | |
4211 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
|
4212 if(pic) h->long_ref_count--; |
1168 | 4213 |
4214 return pic; | |
4215 } | |
4216 | |
4217 /** | |
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
|
4218 * 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
|
4219 */ |
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 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
|
4221 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
|
4222 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
|
4223 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
|
4224 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
|
4225 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
|
4226 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
|
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 } |
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 /** |
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 * 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
|
4233 */ |
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 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
|
4235 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
|
4236 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
|
4237 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
|
4238 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
|
4239 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
|
4240 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
|
4241 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
|
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 } |
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
|
4245 } |
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
|
4246 |
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
|
4247 /** |
1168 | 4248 * Executes the reference picture marking (memory management control operations). |
4249 */ | |
4250 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4251 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
|
4252 int i, j; |
1168 | 4253 int current_is_long=0; |
4254 Picture *pic; | |
2967 | 4255 |
1168 | 4256 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
|
4257 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4258 |
1168 | 4259 for(i=0; i<mmco_count; i++){ |
4260 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
|
4261 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 | 4262 |
4263 switch(mmco[i].opcode){ | |
4264 case MMCO_SHORT2UNUSED: | |
4265 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
|
4266 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4267 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4268 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
|
4269 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4270 break; |
4271 case MMCO_SHORT2LONG: | |
4272 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
|
4273 if(pic) unreference_pic(h, pic); |
2967 | 4274 |
1168 | 4275 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
|
4276 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
|
4277 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
|
4278 h->long_ref_count++; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
4279 } |
1168 | 4280 break; |
4281 case MMCO_LONG2UNUSED: | |
4282 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
|
4283 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4284 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4285 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
|
4286 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4287 break; |
4288 case MMCO_LONG: | |
4289 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
|
4290 if(pic) unreference_pic(h, pic); |
2967 | 4291 |
1168 | 4292 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4293 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4294 h->long_ref_count++; | |
2967 | 4295 |
1168 | 4296 current_is_long=1; |
4297 break; | |
4298 case MMCO_SET_MAX_LONG: | |
4299 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
|
4300 // 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
|
4301 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
|
4302 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
|
4303 if (pic) unreference_pic(h, pic); |
1168 | 4304 } |
4305 break; | |
4306 case MMCO_RESET: | |
4307 while(h->short_ref_count){ | |
4308 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
|
4309 if(pic) unreference_pic(h, pic); |
1168 | 4310 } |
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
|
4311 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
|
4312 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
|
4313 if(pic) unreference_pic(h, pic); |
1168 | 4314 } |
4315 break; | |
4316 default: assert(0); | |
4317 } | |
4318 } | |
2967 | 4319 |
1168 | 4320 if(!current_is_long){ |
4321 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4322 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4323 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4324 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4325 } |
2967 | 4326 |
1168 | 4327 if(h->short_ref_count) |
1169 | 4328 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4329 | |
4330 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4331 h->short_ref[0]->long_ref=0; |
4332 h->short_ref_count++; | |
4333 } | |
2967 | 4334 |
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
|
4335 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
|
4336 print_long_term(h); |
2967 | 4337 return 0; |
1168 | 4338 } |
4339 | |
4340 static int decode_ref_pic_marking(H264Context *h){ | |
4341 MpegEncContext * const s = &h->s; | |
4342 int i; | |
2967 | 4343 |
1168 | 4344 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4345 s->broken_link= get_bits1(&s->gb) -1; | |
4346 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4347 if(h->mmco[0].long_index == -1) | |
4348 h->mmco_index= 0; | |
4349 else{ | |
4350 h->mmco[0].opcode= MMCO_LONG; | |
4351 h->mmco_index= 1; | |
2967 | 4352 } |
1168 | 4353 }else{ |
4354 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4355 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4356 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4357 | |
4358 h->mmco[i].opcode= opcode; | |
4359 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4360 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 | |
4361 /* 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
|
4362 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4363 return -1; |
4364 }*/ | |
4365 } | |
4366 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
|
4367 unsigned int long_index= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4368 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
|
4369 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4370 return -1; |
4371 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4372 h->mmco[i].long_index= long_index; |
1168 | 4373 } |
2967 | 4374 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4375 if(opcode > (unsigned)MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4376 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4377 return -1; |
4378 } | |
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
|
4379 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
|
4380 break; |
1168 | 4381 } |
4382 h->mmco_index= i; | |
4383 }else{ | |
4384 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4385 | |
4386 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4387 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4388 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4389 h->mmco_index= 1; | |
4390 }else | |
4391 h->mmco_index= 0; | |
4392 } | |
4393 } | |
2967 | 4394 |
4395 return 0; | |
1168 | 4396 } |
4397 | |
4398 static int init_poc(H264Context *h){ | |
4399 MpegEncContext * const s = &h->s; | |
4400 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4401 int field_poc[2]; | |
4402 | |
4403 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4404 h->frame_num_offset= 0; | |
4405 }else{ | |
4406 if(h->frame_num < h->prev_frame_num) | |
4407 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4408 else | |
4409 h->frame_num_offset= h->prev_frame_num_offset; | |
4410 } | |
4411 | |
4412 if(h->sps.poc_type==0){ | |
4413 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4414 | |
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
|
4415 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
|
4416 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
|
4417 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
|
4418 } |
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
|
4419 |
1168 | 4420 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4421 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4422 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4423 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4424 else | |
4425 h->poc_msb = h->prev_poc_msb; | |
4426 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4427 field_poc[0] = |
1168 | 4428 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4429 if(s->picture_structure == PICT_FRAME) |
1168 | 4430 field_poc[1] += h->delta_poc_bottom; |
4431 }else if(h->sps.poc_type==1){ | |
4432 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4433 int i; | |
4434 | |
4435 if(h->sps.poc_cycle_length != 0) | |
4436 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4437 else | |
4438 abs_frame_num = 0; | |
4439 | |
4440 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4441 abs_frame_num--; | |
2967 | 4442 |
1168 | 4443 expected_delta_per_poc_cycle = 0; |
4444 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4445 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4446 | |
4447 if(abs_frame_num > 0){ | |
4448 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4449 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4450 | |
4451 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4452 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4453 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4454 } else | |
4455 expectedpoc = 0; | |
4456 | |
2967 | 4457 if(h->nal_ref_idc == 0) |
1168 | 4458 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4459 |
1168 | 4460 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4461 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4462 | |
4463 if(s->picture_structure == PICT_FRAME) | |
4464 field_poc[1] += h->delta_poc[1]; | |
4465 }else{ | |
4466 int poc; | |
4467 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4468 poc= 0; | |
4469 }else{ | |
4470 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4471 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4472 } | |
4473 field_poc[0]= poc; | |
4474 field_poc[1]= poc; | |
4475 } | |
2967 | 4476 |
1168 | 4477 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4478 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4479 if(s->picture_structure != PICT_TOP_FIELD) | |
4480 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4481 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4482 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4483 | |
4484 return 0; | |
4485 } | |
4486 | |
4487 /** | |
4488 * decodes a slice header. | |
4489 * this will allso call MPV_common_init() and frame_start() as needed | |
4490 */ | |
4491 static int decode_slice_header(H264Context *h){ | |
4492 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4493 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
|
4494 unsigned int pps_id; |
1168 | 4495 int num_ref_idx_active_override_flag; |
4496 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
|
4497 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
|
4498 int default_ref_list_done = 0; |
1168 | 4499 |
4500 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
|
4501 s->dropable= h->nal_ref_idc == 0; |
1168 | 4502 |
4503 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4504 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4505 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
|
4506 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4507 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 | 4508 return -1; |
1168 | 4509 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4510 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4511 slice_type -= 5; |
1168 | 4512 h->slice_type_fixed=1; |
4513 }else | |
4514 h->slice_type_fixed=0; | |
2967 | 4515 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4516 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
|
4517 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
|
4518 || (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
|
4519 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
|
4520 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4521 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
|
4522 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4523 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4524 |
1168 | 4525 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
|
4526 if(pps_id>=MAX_PPS_COUNT){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4527 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4528 return -1; |
4529 } | |
4530 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4531 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
|
4532 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4533 return -1; |
4534 } | |
4535 | |
1168 | 4536 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4537 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
|
4538 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4539 return -1; |
4540 } | |
2919 | 4541 |
4363 | 4542 if(h->dequant_coeff_pps != pps_id){ |
4543 h->dequant_coeff_pps = pps_id; | |
2919 | 4544 init_dequant_tables(h); |
4545 } | |
2967 | 4546 |
1168 | 4547 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
|
4548 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4549 |
3178 | 4550 h->b_stride= s->mb_width*4; |
4551 h->b8_stride= s->mb_width*2; | |
1168 | 4552 |
1371 | 4553 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4554 if(h->sps.frame_mbs_only_flag) |
1371 | 4555 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4556 else |
1371 | 4557 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4558 |
4559 if (s->context_initialized | |
1548 | 4560 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4561 free_tables(h); |
4562 MPV_common_end(s); | |
4563 } | |
4564 if (!s->context_initialized) { | |
4565 if (MPV_common_init(s) < 0) | |
4566 return -1; | |
2967 | 4567 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4568 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
|
4569 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
|
4570 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
|
4571 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4572 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4573 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4574 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4575 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4576 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4577 #undef T |
4578 } | |
4579 } | |
4580 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4581 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4582 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4583 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4584 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4585 }else{ |
4586 int i; | |
4587 for(i=0; i<64; i++){ | |
4588 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4589 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4590 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4591 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4592 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4593 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4594 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4595 } |
2763 | 4596 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4597 h->zigzag_scan_q0 = zigzag_scan; |
4598 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4599 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4600 h->field_scan_q0 = field_scan; |
4601 h->field_scan8x8_q0 = field_scan8x8; | |
4602 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4603 }else{ |
3316 | 4604 h->zigzag_scan_q0 = h->zigzag_scan; |
4605 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4606 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4607 h->field_scan_q0 = h->field_scan; |
4608 h->field_scan8x8_q0 = h->field_scan8x8; | |
4609 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4610 } |
1168 | 4611 |
4612 alloc_tables(h); | |
4613 | |
4614 s->avctx->width = s->width; | |
4615 s->avctx->height = s->height; | |
1548 | 4616 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4617 if(!s->avctx->sample_aspect_ratio.den) |
4618 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
|
4619 |
2648 | 4620 if(h->sps.timing_info_present_flag){ |
3052 | 4621 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
|
4622 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
|
4623 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4624 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
|
4625 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
|
4626 } |
1168 | 4627 } |
4628 | |
2392 | 4629 if(h->slice_num == 0){ |
2935 | 4630 if(frame_start(h) < 0) |
4631 return -1; | |
1168 | 4632 } |
4633 | |
1169 | 4634 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4635 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4636 | |
3316 | 4637 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4638 h->mb_aff_frame = 0; |
1168 | 4639 if(h->sps.frame_mbs_only_flag){ |
4640 s->picture_structure= PICT_FRAME; | |
4641 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4642 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4643 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4644 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
|
4645 } else { |
1168 | 4646 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4647 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
|
4648 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4649 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4650 assert(s->mb_num == s->mb_width * s->mb_height); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4651 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
|
4652 first_mb_in_slice >= s->mb_num){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4653 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
|
4654 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4655 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4656 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4657 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
|
4658 assert(s->mb_y < s->mb_height); |
2967 | 4659 |
1168 | 4660 if(s->picture_structure==PICT_FRAME){ |
4661 h->curr_pic_num= h->frame_num; | |
4662 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4663 }else{ | |
4664 h->curr_pic_num= 2*h->frame_num; | |
4665 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4666 } | |
2967 | 4667 |
1168 | 4668 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4669 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4670 } |
2967 | 4671 |
1168 | 4672 if(h->sps.poc_type==0){ |
4673 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4674 |
1168 | 4675 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4676 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4677 } | |
4678 } | |
2967 | 4679 |
1168 | 4680 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4681 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4682 |
1168 | 4683 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4684 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4685 } | |
2967 | 4686 |
1168 | 4687 init_poc(h); |
2967 | 4688 |
1168 | 4689 if(h->pps.redundant_pic_cnt_present){ |
4690 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4691 } | |
4692 | |
4693 //set defaults, might be overriden a few line later | |
4694 h->ref_count[0]= h->pps.ref_count[0]; | |
4695 h->ref_count[1]= h->pps.ref_count[1]; | |
4696 | |
4697 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4698 if(h->slice_type == B_TYPE){ | |
4699 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4700 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4701 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4702 } |
4703 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4704 |
1168 | 4705 if(num_ref_idx_active_override_flag){ |
4706 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4707 if(h->slice_type==B_TYPE) | |
4708 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4709 | |
4532 | 4710 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
|
4711 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
|
4712 h->ref_count[0]= h->ref_count[1]= 1; |
1168 | 4713 return -1; |
4714 } | |
4715 } | |
4532 | 4716 if(h->slice_type == B_TYPE) |
4717 h->list_count= 2; | |
4718 else | |
4719 h->list_count= 1; | |
4720 }else | |
4721 h->list_count= 0; | |
1168 | 4722 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4723 if(!default_ref_list_done){ |
1168 | 4724 fill_default_ref_list(h); |
4725 } | |
4726 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4727 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
|
4728 return -1; |
1168 | 4729 |
2967 | 4730 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4731 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4732 pred_weight_table(h); | |
2415 | 4733 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4734 implicit_weight_table(h); | |
4735 else | |
4736 h->use_weight = 0; | |
2967 | 4737 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4738 if(s->current_picture.reference) |
1168 | 4739 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
|
4740 |
3316 | 4741 if(FRAME_MBAFF) |
4742 fill_mbaff_ref_list(h); | |
4743 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4744 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
|
4745 tmp = get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4746 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4747 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
|
4748 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4749 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4750 h->cabac_init_idc= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4751 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4752 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4753 h->last_qscale_diff = 0; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4754 tmp = h->pps.init_qp + get_se_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4755 if(tmp>51){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4756 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); |
1898 | 4757 return -1; |
4758 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4759 s->qscale= tmp; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4760 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4761 //FIXME qscale / qp ... stuff |
4762 if(h->slice_type == SP_TYPE){ | |
1453 | 4763 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4764 } |
4765 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4766 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4767 } |
4768 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4769 h->deblocking_filter = 1; |
1898 | 4770 h->slice_alpha_c0_offset = 0; |
4771 h->slice_beta_offset = 0; | |
1168 | 4772 if( h->pps.deblocking_filter_parameters_present ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4773 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4774 if(tmp > 2){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4775 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
|
4776 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4777 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
4778 h->deblocking_filter= tmp; |
2967 | 4779 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
|
4780 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
|
4781 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4782 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
|
4783 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
|
4784 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4785 } |
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
|
4786 } |
2792 | 4787 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4788 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4789 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4790 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4791 h->deblocking_filter= 0; | |
1168 | 4792 |
4793 #if 0 //FMO | |
4794 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4795 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4796 #endif | |
4797 | |
2392 | 4798 h->slice_num++; |
4799 | |
3316 | 4800 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4801 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4802 | |
1168 | 4803 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
|
4804 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
|
4805 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4806 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4807 first_mb_in_slice, |
1264 | 4808 av_get_pict_type_char(h->slice_type), |
1168 | 4809 pps_id, h->frame_num, |
4810 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4811 h->ref_count[0], h->ref_count[1], | |
4812 s->qscale, | |
2583 | 4813 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4814 h->use_weight, |
4815 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4816 ); |
4817 } | |
4818 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4819 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
|
4820 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
|
4821 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
|
4822 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4823 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
|
4824 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
|
4825 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4826 |
1168 | 4827 return 0; |
4828 } | |
4829 | |
4830 /** | |
4831 * | |
4832 */ | |
4833 static inline int get_level_prefix(GetBitContext *gb){ | |
4834 unsigned int buf; | |
4835 int log; | |
2967 | 4836 |
1168 | 4837 OPEN_READER(re, gb); |
4838 UPDATE_CACHE(re, gb); | |
4839 buf=GET_CACHE(re, gb); | |
2967 | 4840 |
1168 | 4841 log= 32 - av_log2(buf); |
4842 #ifdef TRACE | |
4843 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
|
4844 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 | 4845 #endif |
4846 | |
4847 LAST_SKIP_BITS(re, gb, log); | |
4848 CLOSE_READER(re, gb); | |
4849 | |
4850 return log-1; | |
4851 } | |
4852 | |
2755 | 4853 static inline int get_dct8x8_allowed(H264Context *h){ |
4854 int i; | |
4855 for(i=0; i<4; i++){ | |
4856 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
|
4857 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4858 return 0; |
4859 } | |
4860 return 1; | |
4861 } | |
4862 | |
1168 | 4863 /** |
4864 * decodes a residual block. | |
4865 * @param n block index | |
4866 * @param scantable scantable | |
4867 * @param max_coeff number of coefficients in the block | |
4868 * @return <0 if an error occured | |
4869 */ | |
2919 | 4870 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4871 MpegEncContext * const s = &h->s; |
4872 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 | 4873 int level[16]; |
4874 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4875 |
4876 //FIXME put trailing_onex into the context | |
4877 | |
4878 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4879 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4880 total_coeff= coeff_token>>2; | |
2967 | 4881 }else{ |
1168 | 4882 if(n == LUMA_DC_BLOCK_INDEX){ |
4883 total_coeff= pred_non_zero_count(h, 0); | |
4884 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4885 total_coeff= coeff_token>>2; | |
4886 }else{ | |
4887 total_coeff= pred_non_zero_count(h, n); | |
4888 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4889 total_coeff= coeff_token>>2; | |
4890 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4891 } | |
4892 } | |
4893 | |
4894 //FIXME set last_non_zero? | |
4895 | |
4896 if(total_coeff==0) | |
4897 return 0; | |
4391
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4898 if(total_coeff > (unsigned)max_coeff) { |
20944c70a3c0
fix segfault with darkkben.free.fr/corrupted_h264.mp4
michael
parents:
4390
diff
changeset
|
4899 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 | 4900 return -1; |
4901 } | |
2967 | 4902 |
1168 | 4903 trailing_ones= coeff_token&3; |
1170 | 4904 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4905 assert(total_coeff<=16); |
2967 | 4906 |
1168 | 4907 for(i=0; i<trailing_ones; i++){ |
4908 level[i]= 1 - 2*get_bits1(gb); | |
4909 } | |
4910 | |
2897 | 4911 if(i<total_coeff) { |
1168 | 4912 int level_code, mask; |
2897 | 4913 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4914 int prefix= get_level_prefix(gb); | |
4915 | |
4916 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4917 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4918 if(suffix_length) | |
4919 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4920 else | |
4921 level_code= (prefix<<suffix_length); //part | |
4922 }else if(prefix==14){ | |
4923 if(suffix_length) | |
4924 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4925 else | |
4926 level_code= prefix + get_bits(gb, 4); //part | |
4927 }else if(prefix==15){ | |
4928 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
|
4929 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4930 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4931 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4932 return -1; |
4933 } | |
4934 | |
2897 | 4935 if(trailing_ones < 3) level_code += 2; |
4936 | |
4937 suffix_length = 1; | |
4938 if(level_code > 5) | |
4939 suffix_length++; | |
1168 | 4940 mask= -(level_code&1); |
4941 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4942 i++; |
4943 | |
4944 //remaining coefficients have suffix_length > 0 | |
4945 for(;i<total_coeff;i++) { | |
4946 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4947 prefix = get_level_prefix(gb); | |
4948 if(prefix<15){ | |
4949 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4950 }else if(prefix==15){ | |
4951 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4952 }else{ | |
4953 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4954 return -1; | |
4955 } | |
4956 mask= -(level_code&1); | |
4957 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4958 if(level_code > suffix_limit[suffix_length]) | |
4959 suffix_length++; | |
4960 } | |
1168 | 4961 } |
4962 | |
4963 if(total_coeff == max_coeff) | |
4964 zeros_left=0; | |
4965 else{ | |
4966 if(n == CHROMA_DC_BLOCK_INDEX) | |
4967 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4968 else | |
4969 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4970 } | |
2897 | 4971 |
4972 coeff_num = zeros_left + total_coeff - 1; | |
4973 j = scantable[coeff_num]; | |
4974 if(n > 24){ | |
4975 block[j] = level[0]; | |
4976 for(i=1;i<total_coeff;i++) { | |
4977 if(zeros_left <= 0) | |
4978 run_before = 0; | |
4979 else if(zeros_left < 7){ | |
4980 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4981 }else{ | |
4982 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4983 } | |
4984 zeros_left -= run_before; | |
4985 coeff_num -= 1 + run_before; | |
4986 j= scantable[ coeff_num ]; | |
4987 | |
4988 block[j]= level[i]; | |
4989 } | |
4990 }else{ | |
2919 | 4991 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4992 for(i=1;i<total_coeff;i++) { |
4993 if(zeros_left <= 0) | |
4994 run_before = 0; | |
4995 else if(zeros_left < 7){ | |
4996 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4997 }else{ | |
4998 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4999 } | |
5000 zeros_left -= run_before; | |
5001 coeff_num -= 1 + run_before; | |
5002 j= scantable[ coeff_num ]; | |
5003 | |
2919 | 5004 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 5005 } |
1168 | 5006 } |
5007 | |
5008 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5009 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 5010 return -1; |
5011 } | |
2897 | 5012 |
1168 | 5013 return 0; |
5014 } | |
5015 | |
3316 | 5016 static void predict_field_decoding_flag(H264Context *h){ |
5017 MpegEncContext * const s = &h->s; | |
5018 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
5019 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
5020 ? s->current_picture.mb_type[mb_xy-1] | |
5021 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
5022 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
5023 : 0; | |
5024 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
5025 } | |
5026 | |
1168 | 5027 /** |
2396 | 5028 * decodes a P_SKIP or B_SKIP macroblock |
5029 */ | |
5030 static void decode_mb_skip(H264Context *h){ | |
5031 MpegEncContext * const s = &h->s; | |
5032 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
|
5033 int mb_type=0; |
2967 | 5034 |
2396 | 5035 memset(h->non_zero_count[mb_xy], 0, 16); |
5036 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
5037 | |
3316 | 5038 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5039 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5040 |
2396 | 5041 if( h->slice_type == B_TYPE ) |
5042 { | |
5043 // 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
|
5044 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5045 |
2449 | 5046 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5047 pred_direct_motion(h, &mb_type); |
3927 | 5048 mb_type|= MB_TYPE_SKIP; |
2396 | 5049 } |
5050 else | |
5051 { | |
5052 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5053 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5054 |
2449 | 5055 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5056 pred_pskip_motion(h, &mx, &my); |
5057 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5058 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5059 } | |
5060 | |
5061 write_back_motion(h, mb_type); | |
3927 | 5062 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5063 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5064 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
|
5065 h->prev_mb_skipped= 1; |
2396 | 5066 } |
5067 | |
5068 /** | |
1168 | 5069 * decodes a macroblock |
5070 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5071 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5072 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5073 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
|
5074 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
|
5075 int partition_count; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5076 unsigned int mb_type, cbp; |
2755 | 5077 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5078 |
2967 | 5079 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5080 |
1170 | 5081 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5082 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5083 down the code */ | |
1168 | 5084 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5085 if(s->mb_skip_run==-1) | |
5086 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5087 |
1168 | 5088 if (s->mb_skip_run--) { |
3316 | 5089 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5090 if(s->mb_skip_run==0) | |
5091 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5092 else | |
5093 predict_field_decoding_flag(h); | |
5094 } | |
2396 | 5095 decode_mb_skip(h); |
1168 | 5096 return 0; |
5097 } | |
5098 } | |
3316 | 5099 if(FRAME_MBAFF){ |
5100 if( (s->mb_y&1) == 0 ) | |
5101 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5102 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5103 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5104 |
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
|
5105 h->prev_mb_skipped= 0; |
2967 | 5106 |
1168 | 5107 mb_type= get_ue_golomb(&s->gb); |
5108 if(h->slice_type == B_TYPE){ | |
5109 if(mb_type < 23){ | |
5110 partition_count= b_mb_type_info[mb_type].partition_count; | |
5111 mb_type= b_mb_type_info[mb_type].type; | |
5112 }else{ | |
5113 mb_type -= 23; | |
5114 goto decode_intra_mb; | |
5115 } | |
5116 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5117 if(mb_type < 5){ | |
5118 partition_count= p_mb_type_info[mb_type].partition_count; | |
5119 mb_type= p_mb_type_info[mb_type].type; | |
5120 }else{ | |
5121 mb_type -= 5; | |
5122 goto decode_intra_mb; | |
5123 } | |
5124 }else{ | |
5125 assert(h->slice_type == I_TYPE); | |
5126 decode_intra_mb: | |
5127 if(mb_type > 25){ | |
3954 | 5128 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 | 5129 return -1; |
5130 } | |
5131 partition_count=0; | |
5132 cbp= i_mb_type_info[mb_type].cbp; | |
5133 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5134 mb_type= i_mb_type_info[mb_type].type; | |
5135 } | |
5136 | |
3316 | 5137 if(MB_FIELD) |
1168 | 5138 mb_type |= MB_TYPE_INTERLACED; |
5139 | |
5140 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5141 |
1168 | 5142 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5143 unsigned int x, y; |
2967 | 5144 |
1168 | 5145 // we assume these blocks are very rare so we dont optimize it |
5146 align_get_bits(&s->gb); | |
2967 | 5147 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5148 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5149 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5150 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5151 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5152 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
|
5153 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5154 } |
5155 } | |
5156 for(y=0; y<8; y++){ | |
5157 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5158 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5159 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
|
5160 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5161 } |
5162 } | |
5163 for(y=0; y<8; y++){ | |
5164 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5165 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5166 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
|
5167 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5168 } |
5169 } | |
2967 | 5170 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5171 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5172 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
|
5173 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
|
5174 // 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
|
5175 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5176 |
2755 | 5177 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5178 return 0; |
5179 } | |
2967 | 5180 |
3316 | 5181 if(MB_MBAFF){ |
5182 h->ref_count[0] <<= 1; | |
5183 h->ref_count[1] <<= 1; | |
5184 } | |
5185 | |
2449 | 5186 fill_caches(h, mb_type, 0); |
1168 | 5187 |
5188 //mb_pred | |
5189 if(IS_INTRA(mb_type)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5190 int pred_mode; |
1168 | 5191 // init_top_left_availability(h); |
5192 if(IS_INTRA4x4(mb_type)){ | |
5193 int i; | |
2755 | 5194 int di = 1; |
5195 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5196 mb_type |= MB_TYPE_8x8DCT; | |
5197 di = 4; | |
5198 } | |
1168 | 5199 |
5200 // fill_intra4x4_pred_table(h); | |
2755 | 5201 for(i=0; i<16; i+=di){ |
3409 | 5202 int mode= pred_intra_mode(h, i); |
5203 | |
5204 if(!get_bits1(&s->gb)){ | |
1168 | 5205 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5206 mode = rem_mode + (rem_mode >= mode); |
1168 | 5207 } |
2967 | 5208 |
2755 | 5209 if(di==4) |
5210 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5211 else | |
5212 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5213 } |
5214 write_back_intra_pred_mode(h); | |
5215 if( check_intra4x4_pred_mode(h) < 0) | |
5216 return -1; | |
5217 }else{ | |
5218 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5219 if(h->intra16x16_pred_mode < 0) | |
5220 return -1; | |
5221 } | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5222 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5223 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
|
5224 if(pred_mode < 0) |
1168 | 5225 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5226 h->chroma_pred_mode= pred_mode; |
1168 | 5227 }else if(partition_count==4){ |
5228 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5229 |
1168 | 5230 if(h->slice_type == B_TYPE){ |
5231 for(i=0; i<4; i++){ | |
5232 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5233 if(h->sub_mb_type[i] >=13){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5234 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 | 5235 return -1; |
5236 } | |
5237 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5238 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5239 } | |
2396 | 5240 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5241 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5242 pred_direct_motion(h, &mb_type); |
3003 | 5243 h->ref_cache[0][scan8[4]] = |
5244 h->ref_cache[1][scan8[4]] = | |
5245 h->ref_cache[0][scan8[12]] = | |
5246 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5247 } | |
1168 | 5248 }else{ |
5249 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5250 for(i=0; i<4; i++){ | |
5251 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5252 if(h->sub_mb_type[i] >=4){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5253 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 | 5254 return -1; |
5255 } | |
5256 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5257 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5258 } | |
5259 } | |
2967 | 5260 |
1168 | 5261 for(list=0; list<2; list++){ |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5262 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5263 if(ref_count == 0) continue; |
5264 for(i=0; i<4; i++){ | |
2396 | 5265 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5266 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5267 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
|
5268 if(tmp>=ref_count){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5269 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
|
5270 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5271 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5272 ref[list][i]= tmp; |
1168 | 5273 }else{ |
5274 //FIXME | |
5275 ref[list][i] = -1; | |
5276 } | |
5277 } | |
5278 } | |
2967 | 5279 |
2755 | 5280 if(dct8x8_allowed) |
5281 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5282 |
1168 | 5283 for(list=0; list<2; list++){ |
5284 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
5285 if(ref_count == 0) continue; | |
5286 | |
5287 for(i=0; i<4; i++){ | |
3003 | 5288 if(IS_DIRECT(h->sub_mb_type[i])) { |
5289 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5290 continue; | |
5291 } | |
1168 | 5292 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5293 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5294 | |
2396 | 5295 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5296 const int sub_mb_type= h->sub_mb_type[i]; |
5297 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5298 for(j=0; j<sub_partition_count[i]; j++){ | |
5299 int mx, my; | |
5300 const int index= 4*i + block_width*j; | |
5301 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5302 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5303 mx += get_se_golomb(&s->gb); | |
5304 my += get_se_golomb(&s->gb); | |
1170 | 5305 tprintf("final mv:%d %d\n", mx, my); |
5306 | |
1168 | 5307 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 5308 mv_cache[ 1 ][0]= |
1168 | 5309 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 5310 mv_cache[ 1 ][1]= |
1168 | 5311 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5312 }else if(IS_SUB_8X4(sub_mb_type)){ | |
4530 | 5313 mv_cache[ 1 ][0]= mx; |
5314 mv_cache[ 1 ][1]= my; | |
1168 | 5315 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 5316 mv_cache[ 8 ][0]= mx; |
5317 mv_cache[ 8 ][1]= my; | |
1168 | 5318 } |
4530 | 5319 mv_cache[ 0 ][0]= mx; |
5320 mv_cache[ 0 ][1]= my; | |
1168 | 5321 } |
5322 }else{ | |
5323 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5324 p[0] = p[1]= | |
5325 p[8] = p[9]= 0; | |
5326 } | |
5327 } | |
5328 } | |
2396 | 5329 }else if(IS_DIRECT(mb_type)){ |
5330 pred_direct_motion(h, &mb_type); | |
2755 | 5331 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5332 }else{ |
1168 | 5333 int list, mx, my, i; |
5334 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5335 if(IS_16X16(mb_type)){ | |
5336 for(list=0; list<2; list++){ | |
2392 | 5337 if(h->ref_count[list]>0){ |
1168 | 5338 if(IS_DIR(mb_type, 0, list)){ |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5339 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
|
5340 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5341 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
|
5342 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5343 } |
1168 | 5344 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); |
2523 | 5345 }else |
5346 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 5347 } |
5348 } | |
5349 for(list=0; list<2; list++){ | |
5350 if(IS_DIR(mb_type, 0, list)){ | |
5351 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5352 mx += get_se_golomb(&s->gb); | |
5353 my += get_se_golomb(&s->gb); | |
1170 | 5354 tprintf("final mv:%d %d\n", mx, my); |
5355 | |
1269 | 5356 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5357 }else |
5358 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1168 | 5359 } |
5360 } | |
5361 else if(IS_16X8(mb_type)){ | |
5362 for(list=0; list<2; list++){ | |
5363 if(h->ref_count[list]>0){ | |
5364 for(i=0; i<2; i++){ | |
5365 if(IS_DIR(mb_type, i, list)){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5366 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
|
5367 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5368 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
|
5369 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5370 } |
1168 | 5371 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); |
2523 | 5372 }else |
2396 | 5373 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5374 } |
5375 } | |
5376 } | |
5377 for(list=0; list<2; list++){ | |
5378 for(i=0; i<2; i++){ | |
5379 if(IS_DIR(mb_type, i, list)){ | |
5380 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5381 mx += get_se_golomb(&s->gb); | |
5382 my += get_se_golomb(&s->gb); | |
1170 | 5383 tprintf("final mv:%d %d\n", mx, my); |
5384 | |
1269 | 5385 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5386 }else |
5387 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 5388 } |
5389 } | |
5390 }else{ | |
5391 assert(IS_8X16(mb_type)); | |
5392 for(list=0; list<2; list++){ | |
5393 if(h->ref_count[list]>0){ | |
5394 for(i=0; i<2; i++){ | |
5395 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5396 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
|
5397 if(val >= h->ref_count[list]){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5398 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
|
5399 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5400 } |
1168 | 5401 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); |
2523 | 5402 }else |
2396 | 5403 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5404 } |
5405 } | |
5406 } | |
5407 for(list=0; list<2; list++){ | |
5408 for(i=0; i<2; i++){ | |
5409 if(IS_DIR(mb_type, i, list)){ | |
5410 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5411 mx += get_se_golomb(&s->gb); | |
5412 my += get_se_golomb(&s->gb); | |
1170 | 5413 tprintf("final mv:%d %d\n", mx, my); |
5414 | |
1269 | 5415 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5416 }else |
5417 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 5418 } |
5419 } | |
5420 } | |
5421 } | |
2967 | 5422 |
1168 | 5423 if(IS_INTER(mb_type)) |
5424 write_back_motion(h, mb_type); | |
2967 | 5425 |
1168 | 5426 if(!IS_INTRA16x16(mb_type)){ |
5427 cbp= get_ue_golomb(&s->gb); | |
5428 if(cbp > 47){ | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5429 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5430 return -1; |
5431 } | |
2967 | 5432 |
1168 | 5433 if(IS_INTRA4x4(mb_type)) |
5434 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5435 else | |
5436 cbp= golomb_to_inter_cbp[cbp]; | |
5437 } | |
3651 | 5438 h->cbp = cbp; |
1168 | 5439 |
2755 | 5440 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5441 if(get_bits1(&s->gb)) | |
5442 mb_type |= MB_TYPE_8x8DCT; | |
5443 } | |
5444 s->current_picture.mb_type[mb_xy]= mb_type; | |
5445 | |
1168 | 5446 if(cbp || IS_INTRA16x16(mb_type)){ |
5447 int i8x8, i4x4, chroma_idx; | |
5448 int chroma_qp, dquant; | |
5449 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5450 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5451 |
1168 | 5452 // fill_non_zero_count_cache(h); |
5453 | |
5454 if(IS_INTERLACED(mb_type)){ | |
3316 | 5455 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5456 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5457 dc_scan= luma_dc_field_scan; |
5458 }else{ | |
3316 | 5459 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5460 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5461 dc_scan= luma_dc_zigzag_scan; |
5462 } | |
5463 | |
5464 dquant= get_se_golomb(&s->gb); | |
5465 | |
5466 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5467 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 | 5468 return -1; |
5469 } | |
2967 | 5470 |
1168 | 5471 s->qscale += dquant; |
5472 if(((unsigned)s->qscale) > 51){ | |
5473 if(s->qscale<0) s->qscale+= 52; | |
5474 else s->qscale-= 52; | |
5475 } | |
2967 | 5476 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5477 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5478 if(IS_INTRA16x16(mb_type)){ |
2919 | 5479 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
|
5480 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5481 } |
5482 | |
5483 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5484 | |
5485 if(cbp&15){ | |
5486 for(i8x8=0; i8x8<4; i8x8++){ | |
5487 for(i4x4=0; i4x4<4; i4x4++){ | |
5488 const int index= i4x4 + 4*i8x8; | |
2919 | 5489 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5490 return -1; |
5491 } | |
5492 } | |
5493 } | |
5494 }else{ | |
1636 | 5495 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5496 } |
5497 }else{ | |
5498 for(i8x8=0; i8x8<4; i8x8++){ | |
5499 if(cbp & (1<<i8x8)){ | |
2755 | 5500 if(IS_8x8DCT(mb_type)){ |
5501 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5502 uint8_t *nnz; |
2755 | 5503 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5504 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5505 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5506 return -1; |
5507 } | |
2757 | 5508 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
|
5509 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5510 }else{ |
5511 for(i4x4=0; i4x4<4; i4x4++){ | |
5512 const int index= i4x4 + 4*i8x8; | |
2967 | 5513 |
2919 | 5514 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 | 5515 return -1; |
5516 } | |
1168 | 5517 } |
5518 } | |
5519 }else{ | |
5520 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5521 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5522 } | |
5523 } | |
5524 } | |
2967 | 5525 |
1168 | 5526 if(cbp&0x30){ |
5527 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5528 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5529 return -1; |
5530 } | |
5531 } | |
5532 | |
5533 if(cbp&0x20){ | |
5534 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5535 for(i4x4=0; i4x4<4; i4x4++){ | |
5536 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5537 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 | 5538 return -1; |
5539 } | |
5540 } | |
5541 } | |
5542 }else{ | |
5543 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5544 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5545 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5546 } | |
5547 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5548 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
|
5549 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
|
5550 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
|
5551 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5552 } |
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
|
5553 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5554 write_back_non_zero_count(h); |
5555 | |
3316 | 5556 if(MB_MBAFF){ |
5557 h->ref_count[0] >>= 1; | |
5558 h->ref_count[1] >>= 1; | |
5559 } | |
5560 | |
1168 | 5561 return 0; |
5562 } | |
5563 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5564 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
|
5565 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
|
5566 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
|
5567 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
|
5568 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
|
5569 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
|
5570 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5571 unsigned int ctx = 0; |
2967 | 5572 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5573 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
|
5574 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5575 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5576 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
|
5577 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5578 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5579 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5580 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
|
5581 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5582 |
2312 | 5583 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5584 uint8_t *state= &h->cabac_state[ctx_base]; | |
5585 int mb_type; | |
2967 | 5586 |
2312 | 5587 if(intra_slice){ |
5588 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
|
5589 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
|
5590 const int mbb_xy = h->top_mb_xy; |
2312 | 5591 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5592 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
|
5593 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5594 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
|
5595 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5596 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5597 return 0; /* I4x4 */ |
5598 state += 2; | |
5599 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5600 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
|
5601 return 0; /* I4x4 */ |
2312 | 5602 } |
5603 | |
5604 if( get_cabac_terminate( &h->cabac ) ) | |
5605 return 25; /* PCM */ | |
5606 | |
5607 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
|
5608 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
|
5609 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
|
5610 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
|
5611 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
|
5612 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5613 return mb_type; |
5614 } | |
5615 | |
5616 static int decode_cabac_mb_type( H264Context *h ) { | |
5617 MpegEncContext * const s = &h->s; | |
5618 | |
5619 if( h->slice_type == I_TYPE ) { | |
5620 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
|
5621 } 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
|
5622 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
|
5623 /* 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
|
5624 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5625 /* 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
|
5626 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
|
5627 } else { |
3138 | 5628 /* 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
|
5629 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
|
5630 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5631 } else { |
2312 | 5632 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
|
5633 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5634 } 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
|
5635 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
|
5636 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
|
5637 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
|
5638 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5639 |
3138 | 5640 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
|
5641 ctx++; |
3138 | 5642 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
|
5643 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5644 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5645 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
|
5646 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
|
5647 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5648 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
|
5649 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
|
5650 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5651 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5652 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
|
5653 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
|
5654 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
|
5655 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
|
5656 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
|
5657 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
|
5658 else if( bits == 13 ) { |
2312 | 5659 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
|
5660 } 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
|
5661 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
|
5662 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
|
5663 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
|
5664 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5665 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
|
5666 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
|
5667 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5668 /* 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
|
5669 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
|
5670 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5671 } |
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 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
|
5674 MpegEncContext * const s = &h->s; |
3316 | 5675 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
|
5676 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
|
5677 |
3316 | 5678 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5679 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5680 mba_xy = mb_xy - 1; | |
5681 if( (mb_y&1) | |
5682 && h->slice_table[mba_xy] == h->slice_num | |
5683 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5684 mba_xy += s->mb_stride; | |
5685 if( MB_FIELD ){ | |
5686 mbb_xy = mb_xy - s->mb_stride; | |
5687 if( !(mb_y&1) | |
5688 && h->slice_table[mbb_xy] == h->slice_num | |
5689 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5690 mbb_xy -= s->mb_stride; | |
5691 }else | |
5692 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5693 }else{ | |
5694 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5695 mba_xy = mb_xy - 1; | |
5696 mbb_xy = mb_xy - s->mb_stride; | |
5697 } | |
5698 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5699 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
|
5700 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5701 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
|
5702 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5703 |
3138 | 5704 if( h->slice_type == B_TYPE ) |
5705 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
|
5706 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
|
5707 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5708 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5709 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
|
5710 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
|
5711 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5712 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
|
5713 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
|
5714 |
2928 | 5715 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5716 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5717 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5718 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5719 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
|
5720 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
|
5721 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5722 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5725 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
|
5726 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
|
5727 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
|
5728 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5729 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
|
5730 |
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
|
5731 /* 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
|
5732 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
|
5733 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
|
5734 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5735 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
|
5736 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5737 |
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+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
|
5739 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
|
5740 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5741 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
|
5742 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
|
5743 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
|
5744 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
|
5745 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5746 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
|
5747 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5748 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5749 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
|
5750 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
|
5751 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5752 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
|
5753 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
|
5754 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5755 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
|
5756 { 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
|
5757 { 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
|
5758 { 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
|
5759 { 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
|
5760 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5761 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5762 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
|
5763 int cbp = 0; |
3138 | 5764 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
|
5765 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
|
5766 |
3138 | 5767 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5768 cbp_b = h->top_cbp; | |
5769 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5770 } | |
5771 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5772 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
|
5773 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
|
5774 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
|
5775 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
|
5776 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5777 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
|
5778 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
|
5779 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5780 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
|
5781 cbp_a = cbp; |
3138 | 5782 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
|
5783 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
|
5784 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
|
5785 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5786 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5787 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
|
5788 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
|
5789 |
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
|
5790 /* 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
|
5791 /* 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
|
5792 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
|
5793 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
|
5794 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
|
5795 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5796 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5797 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5798 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
|
5799 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
|
5800 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
|
5801 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5804 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
|
5805 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
|
5806 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5807 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5808 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
|
5809 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5810 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
|
5811 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
|
5812 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
|
5813 |
2314 | 5814 cbp_a = (h->left_cbp>>4)&0x03; |
5815 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
|
5816 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5817 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
|
5818 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
|
5819 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
|
5820 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
|
5821 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
|
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 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
|
5824 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
|
5825 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
|
5826 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
|
5827 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5828 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
|
5829 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
|
5830 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
|
5831 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
|
5832 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
|
5833 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5834 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
|
5835 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
|
5836 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5837 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
|
5838 |
3316 | 5839 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
|
5840 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5841 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5842 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
|
5843 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
|
5844 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
|
5845 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5846 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
|
5847 val++; |
3128 | 5848 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5849 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
|
5850 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5851 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5852 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
|
5853 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
|
5854 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5855 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
|
5856 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5857 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
|
5858 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
|
5859 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
|
5860 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
|
5861 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
|
5862 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
|
5863 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
|
5864 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
|
5865 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5866 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
|
5867 int type; |
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[36] ) ) |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5869 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
|
5870 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
|
5871 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
|
5872 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5873 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
|
5874 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
|
5875 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
|
5876 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5877 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5878 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
|
5879 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
|
5880 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
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 |
2755 | 5883 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
|
5884 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5885 } |
5886 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5887 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
|
5888 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
|
5889 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
|
5890 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
|
5891 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
|
5892 |
2396 | 5893 if( h->slice_type == B_TYPE) { |
5894 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5895 ctx++; | |
5896 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5897 ctx += 2; | |
5898 } else { | |
5899 if( refa > 0 ) | |
5900 ctx++; | |
5901 if( refb > 0 ) | |
5902 ctx += 2; | |
5903 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5904 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5905 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
|
5906 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5907 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
|
5908 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5909 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5910 ctx = 5; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5911 if(ref >= 32 /*h->ref_list[list]*/){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5912 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
|
5913 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
|
5914 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5915 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5916 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5917 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5918 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5919 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
|
5920 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
|
5921 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
|
5922 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5923 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
|
5924 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5925 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
|
5926 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5927 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
|
5928 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5929 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5930 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5931 |
2317 | 5932 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5933 return 0; | |
5934 | |
5935 mvd= 1; | |
5936 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
|
5937 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
|
5938 mvd++; |
2317 | 5939 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
|
5940 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5941 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5942 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5943 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
|
5944 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
|
5945 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
|
5946 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
|
5947 k++; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5948 if(k>24){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5949 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
|
5950 return INT_MIN; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
5951 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5952 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5953 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5954 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
|
5955 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
|
5956 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5957 } |
4042 | 5958 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
|
5959 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5960 |
2316 | 5961 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5962 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
|
5963 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
|
5964 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5965 if( cat == 0 ) { |
2314 | 5966 nza = h->left_cbp&0x100; |
5967 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
|
5968 } else if( cat == 1 || cat == 2 ) { |
2314 | 5969 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5970 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
|
5971 } else if( cat == 3 ) { |
2314 | 5972 nza = (h->left_cbp>>(6+idx))&0x01; |
5973 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5974 } else { | |
5975 assert(cat == 4); | |
5976 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5977 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5978 } | |
5979 | |
5980 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
|
5981 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5982 |
2314 | 5983 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
|
5984 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
|
5985 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5986 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
|
5987 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5988 |
4051 | 5989 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
5990 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
5991 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
5992 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
5993 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
5994 }; | |
5995 | |
3028 | 5996 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
|
5997 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5998 static const int significant_coeff_flag_offset[2][6] = { |
5999 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
6000 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
6001 }; | |
6002 static const int last_coeff_flag_offset[2][6] = { | |
6003 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
6004 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
6005 }; | |
6006 static const int coeff_abs_level_m1_offset[6] = { | |
6007 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
6008 }; | |
4007 | 6009 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 6010 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 6011 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
6012 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 6013 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
6014 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
6015 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
6016 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
6017 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 6018 }; |
6019 | |
6020 int index[64]; | |
2313 | 6021 |
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
|
6022 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
|
6023 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
|
6024 |
2316 | 6025 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
|
6026 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
|
6027 |
2898 | 6028 uint8_t *significant_coeff_ctx_base; |
6029 uint8_t *last_coeff_ctx_base; | |
6030 uint8_t *abs_level_m1_ctx_base; | |
2755 | 6031 |
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
|
6032 #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
|
6033 #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
|
6034 #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
|
6035 #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
|
6036 #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
|
6037 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
|
6038 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
|
6039 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
|
6040 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
|
6041 #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
|
6042 #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
|
6043 #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
|
6044 |
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
|
6045 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6046 /* 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
|
6047 * 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
|
6048 * 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
|
6049 * 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
|
6050 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 6051 * 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
|
6052 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6053 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6054 /* read coded block flag */ |
2898 | 6055 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
|
6056 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 6057 if( cat == 1 || cat == 2 ) |
6058 h->non_zero_count_cache[scan8[n]] = 0; | |
6059 else if( cat == 4 ) | |
6060 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
|
6061 #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
|
6062 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
|
6063 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
|
6064 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
|
6065 #endif |
2755 | 6066 return 0; |
6067 } | |
2898 | 6068 } |
6069 | |
6070 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6071 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6072 last_coeff_ctx_base = h->cabac_state |
3316 | 6073 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6074 abs_level_m1_ctx_base = h->cabac_state |
6075 + coeff_abs_level_m1_offset[cat]; | |
6076 | |
6077 if( cat == 5 ) { | |
6078 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6079 for(last= 0; last < coefs; last++) { \ | |
6080 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
|
6081 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6082 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6083 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
|
6084 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6085 last= max_coeff; \ |
6086 break; \ | |
6087 } \ | |
6088 } \ | |
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
|
6089 }\ |
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
|
6090 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
|
6091 index[coeff_count++] = last;\ |
2898 | 6092 } |
4009 | 6093 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
|
6094 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6095 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6096 } else { | |
6097 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6098 #else | |
3316 | 6099 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6100 } else { |
6101 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
|
6102 #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
|
6103 } |
2316 | 6104 assert(coeff_count > 0); |
6105 | |
6106 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
|
6107 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
|
6108 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
|
6109 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6110 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
|
6111 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6112 else if( cat == 4 ) |
6113 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6114 else { |
2755 | 6115 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6116 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6117 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6118 |
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
|
6119 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6120 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
|
6121 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
|
6122 |
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
|
6123 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6124 if( !qmul ) { |
4040 | 6125 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6126 }else{ |
4040 | 6127 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6128 } |
2967 | 6129 |
2313 | 6130 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
|
6131 } else { |
2313 | 6132 int coeff_abs = 2; |
2898 | 6133 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
|
6134 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6135 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
|
6136 } |
2313 | 6137 |
6138 if( coeff_abs >= 15 ) { | |
6139 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
|
6140 while( get_cabac_bypass( CC ) ) { |
2313 | 6141 j++; |
6142 } | |
2967 | 6143 |
4016 | 6144 coeff_abs=1; |
2313 | 6145 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
|
6146 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6147 } |
4016 | 6148 coeff_abs+= 14; |
2313 | 6149 } |
6150 | |
2898 | 6151 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
|
6152 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6153 else block[j] = coeff_abs; |
6154 }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
|
6155 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6156 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6157 } |
2967 | 6158 |
2313 | 6159 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
|
6160 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6161 } |
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
|
6162 #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
|
6163 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
|
6164 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
|
6165 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
|
6166 #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
|
6167 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
|
6168 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6169 |
3077 | 6170 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
|
6171 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6172 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
|
6173 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
|
6174 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
|
6175 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6176 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
|
6177 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
|
6178 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
|
6179 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
|
6180 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6181 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
|
6182 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
|
6183 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6184 ? !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
|
6185 : (!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
|
6186 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6187 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
|
6188 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6189 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
|
6190 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
|
6191 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6192 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6193 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6194 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6195 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6196 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6197 * 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
|
6198 * @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
|
6199 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6200 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
|
6201 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
|
6202 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
|
6203 int mb_type, partition_count, cbp = 0; |
2755 | 6204 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
|
6205 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6206 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
|
6207 |
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
|
6208 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
|
6209 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6210 int skip; |
6211 /* a skipped mb needs the aff flag from the following mb */ | |
6212 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6213 predict_field_decoding_flag(h); | |
6214 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6215 skip = h->next_mb_skipped; | |
6216 else | |
6217 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
|
6218 /* read skip flags */ |
3316 | 6219 if( skip ) { |
6220 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6221 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6222 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6223 if(h->next_mb_skipped) | |
6224 predict_field_decoding_flag(h); | |
6225 else | |
6226 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6227 } | |
6228 | |
2396 | 6229 decode_mb_skip(h); |
6230 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6231 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
|
6232 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
|
6233 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
|
6234 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6235 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
|
6236 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6237 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6238 } |
3316 | 6239 if(FRAME_MBAFF){ |
6240 if( (s->mb_y&1) == 0 ) | |
6241 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
|
6242 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
|
6243 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6244 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
|
6245 |
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
|
6246 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
|
6247 |
3077 | 6248 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
|
6249 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
|
6250 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
|
6251 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
|
6252 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6253 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6254 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
|
6255 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
|
6256 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
|
6257 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
|
6258 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6259 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
|
6260 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
|
6261 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6262 } 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
|
6263 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
|
6264 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
|
6265 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
|
6266 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6267 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
|
6268 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
|
6269 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6270 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6271 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
|
6272 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
|
6273 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
|
6274 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
|
6275 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
|
6276 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
|
6277 } |
3316 | 6278 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
|
6279 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
|
6280 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6281 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
|
6282 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6283 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6284 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6285 unsigned int x, y; |
2967 | 6286 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6287 // 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
|
6288 // 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
|
6289 // 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
|
6290 ptr= h->cabac.bytestream; |
4344 | 6291 if(h->cabac.low&0x1) ptr--; |
6292 if(CABAC_BITS==16){ | |
6293 if(h->cabac.low&0x1FF) ptr--; | |
6294 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6295 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6296 // 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
|
6297 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6298 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
|
6299 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6300 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6301 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
|
6302 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6303 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6304 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6305 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
|
6306 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6307 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
|
6308 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
|
6309 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6310 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6311 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6312 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
|
6313 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6314 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
|
6315 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
|
6316 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6317 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6318 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6319 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
|
6320 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6321 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6322 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
|
6323 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
|
6324 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6325 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
|
6326 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
|
6327 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6328 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6329 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
|
6330 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
|
6331 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6332 |
3316 | 6333 if(MB_MBAFF){ |
6334 h->ref_count[0] <<= 1; | |
6335 h->ref_count[1] <<= 1; | |
6336 } | |
6337 | |
2449 | 6338 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
|
6339 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6340 if( IS_INTRA( mb_type ) ) { |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6341 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
|
6342 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6343 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6344 mb_type |= MB_TYPE_8x8DCT; | |
6345 for( i = 0; i < 16; i+=4 ) { | |
6346 int pred = pred_intra_mode( h, i ); | |
6347 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6348 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6349 } | |
6350 } else { | |
6351 for( i = 0; i < 16; i++ ) { | |
6352 int pred = pred_intra_mode( h, i ); | |
6353 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
|
6354 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6355 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6356 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6357 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6358 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
|
6359 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
|
6360 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6361 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
|
6362 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
|
6363 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6364 h->chroma_pred_mode_table[mb_xy] = |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6365 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6366 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6367 pred_mode= check_intra_pred_mode( h, pred_mode ); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6368 if( pred_mode < 0 ) return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
6369 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
|
6370 } 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
|
6371 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
|
6372 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6373 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
|
6374 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
|
6375 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
|
6376 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
|
6377 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
|
6378 } |
3482 | 6379 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6380 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6381 pred_direct_motion(h, &mb_type); |
6382 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6383 for( i = 0; i < 4; i++ ) | |
6384 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6385 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6386 } | |
6387 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6388 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6389 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
|
6390 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
|
6391 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
|
6392 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
|
6393 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6394 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6395 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6396 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
|
6397 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
|
6398 for( i = 0; i < 4; i++ ) { |
2396 | 6399 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6400 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
|
6401 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
|
6402 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
|
6403 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6404 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
|
6405 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6406 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
|
6407 } |
2110 | 6408 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
|
6409 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
|
6410 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6411 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6412 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6413 |
2755 | 6414 if(dct8x8_allowed) |
6415 dct8x8_allowed = get_dct8x8_allowed(h); | |
6416 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6417 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
|
6418 for(i=0; i<4; i++){ |
2396 | 6419 if(IS_DIRECT(h->sub_mb_type[i])){ |
6420 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6421 continue; | |
6422 } | |
2110 | 6423 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
|
6424 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6425 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
|
6426 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
|
6427 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
|
6428 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
|
6429 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
|
6430 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
|
6431 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
|
6432 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
|
6433 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
|
6434 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
|
6435 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6436 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
|
6437 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
|
6438 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
|
6439 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6440 if(IS_SUB_8X8(sub_mb_type)){ |
4530 | 6441 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
|
6442 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
4530 | 6443 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
|
6444 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
|
6445 |
4530 | 6446 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
|
6447 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
4530 | 6448 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
|
6449 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
|
6450 }else if(IS_SUB_8X4(sub_mb_type)){ |
4530 | 6451 mv_cache[ 1 ][0]= mx; |
6452 mv_cache[ 1 ][1]= my; | |
6453 | |
6454 mvd_cache[ 1 ][0]= mx - mpx; | |
6455 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
|
6456 }else if(IS_SUB_4X8(sub_mb_type)){ |
4530 | 6457 mv_cache[ 8 ][0]= mx; |
6458 mv_cache[ 8 ][1]= my; | |
6459 | |
6460 mvd_cache[ 8 ][0]= mx - mpx; | |
6461 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
|
6462 } |
4530 | 6463 mv_cache[ 0 ][0]= mx; |
6464 mv_cache[ 0 ][1]= my; | |
6465 | |
6466 mvd_cache[ 0 ][0]= mx - mpx; | |
6467 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
|
6468 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6469 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6470 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
|
6471 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
|
6472 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
|
6473 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
|
6474 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6475 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6476 } |
2396 | 6477 } else if( IS_DIRECT(mb_type) ) { |
6478 pred_direct_motion(h, &mb_type); | |
6479 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6480 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6481 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6482 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6483 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
|
6484 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
|
6485 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
|
6486 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
|
6487 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
|
6488 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
|
6489 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
|
6490 } |
2523 | 6491 }else |
6492 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
|
6493 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6494 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
|
6495 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
|
6496 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
|
6497 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6498 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
|
6499 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
|
6500 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
|
6501 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6502 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
|
6503 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6504 }else |
6505 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
|
6506 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6507 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6508 else if(IS_16X8(mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6509 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
|
6510 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
|
6511 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
|
6512 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
|
6513 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
|
6514 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6515 }else |
6516 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
|
6517 } |
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 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6520 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
|
6521 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
|
6522 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
|
6523 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
|
6524 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
|
6525 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
|
6526 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
|
6527 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6528 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
|
6529 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6530 }else{ |
2396 | 6531 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6532 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
|
6533 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6534 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6535 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6536 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6537 assert(IS_8X16(mb_type)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6538 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
|
6539 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
|
6540 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
|
6541 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
|
6542 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
|
6543 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6544 }else |
6545 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
|
6546 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6547 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6548 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6549 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
|
6550 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
|
6551 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
|
6552 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
|
6553 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
|
6554 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
|
6555 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6556 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
|
6557 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
|
6558 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6559 }else{ |
2396 | 6560 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6561 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
|
6562 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6563 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6564 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6565 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6566 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6567 |
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
|
6568 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
|
6569 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
|
6570 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
|
6571 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6572 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6573 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
|
6574 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
|
6575 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
|
6576 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6577 |
3651 | 6578 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
|
6579 |
2755 | 6580 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6581 if( decode_cabac_mb_transform_size( h ) ) | |
6582 mb_type |= MB_TYPE_8x8DCT; | |
6583 } | |
6584 s->current_picture.mb_type[mb_xy]= mb_type; | |
6585 | |
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 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6587 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
|
6588 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
|
6589 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6590 if(IS_INTERLACED(mb_type)){ |
3316 | 6591 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6592 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
|
6593 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
|
6594 }else{ |
3316 | 6595 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6596 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
|
6597 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
|
6598 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6599 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6600 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
|
6601 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6602 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
|
6603 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6604 } |
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 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
|
6606 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
|
6607 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
|
6608 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
|
6609 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6610 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
|
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 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
|
6613 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
|
6614 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6615 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
|
6616 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
|
6617 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
|
6618 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
|
6619 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6620 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
|
6621 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
|
6622 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6623 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6624 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
|
6625 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6626 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6627 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
|
6628 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
|
6629 if( cbp & (1<<i8x8) ) { |
2755 | 6630 if( IS_8x8DCT(mb_type) ) { |
6631 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6632 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6633 return -1; |
6634 } 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
|
6635 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
|
6636 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
|
6637 //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
|
6638 //START_TIMER |
2919 | 6639 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
|
6640 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6641 //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
|
6642 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6643 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6644 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
|
6645 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
|
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 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6649 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6650 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
|
6651 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
|
6652 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
|
6653 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6654 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6659 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
|
6660 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
|
6661 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
|
6662 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
|
6663 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
|
6664 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6665 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
|
6666 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
|
6667 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6668 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6669 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6670 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
|
6671 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
|
6672 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
|
6673 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6674 } else { |
2315 | 6675 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6676 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6677 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6678 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6679 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
|
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 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
|
6683 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
|
6684 |
3316 | 6685 if(MB_MBAFF){ |
6686 h->ref_count[0] >>= 1; | |
6687 h->ref_count[1] >>= 1; | |
6688 } | |
6689 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6690 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
|
6691 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6692 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6693 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6694 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
|
6695 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
|
6696 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
|
6697 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
|
6698 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
|
6699 |
2633 | 6700 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
|
6701 int8_t tc[4]; |
2633 | 6702 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
|
6703 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6704 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6705 } else { | |
6706 /* 16px edge length, because bS=4 is triggered by being at | |
6707 * the edge of an intra MB, so all 4 bS are the same */ | |
6708 for( d = 0; d < 16; d++ ) { | |
1898 | 6709 const int p0 = pix[-1]; |
6710 const int p1 = pix[-2]; | |
6711 const int p2 = pix[-3]; | |
6712 | |
6713 const int q0 = pix[0]; | |
6714 const int q1 = pix[1]; | |
6715 const int q2 = pix[2]; | |
6716 | |
4001 | 6717 if( FFABS( p0 - q0 ) < alpha && |
6718 FFABS( p1 - p0 ) < beta && | |
6719 FFABS( q1 - q0 ) < beta ) { | |
6720 | |
6721 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6722 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6723 { |
6724 const int p3 = pix[-4]; | |
6725 /* p0', p1', p2' */ | |
6726 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6727 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6728 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6729 } else { | |
6730 /* p0' */ | |
6731 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6732 } | |
4001 | 6733 if( FFABS( q2 - q0 ) < beta) |
1898 | 6734 { |
6735 const int q3 = pix[3]; | |
6736 /* q0', q1', q2' */ | |
6737 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6738 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6739 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6740 } else { | |
6741 /* q0' */ | |
6742 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6743 } | |
6744 }else{ | |
6745 /* p0', q0' */ | |
6746 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6747 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6748 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6749 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
|
6750 } |
1898 | 6751 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
|
6752 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6753 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6754 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6755 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6756 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6757 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
|
6758 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
|
6759 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
|
6760 |
2633 | 6761 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
|
6762 int8_t tc[4]; |
2633 | 6763 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
|
6764 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6765 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6766 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6767 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
|
6768 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6769 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6770 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6771 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
|
6772 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6773 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
|
6774 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6775 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6776 int beta; |
2967 | 6777 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6778 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6779 int bS_index = (i >> 1); |
3316 | 6780 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6781 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6782 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6783 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6784 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6785 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6786 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6787 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6788 |
3316 | 6789 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
|
6790 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
|
6791 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
|
6792 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
|
6793 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6794 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
|
6795 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
|
6796 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6797 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6798 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6799 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6800 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6801 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6802 |
4001 | 6803 if( FFABS( p0 - q0 ) < alpha && |
6804 FFABS( p1 - p0 ) < beta && | |
6805 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6806 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6807 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6808 |
4001 | 6809 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6810 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
|
6811 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6812 } |
4001 | 6813 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6814 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
|
6815 tc++; |
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 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6818 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
|
6819 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
|
6820 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
|
6821 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
|
6822 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6823 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6824 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6825 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6826 const int p2 = pix[-3]; |
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 q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6829 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6830 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6831 |
4001 | 6832 if( FFABS( p0 - q0 ) < alpha && |
6833 FFABS( p1 - p0 ) < beta && | |
6834 FFABS( q1 - q0 ) < beta ) { | |
6835 | |
6836 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6837 if( FFABS( p2 - p0 ) < 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 p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6840 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6841 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
|
6842 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
|
6843 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
|
6844 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6845 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 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
|
6847 } |
4001 | 6848 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6849 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6850 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6851 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6852 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
|
6853 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
|
6854 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
|
6855 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6856 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6857 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
|
6858 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6859 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6860 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6861 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
|
6862 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
|
6863 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6864 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
|
6865 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6866 } |
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 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6869 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
|
6870 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6871 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
|
6872 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6873 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6874 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6875 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6876 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6877 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6878 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6879 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6880 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6881 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6882 |
3316 | 6883 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
|
6884 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
|
6885 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
|
6886 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6887 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6888 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
|
6889 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
|
6890 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6891 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6892 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6893 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6894 |
4001 | 6895 if( FFABS( p0 - q0 ) < alpha && |
6896 FFABS( p1 - p0 ) < beta && | |
6897 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6898 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
|
6899 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6900 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
|
6901 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
|
6902 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
|
6903 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6904 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6905 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6906 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6907 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6908 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6909 |
4001 | 6910 if( FFABS( p0 - q0 ) < alpha && |
6911 FFABS( p1 - p0 ) < beta && | |
6912 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6913 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6914 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
|
6915 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
|
6916 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
|
6917 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6918 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6919 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6920 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6921 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6922 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
|
6923 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
|
6924 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
|
6925 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
|
6926 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
|
6927 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
|
6928 |
2633 | 6929 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
|
6930 int8_t tc[4]; |
2633 | 6931 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
|
6932 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6933 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6934 } else { | |
6935 /* 16px edge length, see filter_mb_edgev */ | |
6936 for( d = 0; d < 16; d++ ) { | |
1898 | 6937 const int p0 = pix[-1*pix_next]; |
6938 const int p1 = pix[-2*pix_next]; | |
6939 const int p2 = pix[-3*pix_next]; | |
6940 const int q0 = pix[0]; | |
6941 const int q1 = pix[1*pix_next]; | |
6942 const int q2 = pix[2*pix_next]; | |
6943 | |
4001 | 6944 if( FFABS( p0 - q0 ) < alpha && |
6945 FFABS( p1 - p0 ) < beta && | |
6946 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6947 |
6948 const int p3 = pix[-4*pix_next]; | |
6949 const int q3 = pix[ 3*pix_next]; | |
6950 | |
4001 | 6951 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6952 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6953 /* p0', p1', p2' */ |
6954 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6955 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6956 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6957 } else { | |
6958 /* p0' */ | |
6959 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6960 } | |
4001 | 6961 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6962 /* q0', q1', q2' */ |
6963 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6964 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6965 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6966 } else { | |
6967 /* q0' */ | |
6968 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6969 } | |
6970 }else{ | |
6971 /* p0', q0' */ | |
6972 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6973 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6974 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6975 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
|
6976 } |
1898 | 6977 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
|
6978 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6979 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6980 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6981 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6982 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6983 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6984 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
|
6985 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
|
6986 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
|
6987 |
2633 | 6988 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
|
6989 int8_t tc[4]; |
2633 | 6990 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
|
6991 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6992 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6993 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6994 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
|
6995 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6996 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6997 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6998 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
|
6999 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7000 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7001 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7002 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7003 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
|
7004 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
|
7005 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7006 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7007 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7008 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7009 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7010 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7011 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7012 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7013 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7014 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7015 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7016 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7017 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7018 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7019 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7020 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 7021 qp_thresh = 15 - h->slice_alpha_c0_offset; |
7022 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
7023 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
7024 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7025 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7027 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7028 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7029 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7030 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7031 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7032 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7033 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7034 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7035 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7036 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7037 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7038 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7039 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7040 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7041 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7043 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7044 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7045 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7046 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7047 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7048 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7049 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7050 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7051 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7052 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7053 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7054 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7055 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 7056 int edges; |
7057 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
7058 edges = 4; | |
7059 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
7060 } else { | |
7061 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
7062 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7063 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7064 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7065 ? 3 : 0; | |
7066 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7067 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7068 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7069 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7070 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7071 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7072 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7073 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7074 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7075 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7076 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7077 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7078 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
|
7079 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7080 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
|
7081 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
|
7082 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7083 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7084 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7085 FILTER(v,0,0); |
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 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7088 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7089 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7090 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7091 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7092 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7093 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7094 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7095 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7096 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7097 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7098 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7099 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7100 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7101 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7102 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7103 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7104 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7105 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7106 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
|
7107 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
|
7108 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7109 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7110 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
|
7111 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
|
7112 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7113 /* 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
|
7114 * 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
|
7115 * frame numbers, not indices. */ |
3316 | 7116 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7117 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
|
7118 |
3101 | 7119 //for sufficiently low qp, filtering wouldn't do anything |
7120 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7121 if(!FRAME_MBAFF){ |
3101 | 7122 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7123 int qp = s->current_picture.qscale_table[mb_xy]; | |
7124 if(qp <= qp_thresh | |
7125 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7126 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7127 return; | |
7128 } | |
7129 } | |
7130 | |
3316 | 7131 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7132 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7133 && 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
|
7134 // and current and left pair do not have the same interlaced type |
3316 | 7135 && (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
|
7136 // 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
|
7137 && (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
|
7138 /* 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
|
7139 * 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
|
7140 */ |
3316 | 7141 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7142 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
|
7143 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7144 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7145 int chroma_qp[2]; |
3316 | 7146 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
|
7147 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7148 first_vertical_edge_done = 1; |
3316 | 7149 |
7150 if( IS_INTRA(mb_type) ) | |
7151 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7152 else { | |
7153 for( i = 0; i < 8; i++ ) { | |
7154 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7155 | |
7156 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7157 bS[i] = 4; | |
7158 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7159 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7160 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7161 bS[i] = 2; | |
7162 else | |
7163 bS[i] = 1; | |
7164 } | |
7165 } | |
7166 | |
7167 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7168 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7169 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7170 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7171 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7172 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7173 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7174 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7175 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7176 | |
7177 /* Filter edge */ | |
7178 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); | |
7179 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7180 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7181 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7182 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
|
7183 } |
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
|
7184 /* 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
|
7185 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
|
7186 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7187 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7188 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7189 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7190 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7191 | |
3101 | 7192 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7193 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7194 // how often to recheck mv-based bS when iterating between edges |
7195 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7196 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7197 // how often to recheck mv-based bS when iterating along each edge | |
7198 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7199 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7200 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7201 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7202 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7203 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7204 |
2454 | 7205 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
|
7206 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
|
7207 |
3316 | 7208 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7209 && !IS_INTERLACED(mb_type) | |
7210 && IS_INTERLACED(mbm_type) | |
7211 ) { | |
7212 // This is a special case in the norm where the filtering must | |
7213 // be done twice (one each of the field) even if we are in a | |
7214 // frame macroblock. | |
7215 // | |
7216 static const int nnz_idx[4] = {4,5,6,3}; | |
7217 unsigned int tmp_linesize = 2 * linesize; | |
7218 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7219 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7220 int qp, chroma_qp; | |
7221 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7222 int16_t bS[4]; |
3316 | 7223 |
7224 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7225 if( IS_INTRA(mb_type) || | |
7226 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7227 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7228 } else { | |
7229 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7230 for( i = 0; i < 4; i++ ) { | |
7231 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7232 mbn_nnz[nnz_idx[i]] != 0 ) | |
7233 bS[i] = 2; | |
7234 else | |
7235 bS[i] = 1; | |
7236 } | |
7237 } | |
7238 // Do not use s->qscale as luma quantizer because it has not the same | |
7239 // value in IPCM macroblocks. | |
7240 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7241 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); | |
7242 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7243 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7244 chroma_qp = ( h->chroma_qp + | |
7245 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7246 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7247 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7248 } | |
7249 | |
7250 start = 1; | |
7251 } | |
7252 | |
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
|
7253 /* Calculate bS */ |
2924 | 7254 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7255 /* mbn_xy: neighbor macroblock */ |
2924 | 7256 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7257 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7258 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
|
7259 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
|
7260 |
2924 | 7261 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7262 continue; |
7263 | |
2924 | 7264 if( IS_INTRA(mb_type) || |
7265 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7266 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7267 if (edge == 0) { |
2924 | 7268 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7269 || ((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
|
7270 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7271 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7272 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7273 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7274 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7275 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7276 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7277 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7278 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
|
7279 } else { |
2924 | 7280 int i, l; |
7281 int mv_done; | |
7282 | |
7283 if( edge & mask_edge ) { | |
7284 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7285 mv_done = 1; | |
7286 } | |
3316 | 7287 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7288 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7289 mv_done = 1; | |
7290 } | |
2924 | 7291 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7292 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7293 int bn_idx= b_idx - (dir ? 8:1); | |
7294 int v = 0; | |
7295 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7296 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7297 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7298 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7299 } |
7300 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7301 mv_done = 1; | |
7302 } | |
7303 else | |
7304 mv_done = 0; | |
7305 | |
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
|
7306 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
|
7307 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
|
7308 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
|
7309 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
|
7310 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
|
7311 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7312 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7313 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
|
7314 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
|
7315 } |
2924 | 7316 else if(!mv_done) |
2523 | 7317 { |
7318 bS[i] = 0; | |
7319 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
|
7320 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7321 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7322 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7323 bS[i] = 1; |
7324 break; | |
7325 } | |
7326 } | |
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
|
7327 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7328 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7329 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7330 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
|
7331 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
|
7332 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7333 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7334 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7335 // 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
|
7336 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7337 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
|
7338 //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
|
7339 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
|
7340 { 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
|
7341 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
|
7342 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7343 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
|
7344 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
|
7345 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
|
7346 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
|
7347 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
|
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 } 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
|
7350 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7351 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
|
7352 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
|
7353 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
|
7354 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
|
7355 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
|
7356 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7357 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7358 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7359 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7360 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7361 |
1168 | 7362 static int decode_slice(H264Context *h){ |
7363 MpegEncContext * const s = &h->s; | |
7364 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7365 | |
7366 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
|
7367 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7368 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
|
7369 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
|
7370 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7371 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7372 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
|
7373 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7374 /* 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
|
7375 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
|
7376 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
|
7377 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7378 ( 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
|
7379 /* calculate pre-state */ |
2755 | 7380 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
|
7381 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
|
7382 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
|
7383 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
|
7384 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7385 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
|
7386 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7387 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7388 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
|
7389 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7390 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7391 } |
7392 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7393 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7394 //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
|
7395 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
|
7396 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
|
7397 //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
|
7398 |
2163 | 7399 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
|
7400 |
3316 | 7401 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
|
7402 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
|
7403 |
2163 | 7404 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
|
7405 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7406 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
|
7407 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
|
7408 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7409 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
|
7410 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7411 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
|
7412 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
|
7413 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
|
7414 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
|
7415 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7416 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7417 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
|
7418 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
|
7419 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7420 ++s->mb_y; |
3316 | 7421 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7422 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7423 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7424 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7425 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7426 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7427 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
|
7428 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
|
7429 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
|
7430 } |
1168 | 7431 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7432 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7433 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7434 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7435 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
|
7436 |
2163 | 7437 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
|
7438 |
3316 | 7439 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
|
7440 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
|
7441 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
|
7442 |
2163 | 7443 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
|
7444 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
|
7445 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7446 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7447 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
|
7448 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
|
7449 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
|
7450 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7451 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
|
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 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7454 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
|
7455 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
|
7456 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
|
7457 ++s->mb_y; |
3316 | 7458 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7459 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7460 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7461 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
|
7462 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
|
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 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
|
7465 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
|
7466 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7467 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
|
7468 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7469 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
|
7470 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7471 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
|
7472 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7473 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7474 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7475 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7476 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7477 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
|
7478 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7479 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); |
7480 | |
7481 return 0; | |
7482 }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
|
7483 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 | 7484 |
7485 return -1; | |
7486 } | |
7487 } | |
7488 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7489 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7490 |
1168 | 7491 #if 0 |
7492 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7493 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7494 int ret= decode_mb(h); | |
2967 | 7495 |
1168 | 7496 hl_decode_mb(h); |
7497 | |
7498 if(ret<0){ | |
3177 | 7499 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7500 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); |
7501 | |
7502 return -1; | |
7503 } | |
2967 | 7504 |
1168 | 7505 if(++s->mb_x >= s->mb_width){ |
7506 s->mb_x=0; | |
7507 if(++s->mb_y >= s->mb_height){ | |
7508 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7509 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); | |
7510 | |
7511 return 0; | |
7512 }else{ | |
7513 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); | |
7514 | |
7515 return -1; | |
7516 } | |
7517 } | |
7518 } | |
2967 | 7519 |
1168 | 7520 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7521 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7522 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); | |
7523 | |
7524 return 0; | |
7525 }else{ | |
7526 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); | |
7527 | |
7528 return -1; | |
7529 } | |
7530 } | |
7531 } | |
7532 s->mb_x=0; | |
7533 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7534 } | |
7535 #endif | |
7536 return -1; //not reached | |
7537 } | |
7538 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7539 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
|
7540 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7541 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7542 int e, build, i; |
2967 | 7543 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7544 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7545 return -1; |
2967 | 7546 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7547 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
|
7548 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
|
7549 } |
2967 | 7550 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7551 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7552 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
|
7553 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7554 h->x264_build= build; |
2967 | 7555 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7556 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
|
7557 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
|
7558 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7559 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7560 skip_bits(&s->gb, 8); |
2967 | 7561 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7562 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7563 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7564 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7565 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7566 MpegEncContext * const s = &h->s; |
2967 | 7567 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7568 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
|
7569 int size, type; |
2967 | 7570 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7571 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7572 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7573 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7574 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7575 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7576 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7577 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7578 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7579 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7580 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7581 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7582 case 5: |
3318 | 7583 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
|
7584 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7585 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7586 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7587 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7588 } |
2967 | 7589 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7590 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7591 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7592 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7593 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7594 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7595 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7596 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7597 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
|
7598 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7599 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7600 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
|
7601 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
|
7602 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
|
7603 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
|
7604 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
|
7605 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
|
7606 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
|
7607 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7608 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
|
7609 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
|
7610 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
|
7611 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
|
7612 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7613 |
1168 | 7614 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7615 MpegEncContext * const s = &h->s; | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7616 int aspect_ratio_info_present_flag; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7617 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
|
7618 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7619 |
7620 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7621 |
1168 | 7622 if( aspect_ratio_info_present_flag ) { |
7623 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7624 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7625 sps->sar.num= get_bits(&s->gb, 16); |
7626 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
|
7627 }else if(aspect_ratio_idc < 14){ |
1548 | 7628 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7629 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7630 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7631 return -1; |
7632 } | |
7633 }else{ | |
2967 | 7634 sps->sar.num= |
1548 | 7635 sps->sar.den= 0; |
1168 | 7636 } |
7637 // 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
|
7638 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7639 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
|
7640 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
|
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 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7643 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
|
7644 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
|
7645 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
|
7646 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
|
7647 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
|
7648 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
|
7649 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
|
7650 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7651 } |
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 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
|
7654 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
|
7655 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
|
7656 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7657 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7658 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
|
7659 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
|
7660 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
|
7661 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
|
7662 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
|
7663 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7664 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7665 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
|
7666 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
|
7667 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7668 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
|
7669 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
|
7670 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7671 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
|
7672 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
|
7673 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
|
7674 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7675 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
|
7676 if(sps->bitstream_restriction_flag){ |
4389 | 7677 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
|
7678 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
|
7679 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
|
7680 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
|
7681 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
|
7682 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
4389 | 7683 num_reorder_frames= get_ue_golomb(&s->gb); |
7684 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/ | |
7685 | |
7686 if(num_reorder_frames > 16 /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){ | |
7687 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", num_reorder_frames); | |
7688 return -1; | |
7689 } | |
7690 | |
7691 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
|
7692 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7693 |
1168 | 7694 return 0; |
7695 } | |
7696 | |
3004 | 7697 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7698 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7699 MpegEncContext * const s = &h->s; |
7700 int i, last = 8, next = 8; | |
7701 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7702 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7703 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7704 else |
7705 for(i=0;i<size;i++){ | |
7706 if(next) | |
7707 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7708 if(!i && !next){ /* matrix not written, we use the preset one */ |
7709 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7710 break; |
7711 } | |
7712 last = factors[scan[i]] = next ? next : last; | |
7713 } | |
7714 } | |
7715 | |
7716 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7717 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7718 MpegEncContext * const s = &h->s; | |
7719 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7720 const uint8_t *fallback[4] = { | |
7721 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7722 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7723 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7724 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7725 }; | |
7726 if(get_bits1(&s->gb)){ | |
7727 sps->scaling_matrix_present |= is_sps; | |
3004 | 7728 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7729 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7730 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7731 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7732 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7733 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7734 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7735 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7736 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7737 } |
7738 } else if(fallback_sps) { | |
7739 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7740 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7741 } | |
7742 } | |
7743 | |
1168 | 7744 static inline int decode_seq_parameter_set(H264Context *h){ |
7745 MpegEncContext * const s = &h->s; | |
1371 | 7746 int profile_idc, level_idc; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7747 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
|
7748 int i; |
1168 | 7749 SPS *sps; |
2967 | 7750 |
1168 | 7751 profile_idc= get_bits(&s->gb, 8); |
1371 | 7752 get_bits1(&s->gb); //constraint_set0_flag |
7753 get_bits1(&s->gb); //constraint_set1_flag | |
7754 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7755 get_bits1(&s->gb); //constraint_set3_flag |
7756 get_bits(&s->gb, 4); // reserved | |
1168 | 7757 level_idc= get_bits(&s->gb, 8); |
7758 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7759 |
4362
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7760 if (sps_id >= MAX_SPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7761 // 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
|
7762 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
|
7763 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7764 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7765 |
1168 | 7766 sps= &h->sps_buffer[ sps_id ]; |
7767 sps->profile_idc= profile_idc; | |
7768 sps->level_idc= level_idc; | |
2312 | 7769 |
2755 | 7770 if(sps->profile_idc >= 100){ //high profile |
7771 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7772 get_bits1(&s->gb); //residual_color_transform_flag | |
7773 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7774 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7775 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7776 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7777 }else | |
7778 sps->scaling_matrix_present = 0; | |
2755 | 7779 |
1168 | 7780 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7781 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7782 |
1168 | 7783 if(sps->poc_type == 0){ //FIXME #define |
7784 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7785 } else if(sps->poc_type == 1){//FIXME #define | |
7786 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7787 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7788 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
|
7789 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7790 |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7791 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
|
7792 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
|
7793 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7794 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7795 sps->poc_cycle_length= tmp; |
2967 | 7796 |
1168 | 7797 for(i=0; i<sps->poc_cycle_length; i++) |
7798 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
|
7799 }else if(sps->poc_type != 2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7800 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7801 return -1; |
7802 } | |
7803 | |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7804 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7805 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
|
7806 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
|
7807 } |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7808 sps->ref_frame_count= tmp; |
1371 | 7809 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
|
7810 mb_width= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7811 mb_height= get_ue_golomb(&s->gb) + 1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7812 if(mb_width >= INT_MAX/16 || mb_height >= INT_MAX/16 || |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7813 avcodec_check_dimensions(NULL, 16*mb_width, 16*mb_height)){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7814 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n"); |
2422 | 7815 return -1; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7816 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7817 sps->mb_width = mb_width; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7818 sps->mb_height= mb_height; |
2422 | 7819 |
1168 | 7820 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7821 if(!sps->frame_mbs_only_flag) | |
7822 sps->mb_aff= get_bits1(&s->gb); | |
7823 else | |
7824 sps->mb_aff= 0; | |
7825 | |
7826 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7827 | |
3316 | 7828 #ifndef ALLOW_INTERLACE |
7829 if(sps->mb_aff) | |
3954 | 7830 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7831 #endif |
7832 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7833 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7834 | |
1371 | 7835 sps->crop= get_bits1(&s->gb); |
7836 if(sps->crop){ | |
7837 sps->crop_left = get_ue_golomb(&s->gb); | |
7838 sps->crop_right = get_ue_golomb(&s->gb); | |
7839 sps->crop_top = get_ue_golomb(&s->gb); | |
7840 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7841 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
|
7842 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7843 } |
7844 }else{ | |
2967 | 7845 sps->crop_left = |
7846 sps->crop_right = | |
7847 sps->crop_top = | |
1371 | 7848 sps->crop_bottom= 0; |
7849 } | |
7850 | |
1168 | 7851 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7852 if( sps->vui_parameters_present_flag ) | |
7853 decode_vui_parameters(h, sps); | |
2967 | 7854 |
1168 | 7855 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
|
7856 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 | 7857 sps_id, sps->profile_idc, sps->level_idc, |
7858 sps->poc_type, | |
7859 sps->ref_frame_count, | |
7860 sps->mb_width, sps->mb_height, | |
7861 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7862 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7863 sps->crop_left, sps->crop_right, |
7864 sps->crop_top, sps->crop_bottom, | |
1168 | 7865 sps->vui_parameters_present_flag ? "VUI" : "" |
7866 ); | |
7867 } | |
7868 return 0; | |
7869 } | |
7870 | |
2755 | 7871 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7872 MpegEncContext * const s = &h->s; |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7873 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
|
7874 PPS *pps; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7875 |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7876 if(pps_id>=MAX_PPS_COUNT){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7877 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
|
7878 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7879 } |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
7880 pps = &h->pps_buffer[pps_id]; |
2967 | 7881 |
4365
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7882 tmp= get_ue_golomb(&s->gb); |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7883 if(tmp>=MAX_SPS_COUNT){ |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7884 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
|
7885 return -1; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7886 } |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7887 pps->sps_id= tmp; |
9cebff821565
checking bitstream values and other related changes
michael
parents:
4364
diff
changeset
|
7888 |
1168 | 7889 pps->cabac= get_bits1(&s->gb); |
7890 pps->pic_order_present= get_bits1(&s->gb); | |
7891 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7892 if(pps->slice_group_count > 1 ){ | |
7893 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
|
7894 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7895 switch(pps->mb_slice_group_map_type){ |
7896 case 0: | |
7897 #if 0 | |
7898 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7899 | run_length[ i ] |1 |ue(v) | | |
7900 #endif | |
7901 break; | |
7902 case 2: | |
7903 #if 0 | |
7904 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7905 |{ | | | | |
7906 | top_left_mb[ i ] |1 |ue(v) | | |
7907 | bottom_right_mb[ i ] |1 |ue(v) | | |
7908 | } | | | | |
7909 #endif | |
7910 break; | |
7911 case 3: | |
7912 case 4: | |
7913 case 5: | |
7914 #if 0 | |
7915 | slice_group_change_direction_flag |1 |u(1) | | |
7916 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7917 #endif | |
7918 break; | |
7919 case 6: | |
7920 #if 0 | |
7921 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7922 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7923 |) | | | | |
7924 | slice_group_id[ i ] |1 |u(v) | | |
7925 #endif | |
1214 | 7926 break; |
1168 | 7927 } |
7928 } | |
7929 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7930 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4531 | 7931 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
|
7932 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
|
7933 pps->ref_count[0]= pps->ref_count[1]= 1; |
1168 | 7934 return -1; |
7935 } | |
2967 | 7936 |
1168 | 7937 pps->weighted_pred= get_bits1(&s->gb); |
7938 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7939 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7940 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7941 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7942 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7943 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7944 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7945 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7946 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
|
7947 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7948 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7949 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7950 |
7951 if(get_bits_count(&s->gb) < bit_length){ | |
7952 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7953 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7954 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7955 } | |
2967 | 7956 |
1168 | 7957 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
|
7958 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 | 7959 pps_id, pps->sps_id, |
7960 pps->cabac ? "CABAC" : "CAVLC", | |
7961 pps->slice_group_count, | |
7962 pps->ref_count[0], pps->ref_count[1], | |
7963 pps->weighted_pred ? "weighted" : "", | |
7964 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7965 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7966 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7967 pps->redundant_pic_cnt_present ? "REDU" : "", |
7968 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7969 ); |
7970 } | |
2967 | 7971 |
1168 | 7972 return 0; |
7973 } | |
7974 | |
7975 /** | |
7976 * finds the end of the current frame in the bitstream. | |
7977 * @return the position of the first byte of the next frame, or -1 | |
7978 */ | |
2392 | 7979 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7980 int i; |
1168 | 7981 uint32_t state; |
2392 | 7982 ParseContext *pc = &(h->s.parse_context); |
1168 | 7983 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7984 // mb_addr= pc->mb_addr - 1; | |
7985 state= pc->state; | |
2392 | 7986 for(i=0; i<=buf_size; i++){ |
1168 | 7987 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7988 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7989 if(pc->frame_start_found){ |
2392 | 7990 // If there isn't one more byte in the buffer |
7991 // the test on first_mb_in_slice cannot be done yet | |
7992 // do it at next call. | |
7993 if (i >= buf_size) break; | |
7994 if (buf[i] & 0x80) { | |
7995 // first_mb_in_slice is 0, probably the first nal of a new | |
7996 // slice | |
7997 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 7998 pc->state=-1; |
2392 | 7999 pc->frame_start_found= 0; |
8000 return i-4; | |
8001 } | |
1168 | 8002 } |
2392 | 8003 pc->frame_start_found = 1; |
1168 | 8004 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8005 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
|
8006 if(pc->frame_start_found){ |
2967 | 8007 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8008 pc->frame_start_found= 0; |
2967 | 8009 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8010 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8011 } |
2392 | 8012 if (i<buf_size) |
8013 state= (state<<8) | buf[i]; | |
1168 | 8014 } |
2967 | 8015 |
1168 | 8016 pc->state= state; |
1219 | 8017 return END_NOT_FOUND; |
1168 | 8018 } |
8019 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8020 #ifdef CONFIG_H264_PARSER |
1988 | 8021 static int h264_parse(AVCodecParserContext *s, |
8022 AVCodecContext *avctx, | |
2967 | 8023 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 8024 const uint8_t *buf, int buf_size) |
8025 { | |
2392 | 8026 H264Context *h = s->priv_data; |
8027 ParseContext *pc = &h->s.parse_context; | |
1988 | 8028 int next; |
2967 | 8029 |
2392 | 8030 next= find_frame_end(h, buf, buf_size); |
1988 | 8031 |
8032 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
8033 *poutbuf = NULL; | |
8034 *poutbuf_size = 0; | |
8035 return buf_size; | |
8036 } | |
8037 | |
8038 *poutbuf = (uint8_t *)buf; | |
8039 *poutbuf_size = buf_size; | |
8040 return next; | |
8041 } | |
8042 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8043 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8044 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8045 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8046 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8047 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8048 int has_sps= 0; |
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 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8051 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8052 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8053 /* 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
|
8054 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8055 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
|
8056 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8057 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
|
8058 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8059 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8060 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8061 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8062 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8063 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8064 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8065 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8066 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8067 |
1168 | 8068 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
8069 MpegEncContext * const s = &h->s; | |
8070 AVCodecContext * const avctx= s->avctx; | |
8071 int buf_index=0; | |
1322 | 8072 #if 0 |
1168 | 8073 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8074 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8075 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 8076 } |
8077 #endif | |
2392 | 8078 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
8079 s->current_picture_ptr= NULL; |
1168 | 8080 for(;;){ |
8081 int consumed; | |
8082 int dst_length; | |
8083 int bit_length; | |
8084 uint8_t *ptr; | |
2227 | 8085 int i, nalsize = 0; |
2967 | 8086 |
2227 | 8087 if(h->is_avc) { |
8088 if(buf_index >= buf_size) break; | |
8089 nalsize = 0; | |
8090 for(i = 0; i < h->nal_length_size; i++) | |
8091 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
|
8092 if(nalsize <= 1 || nalsize > buf_size){ |
3126 | 8093 if(nalsize == 1){ |
8094 buf_index++; | |
8095 continue; | |
8096 }else{ | |
8097 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
8098 break; | |
8099 } | |
8100 } | |
2227 | 8101 } else { |
1168 | 8102 // start code prefix search |
8103 for(; buf_index + 3 < buf_size; buf_index++){ | |
8104 // this should allways succeed in the first iteration | |
8105 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8106 break; | |
8107 } | |
2967 | 8108 |
1168 | 8109 if(buf_index+3 >= buf_size) break; |
2967 | 8110 |
1168 | 8111 buf_index+=3; |
2967 | 8112 } |
8113 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8114 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
|
8115 if (ptr==NULL || dst_length <= 0){ |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8116 return -1; |
0271b214458b
harden h264 decoding to prevent some crashes when input data is corrupted.
gpoirier
parents:
4354
diff
changeset
|
8117 } |
3341 | 8118 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8119 dst_length--; | |
1168 | 8120 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8121 | |
8122 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8123 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 | 8124 } |
2967 | 8125 |
2227 | 8126 if (h->is_avc && (nalsize != consumed)) |
8127 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8128 | |
1168 | 8129 buf_index += consumed; |
8130 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8131 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8132 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8133 continue; |
2967 | 8134 |
1168 | 8135 switch(h->nal_unit_type){ |
8136 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8137 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8138 case NAL_SLICE: |
8139 init_get_bits(&s->gb, ptr, bit_length); | |
8140 h->intra_gb_ptr= | |
8141 h->inter_gb_ptr= &s->gb; | |
8142 s->data_partitioning = 0; | |
2967 | 8143 |
2771 | 8144 if(decode_slice_header(h) < 0){ |
8145 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8146 break; | |
8147 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8148 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8149 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8150 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8151 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8152 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8153 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8154 decode_slice(h); |
8155 break; | |
8156 case NAL_DPA: | |
8157 init_get_bits(&s->gb, ptr, bit_length); | |
8158 h->intra_gb_ptr= | |
8159 h->inter_gb_ptr= NULL; | |
8160 s->data_partitioning = 1; | |
2967 | 8161 |
2771 | 8162 if(decode_slice_header(h) < 0){ |
8163 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8164 } | |
1168 | 8165 break; |
8166 case NAL_DPB: | |
8167 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8168 h->intra_gb_ptr= &h->intra_gb; | |
8169 break; | |
8170 case NAL_DPC: | |
8171 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8172 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8173 |
2967 | 8174 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
|
8175 && s->context_initialized |
2793 | 8176 && s->hurry_up < 5 |
8177 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8178 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8179 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8180 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8181 decode_slice(h); |
8182 break; | |
8183 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8184 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
|
8185 decode_sei(h); |
1168 | 8186 break; |
8187 case NAL_SPS: | |
8188 init_get_bits(&s->gb, ptr, bit_length); | |
8189 decode_seq_parameter_set(h); | |
2967 | 8190 |
1168 | 8191 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8192 s->low_delay=1; | |
2967 | 8193 |
2538 | 8194 if(avctx->has_b_frames < 2) |
8195 avctx->has_b_frames= !s->low_delay; | |
1168 | 8196 break; |
8197 case NAL_PPS: | |
8198 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8199 |
2755 | 8200 decode_picture_parameter_set(h, bit_length); |
1168 | 8201 |
8202 break; | |
2960 | 8203 case NAL_AUD: |
8204 case NAL_END_SEQUENCE: | |
8205 case NAL_END_STREAM: | |
8206 case NAL_FILLER_DATA: | |
8207 case NAL_SPS_EXT: | |
8208 case NAL_AUXILIARY_SLICE: | |
1168 | 8209 break; |
2979 | 8210 default: |
8211 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8212 } |
8213 } | |
8214 | |
1174 | 8215 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
|
8216 |
2971 | 8217 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
|
8218 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8219 |
1168 | 8220 h->prev_frame_num_offset= h->frame_num_offset; |
8221 h->prev_frame_num= h->frame_num; | |
8222 if(s->current_picture_ptr->reference){ | |
8223 h->prev_poc_msb= h->poc_msb; | |
8224 h->prev_poc_lsb= h->poc_lsb; | |
8225 } | |
8226 if(s->current_picture_ptr->reference) | |
8227 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8228 | |
8229 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
|
8230 |
1168 | 8231 MPV_frame_end(s); |
8232 | |
8233 return buf_index; | |
8234 } | |
8235 | |
8236 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8237 * returns the number of bytes consumed for building the current frame |
1168 | 8238 */ |
8239 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8240 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8241 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8242 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8243 |
1168 | 8244 return pos; |
8245 }else{ | |
8246 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8247 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8248 | |
8249 return pos; | |
8250 } | |
8251 } | |
8252 | |
2967 | 8253 static int decode_frame(AVCodecContext *avctx, |
1168 | 8254 void *data, int *data_size, |
8255 uint8_t *buf, int buf_size) | |
8256 { | |
8257 H264Context *h = avctx->priv_data; | |
8258 MpegEncContext *s = &h->s; | |
2967 | 8259 AVFrame *pict = data; |
1168 | 8260 int buf_index; |
2967 | 8261 |
1168 | 8262 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8263 s->flags2= avctx->flags2; |
1168 | 8264 |
8265 /* no supplementary picture */ | |
8266 if (buf_size == 0) { | |
8267 return 0; | |
8268 } | |
2967 | 8269 |
1168 | 8270 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8271 int next= find_frame_end(h, buf, buf_size); |
2967 | 8272 |
1988 | 8273 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8274 return buf_size; |
8275 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8276 } | |
8277 | |
2227 | 8278 if(h->is_avc && !h->got_avcC) { |
8279 int i, cnt, nalsize; | |
8280 unsigned char *p = avctx->extradata; | |
8281 if(avctx->extradata_size < 7) { | |
8282 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8283 return -1; | |
8284 } | |
8285 if(*p != 1) { | |
8286 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8287 return -1; | |
8288 } | |
8289 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8290 so put a fake nal_length_size = 2 while parsing them */ | |
8291 h->nal_length_size = 2; | |
8292 // Decode sps from avcC | |
8293 cnt = *(p+5) & 0x1f; // Number of sps | |
8294 p += 6; | |
8295 for (i = 0; i < cnt; i++) { | |
4364 | 8296 nalsize = AV_RB16(p) + 2; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8297 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8298 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8299 return -1; | |
8300 } | |
8301 p += nalsize; | |
2967 | 8302 } |
2227 | 8303 // Decode pps from avcC |
8304 cnt = *(p++); // Number of pps | |
8305 for (i = 0; i < cnt; i++) { | |
4364 | 8306 nalsize = AV_RB16(p) + 2; |
2227 | 8307 if(decode_nal_units(h, p, nalsize) != nalsize) { |
8308 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8309 return -1; | |
8310 } | |
8311 p += nalsize; | |
2967 | 8312 } |
2227 | 8313 // Now store right nal length size, that will be use to parse all other nals |
8314 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8315 // Do not reparse avcC | |
8316 h->got_avcC = 1; | |
8317 } | |
8318 | |
4507
b80c704183e9
always decode extradata when of non-avc stream (like RTSP)
gpoirier
parents:
4391
diff
changeset
|
8319 if(avctx->frame_number==0 && !h->is_avc && s->avctx->extradata_size){ |
2967 | 8320 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8321 return -1; |
8322 } | |
8323 | |
8324 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8325 if(buf_index < 0) |
1168 | 8326 return -1; |
8327 | |
2967 | 8328 //FIXME do something with unavailable reference frames |
8329 | |
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
|
8330 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8331 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8332 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8333 return -1; |
8334 } | |
8335 | |
2409 | 8336 { |
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
|
8337 Picture *out = s->current_picture_ptr; |
2561 | 8338 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8339 *data_size = sizeof(AVFrame); |
2561 | 8340 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8341 /* Sort B-frames into display order */ |
2409 | 8342 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
|
8343 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8344 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
|
8345 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8346 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
|
8347 && 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
|
8348 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
|
8349 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8350 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8351 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8352 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8353 while(h->delayed_pic[pics]) pics++; |
4388 | 8354 |
8355 assert(pics+1 < sizeof(h->delayed_pic) / sizeof(h->delayed_pic[0])); | |
8356 | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8357 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
|
8358 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8359 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8360 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8361 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8362 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
|
8363 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
|
8364 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8365 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8366 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8367 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8368 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
|
8369 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
|
8370 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8371 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8372 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8373 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8374 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8375 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8376 { } | |
8377 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
|
8378 out = prev; |
2923 | 8379 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8380 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8381 ((!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
|
8382 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8383 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8384 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8385 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8386 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8387 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8388 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8389 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8390 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8391 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
|
8392 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
|
8393 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
|
8394 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8395 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8396 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8397 *data_size = 0; |
2561 | 8398 else |
8399 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8400 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
|
8401 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8402 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
|
8403 #endif |
2409 | 8404 |
2937 | 8405 if(out) |
8406 *pict= *(AVFrame*)out; | |
8407 else | |
8408 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8409 } | |
8410 | |
8411 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
|
8412 ff_print_debug_info(s, pict); |
1168 | 8413 //printf("out %d\n", (int)pict->data[0]); |
8414 #if 0 //? | |
8415 | |
8416 /* Return the Picture timestamp as the frame number */ | |
8417 /* we substract 1 because it is added on utils.c */ | |
8418 avctx->frame_number = s->picture_number - 1; | |
8419 #endif | |
8420 return get_consumed_bytes(s, buf_index, buf_size); | |
8421 } | |
8422 #if 0 | |
8423 static inline void fill_mb_avail(H264Context *h){ | |
8424 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
|
8425 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8426 |
8427 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
|
8428 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
|
8429 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
|
8430 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8431 }else{ |
8432 h->mb_avail[0]= | |
8433 h->mb_avail[1]= | |
8434 h->mb_avail[2]= 0; | |
8435 } | |
8436 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8437 h->mb_avail[4]= 1; //FIXME move out | |
8438 h->mb_avail[5]= 0; //FIXME move out | |
8439 } | |
8440 #endif | |
8441 | |
8442 #if 0 //selftest | |
8443 #define COUNT 8000 | |
8444 #define SIZE (COUNT*40) | |
8445 int main(){ | |
8446 int i; | |
8447 uint8_t temp[SIZE]; | |
8448 PutBitContext pb; | |
8449 GetBitContext gb; | |
8450 // int int_temp[10000]; | |
8451 DSPContext dsp; | |
8452 AVCodecContext avctx; | |
2967 | 8453 |
1168 | 8454 dsputil_init(&dsp, &avctx); |
8455 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8456 init_put_bits(&pb, temp, SIZE); |
1168 | 8457 printf("testing unsigned exp golomb\n"); |
8458 for(i=0; i<COUNT; i++){ | |
8459 START_TIMER | |
8460 set_ue_golomb(&pb, i); | |
8461 STOP_TIMER("set_ue_golomb"); | |
8462 } | |
8463 flush_put_bits(&pb); | |
2967 | 8464 |
1168 | 8465 init_get_bits(&gb, temp, 8*SIZE); |
8466 for(i=0; i<COUNT; i++){ | |
8467 int j, s; | |
2967 | 8468 |
1168 | 8469 s= show_bits(&gb, 24); |
2967 | 8470 |
1168 | 8471 START_TIMER |
8472 j= get_ue_golomb(&gb); | |
8473 if(j != i){ | |
8474 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8475 // return -1; | |
8476 } | |
8477 STOP_TIMER("get_ue_golomb"); | |
8478 } | |
2967 | 8479 |
8480 | |
1524 | 8481 init_put_bits(&pb, temp, SIZE); |
1168 | 8482 printf("testing signed exp golomb\n"); |
8483 for(i=0; i<COUNT; i++){ | |
8484 START_TIMER | |
8485 set_se_golomb(&pb, i - COUNT/2); | |
8486 STOP_TIMER("set_se_golomb"); | |
8487 } | |
8488 flush_put_bits(&pb); | |
2967 | 8489 |
1168 | 8490 init_get_bits(&gb, temp, 8*SIZE); |
8491 for(i=0; i<COUNT; i++){ | |
8492 int j, s; | |
2967 | 8493 |
1168 | 8494 s= show_bits(&gb, 24); |
2967 | 8495 |
1168 | 8496 START_TIMER |
8497 j= get_se_golomb(&gb); | |
8498 if(j != i - COUNT/2){ | |
8499 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8500 // return -1; | |
8501 } | |
8502 STOP_TIMER("get_se_golomb"); | |
8503 } | |
8504 | |
8505 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8506 |
1168 | 8507 DCTELEM block[16]; |
8508 uint8_t src[16], ref[16]; | |
8509 uint64_t error= 0, max_error=0; | |
8510 | |
8511 for(i=0; i<COUNT; i++){ | |
8512 int j; | |
8513 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8514 for(j=0; j<16; j++){ | |
8515 ref[j]= random()%255; | |
8516 src[j]= random()%255; | |
8517 } | |
8518 | |
8519 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8520 |
1168 | 8521 //normalize |
8522 for(j=0; j<16; j++){ | |
8523 // printf("%d ", block[j]); | |
8524 block[j]= block[j]*4; | |
8525 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8526 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8527 } | |
8528 // printf("\n"); | |
2967 | 8529 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8530 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8531 /* for(j=0; j<16; j++){ |
8532 printf("%d ", ref[j]); | |
8533 } | |
8534 printf("\n");*/ | |
2967 | 8535 |
1168 | 8536 for(j=0; j<16; j++){ |
4001 | 8537 int diff= FFABS(src[j] - ref[j]); |
2967 | 8538 |
1168 | 8539 error+= diff*diff; |
8540 max_error= FFMAX(max_error, diff); | |
8541 } | |
8542 } | |
8543 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8544 #if 0 | |
8545 printf("testing quantizer\n"); | |
8546 for(qp=0; qp<52; qp++){ | |
8547 for(i=0; i<16; i++) | |
8548 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8549 |
1168 | 8550 } |
8551 #endif | |
8552 printf("Testing NAL layer\n"); | |
2967 | 8553 |
1168 | 8554 uint8_t bitstream[COUNT]; |
8555 uint8_t nal[COUNT*2]; | |
8556 H264Context h; | |
8557 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8558 |
1168 | 8559 for(i=0; i<COUNT; i++){ |
8560 int zeros= i; | |
8561 int nal_length; | |
8562 int consumed; | |
8563 int out_length; | |
8564 uint8_t *out; | |
8565 int j; | |
2967 | 8566 |
1168 | 8567 for(j=0; j<COUNT; j++){ |
8568 bitstream[j]= (random() % 255) + 1; | |
8569 } | |
2967 | 8570 |
1168 | 8571 for(j=0; j<zeros; j++){ |
8572 int pos= random() % COUNT; | |
8573 while(bitstream[pos] == 0){ | |
8574 pos++; | |
8575 pos %= COUNT; | |
8576 } | |
8577 bitstream[pos]=0; | |
8578 } | |
2967 | 8579 |
1168 | 8580 START_TIMER |
2967 | 8581 |
1168 | 8582 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8583 if(nal_length<0){ | |
8584 printf("encoding failed\n"); | |
8585 return -1; | |
8586 } | |
2967 | 8587 |
1168 | 8588 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8589 | |
8590 STOP_TIMER("NAL") | |
2967 | 8591 |
1168 | 8592 if(out_length != COUNT){ |
8593 printf("incorrect length %d %d\n", out_length, COUNT); | |
8594 return -1; | |
8595 } | |
2967 | 8596 |
1168 | 8597 if(consumed != nal_length){ |
8598 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8599 return -1; | |
8600 } | |
2967 | 8601 |
1168 | 8602 if(memcmp(bitstream, out, COUNT)){ |
8603 printf("missmatch\n"); | |
8604 return -1; | |
8605 } | |
8606 } | |
2967 | 8607 |
1168 | 8608 printf("Testing RBSP\n"); |
2967 | 8609 |
8610 | |
1168 | 8611 return 0; |
8612 } | |
8613 #endif | |
8614 | |
8615 | |
8616 static int decode_end(AVCodecContext *avctx) | |
8617 { | |
8618 H264Context *h = avctx->priv_data; | |
8619 MpegEncContext *s = &h->s; | |
2967 | 8620 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8621 av_freep(&h->rbsp_buffer); |
1168 | 8622 free_tables(h); //FIXME cleanup init stuff perhaps |
8623 MPV_common_end(s); | |
8624 | |
8625 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8626 |
1168 | 8627 return 0; |
8628 } | |
8629 | |
8630 | |
8631 AVCodec h264_decoder = { | |
8632 "h264", | |
8633 CODEC_TYPE_VIDEO, | |
8634 CODEC_ID_H264, | |
8635 sizeof(H264Context), | |
8636 decode_init, | |
8637 NULL, | |
8638 decode_end, | |
8639 decode_frame, | |
2453 | 8640 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8641 .flush= flush_dpb, |
1168 | 8642 }; |
8643 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8644 #ifdef CONFIG_H264_PARSER |
1988 | 8645 AVCodecParser h264_parser = { |
8646 { CODEC_ID_H264 }, | |
2392 | 8647 sizeof(H264Context), |
1988 | 8648 NULL, |
8649 h264_parse, | |
8650 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8651 h264_split, |
1988 | 8652 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8653 #endif |
1988 | 8654 |
1234 | 8655 #include "svq3.c" |