Mercurial > libavcodec.hg
annotate h264.c @ 4354:d18568fb0187 libavcodec
Avoid calling decode_slice when context_initialized is not set.
Avoids a crash due to dsp.clear_blocks being NULL when called.
author | reimar |
---|---|
date | Tue, 16 Jan 2007 17:46:26 +0000 |
parents | 4aa24216f71a |
children | 0271b214458b |
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{ | |
120 int sps_id; | |
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; | |
125 int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 | |
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 |
1168 | 277 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 */ | |
3316 | 328 int ref_count[2]; ///< counts frames or fields, depending on current mb mode |
2582 | 329 Picture *short_ref[32]; |
330 Picture *long_ref[32]; | |
1168 | 331 Picture default_ref_list[2][32]; |
3316 | 332 Picture ref_list[2][48]; ///< 0..15: frame refs, 16..47: mbaff field refs |
2409 | 333 Picture *delayed_pic[16]; //FIXME size? |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
334 Picture *delayed_output_pic; |
2967 | 335 |
1168 | 336 /** |
337 * memory management control operations buffer. | |
338 */ | |
339 MMCO mmco[MAX_MMCO_COUNT]; | |
340 int mmco_index; | |
2967 | 341 |
1168 | 342 int long_ref_count; ///< number of actual long term references |
343 int short_ref_count; ///< number of actual short term references | |
2967 | 344 |
1168 | 345 //data partitioning |
346 GetBitContext intra_gb; | |
347 GetBitContext inter_gb; | |
348 GetBitContext *intra_gb_ptr; | |
349 GetBitContext *inter_gb_ptr; | |
2967 | 350 |
3089 | 351 DECLARE_ALIGNED_8(DCTELEM, mb[16*24]); |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
352 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
353 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
354 * Cabac |
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 CABACContext cabac; |
2755 | 357 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
|
358 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
|
359 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
360 /* 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
|
361 uint16_t *cbp_table; |
3651 | 362 int cbp; |
2314 | 363 int top_cbp; |
364 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
|
365 /* 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
|
366 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
|
367 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
|
368 int16_t (*mvd_table[2])[2]; |
3089 | 369 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); |
2396 | 370 uint8_t *direct_table; |
371 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
|
372 |
2748
135aa7d0bd17
avoid one transpose (730->680 dezicycles on duron)
michael
parents:
2717
diff
changeset
|
373 uint8_t zigzag_scan[16]; |
3174 | 374 uint8_t zigzag_scan8x8[64]; |
375 uint8_t zigzag_scan8x8_cavlc[64]; | |
3316 | 376 uint8_t field_scan[16]; |
377 uint8_t field_scan8x8[64]; | |
378 uint8_t field_scan8x8_cavlc[64]; | |
2763 | 379 const uint8_t *zigzag_scan_q0; |
3174 | 380 const uint8_t *zigzag_scan8x8_q0; |
381 const uint8_t *zigzag_scan8x8_cavlc_q0; | |
3316 | 382 const uint8_t *field_scan_q0; |
383 const uint8_t *field_scan8x8_q0; | |
384 const uint8_t *field_scan8x8_cavlc_q0; | |
2967 | 385 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
386 int x264_build; |
1168 | 387 }H264Context; |
388 | |
389 static VLC coeff_token_vlc[4]; | |
390 static VLC chroma_dc_coeff_token_vlc; | |
391 | |
392 static VLC total_zeros_vlc[15]; | |
393 static VLC chroma_dc_total_zeros_vlc[3]; | |
394 | |
395 static VLC run_vlc[6]; | |
396 static VLC run7_vlc; | |
397 | |
1234 | 398 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp); |
399 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
|
400 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
|
401 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 | 402 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
403 static av_always_inline uint32_t pack16to32(int a, int b){ |
1269 | 404 #ifdef WORDS_BIGENDIAN |
405 return (b&0xFFFF) + (a<<16); | |
406 #else | |
407 return (a&0xFFFF) + (b<<16); | |
408 #endif | |
409 } | |
410 | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
411 const uint8_t ff_rem6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
412 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
|
413 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
414 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
415 const uint8_t ff_div6[52]={ |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
416 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
|
417 }; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
418 |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
419 |
1168 | 420 /** |
421 * fill a rectangle. | |
2392 | 422 * @param h height of the rectangle, should be a constant |
423 * @param w width of the rectangle, should be a constant | |
1168 | 424 * @param size the size of val (1 or 4), should be a constant |
425 */ | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4277
diff
changeset
|
426 static av_always_inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ |
1187 | 427 uint8_t *p= (uint8_t*)vp; |
1168 | 428 assert(size==1 || size==4); |
3315 | 429 assert(w<=4); |
2967 | 430 |
1168 | 431 w *= size; |
432 stride *= size; | |
2967 | 433 |
2962 | 434 assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0); |
2669 | 435 assert((stride&(w-1))==0); |
3315 | 436 if(w==2){ |
437 const uint16_t v= size==4 ? val : val*0x0101; | |
438 *(uint16_t*)(p + 0*stride)= v; | |
439 if(h==1) return; | |
440 *(uint16_t*)(p + 1*stride)= v; | |
441 if(h==2) return; | |
1168 | 442 *(uint16_t*)(p + 2*stride)= |
3315 | 443 *(uint16_t*)(p + 3*stride)= v; |
444 }else if(w==4){ | |
445 const uint32_t v= size==4 ? val : val*0x01010101; | |
446 *(uint32_t*)(p + 0*stride)= v; | |
447 if(h==1) return; | |
448 *(uint32_t*)(p + 1*stride)= v; | |
449 if(h==2) return; | |
1168 | 450 *(uint32_t*)(p + 2*stride)= |
3315 | 451 *(uint32_t*)(p + 3*stride)= v; |
452 }else if(w==8){ | |
453 //gcc can't optimize 64bit math on x86_32 | |
454 #if defined(ARCH_X86_64) || (defined(MP_WORDSIZE) && MP_WORDSIZE >= 64) | |
455 const uint64_t v= val*0x0100000001ULL; | |
456 *(uint64_t*)(p + 0*stride)= v; | |
457 if(h==1) return; | |
458 *(uint64_t*)(p + 1*stride)= v; | |
459 if(h==2) return; | |
1168 | 460 *(uint64_t*)(p + 2*stride)= |
3315 | 461 *(uint64_t*)(p + 3*stride)= v; |
462 }else if(w==16){ | |
463 const uint64_t v= val*0x0100000001ULL; | |
1168 | 464 *(uint64_t*)(p + 0+0*stride)= |
465 *(uint64_t*)(p + 8+0*stride)= | |
466 *(uint64_t*)(p + 0+1*stride)= | |
3315 | 467 *(uint64_t*)(p + 8+1*stride)= v; |
468 if(h==2) return; | |
1168 | 469 *(uint64_t*)(p + 0+2*stride)= |
470 *(uint64_t*)(p + 8+2*stride)= | |
471 *(uint64_t*)(p + 0+3*stride)= | |
3315 | 472 *(uint64_t*)(p + 8+3*stride)= v; |
473 #else | |
474 *(uint32_t*)(p + 0+0*stride)= | |
475 *(uint32_t*)(p + 4+0*stride)= val; | |
476 if(h==1) return; | |
477 *(uint32_t*)(p + 0+1*stride)= | |
478 *(uint32_t*)(p + 4+1*stride)= val; | |
479 if(h==2) return; | |
480 *(uint32_t*)(p + 0+2*stride)= | |
481 *(uint32_t*)(p + 4+2*stride)= | |
482 *(uint32_t*)(p + 0+3*stride)= | |
483 *(uint32_t*)(p + 4+3*stride)= val; | |
484 }else if(w==16){ | |
485 *(uint32_t*)(p + 0+0*stride)= | |
486 *(uint32_t*)(p + 4+0*stride)= | |
487 *(uint32_t*)(p + 8+0*stride)= | |
488 *(uint32_t*)(p +12+0*stride)= | |
489 *(uint32_t*)(p + 0+1*stride)= | |
490 *(uint32_t*)(p + 4+1*stride)= | |
491 *(uint32_t*)(p + 8+1*stride)= | |
492 *(uint32_t*)(p +12+1*stride)= val; | |
493 if(h==2) return; | |
494 *(uint32_t*)(p + 0+2*stride)= | |
495 *(uint32_t*)(p + 4+2*stride)= | |
496 *(uint32_t*)(p + 8+2*stride)= | |
497 *(uint32_t*)(p +12+2*stride)= | |
498 *(uint32_t*)(p + 0+3*stride)= | |
499 *(uint32_t*)(p + 4+3*stride)= | |
500 *(uint32_t*)(p + 8+3*stride)= | |
501 *(uint32_t*)(p +12+3*stride)= val; | |
502 #endif | |
1168 | 503 }else |
504 assert(0); | |
3315 | 505 assert(h==4); |
1168 | 506 } |
507 | |
3028 | 508 static void fill_caches(H264Context *h, int mb_type, int for_deblock){ |
1168 | 509 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
|
510 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 511 int topleft_xy, top_xy, topright_xy, left_xy[2]; |
512 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
|
513 int left_block[8]; |
1168 | 514 int i; |
515 | |
3482 | 516 //FIXME deblocking could skip the intra and nnz parts. |
517 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
|
518 return; |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
519 |
2967 | 520 //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it |
521 | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
522 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
|
523 topleft_xy = top_xy - 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
524 topright_xy= top_xy + 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
525 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
|
526 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
527 left_block[1]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
528 left_block[2]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
529 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
530 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
531 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
532 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
533 left_block[7]= 11; |
3316 | 534 if(FRAME_MBAFF){ |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
535 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
|
536 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
|
537 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
|
538 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
|
539 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
|
540 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
|
541 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
|
542 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
|
543 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
|
544 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
|
545 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
|
546 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
547 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
548 : (!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
|
549 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
550 top_xy -= s->mb_stride; |
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 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
553 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
554 : (!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
|
555 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
556 topleft_xy -= s->mb_stride; |
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 if (bottom |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
559 ? !curr_mb_frame_flag // bottom macroblock |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
560 : (!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
|
561 ) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
562 topright_xy -= s->mb_stride; |
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 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
|
565 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
|
566 if (curr_mb_frame_flag) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
567 if (bottom) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
568 left_block[0]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
569 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
570 left_block[2]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
571 left_block[3]= 3; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
572 left_block[4]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
573 left_block[5]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
574 left_block[6]= 8; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
575 left_block[7]= 11; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
576 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
577 left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
578 left_block[1]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
579 left_block[2]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
580 left_block[3]= 1; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
581 left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
582 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
583 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
584 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
585 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
586 } else { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
587 left_xy[1] += s->mb_stride; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
588 //left_block[0]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
589 left_block[1]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
590 left_block[2]= 0; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
591 left_block[3]= 2; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
592 //left_block[4]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
593 left_block[5]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
594 left_block[6]= 7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
595 left_block[7]= 10; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
596 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
597 } |
1168 | 598 } |
599 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
600 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
|
601 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
|
602 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
|
603 if(for_deblock){ |
3482 | 604 topleft_type = 0; |
605 topright_type = 0; | |
2449 | 606 top_type = h->slice_table[top_xy ] < 255 ? s->current_picture.mb_type[top_xy] : 0; |
607 left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0; | |
608 left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0; | |
3316 | 609 |
610 if(FRAME_MBAFF && !IS_INTRA(mb_type)){ | |
611 int list; | |
612 int v = *(uint16_t*)&h->non_zero_count[mb_xy][14]; | |
613 for(i=0; i<16; i++) | |
614 h->non_zero_count_cache[scan8[i]] = (v>>i)&1; | |
615 for(list=0; list<1+(h->slice_type==B_TYPE); list++){ | |
616 if(USES_LIST(mb_type,list)){ | |
617 uint32_t *src = (uint32_t*)s->current_picture.motion_val[list][h->mb2b_xy[mb_xy]]; | |
618 uint32_t *dst = (uint32_t*)h->mv_cache[list][scan8[0]]; | |
3776 | 619 int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]]; |
3316 | 620 for(i=0; i<4; i++, dst+=8, src+=h->b_stride){ |
621 dst[0] = src[0]; | |
622 dst[1] = src[1]; | |
623 dst[2] = src[2]; | |
624 dst[3] = src[3]; | |
625 } | |
626 *(uint32_t*)&h->ref_cache[list][scan8[ 0]] = | |
627 *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = pack16to32(ref[0],ref[1])*0x0101; | |
628 ref += h->b8_stride; | |
629 *(uint32_t*)&h->ref_cache[list][scan8[ 8]] = | |
630 *(uint32_t*)&h->ref_cache[list][scan8[10]] = pack16to32(ref[0],ref[1])*0x0101; | |
631 }else{ | |
632 fill_rectangle(&h-> mv_cache[list][scan8[ 0]], 4, 4, 8, 0, 4); | |
633 fill_rectangle(&h->ref_cache[list][scan8[ 0]], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); | |
634 } | |
635 } | |
636 } | |
2449 | 637 }else{ |
638 topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0; | |
639 top_type = h->slice_table[top_xy ] == h->slice_num ? s->current_picture.mb_type[top_xy] : 0; | |
640 topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0; | |
641 left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0; | |
642 left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0; | |
643 } | |
1168 | 644 |
645 if(IS_INTRA(mb_type)){ | |
2967 | 646 h->topleft_samples_available= |
647 h->top_samples_available= | |
1168 | 648 h->left_samples_available= 0xFFFF; |
649 h->topright_samples_available= 0xEEEA; | |
650 | |
651 if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){ | |
652 h->topleft_samples_available= 0xB3FF; | |
653 h->top_samples_available= 0x33FF; | |
654 h->topright_samples_available= 0x26EA; | |
655 } | |
656 for(i=0; i<2; i++){ | |
657 if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){ | |
658 h->topleft_samples_available&= 0xDF5F; | |
659 h->left_samples_available&= 0x5F5F; | |
660 } | |
661 } | |
2967 | 662 |
1168 | 663 if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred)) |
664 h->topleft_samples_available&= 0x7FFF; | |
2967 | 665 |
1168 | 666 if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred)) |
667 h->topright_samples_available&= 0xFBFF; | |
2967 | 668 |
1168 | 669 if(IS_INTRA4x4(mb_type)){ |
670 if(IS_INTRA4x4(top_type)){ | |
671 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4]; | |
672 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5]; | |
673 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6]; | |
674 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3]; | |
675 }else{ | |
676 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
677 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
|
678 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
679 else{ |
1168 | 680 pred= 2; |
681 } | |
682 h->intra4x4_pred_mode_cache[4+8*0]= | |
683 h->intra4x4_pred_mode_cache[5+8*0]= | |
684 h->intra4x4_pred_mode_cache[6+8*0]= | |
685 h->intra4x4_pred_mode_cache[7+8*0]= pred; | |
686 } | |
687 for(i=0; i<2; i++){ | |
688 if(IS_INTRA4x4(left_type[i])){ | |
689 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]]; | |
690 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]]; | |
691 }else{ | |
692 int pred; | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
693 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
|
694 pred= -1; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
695 else{ |
1168 | 696 pred= 2; |
697 } | |
698 h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= | |
699 h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred; | |
700 } | |
701 } | |
702 } | |
703 } | |
2967 | 704 |
705 | |
1168 | 706 /* |
2967 | 707 0 . T T. T T T T |
708 1 L . .L . . . . | |
709 2 L . .L . . . . | |
710 3 . T TL . . . . | |
711 4 L . .L . . . . | |
712 5 L . .. . . . . | |
1168 | 713 */ |
714 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec) | |
715 if(top_type){ | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
716 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
|
717 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
|
718 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
|
719 h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3]; |
2967 | 720 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
721 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
|
722 h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8]; |
2967 | 723 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
724 h->non_zero_count_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
|
725 h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11]; |
2967 | 726 |
1168 | 727 }else{ |
2967 | 728 h->non_zero_count_cache[4+8*0]= |
1168 | 729 h->non_zero_count_cache[5+8*0]= |
730 h->non_zero_count_cache[6+8*0]= | |
731 h->non_zero_count_cache[7+8*0]= | |
2967 | 732 |
1168 | 733 h->non_zero_count_cache[1+8*0]= |
734 h->non_zero_count_cache[2+8*0]= | |
2967 | 735 |
1168 | 736 h->non_zero_count_cache[1+8*3]= |
2314 | 737 h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64; |
2967 | 738 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
739 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
740 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
741 for (i=0; i<2; i++) { |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
742 if(left_type[i]){ |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
743 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
|
744 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
|
745 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
|
746 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
|
747 }else{ |
2967 | 748 h->non_zero_count_cache[3+8*1 + 2*8*i]= |
749 h->non_zero_count_cache[3+8*2 + 2*8*i]= | |
750 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
|
751 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
|
752 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
753 } |
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 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
|
756 // top_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
757 if(top_type) { |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
758 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
|
759 } 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
|
760 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
|
761 } else { |
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 = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
763 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
764 // left_cbp |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
765 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
|
766 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
|
767 } 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
|
768 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
|
769 } else { |
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 = 0; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
771 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
772 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
|
773 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
|
774 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
775 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
|
776 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
|
777 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
778 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
779 |
1168 | 780 #if 1 |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
781 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ |
1168 | 782 int list; |
2623
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
783 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
|
784 if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){ |
1168 | 785 /*if(!h->mv_cache_clean[list]){ |
786 memset(h->mv_cache [list], 0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all? | |
787 memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t)); | |
788 h->mv_cache_clean[list]= 1; | |
789 }*/ | |
2396 | 790 continue; |
1168 | 791 } |
792 h->mv_cache_clean[list]= 0; | |
2967 | 793 |
3212 | 794 if(USES_LIST(top_type, list)){ |
1168 | 795 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; |
796 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride; | |
797 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0]; | |
798 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1]; | |
799 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2]; | |
800 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3]; | |
801 h->ref_cache[list][scan8[0] + 0 - 1*8]= | |
802 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0]; | |
803 h->ref_cache[list][scan8[0] + 2 - 1*8]= | |
804 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1]; | |
805 }else{ | |
2967 | 806 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]= |
807 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]= | |
808 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]= | |
1168 | 809 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0; |
810 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101; | |
811 } | |
812 | |
813 //FIXME unify cleanup or sth | |
3212 | 814 if(USES_LIST(left_type[0], list)){ |
1168 | 815 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; |
816 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1; | |
817 *(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]]; | |
818 *(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 | 819 h->ref_cache[list][scan8[0] - 1 + 0*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)]; |
820 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 | 821 }else{ |
822 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]= | |
823 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0; | |
824 h->ref_cache[list][scan8[0] - 1 + 0*8]= | |
825 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
826 } | |
2967 | 827 |
3212 | 828 if(USES_LIST(left_type[1], list)){ |
1168 | 829 const int b_xy= h->mb2b_xy[left_xy[1]] + 3; |
830 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1; | |
831 *(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]]; | |
832 *(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 | 833 h->ref_cache[list][scan8[0] - 1 + 2*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)]; |
834 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 | 835 }else{ |
836 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]= | |
837 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0; | |
838 h->ref_cache[list][scan8[0] - 1 + 2*8]= | |
839 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE; | |
2669 | 840 assert((!left_type[0]) == (!left_type[1])); |
1168 | 841 } |
842 | |
3519 | 843 if((for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred)) && !FRAME_MBAFF) |
2449 | 844 continue; |
845 | |
3212 | 846 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
|
847 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
|
848 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
|
849 *(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
|
850 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
|
851 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
852 *(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
|
853 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
|
854 } |
2967 | 855 |
3212 | 856 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
|
857 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
|
858 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
|
859 *(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
|
860 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
|
861 }else{ |
aaf8e94bce00
deblocking filter doesn't need to call fill_caches again. 1.4% faster decoding.
lorenm
parents:
2597
diff
changeset
|
862 *(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
|
863 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
|
864 } |
2967 | 865 |
3519 | 866 if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF) |
3482 | 867 continue; |
2967 | 868 |
869 h->ref_cache[list][scan8[5 ]+1] = | |
870 h->ref_cache[list][scan8[7 ]+1] = | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
871 h->ref_cache[list][scan8[13]+1] = //FIXME remove past 3 (init somewhere else) |
2967 | 872 h->ref_cache[list][scan8[4 ]] = |
1168 | 873 h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE; |
874 *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]= | |
875 *(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
|
876 *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else) |
1168 | 877 *(uint32_t*)h->mv_cache [list][scan8[4 ]]= |
878 *(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
|
879 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
880 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
|
881 /* XXX beurk, Load mvd */ |
3212 | 882 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
|
883 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
|
884 *(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
|
885 *(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
|
886 *(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
|
887 *(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
|
888 }else{ |
2967 | 889 *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]= |
890 *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]= | |
891 *(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
|
892 *(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
|
893 } |
3212 | 894 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
|
895 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
|
896 *(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
|
897 *(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
|
898 }else{ |
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 + 0*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
900 *(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
|
901 } |
3212 | 902 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
|
903 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
|
904 *(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
|
905 *(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
|
906 }else{ |
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 + 2*8]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
908 *(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
|
909 } |
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[5 ]+1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
911 *(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
|
912 *(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
|
913 *(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
|
914 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0; |
2396 | 915 |
916 if(h->slice_type == B_TYPE){ | |
917 fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1); | |
918 | |
919 if(IS_DIRECT(top_type)){ | |
920 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101; | |
921 }else if(IS_8X8(top_type)){ | |
922 int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride; | |
923 h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy]; | |
924 h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1]; | |
925 }else{ | |
926 *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0; | |
927 } | |
2967 | 928 |
3316 | 929 if(IS_DIRECT(left_type[0])) |
930 h->direct_cache[scan8[0] - 1 + 0*8]= 1; | |
931 else if(IS_8X8(left_type[0])) | |
932 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)]; | |
933 else | |
934 h->direct_cache[scan8[0] - 1 + 0*8]= 0; | |
935 | |
936 if(IS_DIRECT(left_type[1])) | |
2396 | 937 h->direct_cache[scan8[0] - 1 + 2*8]= 1; |
3316 | 938 else if(IS_8X8(left_type[1])) |
939 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)]; | |
940 else | |
2396 | 941 h->direct_cache[scan8[0] - 1 + 2*8]= 0; |
3316 | 942 } |
943 } | |
944 | |
945 if(FRAME_MBAFF){ | |
946 #define MAP_MVS\ | |
947 MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\ | |
948 MAP_F2F(scan8[0] + 0 - 1*8, top_type)\ | |
949 MAP_F2F(scan8[0] + 1 - 1*8, top_type)\ | |
950 MAP_F2F(scan8[0] + 2 - 1*8, top_type)\ | |
951 MAP_F2F(scan8[0] + 3 - 1*8, top_type)\ | |
952 MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\ | |
953 MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\ | |
954 MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\ | |
955 MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\ | |
956 MAP_F2F(scan8[0] - 1 + 3*8, left_type[1]) | |
957 if(MB_FIELD){ | |
958 #define MAP_F2F(idx, mb_type)\ | |
959 if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
960 h->ref_cache[list][idx] <<= 1;\ | |
961 h->mv_cache[list][idx][1] /= 2;\ | |
962 h->mvd_cache[list][idx][1] /= 2;\ | |
2396 | 963 } |
3316 | 964 MAP_MVS |
965 #undef MAP_F2F | |
966 }else{ | |
967 #define MAP_F2F(idx, mb_type)\ | |
968 if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\ | |
969 h->ref_cache[list][idx] >>= 1;\ | |
970 h->mv_cache[list][idx][1] <<= 1;\ | |
971 h->mvd_cache[list][idx][1] <<= 1;\ | |
972 } | |
973 MAP_MVS | |
974 #undef MAP_F2F | |
2396 | 975 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
976 } |
1168 | 977 } |
978 } | |
979 #endif | |
2755 | 980 |
981 h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]); | |
1168 | 982 } |
983 | |
984 static inline void write_back_intra_pred_mode(H264Context *h){ | |
985 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
|
986 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 987 |
988 h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1]; | |
989 h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2]; | |
990 h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3]; | |
991 h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4]; | |
992 h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4]; | |
993 h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4]; | |
994 h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4]; | |
995 } | |
996 | |
997 /** | |
998 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
999 */ | |
1000 static inline int check_intra4x4_pred_mode(H264Context *h){ | |
1001 MpegEncContext * const s = &h->s; | |
1002 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; | |
1003 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; | |
1004 int i; | |
2967 | 1005 |
1168 | 1006 if(!(h->top_samples_available&0x8000)){ |
1007 for(i=0; i<4; i++){ | |
1008 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; | |
1009 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1010 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 | 1011 return -1; |
1012 } else if(status){ | |
1013 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; | |
1014 } | |
1015 } | |
1016 } | |
2967 | 1017 |
1168 | 1018 if(!(h->left_samples_available&0x8000)){ |
1019 for(i=0; i<4; i++){ | |
1020 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; | |
1021 if(status<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1022 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 | 1023 return -1; |
1024 } else if(status){ | |
1025 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; | |
1026 } | |
1027 } | |
1028 } | |
1029 | |
1030 return 0; | |
1031 } //FIXME cleanup like next | |
1032 | |
1033 /** | |
1034 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks. | |
1035 */ | |
1036 static inline int check_intra_pred_mode(H264Context *h, int mode){ | |
1037 MpegEncContext * const s = &h->s; | |
1038 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; | |
1039 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; | |
2967 | 1040 |
2392 | 1041 if(mode < 0 || mode > 6) { |
1042 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 | 1043 return -1; |
2392 | 1044 } |
2967 | 1045 |
1168 | 1046 if(!(h->top_samples_available&0x8000)){ |
1047 mode= top[ mode ]; | |
1048 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1049 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 | 1050 return -1; |
1051 } | |
1052 } | |
2967 | 1053 |
1168 | 1054 if(!(h->left_samples_available&0x8000)){ |
1055 mode= left[ mode ]; | |
1056 if(mode<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
1057 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 | 1058 return -1; |
2967 | 1059 } |
1168 | 1060 } |
1061 | |
1062 return mode; | |
1063 } | |
1064 | |
1065 /** | |
1066 * gets the predicted intra4x4 prediction mode. | |
1067 */ | |
1068 static inline int pred_intra_mode(H264Context *h, int n){ | |
1069 const int index8= scan8[n]; | |
1070 const int left= h->intra4x4_pred_mode_cache[index8 - 1]; | |
1071 const int top = h->intra4x4_pred_mode_cache[index8 - 8]; | |
1072 const int min= FFMIN(left, top); | |
1073 | |
1170 | 1074 tprintf("mode:%d %d min:%d\n", left ,top, min); |
1168 | 1075 |
1076 if(min<0) return DC_PRED; | |
1077 else return min; | |
1078 } | |
1079 | |
1080 static inline void write_back_non_zero_count(H264Context *h){ | |
1081 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
|
1082 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
|
1083 |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
1084 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
|
1085 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
|
1086 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
|
1087 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
|
1088 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
|
1089 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
|
1090 h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4]; |
2967 | 1091 |
2551
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][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
|
1093 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
|
1094 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
|
1095 |
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][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
|
1097 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
|
1098 h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4]; |
3316 | 1099 |
1100 if(FRAME_MBAFF){ | |
1101 // store all luma nnzs, for deblocking | |
1102 int v = 0, i; | |
1103 for(i=0; i<16; i++) | |
1104 v += (!!h->non_zero_count_cache[scan8[i]]) << i; | |
1105 *(uint16_t*)&h->non_zero_count[mb_xy][14] = v; | |
1106 } | |
1168 | 1107 } |
1108 | |
1109 /** | |
1110 * gets the predicted number of non zero coefficients. | |
1111 * @param n block index | |
1112 */ | |
1113 static inline int pred_non_zero_count(H264Context *h, int n){ | |
1114 const int index8= scan8[n]; | |
1115 const int left= h->non_zero_count_cache[index8 - 1]; | |
1116 const int top = h->non_zero_count_cache[index8 - 8]; | |
1117 int i= left + top; | |
2967 | 1118 |
1168 | 1119 if(i<64) i= (i+1)>>1; |
1120 | |
1170 | 1121 tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31); |
1168 | 1122 |
1123 return i&31; | |
1124 } | |
1125 | |
1169 | 1126 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){ |
1127 const int topright_ref= h->ref_cache[list][ i - 8 + part_width ]; | |
1128 | |
3316 | 1129 /* there is no consistent mapping of mvs to neighboring locations that will |
1130 * make mbaff happy, so we can't move all this logic to fill_caches */ | |
1131 if(FRAME_MBAFF){ | |
1132 MpegEncContext *s = &h->s; | |
3776 | 1133 const uint32_t *mb_types = s->current_picture_ptr->mb_type; |
3316 | 1134 const int16_t *mv; |
1135 *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0; | |
1136 *C = h->mv_cache[list][scan8[0]-2]; | |
1137 | |
1138 if(!MB_FIELD | |
1139 && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){ | |
1140 int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3); | |
1141 if(IS_INTERLACED(mb_types[topright_xy])){ | |
1142 #define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\ | |
1143 const int x4 = X4, y4 = Y4;\ | |
1144 const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\ | |
1145 if(!USES_LIST(mb_type,list) && !IS_8X8(mb_type))\ | |
1146 return LIST_NOT_USED;\ | |
1147 mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\ | |
1148 h->mv_cache[list][scan8[0]-2][0] = mv[0];\ | |
1149 h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\ | |
1150 return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP; | |
1151 | |
1152 SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1); | |
1153 } | |
1154 } | |
1155 if(topright_ref == PART_NOT_AVAILABLE | |
1156 && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4 | |
1157 && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){ | |
1158 if(!MB_FIELD | |
1159 && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){ | |
1160 SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1); | |
1161 } | |
1162 if(MB_FIELD | |
1163 && !IS_INTERLACED(mb_types[h->left_mb_xy[0]]) | |
1164 && i >= scan8[0]+8){ | |
1165 // leftshift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's ok. | |
1166 SET_DIAG_MV(>>1, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2); | |
1167 } | |
1168 } | |
1169 #undef SET_DIAG_MV | |
1170 } | |
1171 | |
1169 | 1172 if(topright_ref != PART_NOT_AVAILABLE){ |
1173 *C= h->mv_cache[list][ i - 8 + part_width ]; | |
1174 return topright_ref; | |
1175 }else{ | |
1170 | 1176 tprintf("topright MV not available\n"); |
1177 | |
1169 | 1178 *C= h->mv_cache[list][ i - 8 - 1 ]; |
1179 return h->ref_cache[list][ i - 8 - 1 ]; | |
1180 } | |
1181 } | |
1182 | |
1168 | 1183 /** |
1184 * gets the predicted MV. | |
1185 * @param n the block index | |
1186 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4) | |
1187 * @param mx the x component of the predicted motion vector | |
1188 * @param my the y component of the predicted motion vector | |
1189 */ | |
1190 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){ | |
1191 const int index8= scan8[n]; | |
1192 const int top_ref= h->ref_cache[list][ index8 - 8 ]; | |
1193 const int left_ref= h->ref_cache[list][ index8 - 1 ]; | |
1194 const int16_t * const A= h->mv_cache[list][ index8 - 1 ]; | |
1195 const int16_t * const B= h->mv_cache[list][ index8 - 8 ]; | |
1169 | 1196 const int16_t * C; |
1197 int diagonal_ref, match_count; | |
1198 | |
1168 | 1199 assert(part_width==1 || part_width==2 || part_width==4); |
1169 | 1200 |
1168 | 1201 /* mv_cache |
2967 | 1202 B . . A T T T T |
1168 | 1203 U . . L . . , . |
1204 U . . L . . . . | |
1205 U . . L . . , . | |
1206 . . . L . . . . | |
1207 */ | |
1169 | 1208 |
1209 diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width); | |
1210 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
|
1211 tprintf("pred_motion match_count=%d\n", match_count); |
1169 | 1212 if(match_count > 1){ //most common |
1213 *mx= mid_pred(A[0], B[0], C[0]); | |
1214 *my= mid_pred(A[1], B[1], C[1]); | |
1215 }else if(match_count==1){ | |
1216 if(left_ref==ref){ | |
1217 *mx= A[0]; | |
2967 | 1218 *my= A[1]; |
1169 | 1219 }else if(top_ref==ref){ |
1220 *mx= B[0]; | |
2967 | 1221 *my= B[1]; |
1169 | 1222 }else{ |
1223 *mx= C[0]; | |
2967 | 1224 *my= C[1]; |
1169 | 1225 } |
1226 }else{ | |
1227 if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){ | |
1228 *mx= A[0]; | |
2967 | 1229 *my= A[1]; |
1168 | 1230 }else{ |
1231 *mx= mid_pred(A[0], B[0], C[0]); | |
1232 *my= mid_pred(A[1], B[1], C[1]); | |
1233 } | |
1169 | 1234 } |
2967 | 1235 |
1187 | 1236 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 | 1237 } |
1238 | |
1239 /** | |
1240 * gets the directionally predicted 16x8 MV. | |
1241 * @param n the block index | |
1242 * @param mx the x component of the predicted motion vector | |
1243 * @param my the y component of the predicted motion vector | |
1244 */ | |
1245 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1246 if(n==0){ | |
1247 const int top_ref= h->ref_cache[list][ scan8[0] - 8 ]; | |
1248 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; | |
1249 | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1250 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 | 1251 |
1168 | 1252 if(top_ref == ref){ |
1253 *mx= B[0]; | |
1254 *my= B[1]; | |
1255 return; | |
1256 } | |
1257 }else{ | |
1258 const int left_ref= h->ref_cache[list][ scan8[8] - 1 ]; | |
1259 const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ]; | |
2967 | 1260 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1261 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 | 1262 |
1263 if(left_ref == ref){ | |
1264 *mx= A[0]; | |
1265 *my= A[1]; | |
1266 return; | |
1267 } | |
1268 } | |
1269 | |
1270 //RARE | |
1271 pred_motion(h, n, 4, list, ref, mx, my); | |
1272 } | |
1273 | |
1274 /** | |
1275 * gets the directionally predicted 8x16 MV. | |
1276 * @param n the block index | |
1277 * @param mx the x component of the predicted motion vector | |
1278 * @param my the y component of the predicted motion vector | |
1279 */ | |
1280 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){ | |
1281 if(n==0){ | |
1282 const int left_ref= h->ref_cache[list][ scan8[0] - 1 ]; | |
1283 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; | |
2967 | 1284 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1285 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 | 1286 |
1287 if(left_ref == ref){ | |
1288 *mx= A[0]; | |
1289 *my= A[1]; | |
1290 return; | |
1291 } | |
1292 }else{ | |
1169 | 1293 const int16_t * C; |
1294 int diagonal_ref; | |
1295 | |
1296 diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2); | |
2967 | 1297 |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
1298 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 | 1299 |
2967 | 1300 if(diagonal_ref == ref){ |
1168 | 1301 *mx= C[0]; |
1302 *my= C[1]; | |
1303 return; | |
1304 } | |
1305 } | |
1306 | |
1307 //RARE | |
1308 pred_motion(h, n, 2, list, ref, mx, my); | |
1309 } | |
1310 | |
1311 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){ | |
1312 const int top_ref = h->ref_cache[0][ scan8[0] - 8 ]; | |
1313 const int left_ref= h->ref_cache[0][ scan8[0] - 1 ]; | |
1314 | |
2392 | 1315 tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y); |
1168 | 1316 |
1317 if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE | |
1318 || (top_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0) | |
1319 || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){ | |
2967 | 1320 |
1168 | 1321 *mx = *my = 0; |
1322 return; | |
1323 } | |
2967 | 1324 |
1168 | 1325 pred_motion(h, 0, 4, 0, 0, mx, my); |
1326 | |
1327 return; | |
1328 } | |
1329 | |
2396 | 1330 static inline void direct_dist_scale_factor(H264Context * const h){ |
1331 const int poc = h->s.current_picture_ptr->poc; | |
1332 const int poc1 = h->ref_list[1][0].poc; | |
1333 int i; | |
1334 for(i=0; i<h->ref_count[0]; i++){ | |
1335 int poc0 = h->ref_list[0][i].poc; | |
1336 int td = clip(poc1 - poc0, -128, 127); | |
1337 if(td == 0 /* FIXME || pic0 is a long-term ref */){ | |
1338 h->dist_scale_factor[i] = 256; | |
1339 }else{ | |
1340 int tb = clip(poc - poc0, -128, 127); | |
4001 | 1341 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2396 | 1342 h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023); |
1343 } | |
1344 } | |
3316 | 1345 if(FRAME_MBAFF){ |
1346 for(i=0; i<h->ref_count[0]; i++){ | |
1347 h->dist_scale_factor_field[2*i] = | |
1348 h->dist_scale_factor_field[2*i+1] = h->dist_scale_factor[i]; | |
1349 } | |
1350 } | |
2396 | 1351 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1352 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
|
1353 MpegEncContext * const s = &h->s; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1354 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
|
1355 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
|
1356 int list, i, j; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1357 if(cur->pict_type == I_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1358 cur->ref_count[0] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1359 if(cur->pict_type != B_TYPE) |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1360 cur->ref_count[1] = 0; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1361 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1362 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
|
1363 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
|
1364 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
|
1365 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1366 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
|
1367 return; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1368 for(list=0; list<2; list++){ |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1369 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
|
1370 const int poc = ref1->ref_poc[list][i]; |
3125 | 1371 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
|
1372 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
|
1373 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
|
1374 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
|
1375 break; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1376 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1377 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1378 } |
3316 | 1379 if(FRAME_MBAFF){ |
1380 for(list=0; list<2; list++){ | |
1381 for(i=0; i<ref1->ref_count[list]; i++){ | |
1382 j = h->map_col_to_list0[list][i]; | |
1383 h->map_col_to_list0_field[list][2*i] = 2*j; | |
1384 h->map_col_to_list0_field[list][2*i+1] = 2*j+1; | |
1385 } | |
1386 } | |
1387 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
1388 } |
2396 | 1389 |
1390 static inline void pred_direct_motion(H264Context * const h, int *mb_type){ | |
1391 MpegEncContext * const s = &h->s; | |
1392 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1393 const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1394 const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1395 const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy]; | |
1396 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
|
1397 const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy]; |
2396 | 1398 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
|
1399 const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy]; |
2396 | 1400 const int is_b8x8 = IS_8X8(*mb_type); |
1401 int sub_mb_type; | |
1402 int i8, i4; | |
1403 | |
3316 | 1404 #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) |
2396 | 1405 if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){ |
1406 /* FIXME save sub mb types from previous frames (or derive from MVs) | |
1407 * so we know exactly what block size to use */ | |
1408 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ | |
2536 | 1409 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
3316 | 1410 }else if(!is_b8x8 && (mb_type_col & MB_TYPE_16x16_OR_INTRA)){ |
2396 | 1411 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ |
1412 *mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ | |
1413 }else{ | |
1414 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ | |
2536 | 1415 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1; |
2396 | 1416 } |
1417 if(!is_b8x8) | |
1418 *mb_type |= MB_TYPE_DIRECT2; | |
3316 | 1419 if(MB_FIELD) |
1420 *mb_type |= MB_TYPE_INTERLACED; | |
2396 | 1421 |
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
|
1422 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 | 1423 |
2396 | 1424 if(h->direct_spatial_mv_pred){ |
1425 int ref[2]; | |
1426 int mv[2][2]; | |
1427 int list; | |
1428 | |
3316 | 1429 /* FIXME interlacing + spatial direct uses wrong colocated block positions */ |
1430 | |
2396 | 1431 /* ref = min(neighbors) */ |
1432 for(list=0; list<2; list++){ | |
1433 int refa = h->ref_cache[list][scan8[0] - 1]; | |
1434 int refb = h->ref_cache[list][scan8[0] - 8]; | |
1435 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; | |
1436 if(refc == -2) | |
1437 refc = h->ref_cache[list][scan8[0] - 8 - 1]; | |
1438 ref[list] = refa; | |
1439 if(ref[list] < 0 || (refb < ref[list] && refb >= 0)) | |
1440 ref[list] = refb; | |
1441 if(ref[list] < 0 || (refc < ref[list] && refc >= 0)) | |
1442 ref[list] = refc; | |
1443 if(ref[list] < 0) | |
1444 ref[list] = -1; | |
1445 } | |
1446 | |
1447 if(ref[0] < 0 && ref[1] < 0){ | |
1448 ref[0] = ref[1] = 0; | |
1449 mv[0][0] = mv[0][1] = | |
1450 mv[1][0] = mv[1][1] = 0; | |
1451 }else{ | |
1452 for(list=0; list<2; list++){ | |
1453 if(ref[list] >= 0) | |
1454 pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]); | |
1455 else | |
1456 mv[list][0] = mv[list][1] = 0; | |
1457 } | |
1458 } | |
1459 | |
1460 if(ref[1] < 0){ | |
1461 *mb_type &= ~MB_TYPE_P0L1; | |
1462 sub_mb_type &= ~MB_TYPE_P0L1; | |
1463 }else if(ref[0] < 0){ | |
1464 *mb_type &= ~MB_TYPE_P0L0; | |
1465 sub_mb_type &= ~MB_TYPE_P0L0; | |
1466 } | |
1467 | |
1468 if(IS_16X16(*mb_type)){ | |
3001
b52d8ee430f6
fix some potential arithmetic overflows in pred_direct_motion() and
lorenm
parents:
2979
diff
changeset
|
1469 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
|
1470 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); |
2967 | 1471 if(!IS_INTRA(mb_type_col) |
4001 | 1472 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) |
1473 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 | |
2834 | 1474 && (h->x264_build>33 || !h->x264_build)))){ |
2396 | 1475 if(ref[0] > 0) |
1476 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1477 else | |
1478 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1479 if(ref[1] > 0) | |
1480 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1481 else | |
1482 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1483 }else{ | |
1484 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4); | |
1485 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4); | |
1486 } | |
1487 }else{ | |
1488 for(i8=0; i8<4; i8++){ | |
1489 const int x8 = i8&1; | |
1490 const int y8 = i8>>1; | |
2967 | 1491 |
2396 | 1492 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1493 continue; | |
1494 h->sub_mb_type[i8] = sub_mb_type; | |
2967 | 1495 |
2396 | 1496 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4); |
1497 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
|
1498 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
|
1499 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); |
2967 | 1500 |
2396 | 1501 /* col_zero_flag */ |
2967 | 1502 if(!IS_INTRA(mb_type_col) && ( l1ref0[x8 + y8*h->b8_stride] == 0 |
1503 || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0 | |
2834 | 1504 && (h->x264_build>33 || !h->x264_build)))){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1505 const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1; |
3002 | 1506 if(IS_SUB_8X8(sub_mb_type)){ |
1507 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
4001 | 1508 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
3002 | 1509 if(ref[0] == 0) |
1510 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1511 if(ref[1] == 0) | |
1512 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1513 } | |
1514 }else | |
2396 | 1515 for(i4=0; i4<4; i4++){ |
2808
932ec96933f5
fixing colocated mv if colocated block is L1 predicted
michael
parents:
2803
diff
changeset
|
1516 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
4001 | 1517 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ |
2396 | 1518 if(ref[0] == 0) |
1519 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0; | |
1520 if(ref[1] == 0) | |
1521 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0; | |
1522 } | |
1523 } | |
1524 } | |
1525 } | |
1526 } | |
1527 }else{ /* direct temporal mv pred */ | |
3316 | 1528 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; |
1529 const int *dist_scale_factor = h->dist_scale_factor; | |
1530 | |
1531 if(FRAME_MBAFF){ | |
1532 if(IS_INTERLACED(*mb_type)){ | |
1533 map_col_to_list0[0] = h->map_col_to_list0_field[0]; | |
1534 map_col_to_list0[1] = h->map_col_to_list0_field[1]; | |
1535 dist_scale_factor = h->dist_scale_factor_field; | |
1536 } | |
1537 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col)){ | |
1538 /* FIXME assumes direct_8x8_inference == 1 */ | |
1539 const int pair_xy = s->mb_x + (s->mb_y&~1)*s->mb_stride; | |
1540 int mb_types_col[2]; | |
1541 int y_shift; | |
1542 | |
1543 *mb_type = MB_TYPE_8x8|MB_TYPE_L0L1 | |
1544 | (is_b8x8 ? 0 : MB_TYPE_DIRECT2) | |
1545 | (*mb_type & MB_TYPE_INTERLACED); | |
1546 sub_mb_type = MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_16x16; | |
1547 | |
1548 if(IS_INTERLACED(*mb_type)){ | |
1549 /* frame to field scaling */ | |
1550 mb_types_col[0] = h->ref_list[1][0].mb_type[pair_xy]; | |
1551 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1552 if(s->mb_y&1){ | |
1553 l1ref0 -= 2*h->b8_stride; | |
1554 l1ref1 -= 2*h->b8_stride; | |
1555 l1mv0 -= 4*h->b_stride; | |
1556 l1mv1 -= 4*h->b_stride; | |
1557 } | |
1558 y_shift = 0; | |
1559 | |
1560 if( (mb_types_col[0] & MB_TYPE_16x16_OR_INTRA) | |
1561 && (mb_types_col[1] & MB_TYPE_16x16_OR_INTRA) | |
1562 && !is_b8x8) | |
1563 *mb_type |= MB_TYPE_16x8; | |
1564 else | |
1565 *mb_type |= MB_TYPE_8x8; | |
1566 }else{ | |
1567 /* field to frame scaling */ | |
1568 /* col_mb_y = (mb_y&~1) + (topAbsDiffPOC < bottomAbsDiffPOC ? 0 : 1) | |
1569 * but in MBAFF, top and bottom POC are equal */ | |
1570 int dy = (s->mb_y&1) ? 1 : 2; | |
1571 mb_types_col[0] = | |
1572 mb_types_col[1] = h->ref_list[1][0].mb_type[pair_xy+s->mb_stride]; | |
1573 l1ref0 += dy*h->b8_stride; | |
1574 l1ref1 += dy*h->b8_stride; | |
1575 l1mv0 += 2*dy*h->b_stride; | |
1576 l1mv1 += 2*dy*h->b_stride; | |
1577 y_shift = 2; | |
1578 | |
1579 if((mb_types_col[0] & (MB_TYPE_16x16_OR_INTRA|MB_TYPE_16x8)) | |
1580 && !is_b8x8) | |
1581 *mb_type |= MB_TYPE_16x16; | |
1582 else | |
1583 *mb_type |= MB_TYPE_8x8; | |
1584 } | |
1585 | |
1586 for(i8=0; i8<4; i8++){ | |
1587 const int x8 = i8&1; | |
1588 const int y8 = i8>>1; | |
1589 int ref0, scale; | |
1590 const int16_t (*l1mv)[2]= l1mv0; | |
1591 | |
1592 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) | |
1593 continue; | |
1594 h->sub_mb_type[i8] = sub_mb_type; | |
1595 | |
1596 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1597 if(IS_INTRA(mb_types_col[y8])){ | |
1598 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1599 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1600 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1601 continue; | |
1602 } | |
1603 | |
1604 ref0 = l1ref0[x8 + (y8*2>>y_shift)*h->b8_stride]; | |
1605 if(ref0 >= 0) | |
1606 ref0 = map_col_to_list0[0][ref0*2>>y_shift]; | |
1607 else{ | |
1608 ref0 = map_col_to_list0[1][l1ref1[x8 + (y8*2>>y_shift)*h->b8_stride]*2>>y_shift]; | |
1609 l1mv= l1mv1; | |
1610 } | |
1611 scale = dist_scale_factor[ref0]; | |
1612 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); | |
1613 | |
1614 { | |
1615 const int16_t *mv_col = l1mv[x8*3 + (y8*6>>y_shift)*h->b_stride]; | |
1616 int my_col = (mv_col[1]<<y_shift)/2; | |
1617 int mx = (scale * mv_col[0] + 128) >> 8; | |
1618 int my = (scale * my_col + 128) >> 8; | |
1619 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); | |
1620 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); | |
1621 } | |
1622 } | |
1623 return; | |
1624 } | |
1625 } | |
1626 | |
1627 /* one-to-one mv scaling */ | |
1628 | |
2396 | 1629 if(IS_16X16(*mb_type)){ |
1630 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); | |
1631 if(IS_INTRA(mb_type_col)){ | |
1632 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
1633 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1634 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1635 }else{ | |
3316 | 1636 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0]] |
1637 : map_col_to_list0[1][l1ref1[0]]; | |
1638 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
|
1639 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; |
2396 | 1640 int mv_l0[2]; |
3316 | 1641 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1642 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1643 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1); |
1644 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4); | |
1645 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); | |
1646 } | |
1647 }else{ | |
1648 for(i8=0; i8<4; i8++){ | |
1649 const int x8 = i8&1; | |
1650 const int y8 = i8>>1; | |
3316 | 1651 int ref0, scale; |
2834 | 1652 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
|
1653 |
2396 | 1654 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) |
1655 continue; | |
1656 h->sub_mb_type[i8] = sub_mb_type; | |
3316 | 1657 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); |
2396 | 1658 if(IS_INTRA(mb_type_col)){ |
1659 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); | |
1660 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1661 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); | |
1662 continue; | |
1663 } | |
2967 | 1664 |
2396 | 1665 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
|
1666 if(ref0 >= 0) |
3316 | 1667 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
|
1668 else{ |
3316 | 1669 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
|
1670 l1mv= l1mv1; |
75400dfbe117
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
michael
parents:
2808
diff
changeset
|
1671 } |
3316 | 1672 scale = dist_scale_factor[ref0]; |
2967 | 1673 |
2396 | 1674 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); |
3002 | 1675 if(IS_SUB_8X8(sub_mb_type)){ |
1676 const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride]; | |
3316 | 1677 int mx = (scale * mv_col[0] + 128) >> 8; |
1678 int my = (scale * mv_col[1] + 128) >> 8; | |
3002 | 1679 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); |
1680 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); | |
1681 }else | |
2396 | 1682 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
|
1683 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride]; |
2396 | 1684 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; |
3316 | 1685 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; |
1686 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; | |
2396 | 1687 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = |
1688 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); | |
1689 } | |
1690 } | |
1691 } | |
1692 } | |
1693 } | |
1694 | |
1168 | 1695 static inline void write_back_motion(H264Context *h, int mb_type){ |
1696 MpegEncContext * const s = &h->s; | |
1697 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; | |
1698 const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride; | |
1699 int list; | |
1700 | |
3219
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1701 if(!USES_LIST(mb_type, 0)) |
cf233efbcece
10l in 1.199 (write_back_motion with B-pyramid + spatial)
lorenm
parents:
3215
diff
changeset
|
1702 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
|
1703 |
1168 | 1704 for(list=0; list<2; list++){ |
1705 int y; | |
3212 | 1706 if(!USES_LIST(mb_type, list)) |
2396 | 1707 continue; |
2967 | 1708 |
1168 | 1709 for(y=0; y<4; y++){ |
1710 *(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]; | |
1711 *(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]; | |
1712 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1713 if( h->pps.cabac ) { |
3927 | 1714 if(IS_SKIP(mb_type)) |
1715 fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4); | |
1716 else | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1717 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
|
1718 *(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
|
1719 *(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
|
1720 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
1721 } |
3212 | 1722 |
1723 { | |
3776 | 1724 int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy]; |
3212 | 1725 ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]]; |
1726 ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]]; | |
1727 ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]]; | |
1728 ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]]; | |
1168 | 1729 } |
1730 } | |
2967 | 1731 |
2396 | 1732 if(h->slice_type == B_TYPE && h->pps.cabac){ |
1733 if(IS_8X8(mb_type)){ | |
3212 | 1734 uint8_t *direct_table = &h->direct_table[b8_xy]; |
1735 direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0; | |
1736 direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0; | |
1737 direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0; | |
2396 | 1738 } |
1739 } | |
1168 | 1740 } |
1741 | |
1742 /** | |
1743 * Decodes a network abstraction layer unit. | |
1744 * @param consumed is the number of bytes used as input | |
1745 * @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
|
1746 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? |
2967 | 1747 * @returns decoded bytes, might be src+1 if no escapes |
1168 | 1748 */ |
1749 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){ | |
1750 int i, si, di; | |
1751 uint8_t *dst; | |
1752 | |
2979 | 1753 // src[0]&0x80; //forbidden bit |
1168 | 1754 h->nal_ref_idc= src[0]>>5; |
1755 h->nal_unit_type= src[0]&0x1F; | |
1756 | |
1757 src++; length--; | |
2967 | 1758 #if 0 |
1168 | 1759 for(i=0; i<length; i++) |
1760 printf("%2X ", src[i]); | |
1761 #endif | |
1762 for(i=0; i+1<length; i+=2){ | |
1763 if(src[i]) continue; | |
1764 if(i>0 && src[i-1]==0) i--; | |
1765 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ | |
1766 if(src[i+2]!=3){ | |
1767 /* startcode, so we must be past the end */ | |
1768 length=i; | |
1769 } | |
1770 break; | |
1771 } | |
1772 } | |
1773 | |
1774 if(i>=length-1){ //no escaped 0 | |
1775 *dst_length= length; | |
1776 *consumed= length+1; //+1 for the header | |
2967 | 1777 return src; |
1168 | 1778 } |
1779 | |
1780 h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length); | |
1781 dst= h->rbsp_buffer; | |
1782 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1783 //printf("decoding esc\n"); |
1168 | 1784 si=di=0; |
2967 | 1785 while(si<length){ |
1168 | 1786 //remove escapes (very rare 1:2^22) |
1787 if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){ | |
1788 if(src[si+2]==3){ //escape | |
1789 dst[di++]= 0; | |
1790 dst[di++]= 0; | |
1791 si+=3; | |
1957
54411768fa38
h264 nal decoding fix by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1956
diff
changeset
|
1792 continue; |
1168 | 1793 }else //next start code |
1794 break; | |
1795 } | |
1796 | |
1797 dst[di++]= src[si++]; | |
1798 } | |
1799 | |
1800 *dst_length= di; | |
1801 *consumed= si + 1;//+1 for the header | |
1802 //FIXME store exact number of bits in the getbitcontext (its needed for decoding) | |
1803 return dst; | |
1804 } | |
1805 | |
1806 /** | |
1807 * identifies the exact end of the bitstream | |
1808 * @return the length of the trailing, or 0 if damaged | |
1809 */ | |
1810 static int decode_rbsp_trailing(uint8_t *src){ | |
1811 int v= *src; | |
1812 int r; | |
1813 | |
1170 | 1814 tprintf("rbsp trailing %X\n", v); |
1168 | 1815 |
1816 for(r=1; r<9; r++){ | |
1817 if(v&1) return r; | |
1818 v>>=1; | |
1819 } | |
1820 return 0; | |
1821 } | |
1822 | |
1823 /** | |
1824 * idct tranforms the 16 dc values and dequantize them. | |
1825 * @param qp quantization parameter | |
1826 */ | |
2919 | 1827 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1828 #define stride 16 |
1829 int i; | |
1830 int temp[16]; //FIXME check if this is a good idea | |
1831 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1832 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1833 | |
1834 //memset(block, 64, 2*256); | |
1835 //return; | |
1836 for(i=0; i<4; i++){ | |
1837 const int offset= y_offset[i]; | |
1838 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1839 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1840 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1841 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1842 | |
1843 temp[4*i+0]= z0+z3; | |
1844 temp[4*i+1]= z1+z2; | |
1845 temp[4*i+2]= z1-z2; | |
1846 temp[4*i+3]= z0-z3; | |
1847 } | |
1848 | |
1849 for(i=0; i<4; i++){ | |
1850 const int offset= x_offset[i]; | |
1851 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1852 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1853 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1854 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1855 | |
2919 | 1856 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual |
1857 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); | |
1858 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); | |
1859 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); | |
1168 | 1860 } |
1861 } | |
1862 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1863 #if 0 |
1168 | 1864 /** |
1865 * dct tranforms the 16 dc values. | |
1866 * @param qp quantization parameter ??? FIXME | |
1867 */ | |
1868 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ | |
1869 // const int qmul= dequant_coeff[qp][0]; | |
1870 int i; | |
1871 int temp[16]; //FIXME check if this is a good idea | |
1872 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; | |
1873 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; | |
1874 | |
1875 for(i=0; i<4; i++){ | |
1876 const int offset= y_offset[i]; | |
1877 const int z0= block[offset+stride*0] + block[offset+stride*4]; | |
1878 const int z1= block[offset+stride*0] - block[offset+stride*4]; | |
1879 const int z2= block[offset+stride*1] - block[offset+stride*5]; | |
1880 const int z3= block[offset+stride*1] + block[offset+stride*5]; | |
1881 | |
1882 temp[4*i+0]= z0+z3; | |
1883 temp[4*i+1]= z1+z2; | |
1884 temp[4*i+2]= z1-z2; | |
1885 temp[4*i+3]= z0-z3; | |
1886 } | |
1887 | |
1888 for(i=0; i<4; i++){ | |
1889 const int offset= x_offset[i]; | |
1890 const int z0= temp[4*0+i] + temp[4*2+i]; | |
1891 const int z1= temp[4*0+i] - temp[4*2+i]; | |
1892 const int z2= temp[4*1+i] - temp[4*3+i]; | |
1893 const int z3= temp[4*1+i] + temp[4*3+i]; | |
1894 | |
1895 block[stride*0 +offset]= (z0 + z3)>>1; | |
1896 block[stride*2 +offset]= (z1 + z2)>>1; | |
1897 block[stride*8 +offset]= (z1 - z2)>>1; | |
1898 block[stride*10+offset]= (z0 - z3)>>1; | |
1899 } | |
1900 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1901 #endif |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1902 |
1168 | 1903 #undef xStride |
1904 #undef stride | |
1905 | |
2919 | 1906 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ |
1168 | 1907 const int stride= 16*2; |
1908 const int xStride= 16; | |
1909 int a,b,c,d,e; | |
1910 | |
1911 a= block[stride*0 + xStride*0]; | |
1912 b= block[stride*0 + xStride*1]; | |
1913 c= block[stride*1 + xStride*0]; | |
1914 d= block[stride*1 + xStride*1]; | |
1915 | |
1916 e= a-b; | |
1917 a= a+b; | |
1918 b= c-d; | |
1919 c= c+d; | |
1920 | |
2919 | 1921 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; |
1922 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; | |
1923 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; | |
1924 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; | |
1168 | 1925 } |
1926 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1927 #if 0 |
1168 | 1928 static void chroma_dc_dct_c(DCTELEM *block){ |
1929 const int stride= 16*2; | |
1930 const int xStride= 16; | |
1931 int a,b,c,d,e; | |
1932 | |
1933 a= block[stride*0 + xStride*0]; | |
1934 b= block[stride*0 + xStride*1]; | |
1935 c= block[stride*1 + xStride*0]; | |
1936 d= block[stride*1 + xStride*1]; | |
1937 | |
1938 e= a-b; | |
1939 a= a+b; | |
1940 b= c-d; | |
1941 c= c+d; | |
1942 | |
1943 block[stride*0 + xStride*0]= (a+c); | |
1944 block[stride*0 + xStride*1]= (e+b); | |
1945 block[stride*1 + xStride*0]= (a-c); | |
1946 block[stride*1 + xStride*1]= (e-b); | |
1947 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
1948 #endif |
1168 | 1949 |
1950 /** | |
1951 * gets the chroma qp. | |
1952 */ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1953 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){ |
2967 | 1954 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
1955 return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)]; |
1168 | 1956 } |
1957 | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
1958 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close |
1168 | 1959 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away) |
1960 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){ | |
1961 int i; | |
1962 const int * const quant_table= quant_coeff[qscale]; | |
1963 const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6; | |
1964 const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1; | |
1965 const unsigned int threshold2= (threshold1<<1); | |
1966 int last_non_zero; | |
1967 | |
1968 if(seperate_dc){ | |
1969 if(qscale<=18){ | |
1970 //avoid overflows | |
1971 const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6; | |
1972 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1; | |
1973 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1974 | |
1975 int level= block[0]*quant_coeff[qscale+18][0]; | |
1976 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1977 if(level>0){ | |
1978 level= (dc_bias + level)>>(QUANT_SHIFT-2); | |
1979 block[0]= level; | |
1980 }else{ | |
1981 level= (dc_bias - level)>>(QUANT_SHIFT-2); | |
1982 block[0]= -level; | |
1983 } | |
1984 // last_non_zero = i; | |
1985 }else{ | |
1986 block[0]=0; | |
1987 } | |
1988 }else{ | |
1989 const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6; | |
1990 const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1; | |
1991 const unsigned int dc_threshold2= (dc_threshold1<<1); | |
1992 | |
1993 int level= block[0]*quant_table[0]; | |
1994 if(((unsigned)(level+dc_threshold1))>dc_threshold2){ | |
1995 if(level>0){ | |
1996 level= (dc_bias + level)>>(QUANT_SHIFT+1); | |
1997 block[0]= level; | |
1998 }else{ | |
1999 level= (dc_bias - level)>>(QUANT_SHIFT+1); | |
2000 block[0]= -level; | |
2001 } | |
2002 // last_non_zero = i; | |
2003 }else{ | |
2004 block[0]=0; | |
2005 } | |
2006 } | |
2007 last_non_zero= 0; | |
2008 i=1; | |
2009 }else{ | |
2010 last_non_zero= -1; | |
2011 i=0; | |
2012 } | |
2013 | |
2014 for(; i<16; i++){ | |
2015 const int j= scantable[i]; | |
2016 int level= block[j]*quant_table[j]; | |
2017 | |
2018 // if( bias+level >= (1<<(QMAT_SHIFT - 3)) | |
2019 // || bias-level >= (1<<(QMAT_SHIFT - 3))){ | |
2020 if(((unsigned)(level+threshold1))>threshold2){ | |
2021 if(level>0){ | |
2022 level= (bias + level)>>QUANT_SHIFT; | |
2023 block[j]= level; | |
2024 }else{ | |
2025 level= (bias - level)>>QUANT_SHIFT; | |
2026 block[j]= -level; | |
2027 } | |
2028 last_non_zero = i; | |
2029 }else{ | |
2030 block[j]=0; | |
2031 } | |
2032 } | |
2033 | |
2034 return last_non_zero; | |
2035 } | |
2036 | |
2037 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){ | |
2038 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2039 ((uint32_t*)(src+0*stride))[0]= a; | |
2040 ((uint32_t*)(src+1*stride))[0]= a; | |
2041 ((uint32_t*)(src+2*stride))[0]= a; | |
2042 ((uint32_t*)(src+3*stride))[0]= a; | |
2043 } | |
2044 | |
2045 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){ | |
2046 ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101; | |
2047 ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101; | |
2048 ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101; | |
2049 ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101; | |
2050 } | |
2051 | |
2052 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2053 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] | |
2054 + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3; | |
2967 | 2055 |
2056 ((uint32_t*)(src+0*stride))[0]= | |
2057 ((uint32_t*)(src+1*stride))[0]= | |
2058 ((uint32_t*)(src+2*stride))[0]= | |
2059 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2060 } |
2061 | |
2062 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2063 const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2; | |
2967 | 2064 |
2065 ((uint32_t*)(src+0*stride))[0]= | |
2066 ((uint32_t*)(src+1*stride))[0]= | |
2067 ((uint32_t*)(src+2*stride))[0]= | |
2068 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2069 } |
2070 | |
2071 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2072 const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2; | |
2967 | 2073 |
2074 ((uint32_t*)(src+0*stride))[0]= | |
2075 ((uint32_t*)(src+1*stride))[0]= | |
2076 ((uint32_t*)(src+2*stride))[0]= | |
2077 ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101; | |
1168 | 2078 } |
2079 | |
2080 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2081 ((uint32_t*)(src+0*stride))[0]= |
2082 ((uint32_t*)(src+1*stride))[0]= | |
2083 ((uint32_t*)(src+2*stride))[0]= | |
1168 | 2084 ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U; |
2085 } | |
2086 | |
2087 | |
2088 #define LOAD_TOP_RIGHT_EDGE\ | |
2089 const int t4= topright[0];\ | |
2090 const int t5= topright[1];\ | |
2091 const int t6= topright[2];\ | |
2092 const int t7= topright[3];\ | |
2093 | |
2094 #define LOAD_LEFT_EDGE\ | |
2095 const int l0= src[-1+0*stride];\ | |
2096 const int l1= src[-1+1*stride];\ | |
2097 const int l2= src[-1+2*stride];\ | |
2098 const int l3= src[-1+3*stride];\ | |
2099 | |
2100 #define LOAD_TOP_EDGE\ | |
2101 const int t0= src[ 0-1*stride];\ | |
2102 const int t1= src[ 1-1*stride];\ | |
2103 const int t2= src[ 2-1*stride];\ | |
2104 const int t3= src[ 3-1*stride];\ | |
2105 | |
2106 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2107 const int lt= src[-1-1*stride]; | |
2108 LOAD_TOP_EDGE | |
2109 LOAD_LEFT_EDGE | |
2110 | |
2967 | 2111 src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2; |
1168 | 2112 src[0+2*stride]= |
2967 | 2113 src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2; |
1168 | 2114 src[0+1*stride]= |
2115 src[1+2*stride]= | |
2967 | 2116 src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2; |
1168 | 2117 src[0+0*stride]= |
2118 src[1+1*stride]= | |
2119 src[2+2*stride]= | |
2967 | 2120 src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2; |
1168 | 2121 src[1+0*stride]= |
2122 src[2+1*stride]= | |
2123 src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2124 src[2+0*stride]= | |
2125 src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2126 src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
1282 | 2127 } |
1168 | 2128 |
2129 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2130 LOAD_TOP_EDGE |
2131 LOAD_TOP_RIGHT_EDGE | |
2132 // LOAD_LEFT_EDGE | |
1168 | 2133 |
2134 src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2; | |
2135 src[1+0*stride]= | |
2136 src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2; | |
2137 src[2+0*stride]= | |
2138 src[1+1*stride]= | |
2139 src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2; | |
2140 src[3+0*stride]= | |
2141 src[2+1*stride]= | |
2142 src[1+2*stride]= | |
2143 src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2; | |
2144 src[3+1*stride]= | |
2145 src[2+2*stride]= | |
2146 src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2; | |
2147 src[3+2*stride]= | |
2148 src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2; | |
2149 src[3+3*stride]=(t6 + 3*t7 + 2)>>2; | |
1282 | 2150 } |
1168 | 2151 |
2152 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){ | |
2153 const int lt= src[-1-1*stride]; | |
2967 | 2154 LOAD_TOP_EDGE |
2155 LOAD_LEFT_EDGE | |
1168 | 2156 const __attribute__((unused)) int unu= l3; |
2157 | |
2158 src[0+0*stride]= | |
2159 src[1+2*stride]=(lt + t0 + 1)>>1; | |
2160 src[1+0*stride]= | |
2161 src[2+2*stride]=(t0 + t1 + 1)>>1; | |
2162 src[2+0*stride]= | |
2163 src[3+2*stride]=(t1 + t2 + 1)>>1; | |
2164 src[3+0*stride]=(t2 + t3 + 1)>>1; | |
2165 src[0+1*stride]= | |
2166 src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2167 src[1+1*stride]= | |
2168 src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2169 src[2+1*stride]= | |
2170 src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2171 src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2172 src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2173 src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
1282 | 2174 } |
1168 | 2175 |
2176 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2177 LOAD_TOP_EDGE |
2178 LOAD_TOP_RIGHT_EDGE | |
1168 | 2179 const __attribute__((unused)) int unu= t7; |
2180 | |
2181 src[0+0*stride]=(t0 + t1 + 1)>>1; | |
2182 src[1+0*stride]= | |
2183 src[0+2*stride]=(t1 + t2 + 1)>>1; | |
2184 src[2+0*stride]= | |
2185 src[1+2*stride]=(t2 + t3 + 1)>>1; | |
2186 src[3+0*stride]= | |
2187 src[2+2*stride]=(t3 + t4+ 1)>>1; | |
2188 src[3+2*stride]=(t4 + t5+ 1)>>1; | |
2189 src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2190 src[1+1*stride]= | |
2191 src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2; | |
2192 src[2+1*stride]= | |
2193 src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2; | |
2194 src[3+1*stride]= | |
2195 src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2; | |
2196 src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2; | |
1282 | 2197 } |
1168 | 2198 |
2199 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){ | |
2967 | 2200 LOAD_LEFT_EDGE |
1168 | 2201 |
2202 src[0+0*stride]=(l0 + l1 + 1)>>1; | |
2203 src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2204 src[2+0*stride]= | |
2205 src[0+1*stride]=(l1 + l2 + 1)>>1; | |
2206 src[3+0*stride]= | |
2207 src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
2208 src[2+1*stride]= | |
2209 src[0+2*stride]=(l2 + l3 + 1)>>1; | |
2210 src[3+1*stride]= | |
2211 src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2; | |
2212 src[3+2*stride]= | |
2213 src[1+3*stride]= | |
2214 src[0+3*stride]= | |
2215 src[2+2*stride]= | |
2216 src[2+3*stride]= | |
2217 src[3+3*stride]=l3; | |
1282 | 2218 } |
2967 | 2219 |
1168 | 2220 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){ |
2221 const int lt= src[-1-1*stride]; | |
2967 | 2222 LOAD_TOP_EDGE |
2223 LOAD_LEFT_EDGE | |
1168 | 2224 const __attribute__((unused)) int unu= t3; |
2225 | |
2226 src[0+0*stride]= | |
2227 src[2+1*stride]=(lt + l0 + 1)>>1; | |
2228 src[1+0*stride]= | |
2229 src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2; | |
2230 src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2; | |
2231 src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2; | |
2232 src[0+1*stride]= | |
2233 src[2+2*stride]=(l0 + l1 + 1)>>1; | |
2234 src[1+1*stride]= | |
2235 src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2; | |
2236 src[0+2*stride]= | |
2237 src[2+3*stride]=(l1 + l2+ 1)>>1; | |
2238 src[1+2*stride]= | |
2239 src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2; | |
2240 src[0+3*stride]=(l2 + l3 + 1)>>1; | |
2241 src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2; | |
1282 | 2242 } |
1168 | 2243 |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2244 void ff_pred16x16_vertical_c(uint8_t *src, int stride){ |
1168 | 2245 int i; |
2246 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2247 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2248 const uint32_t c= ((uint32_t*)(src-stride))[2]; | |
2249 const uint32_t d= ((uint32_t*)(src-stride))[3]; | |
2967 | 2250 |
1168 | 2251 for(i=0; i<16; i++){ |
2252 ((uint32_t*)(src+i*stride))[0]= a; | |
2253 ((uint32_t*)(src+i*stride))[1]= b; | |
2254 ((uint32_t*)(src+i*stride))[2]= c; | |
2255 ((uint32_t*)(src+i*stride))[3]= d; | |
2256 } | |
2257 } | |
2258 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2259 void ff_pred16x16_horizontal_c(uint8_t *src, int stride){ |
1168 | 2260 int i; |
2261 | |
2262 for(i=0; i<16; i++){ | |
2263 ((uint32_t*)(src+i*stride))[0]= | |
2264 ((uint32_t*)(src+i*stride))[1]= | |
2265 ((uint32_t*)(src+i*stride))[2]= | |
2266 ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101; | |
2267 } | |
2268 } | |
2269 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2270 void ff_pred16x16_dc_c(uint8_t *src, int stride){ |
1168 | 2271 int i, dc=0; |
2272 | |
2273 for(i=0;i<16; i++){ | |
2274 dc+= src[-1+i*stride]; | |
2275 } | |
2967 | 2276 |
1168 | 2277 for(i=0;i<16; i++){ |
2278 dc+= src[i-stride]; | |
2279 } | |
2280 | |
2281 dc= 0x01010101*((dc + 16)>>5); | |
2282 | |
2283 for(i=0; i<16; i++){ | |
2284 ((uint32_t*)(src+i*stride))[0]= | |
2285 ((uint32_t*)(src+i*stride))[1]= | |
2286 ((uint32_t*)(src+i*stride))[2]= | |
2287 ((uint32_t*)(src+i*stride))[3]= dc; | |
2288 } | |
2289 } | |
2290 | |
2291 static void pred16x16_left_dc_c(uint8_t *src, int stride){ | |
2292 int i, dc=0; | |
2293 | |
2294 for(i=0;i<16; i++){ | |
2295 dc+= src[-1+i*stride]; | |
2296 } | |
2967 | 2297 |
1168 | 2298 dc= 0x01010101*((dc + 8)>>4); |
2299 | |
2300 for(i=0; i<16; i++){ | |
2301 ((uint32_t*)(src+i*stride))[0]= | |
2302 ((uint32_t*)(src+i*stride))[1]= | |
2303 ((uint32_t*)(src+i*stride))[2]= | |
2304 ((uint32_t*)(src+i*stride))[3]= dc; | |
2305 } | |
2306 } | |
2307 | |
2308 static void pred16x16_top_dc_c(uint8_t *src, int stride){ | |
2309 int i, dc=0; | |
2310 | |
2311 for(i=0;i<16; i++){ | |
2312 dc+= src[i-stride]; | |
2313 } | |
2314 dc= 0x01010101*((dc + 8)>>4); | |
2315 | |
2316 for(i=0; i<16; i++){ | |
2317 ((uint32_t*)(src+i*stride))[0]= | |
2318 ((uint32_t*)(src+i*stride))[1]= | |
2319 ((uint32_t*)(src+i*stride))[2]= | |
2320 ((uint32_t*)(src+i*stride))[3]= dc; | |
2321 } | |
2322 } | |
2323 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2324 void ff_pred16x16_128_dc_c(uint8_t *src, int stride){ |
1168 | 2325 int i; |
2326 | |
2327 for(i=0; i<16; i++){ | |
2328 ((uint32_t*)(src+i*stride))[0]= | |
2329 ((uint32_t*)(src+i*stride))[1]= | |
2330 ((uint32_t*)(src+i*stride))[2]= | |
2331 ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U; | |
2332 } | |
2333 } | |
2334 | |
1234 | 2335 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
|
2336 int i, j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2337 int a; |
4176 | 2338 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
|
2339 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
|
2340 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
|
2341 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
|
2342 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
|
2343 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
|
2344 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
|
2345 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2346 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
|
2347 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
|
2348 } |
1234 | 2349 if(svq3){ |
2350 H = ( 5*(H/4) ) / 16; | |
2351 V = ( 5*(V/4) ) / 16; | |
1330
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2352 |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2353 /* required for 100% accuracy */ |
c05c381a9c47
- fix PLANE_PRED8x8 prediction (H/V are swapped, this is correct!)
tmmm
parents:
1322
diff
changeset
|
2354 i = H; H = V; V = i; |
1234 | 2355 }else{ |
2356 H = ( 5*H+32 ) >> 6; | |
2357 V = ( 5*V+32 ) >> 6; | |
2358 } | |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2359 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2360 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
|
2361 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
|
2362 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2363 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2364 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
|
2365 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
|
2366 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
|
2367 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
|
2368 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
|
2369 b += 4*H; |
1168 | 2370 } |
1184
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2371 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2372 } |
1168 | 2373 } |
2374 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2375 void ff_pred16x16_plane_c(uint8_t *src, int stride){ |
1234 | 2376 pred16x16_plane_compat_c(src, stride, 0); |
2377 } | |
2378 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2379 void ff_pred8x8_vertical_c(uint8_t *src, int stride){ |
1168 | 2380 int i; |
2381 const uint32_t a= ((uint32_t*)(src-stride))[0]; | |
2382 const uint32_t b= ((uint32_t*)(src-stride))[1]; | |
2967 | 2383 |
1168 | 2384 for(i=0; i<8; i++){ |
2385 ((uint32_t*)(src+i*stride))[0]= a; | |
2386 ((uint32_t*)(src+i*stride))[1]= b; | |
2387 } | |
2388 } | |
2389 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2390 void ff_pred8x8_horizontal_c(uint8_t *src, int stride){ |
1168 | 2391 int i; |
2392 | |
2393 for(i=0; i<8; i++){ | |
2394 ((uint32_t*)(src+i*stride))[0]= | |
2395 ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101; | |
2396 } | |
2397 } | |
2398 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2399 void ff_pred8x8_128_dc_c(uint8_t *src, int stride){ |
1168 | 2400 int i; |
2401 | |
2755 | 2402 for(i=0; i<8; i++){ |
2967 | 2403 ((uint32_t*)(src+i*stride))[0]= |
1168 | 2404 ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U; |
2405 } | |
2406 } | |
2407 | |
2408 static void pred8x8_left_dc_c(uint8_t *src, int stride){ | |
2409 int i; | |
2410 int dc0, dc2; | |
2411 | |
2412 dc0=dc2=0; | |
2413 for(i=0;i<4; i++){ | |
2414 dc0+= src[-1+i*stride]; | |
2415 dc2+= src[-1+(i+4)*stride]; | |
2416 } | |
2417 dc0= 0x01010101*((dc0 + 2)>>2); | |
2418 dc2= 0x01010101*((dc2 + 2)>>2); | |
2419 | |
2420 for(i=0; i<4; i++){ | |
2421 ((uint32_t*)(src+i*stride))[0]= | |
2422 ((uint32_t*)(src+i*stride))[1]= dc0; | |
2423 } | |
2424 for(i=4; i<8; i++){ | |
2425 ((uint32_t*)(src+i*stride))[0]= | |
2426 ((uint32_t*)(src+i*stride))[1]= dc2; | |
2427 } | |
2428 } | |
2429 | |
2430 static void pred8x8_top_dc_c(uint8_t *src, int stride){ | |
2431 int i; | |
2432 int dc0, dc1; | |
2433 | |
2434 dc0=dc1=0; | |
2435 for(i=0;i<4; i++){ | |
2436 dc0+= src[i-stride]; | |
2437 dc1+= src[4+i-stride]; | |
2438 } | |
2439 dc0= 0x01010101*((dc0 + 2)>>2); | |
2440 dc1= 0x01010101*((dc1 + 2)>>2); | |
2441 | |
2442 for(i=0; i<4; i++){ | |
2443 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2444 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2445 } | |
2446 for(i=4; i<8; i++){ | |
2447 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2448 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2449 } | |
2450 } | |
2451 | |
2452 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2453 void ff_pred8x8_dc_c(uint8_t *src, int stride){ |
1168 | 2454 int i; |
2455 int dc0, dc1, dc2, dc3; | |
2456 | |
2457 dc0=dc1=dc2=0; | |
2458 for(i=0;i<4; i++){ | |
2459 dc0+= src[-1+i*stride] + src[i-stride]; | |
2460 dc1+= src[4+i-stride]; | |
2461 dc2+= src[-1+(i+4)*stride]; | |
2462 } | |
2463 dc3= 0x01010101*((dc1 + dc2 + 4)>>3); | |
2464 dc0= 0x01010101*((dc0 + 4)>>3); | |
2465 dc1= 0x01010101*((dc1 + 2)>>2); | |
2466 dc2= 0x01010101*((dc2 + 2)>>2); | |
2467 | |
2468 for(i=0; i<4; i++){ | |
2469 ((uint32_t*)(src+i*stride))[0]= dc0; | |
2470 ((uint32_t*)(src+i*stride))[1]= dc1; | |
2471 } | |
2472 for(i=4; i<8; i++){ | |
2473 ((uint32_t*)(src+i*stride))[0]= dc2; | |
2474 ((uint32_t*)(src+i*stride))[1]= dc3; | |
2475 } | |
2476 } | |
2477 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
2478 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
|
2479 int j, k; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2480 int a; |
4176 | 2481 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
|
2482 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
|
2483 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
|
2484 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
|
2485 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
|
2486 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
|
2487 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
|
2488 src1 += stride; src2 -= stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2489 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
|
2490 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
|
2491 } |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2492 H = ( 17*H+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2493 V = ( 17*V+16 ) >> 5; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2494 |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2495 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
|
2496 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
|
2497 int b = a; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2498 a += V; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2499 src[0] = cm[ (b ) >> 5 ]; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2500 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
|
2501 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
|
2502 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
|
2503 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
|
2504 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
|
2505 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
|
2506 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
|
2507 src += stride; |
05a2ac8978ad
faster 8x8 & 16x16 plane prediction by skal (massimin at planet-d dot net)
michaelni
parents:
1177
diff
changeset
|
2508 } |
1168 | 2509 } |
2510 | |
2755 | 2511 #define SRC(x,y) src[(x)+(y)*stride] |
2512 #define PL(y) \ | |
2513 const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2; | |
2514 #define PREDICT_8x8_LOAD_LEFT \ | |
2515 const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \ | |
2516 + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \ | |
2517 PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \ | |
2834 | 2518 const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2 |
2755 | 2519 |
2520 #define PT(x) \ | |
2521 const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2522 #define PREDICT_8x8_LOAD_TOP \ | |
2523 const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \ | |
2524 + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \ | |
2525 PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \ | |
2834 | 2526 const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \ |
2757 | 2527 + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2 |
2755 | 2528 |
2529 #define PTR(x) \ | |
2530 t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2; | |
2531 #define PREDICT_8x8_LOAD_TOPRIGHT \ | |
2532 int t8, t9, t10, t11, t12, t13, t14, t15; \ | |
2533 if(has_topright) { \ | |
2534 PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \ | |
2535 t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \ | |
2536 } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1); | |
2537 | |
2538 #define PREDICT_8x8_LOAD_TOPLEFT \ | |
2757 | 2539 const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2 |
2755 | 2540 |
2541 #define PREDICT_8x8_DC(v) \ | |
2542 int y; \ | |
2543 for( y = 0; y < 8; y++ ) { \ | |
2544 ((uint32_t*)src)[0] = \ | |
2545 ((uint32_t*)src)[1] = v; \ | |
2546 src += stride; \ | |
2547 } | |
2548 | |
2549 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2550 { | |
2551 PREDICT_8x8_DC(0x80808080); | |
2552 } | |
2553 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2554 { | |
2555 PREDICT_8x8_LOAD_LEFT; | |
2556 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101; | |
2557 PREDICT_8x8_DC(dc); | |
2558 } | |
2559 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2560 { | |
2561 PREDICT_8x8_LOAD_TOP; | |
2562 const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101; | |
2563 PREDICT_8x8_DC(dc); | |
2564 } | |
2565 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2566 { | |
2567 PREDICT_8x8_LOAD_LEFT; | |
2568 PREDICT_8x8_LOAD_TOP; | |
2569 const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7 | |
2570 +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101; | |
2571 PREDICT_8x8_DC(dc); | |
2572 } | |
2573 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2574 { | |
2575 PREDICT_8x8_LOAD_LEFT; | |
2576 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\ | |
2577 ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y | |
2578 ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7); | |
2579 #undef ROW | |
2580 } | |
2581 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2582 { | |
2583 int y; | |
2584 PREDICT_8x8_LOAD_TOP; | |
2585 src[0] = t0; | |
2586 src[1] = t1; | |
2587 src[2] = t2; | |
2588 src[3] = t3; | |
2589 src[4] = t4; | |
2590 src[5] = t5; | |
2591 src[6] = t6; | |
2592 src[7] = t7; | |
2593 for( y = 1; y < 8; y++ ) | |
2594 *(uint64_t*)(src+y*stride) = *(uint64_t*)src; | |
2595 } | |
2596 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2597 { | |
2598 PREDICT_8x8_LOAD_TOP; | |
2599 PREDICT_8x8_LOAD_TOPRIGHT; | |
2600 SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2601 SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2602 SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2603 SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2604 SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2605 SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2606 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; | |
2607 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; | |
2608 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; | |
2609 SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2610 SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2611 SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2; | |
2612 SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2; | |
2613 SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2; | |
2614 SRC(7,7)= (t14 + 3*t15 + 2) >> 2; | |
2615 } | |
2616 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2617 { | |
2618 PREDICT_8x8_LOAD_TOP; | |
2619 PREDICT_8x8_LOAD_LEFT; | |
2620 PREDICT_8x8_LOAD_TOPLEFT; | |
2621 SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2; | |
2622 SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2623 SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2624 SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2625 SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2626 SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2627 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; | |
2628 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; | |
2629 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; | |
2630 SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2631 SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2632 SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2633 SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2634 SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2635 SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2967 | 2636 |
2755 | 2637 } |
2638 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2639 { | |
2640 PREDICT_8x8_LOAD_TOP; | |
2641 PREDICT_8x8_LOAD_LEFT; | |
2642 PREDICT_8x8_LOAD_TOPLEFT; | |
2643 SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2; | |
2644 SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2; | |
2645 SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2; | |
2646 SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2; | |
2647 SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2; | |
2648 SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2; | |
2649 SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2; | |
2650 SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1; | |
2651 SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2; | |
2652 SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1; | |
2653 SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2654 SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1; | |
2655 SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2656 SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1; | |
2657 SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2658 SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1; | |
2659 SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2660 SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1; | |
2661 SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2662 SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1; | |
2663 SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2664 SRC(7,0)= (t6 + t7 + 1) >> 1; | |
2665 } | |
2666 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2667 { | |
2668 PREDICT_8x8_LOAD_TOP; | |
2669 PREDICT_8x8_LOAD_LEFT; | |
2670 PREDICT_8x8_LOAD_TOPLEFT; | |
2671 SRC(0,7)= (l6 + l7 + 1) >> 1; | |
2672 SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2673 SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1; | |
2674 SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2675 SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1; | |
2676 SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2677 SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1; | |
2678 SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2679 SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1; | |
2680 SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2681 SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1; | |
2682 SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2683 SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1; | |
2684 SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2; | |
2685 SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1; | |
2686 SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2; | |
2687 SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2; | |
2688 SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2; | |
2689 SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2; | |
2690 SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2; | |
2691 SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2; | |
2692 SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2; | |
2693 } | |
2694 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2695 { | |
2696 PREDICT_8x8_LOAD_TOP; | |
2697 PREDICT_8x8_LOAD_TOPRIGHT; | |
2698 SRC(0,0)= (t0 + t1 + 1) >> 1; | |
2699 SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2; | |
2700 SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1; | |
2701 SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2; | |
2702 SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1; | |
2703 SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2; | |
2704 SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1; | |
2705 SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2; | |
2706 SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1; | |
2707 SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2; | |
2708 SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1; | |
2709 SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2; | |
2710 SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1; | |
2711 SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2; | |
2712 SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1; | |
2713 SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2; | |
2714 SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1; | |
2715 SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2; | |
2716 SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1; | |
2717 SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2; | |
2718 SRC(7,6)= (t10 + t11 + 1) >> 1; | |
2719 SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2; | |
2720 } | |
2721 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride) | |
2722 { | |
2723 PREDICT_8x8_LOAD_LEFT; | |
2724 SRC(0,0)= (l0 + l1 + 1) >> 1; | |
2725 SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2; | |
2726 SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1; | |
2727 SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2; | |
2728 SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1; | |
2729 SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2; | |
2730 SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1; | |
2731 SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2; | |
2732 SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1; | |
2733 SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2; | |
2734 SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1; | |
2735 SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2; | |
2736 SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1; | |
2737 SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2; | |
2738 SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)= | |
2739 SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)= | |
2740 SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)= | |
2741 SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7; | |
2742 } | |
2743 #undef PREDICT_8x8_LOAD_LEFT | |
2744 #undef PREDICT_8x8_LOAD_TOP | |
2745 #undef PREDICT_8x8_LOAD_TOPLEFT | |
2746 #undef PREDICT_8x8_LOAD_TOPRIGHT | |
2747 #undef PREDICT_8x8_DC | |
2748 #undef PTR | |
2749 #undef PT | |
2750 #undef PL | |
2751 #undef SRC | |
2752 | |
1168 | 2753 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, |
2754 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2755 int src_x_offset, int src_y_offset, | |
2756 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ | |
2757 MpegEncContext * const s = &h->s; | |
2758 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; | |
3316 | 2759 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; |
1168 | 2760 const int luma_xy= (mx&3) + ((my&3)<<2); |
3316 | 2761 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; |
2762 uint8_t * src_cb, * src_cr; | |
2763 int extra_width= h->emu_edge_width; | |
2764 int extra_height= h->emu_edge_height; | |
1168 | 2765 int emu=0; |
2766 const int full_mx= mx>>2; | |
2767 const int full_my= my>>2; | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2768 const int pic_width = 16*s->mb_width; |
3316 | 2769 const int pic_height = 16*s->mb_height >> MB_MBAFF; |
2967 | 2770 |
3125 | 2771 if(!pic->data[0]) |
2772 return; | |
2967 | 2773 |
1168 | 2774 if(mx&7) extra_width -= 3; |
2775 if(my&7) extra_height -= 3; | |
2967 | 2776 |
2777 if( full_mx < 0-extra_width | |
2778 || full_my < 0-extra_height | |
2779 || full_mx + 16/*FIXME*/ > pic_width + extra_width | |
2861
3b920e274b26
fix emulated edge motion compensation when resolution%16!=0
lorenm
parents:
2846
diff
changeset
|
2780 || full_my + 16/*FIXME*/ > pic_height + extra_height){ |
3316 | 2781 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); |
2782 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; | |
1168 | 2783 emu=1; |
2784 } | |
2967 | 2785 |
3316 | 2786 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? |
1168 | 2787 if(!square){ |
3316 | 2788 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); |
1168 | 2789 } |
2967 | 2790 |
1168 | 2791 if(s->flags&CODEC_FLAG_GRAY) return; |
2967 | 2792 |
3316 | 2793 if(MB_MBAFF){ |
2794 // chroma offset when predicting from a field of opposite parity | |
2795 my += 2 * ((s->mb_y & 1) - (h->ref_cache[list][scan8[n]] & 1)); | |
2796 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); | |
2797 } | |
2798 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
2799 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; | |
1168 | 2800 |
2801 if(emu){ | |
3316 | 2802 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); |
2803 src_cb= s->edge_emu_buffer; | |
2804 } | |
2805 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); | |
2806 | |
2807 if(emu){ | |
2808 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 | 2809 src_cr= s->edge_emu_buffer; |
2810 } | |
3316 | 2811 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); |
1168 | 2812 } |
2813 | |
2415 | 2814 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, |
1168 | 2815 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2816 int x_offset, int y_offset, | |
2817 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2818 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2819 int list0, int list1){ | |
2820 MpegEncContext * const s = &h->s; | |
2821 qpel_mc_func *qpix_op= qpix_put; | |
2822 h264_chroma_mc_func chroma_op= chroma_put; | |
2967 | 2823 |
3316 | 2824 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2825 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2826 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
1168 | 2827 x_offset += 8*s->mb_x; |
3316 | 2828 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2829 |
1168 | 2830 if(list0){ |
1169 | 2831 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; |
1168 | 2832 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, |
2833 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2834 qpix_op, chroma_op); | |
2835 | |
2836 qpix_op= qpix_avg; | |
2837 chroma_op= chroma_avg; | |
2838 } | |
2839 | |
2840 if(list1){ | |
1169 | 2841 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; |
1168 | 2842 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, |
2843 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2844 qpix_op, chroma_op); | |
2845 } | |
2846 } | |
2847 | |
2415 | 2848 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, |
2849 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2850 int x_offset, int y_offset, | |
2851 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2852 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, | |
2853 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, | |
2854 int list0, int list1){ | |
2855 MpegEncContext * const s = &h->s; | |
2856 | |
3316 | 2857 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; |
2858 dest_cb += x_offset + y_offset*h->mb_uvlinesize; | |
2859 dest_cr += x_offset + y_offset*h->mb_uvlinesize; | |
2415 | 2860 x_offset += 8*s->mb_x; |
3316 | 2861 y_offset += 8*(s->mb_y >> MB_MBAFF); |
2967 | 2862 |
2415 | 2863 if(list0 && list1){ |
2864 /* don't optimize for luma-only case, since B-frames usually | |
2865 * use implicit weights => chroma too. */ | |
2866 uint8_t *tmp_cb = s->obmc_scratchpad; | |
3316 | 2867 uint8_t *tmp_cr = s->obmc_scratchpad + 8; |
2868 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; | |
2415 | 2869 int refn0 = h->ref_cache[0][ scan8[n] ]; |
2870 int refn1 = h->ref_cache[1][ scan8[n] ]; | |
2871 | |
2872 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, | |
2873 dest_y, dest_cb, dest_cr, | |
2874 x_offset, y_offset, qpix_put, chroma_put); | |
2875 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, | |
2876 tmp_y, tmp_cb, tmp_cr, | |
2877 x_offset, y_offset, qpix_put, chroma_put); | |
2878 | |
2879 if(h->use_weight == 2){ | |
2880 int weight0 = h->implicit_weight[refn0][refn1]; | |
2881 int weight1 = 64 - weight0; | |
3316 | 2882 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); |
2883 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2884 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); | |
2415 | 2885 }else{ |
3316 | 2886 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, |
2967 | 2887 h->luma_weight[0][refn0], h->luma_weight[1][refn1], |
3029 | 2888 h->luma_offset[0][refn0] + h->luma_offset[1][refn1]); |
3316 | 2889 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2890 h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0], |
3029 | 2891 h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]); |
3316 | 2892 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2967 | 2893 h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1], |
3029 | 2894 h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]); |
2415 | 2895 } |
2896 }else{ | |
2897 int list = list1 ? 1 : 0; | |
2898 int refn = h->ref_cache[list][ scan8[n] ]; | |
2899 Picture *ref= &h->ref_list[list][refn]; | |
2900 mc_dir_part(h, ref, n, square, chroma_height, delta, list, | |
2901 dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2902 qpix_put, chroma_put); | |
2903 | |
3316 | 2904 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, |
2415 | 2905 h->luma_weight[list][refn], h->luma_offset[list][refn]); |
2906 if(h->use_weight_chroma){ | |
3316 | 2907 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2908 h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]); |
3316 | 2909 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, |
2415 | 2910 h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]); |
2911 } | |
2912 } | |
2913 } | |
2914 | |
2915 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, | |
2916 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, | |
2917 int x_offset, int y_offset, | |
2918 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, | |
2919 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, | |
2967 | 2920 h264_weight_func *weight_op, h264_biweight_func *weight_avg, |
2415 | 2921 int list0, int list1){ |
2922 if((h->use_weight==2 && list0 && list1 | |
2923 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32)) | |
2924 || h->use_weight==1) | |
2925 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2926 x_offset, y_offset, qpix_put, chroma_put, | |
2927 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); | |
2928 else | |
2929 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, | |
2930 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); | |
2931 } | |
2932 | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2933 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
|
2934 /* fetch pixels for estimated mv 4 macroblocks ahead |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2935 * optimized for 64byte cache lines */ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2936 MpegEncContext * const s = &h->s; |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2937 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
|
2938 if(refn >= 0){ |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2939 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
|
2940 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
|
2941 uint8_t **src= h->ref_list[list][refn].data; |
3316 | 2942 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
|
2943 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
|
2944 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
|
2945 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
|
2946 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2947 } |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2948 |
1168 | 2949 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
2950 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), | |
2415 | 2951 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), |
2952 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ | |
1168 | 2953 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
|
2954 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 2955 const int mb_type= s->current_picture.mb_type[mb_xy]; |
2967 | 2956 |
1168 | 2957 assert(IS_INTER(mb_type)); |
2967 | 2958 |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2959 prefetch_motion(h, 0); |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
2960 |
1168 | 2961 if(IS_16X16(mb_type)){ |
2962 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, | |
2963 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], | |
2415 | 2964 &weight_op[0], &weight_avg[0], |
1168 | 2965 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2966 }else if(IS_16X8(mb_type)){ | |
2967 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, | |
2968 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2969 &weight_op[1], &weight_avg[1], |
1168 | 2970 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
2971 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, | |
2972 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], | |
2415 | 2973 &weight_op[1], &weight_avg[1], |
1168 | 2974 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2975 }else if(IS_8X16(mb_type)){ | |
3316 | 2976 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, |
1168 | 2977 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2978 &weight_op[2], &weight_avg[2], |
1168 | 2979 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); |
3316 | 2980 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, |
1168 | 2981 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], |
2415 | 2982 &weight_op[2], &weight_avg[2], |
1168 | 2983 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); |
2984 }else{ | |
2985 int i; | |
2967 | 2986 |
1168 | 2987 assert(IS_8X8(mb_type)); |
2988 | |
2989 for(i=0; i<4; i++){ | |
2990 const int sub_mb_type= h->sub_mb_type[i]; | |
2991 const int n= 4*i; | |
2992 int x_offset= (i&1)<<2; | |
2993 int y_offset= (i&2)<<1; | |
2994 | |
2995 if(IS_SUB_8X8(sub_mb_type)){ | |
2996 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
2997 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], | |
2415 | 2998 &weight_op[3], &weight_avg[3], |
1168 | 2999 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3000 }else if(IS_SUB_8X4(sub_mb_type)){ | |
3001 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, | |
3002 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3003 &weight_op[4], &weight_avg[4], |
1168 | 3004 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3005 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, | |
3006 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], | |
2415 | 3007 &weight_op[4], &weight_avg[4], |
1168 | 3008 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3009 }else if(IS_SUB_4X8(sub_mb_type)){ | |
3316 | 3010 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, |
1168 | 3011 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3012 &weight_op[5], &weight_avg[5], |
1168 | 3013 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3316 | 3014 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, |
1168 | 3015 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], |
2415 | 3016 &weight_op[5], &weight_avg[5], |
1168 | 3017 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3018 }else{ | |
3019 int j; | |
3020 assert(IS_SUB_4X4(sub_mb_type)); | |
3021 for(j=0; j<4; j++){ | |
3022 int sub_x_offset= x_offset + 2*(j&1); | |
3023 int sub_y_offset= y_offset + (j&2); | |
3024 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, | |
3025 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], | |
2415 | 3026 &weight_op[6], &weight_avg[6], |
1168 | 3027 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); |
3028 } | |
3029 } | |
3030 } | |
3031 } | |
3215
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3032 |
06f98047ff26
prefetch pixels for future motion compensation. 2-5% faster h264.
lorenm
parents:
3212
diff
changeset
|
3033 prefetch_motion(h, 1); |
1168 | 3034 } |
3035 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3036 static void decode_init_vlc(){ |
1168 | 3037 static int done = 0; |
3038 | |
3039 if (!done) { | |
3040 int i; | |
3041 done = 1; | |
3042 | |
2967 | 3043 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, |
1168 | 3044 &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
|
3045 &chroma_dc_coeff_token_bits[0], 1, 1, 1); |
1168 | 3046 |
3047 for(i=0; i<4; i++){ | |
2967 | 3048 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17, |
1168 | 3049 &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
|
3050 &coeff_token_bits[i][0], 1, 1, 1); |
1168 | 3051 } |
3052 | |
3053 for(i=0; i<3; i++){ | |
3054 init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4, | |
3055 &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
|
3056 &chroma_dc_total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3057 } |
3058 for(i=0; i<15; i++){ | |
2967 | 3059 init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16, |
1168 | 3060 &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
|
3061 &total_zeros_bits[i][0], 1, 1, 1); |
1168 | 3062 } |
3063 | |
3064 for(i=0; i<6; i++){ | |
2967 | 3065 init_vlc(&run_vlc[i], RUN_VLC_BITS, 7, |
1168 | 3066 &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
|
3067 &run_bits[i][0], 1, 1, 1); |
1168 | 3068 } |
2967 | 3069 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16, |
1168 | 3070 &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
|
3071 &run_bits[6][0], 1, 1, 1); |
1168 | 3072 } |
3073 } | |
3074 | |
3075 /** | |
3076 * Sets the intra prediction function pointers. | |
3077 */ | |
3078 static void init_pred_ptrs(H264Context *h){ | |
3079 // MpegEncContext * const s = &h->s; | |
3080 | |
3081 h->pred4x4[VERT_PRED ]= pred4x4_vertical_c; | |
3082 h->pred4x4[HOR_PRED ]= pred4x4_horizontal_c; | |
3083 h->pred4x4[DC_PRED ]= pred4x4_dc_c; | |
3084 h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c; | |
3085 h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c; | |
3086 h->pred4x4[VERT_RIGHT_PRED ]= pred4x4_vertical_right_c; | |
3087 h->pred4x4[HOR_DOWN_PRED ]= pred4x4_horizontal_down_c; | |
3088 h->pred4x4[VERT_LEFT_PRED ]= pred4x4_vertical_left_c; | |
3089 h->pred4x4[HOR_UP_PRED ]= pred4x4_horizontal_up_c; | |
3090 h->pred4x4[LEFT_DC_PRED ]= pred4x4_left_dc_c; | |
3091 h->pred4x4[TOP_DC_PRED ]= pred4x4_top_dc_c; | |
3092 h->pred4x4[DC_128_PRED ]= pred4x4_128_dc_c; | |
3093 | |
2755 | 3094 h->pred8x8l[VERT_PRED ]= pred8x8l_vertical_c; |
3095 h->pred8x8l[HOR_PRED ]= pred8x8l_horizontal_c; | |
3096 h->pred8x8l[DC_PRED ]= pred8x8l_dc_c; | |
3097 h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c; | |
3098 h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c; | |
3099 h->pred8x8l[VERT_RIGHT_PRED ]= pred8x8l_vertical_right_c; | |
3100 h->pred8x8l[HOR_DOWN_PRED ]= pred8x8l_horizontal_down_c; | |
3101 h->pred8x8l[VERT_LEFT_PRED ]= pred8x8l_vertical_left_c; | |
3102 h->pred8x8l[HOR_UP_PRED ]= pred8x8l_horizontal_up_c; | |
3103 h->pred8x8l[LEFT_DC_PRED ]= pred8x8l_left_dc_c; | |
3104 h->pred8x8l[TOP_DC_PRED ]= pred8x8l_top_dc_c; | |
3105 h->pred8x8l[DC_128_PRED ]= pred8x8l_128_dc_c; | |
3106 | |
4271
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3107 h->pred8x8[DC_PRED8x8 ]= ff_pred8x8_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3108 h->pred8x8[VERT_PRED8x8 ]= ff_pred8x8_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3109 h->pred8x8[HOR_PRED8x8 ]= ff_pred8x8_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3110 h->pred8x8[PLANE_PRED8x8 ]= ff_pred8x8_plane_c; |
1168 | 3111 h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c; |
3112 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
|
3113 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
|
3114 |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3115 h->pred16x16[DC_PRED8x8 ]= ff_pred16x16_dc_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3116 h->pred16x16[VERT_PRED8x8 ]= ff_pred16x16_vertical_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3117 h->pred16x16[HOR_PRED8x8 ]= ff_pred16x16_horizontal_c; |
8cb3d28d7e40
Export symbols of several H.264 intra prediction functions
takis
parents:
4270
diff
changeset
|
3118 h->pred16x16[PLANE_PRED8x8 ]= ff_pred16x16_plane_c; |
1168 | 3119 h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c; |
3120 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
|
3121 h->pred16x16[DC_128_PRED8x8 ]= ff_pred16x16_128_dc_c; |
1168 | 3122 } |
3123 | |
3124 static void free_tables(H264Context *h){ | |
3125 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
|
3126 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
|
3127 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
|
3128 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
|
3129 av_freep(&h->mvd_table[1]); |
2396 | 3130 av_freep(&h->direct_table); |
1168 | 3131 av_freep(&h->non_zero_count); |
3132 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
|
3133 av_freep(&h->top_borders[1]); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3134 av_freep(&h->top_borders[0]); |
1168 | 3135 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
|
3136 |
1168 | 3137 av_freep(&h->mb2b_xy); |
3138 av_freep(&h->mb2b8_xy); | |
2415 | 3139 |
3140 av_freep(&h->s.obmc_scratchpad); | |
1168 | 3141 } |
3142 | |
2919 | 3143 static void init_dequant8_coeff_table(H264Context *h){ |
3144 int i,q,x; | |
3174 | 3145 const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly |
2919 | 3146 h->dequant8_coeff[0] = h->dequant8_buffer[0]; |
3147 h->dequant8_coeff[1] = h->dequant8_buffer[1]; | |
3148 | |
3149 for(i=0; i<2; i++ ){ | |
3150 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ | |
3151 h->dequant8_coeff[1] = h->dequant8_buffer[0]; | |
3152 break; | |
3153 } | |
3154 | |
3155 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3156 int shift = ff_div6[q]; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3157 int idx = ff_rem6[q]; |
2919 | 3158 for(x=0; x<64; x++) |
3174 | 3159 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = |
3160 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * | |
3161 h->pps.scaling_matrix8[i][x]) << shift; | |
2919 | 3162 } |
3163 } | |
3164 } | |
3165 | |
3166 static void init_dequant4_coeff_table(H264Context *h){ | |
3167 int i,j,q,x; | |
3005 | 3168 const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly |
2919 | 3169 for(i=0; i<6; i++ ){ |
3170 h->dequant4_coeff[i] = h->dequant4_buffer[i]; | |
3171 for(j=0; j<i; j++){ | |
3172 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ | |
3173 h->dequant4_coeff[i] = h->dequant4_buffer[j]; | |
3174 break; | |
3175 } | |
3176 } | |
3177 if(j<i) | |
3178 continue; | |
3179 | |
3180 for(q=0; q<52; q++){ | |
4277
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3181 int shift = ff_div6[q] + 2; |
113f3b395bac
Making rem6 and div6 globally visible and thus adding prefixes.
takis
parents:
4276
diff
changeset
|
3182 int idx = ff_rem6[q]; |
2919 | 3183 for(x=0; x<16; x++) |
3005 | 3184 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = |
3185 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * | |
2919 | 3186 h->pps.scaling_matrix4[i][x]) << shift; |
3187 } | |
3188 } | |
3189 } | |
3190 | |
3191 static void init_dequant_tables(H264Context *h){ | |
3192 int i,x; | |
3193 init_dequant4_coeff_table(h); | |
3194 if(h->pps.transform_8x8_mode) | |
3195 init_dequant8_coeff_table(h); | |
3196 if(h->sps.transform_bypass){ | |
3197 for(i=0; i<6; i++) | |
3198 for(x=0; x<16; x++) | |
3199 h->dequant4_coeff[i][0][x] = 1<<6; | |
3200 if(h->pps.transform_8x8_mode) | |
3201 for(i=0; i<2; i++) | |
3202 for(x=0; x<64; x++) | |
3203 h->dequant8_coeff[i][0][x] = 1<<6; | |
3204 } | |
3205 } | |
3206 | |
3207 | |
1168 | 3208 /** |
3209 * allocates tables. | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3210 * needs width/height |
1168 | 3211 */ |
3212 static int alloc_tables(H264Context *h){ | |
3213 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
|
3214 const int big_mb_num= s->mb_stride * (s->mb_height+1); |
2919 | 3215 int x,y; |
1168 | 3216 |
3217 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
|
3218 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3219 CHECKED_ALLOCZ(h->non_zero_count , big_mb_num * 16 * sizeof(uint8_t)) |
3316 | 3220 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
|
3221 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
|
3222 CHECKED_ALLOCZ(h->top_borders[1] , s->mb_width * (16+8+8) * sizeof(uint8_t)) |
2336 | 3223 CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t)) |
1168 | 3224 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3225 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
|
3226 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
|
3227 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
|
3228 CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t)); |
2396 | 3229 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
|
3230 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
3231 |
3316 | 3232 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(uint8_t)); |
3233 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; | |
1168 | 3234 |
2641
c337f851d0f9
fix storage of motion vectors for frames with more than 4096 macroblocks.
lorenm
parents:
2640
diff
changeset
|
3235 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
|
3236 CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t)); |
1168 | 3237 for(y=0; y<s->mb_height; y++){ |
3238 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
|
3239 const int mb_xy= x + y*s->mb_stride; |
1168 | 3240 const int b_xy = 4*x + 4*y*h->b_stride; |
3241 const int b8_xy= 2*x + 2*y*h->b8_stride; | |
2967 | 3242 |
1168 | 3243 h->mb2b_xy [mb_xy]= b_xy; |
3244 h->mb2b8_xy[mb_xy]= b8_xy; | |
3245 } | |
3246 } | |
2415 | 3247 |
2417 | 3248 s->obmc_scratchpad = NULL; |
3249 | |
2920 | 3250 if(!h->dequant4_coeff[0]) |
3251 init_dequant_tables(h); | |
3252 | |
1168 | 3253 return 0; |
3254 fail: | |
3255 free_tables(h); | |
3256 return -1; | |
3257 } | |
3258 | |
3259 static void common_init(H264Context *h){ | |
3260 MpegEncContext * const s = &h->s; | |
3261 | |
3262 s->width = s->avctx->width; | |
3263 s->height = s->avctx->height; | |
3264 s->codec_id= s->avctx->codec->id; | |
2967 | 3265 |
1168 | 3266 init_pred_ptrs(h); |
3267 | |
2919 | 3268 h->dequant_coeff_pps= -1; |
1698 | 3269 s->unrestricted_mv=1; |
1168 | 3270 s->decode=1; //FIXME |
2920 | 3271 |
3272 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); | |
3273 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
1168 | 3274 } |
3275 | |
3276 static int decode_init(AVCodecContext *avctx){ | |
3277 H264Context *h= avctx->priv_data; | |
3278 MpegEncContext * const s = &h->s; | |
3279 | |
1892 | 3280 MPV_decode_defaults(s); |
2967 | 3281 |
1168 | 3282 s->avctx = avctx; |
3283 common_init(h); | |
3284 | |
3285 s->out_format = FMT_H264; | |
3286 s->workaround_bugs= avctx->workaround_bugs; | |
3287 | |
3288 // set defaults | |
3289 // s->decode_mb= ff_h263_decode_mb; | |
3290 s->low_delay= 1; | |
3291 avctx->pix_fmt= PIX_FMT_YUV420P; | |
3292 | |
4164
171e768324cd
Remove the H264Context parameter from decode_init_vlc() as it is not being used.
takis
parents:
4118
diff
changeset
|
3293 decode_init_vlc(); |
2967 | 3294 |
2547
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3295 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
|
3296 *(char *)avctx->extradata == 1){ |
2227 | 3297 h->is_avc = 1; |
3298 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
|
3299 } else { |
c5781912ad8a
improved detection of "AVC1" style H.264 patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2538
diff
changeset
|
3300 h->is_avc = 0; |
2227 | 3301 } |
3302 | |
1168 | 3303 return 0; |
3304 } | |
3305 | |
2935 | 3306 static int frame_start(H264Context *h){ |
1168 | 3307 MpegEncContext * const s = &h->s; |
3308 int i; | |
3309 | |
2935 | 3310 if(MPV_frame_start(s, s->avctx) < 0) |
3311 return -1; | |
1168 | 3312 ff_er_frame_start(s); |
3313 | |
3314 assert(s->linesize && s->uvlinesize); | |
3315 | |
3316 for(i=0; i<16; i++){ | |
3317 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
|
3318 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); |
1168 | 3319 } |
3320 for(i=0; i<4; i++){ | |
3321 h->block_offset[16+i]= | |
3322 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
|
3323 h->block_offset[24+16+i]= |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3324 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); |
1168 | 3325 } |
3326 | |
2416
06b7d678b582
10l: scratchpad could be allocated before its size was known.
lorenm
parents:
2415
diff
changeset
|
3327 /* 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
|
3328 * 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
|
3329 if(!s->obmc_scratchpad) |
3316 | 3330 s->obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); |
3331 | |
3332 /* some macroblocks will be accessed before they're available */ | |
3333 if(FRAME_MBAFF) | |
3334 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
|
3335 |
1168 | 3336 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; |
2935 | 3337 return 0; |
1168 | 3338 } |
3339 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3340 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
|
3341 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
|
3342 int i; |
2967 | 3343 |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3344 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
|
3345 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
|
3346 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
|
3347 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3348 // 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
|
3349 // 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
|
3350 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
|
3351 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
|
3352 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
|
3353 } |
2967 | 3354 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3355 *(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
|
3356 *(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
|
3357 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3358 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
|
3359 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
|
3360 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
|
3361 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
|
3362 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
|
3363 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
|
3364 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3365 *(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
|
3366 *(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
|
3367 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3368 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3369 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3370 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
|
3371 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
|
3372 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
|
3373 uint64_t temp64; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3374 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
|
3375 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
|
3376 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3377 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
|
3378 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
|
3379 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
|
3380 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3381 #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
|
3382 t= a;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3383 if(xchg)\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3384 a= b;\ |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3385 b= t; |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3386 |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3387 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3388 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
|
3389 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
|
3390 } |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3391 } |
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_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3394 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
|
3395 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1); |
2803 | 3396 if(s->mb_x+1 < s->mb_width){ |
2755 | 3397 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); |
3398 } | |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3399 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3400 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3401 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
|
3402 if(deblock_left){ |
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3403 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
|
3404 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
|
3405 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
|
3406 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3407 } |
2200
733c60a6e30c
h264 deblocking crash patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2175
diff
changeset
|
3408 if(deblock_top){ |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3409 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
|
3410 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
|
3411 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3412 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3413 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3414 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3415 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
|
3416 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3417 int i; |
2967 | 3418 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3419 src_y -= 2 * linesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3420 src_cb -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3421 src_cr -= 2 * uvlinesize; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3422 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3423 // 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
|
3424 // 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
|
3425 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
|
3426 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
|
3427 for(i=2; i<34; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3428 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
|
3429 } |
2967 | 3430 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3431 *(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
|
3432 *(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
|
3433 *(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
|
3434 *(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
|
3435 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3436 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3437 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
|
3438 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
|
3439 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
|
3440 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
|
3441 for(i=2; i<18; i++){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3442 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
|
3443 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
|
3444 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3445 *(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
|
3446 *(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
|
3447 *(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
|
3448 *(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
|
3449 } |
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 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3452 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
|
3453 MpegEncContext * const s = &h->s; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3454 int temp8, i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3455 uint64_t temp64; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3456 int deblock_left = (s->mb_x > 0); |
3316 | 3457 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
|
3458 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3459 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
|
3460 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3461 src_y -= 2 * linesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3462 src_cb -= 2 * uvlinesize + 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3463 src_cr -= 2 * uvlinesize + 1; |
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 #define XCHG(a,b,t,xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3466 t= a;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3467 if(xchg)\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3468 a= b;\ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3469 b= t; |
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 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3472 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
|
3473 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
|
3474 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3475 } |
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_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3478 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
|
3479 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
|
3480 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
|
3481 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1); |
3316 | 3482 if(s->mb_x+1 < s->mb_width){ |
3483 XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1); | |
3484 XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x+1]), *(uint64_t*)(src_y +17 +linesize), temp64, 1); | |
3485 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3486 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3487 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3488 if(!(s->flags&CODEC_FLAG_GRAY)){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3489 if(deblock_left){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3490 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
|
3491 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
|
3492 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
|
3493 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3494 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3495 if(deblock_top){ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3496 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
|
3497 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
|
3498 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
|
3499 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
|
3500 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3501 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3502 } |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3503 |
1168 | 3504 static void hl_decode_mb(H264Context *h){ |
3505 MpegEncContext * const s = &h->s; | |
3506 const int mb_x= s->mb_x; | |
3507 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
|
3508 const int mb_xy= mb_x + mb_y*s->mb_stride; |
1168 | 3509 const int mb_type= s->current_picture.mb_type[mb_xy]; |
3510 uint8_t *dest_y, *dest_cb, *dest_cr; | |
3511 int linesize, uvlinesize /*dct_offset*/; | |
3512 int i; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3513 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
|
3514 const unsigned int bottom = mb_y & 1; |
2763 | 3515 const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass); |
3516 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
|
3517 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); |
1168 | 3518 |
3519 if(!s->decode) | |
3520 return; | |
3521 | |
3522 dest_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16; | |
3523 dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3524 dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8; | |
3525 | |
4000 | 3526 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); |
3527 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); | |
3528 | |
3316 | 3529 if (MB_FIELD) { |
3530 linesize = h->mb_linesize = s->linesize * 2; | |
3531 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
|
3532 block_offset = &h->block_offset[24]; |
1168 | 3533 if(mb_y&1){ //FIXME move out of this func? |
3534 dest_y -= s->linesize*15; | |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3535 dest_cb-= s->uvlinesize*7; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
3536 dest_cr-= s->uvlinesize*7; |
1168 | 3537 } |
3316 | 3538 if(FRAME_MBAFF) { |
3539 int list; | |
3540 for(list=0; list<2; list++){ | |
3541 if(!USES_LIST(mb_type, list)) | |
3542 continue; | |
3543 if(IS_16X16(mb_type)){ | |
3544 int8_t *ref = &h->ref_cache[list][scan8[0]]; | |
3545 fill_rectangle(ref, 4, 4, 8, 16+*ref^(s->mb_y&1), 1); | |
3546 }else{ | |
3547 for(i=0; i<16; i+=4){ | |
3548 //FIXME can refs be smaller than 8x8 when !direct_8x8_inference ? | |
3549 int ref = h->ref_cache[list][scan8[i]]; | |
3550 if(ref >= 0) | |
3551 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, 16+ref^(s->mb_y&1), 1); | |
3552 } | |
3553 } | |
3554 } | |
3555 } | |
1168 | 3556 } else { |
3316 | 3557 linesize = h->mb_linesize = s->linesize; |
3558 uvlinesize = h->mb_uvlinesize = s->uvlinesize; | |
1168 | 3559 // dct_offset = s->linesize * 16; |
3560 } | |
2967 | 3561 |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3562 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3563 idct_dc_add = |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3564 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
|
3565 }else if(IS_8x8DCT(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3566 idct_dc_add = s->dsp.h264_idct8_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3567 idct_add = s->dsp.h264_idct8_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3568 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3569 idct_dc_add = s->dsp.h264_idct_dc_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3570 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3571 } |
1168 | 3572 |
3316 | 3573 if(FRAME_MBAFF && h->deblocking_filter && IS_INTRA(mb_type) |
3574 && (!bottom || !IS_INTRA(s->current_picture.mb_type[mb_xy-s->mb_stride]))){ | |
3575 int mbt_y = mb_y&~1; | |
3576 uint8_t *top_y = s->current_picture.data[0] + (mbt_y * 16* s->linesize ) + mb_x * 16; | |
3577 uint8_t *top_cb = s->current_picture.data[1] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3578 uint8_t *top_cr = s->current_picture.data[2] + (mbt_y * 8 * s->uvlinesize) + mb_x * 8; | |
3579 xchg_pair_border(h, top_y, top_cb, top_cr, s->linesize, s->uvlinesize, 1); | |
3580 } | |
3581 | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3582 if (IS_INTRA_PCM(mb_type)) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3583 unsigned int x, y; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3584 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3585 // 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
|
3586 // 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
|
3587 for(i=0; i<16; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3588 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3589 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
|
3590 *(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
|
3591 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3592 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3593 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3594 for(i=16; i<16+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3595 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3596 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
|
3597 *(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
|
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 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3601 for(i=20; i<20+4; i++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3602 for (y=0; y<4; y++) { |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
3603 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
|
3604 *(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
|
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 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3608 } else { |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3609 if(IS_INTRA(mb_type)){ |
3316 | 3610 if(h->deblocking_filter && !FRAME_MBAFF) |
3611 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
|
3612 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3613 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
|
3614 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
|
3615 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
|
3616 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3617 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3618 if(IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3619 if(!s->encoding){ |
2755 | 3620 if(IS_8x8DCT(mb_type)){ |
3621 for(i=0; i<16; i+=4){ | |
3622 uint8_t * const ptr= dest_y + block_offset[i]; | |
3623 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
|
3624 const int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2755 | 3625 h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, |
3626 (h->topright_samples_available<<(i+1))&0x8000, linesize); | |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3627 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3628 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3629 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3630 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3631 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3632 } |
2755 | 3633 } |
3634 }else | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3635 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
|
3636 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
|
3637 uint8_t *topright; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3638 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
|
3639 int nnz, tr; |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3640 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3641 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
|
3642 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
|
3643 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
|
3644 if(!topright_avail){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3645 tr= ptr[3 - linesize]*0x01010101; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3646 topright= (uint8_t*) &tr; |
2967 | 3647 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3648 topright= ptr + 4 - linesize; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3649 }else |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3650 topright= NULL; |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3651 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3652 h->pred4x4[ dir ](ptr, topright, linesize); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3653 nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3654 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3655 if(s->codec_id == CODEC_ID_H264){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3656 if(nnz == 1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3657 idct_dc_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3658 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3659 idct_add(ptr, h->mb + i*16, linesize); |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3660 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3661 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
|
3662 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3663 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3664 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3665 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3666 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); |
2763 | 3667 if(s->codec_id == CODEC_ID_H264){ |
3668 if(!transform_bypass) | |
2919 | 3669 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]); |
2763 | 3670 }else |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3671 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
|
3672 } |
3316 | 3673 if(h->deblocking_filter && !FRAME_MBAFF) |
3674 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
|
3675 }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
|
3676 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
|
3677 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
|
3678 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
|
3679 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
|
3680 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3681 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3682 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3683 if(!IS_INTRA4x4(mb_type)){ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3684 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3685 if(IS_INTRA16x16(mb_type)){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3686 for(i=0; i<16; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3687 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3688 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
|
3689 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3690 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
|
3691 } |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3692 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3693 const int di = IS_8x8DCT(mb_type) ? 4 : 1; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3694 for(i=0; i<16; i+=di){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3695 int nnz = h->non_zero_count_cache[ scan8[i] ]; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3696 if(nnz){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3697 if(nnz==1 && h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3698 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
|
3699 else |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3700 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
|
3701 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3702 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3703 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3704 }else{ |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3705 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
|
3706 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
|
3707 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
|
3708 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); |
1234 | 3709 } |
1168 | 3710 } |
3711 } | |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3712 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3713 |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3714 if(!(s->flags&CODEC_FLAG_GRAY)){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3715 uint8_t *dest[2] = {dest_cb, dest_cr}; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3716 if(transform_bypass){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3717 idct_add = idct_dc_add = s->dsp.add_pixels4; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3718 }else{ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3719 idct_add = s->dsp.h264_idct_add; |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3720 idct_dc_add = s->dsp.h264_idct_dc_add; |
2919 | 3721 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]); |
3722 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 | 3723 } |
2509
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3724 if(s->codec_id == CODEC_ID_H264){ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3725 for(i=16; i<16+8; i++){ |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3726 if(h->non_zero_count_cache[ scan8[i] ]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3727 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
|
3728 else if(h->mb[i*16]) |
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3729 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
|
3730 } |
b3b06ba8787c
remove goto and reindent patch by (Loic Le Loarer <lll+ffmpeg m4x org>)
michael
parents:
2504
diff
changeset
|
3731 }else{ |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
3732 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
|
3733 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
|
3734 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
|
3735 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
|
3736 } |
1250 | 3737 } |
1168 | 3738 } |
3739 } | |
3740 } | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3741 if(h->deblocking_filter) { |
3316 | 3742 if (FRAME_MBAFF) { |
3743 //FIXME try deblocking one mb at a time? | |
3744 // 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
|
3745 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
|
3746 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
|
3747 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
|
3748 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
|
3749 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
|
3750 if (!bottom) return; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3751 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
|
3752 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
|
3753 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
|
3754 |
3316 | 3755 if(IS_INTRA(mb_type_top | mb_type_bottom)) |
3756 xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0); | |
3757 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3758 backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize); |
3316 | 3759 // deblock a pair |
2967 | 3760 // top |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3761 s->mb_y--; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3762 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
|
3763 fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb |
3316 | 3764 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
|
3765 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
|
3766 // bottom |
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\n"); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3769 fill_caches(h, mb_type_bottom, 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+s->mb_stride]); |
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+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
|
3772 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3773 tprintf("call filter_mb\n"); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
3774 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
|
3775 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
|
3776 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
|
3777 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
3778 } |
1168 | 3779 } |
3780 | |
3781 /** | |
3782 * fills the default_ref_list. | |
3783 */ | |
3784 static int fill_default_ref_list(H264Context *h){ | |
3785 MpegEncContext * const s = &h->s; | |
3786 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
|
3787 int smallest_poc_greater_than_current = -1; |
2582 | 3788 Picture sorted_short_ref[32]; |
2967 | 3789 |
1168 | 3790 if(h->slice_type==B_TYPE){ |
3791 int out_i; | |
2713 | 3792 int limit= INT_MIN; |
1168 | 3793 |
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
|
3794 /* sort frame according to poc in B slice */ |
1168 | 3795 for(out_i=0; out_i<h->short_ref_count; out_i++){ |
2713 | 3796 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
|
3797 int best_poc=INT_MAX; |
1168 | 3798 |
3799 for(i=0; i<h->short_ref_count; i++){ | |
3800 const int poc= h->short_ref[i]->poc; | |
3801 if(poc > limit && poc < best_poc){ | |
3802 best_poc= poc; | |
3803 best_i= i; | |
3804 } | |
3805 } | |
2967 | 3806 |
2713 | 3807 assert(best_i != INT_MIN); |
2967 | 3808 |
1168 | 3809 limit= best_poc; |
3810 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
|
3811 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
|
3812 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
|
3813 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
|
3814 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
|
3815 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3816 } |
1168 | 3817 } |
3818 } | |
3819 | |
3820 if(s->picture_structure == PICT_FRAME){ | |
3821 if(h->slice_type==B_TYPE){ | |
3822 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
|
3823 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
|
3824 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3825 // find the largest poc |
1168 | 3826 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
|
3827 int index = 0; |
2447 | 3828 int j= -99; |
3829 int step= list ? -1 : 1; | |
3830 | |
3831 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) { | |
3832 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
|
3833 if(j != -99 && step == (list ? -1 : 1)) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3834 return -1; |
2447 | 3835 step = -step; |
3836 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
|
3837 } |
2447 | 3838 if(sorted_short_ref[j].reference != 3) continue; |
3839 h->default_ref_list[list][index ]= sorted_short_ref[j]; | |
3840 h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num; | |
1168 | 3841 } |
3842 | |
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 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
|
3844 if(h->long_ref[i] == NULL) continue; |
1168 | 3845 if(h->long_ref[i]->reference != 3) continue; |
3846 | |
3847 h->default_ref_list[ list ][index ]= *h->long_ref[i]; | |
3848 h->default_ref_list[ list ][index++].pic_id= i;; | |
3849 } | |
2967 | 3850 |
2447 | 3851 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
|
3852 // 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
|
3853 // L0 and L1 are identical |
1168 | 3854 Picture temp= h->default_ref_list[1][0]; |
3855 h->default_ref_list[1][0] = h->default_ref_list[1][1]; | |
2673 | 3856 h->default_ref_list[1][1] = temp; |
1168 | 3857 } |
3858 | |
3859 if(index < h->ref_count[ list ]) | |
3860 memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index)); | |
3861 } | |
3862 }else{ | |
3863 int index=0; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3864 for(i=0; i<h->short_ref_count; i++){ |
1168 | 3865 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit |
3866 h->default_ref_list[0][index ]= *h->short_ref[i]; | |
3867 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num; | |
3868 } | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3869 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
|
3870 if(h->long_ref[i] == NULL) continue; |
1168 | 3871 if(h->long_ref[i]->reference != 3) continue; |
3872 h->default_ref_list[0][index ]= *h->long_ref[i]; | |
3873 h->default_ref_list[0][index++].pic_id= i;; | |
3874 } | |
3875 if(index < h->ref_count[0]) | |
3876 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index)); | |
3877 } | |
3878 }else{ //FIELD | |
3879 if(h->slice_type==B_TYPE){ | |
3880 }else{ | |
3881 //FIXME second field balh | |
3882 } | |
3883 } | |
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
|
3884 #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
|
3885 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
|
3886 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
|
3887 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3888 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
|
3889 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
|
3890 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
|
3891 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3892 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
3893 #endif |
1168 | 3894 return 0; |
3895 } | |
3896 | |
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
|
3897 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
|
3898 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
|
3899 |
1168 | 3900 static int decode_ref_pic_list_reordering(H264Context *h){ |
3901 MpegEncContext * const s = &h->s; | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3902 int list, index; |
2967 | 3903 |
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
|
3904 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
|
3905 print_long_term(h); |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
3906 if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func |
2967 | 3907 |
1168 | 3908 for(list=0; list<2; list++){ |
3909 memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]); | |
3910 | |
3911 if(get_bits1(&s->gb)){ | |
3912 int pred= h->curr_pic_num; | |
3913 | |
3914 for(index=0; ; index++){ | |
3915 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb); | |
3916 int pic_id; | |
3917 int i; | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3918 Picture *ref = NULL; |
2967 | 3919 |
3920 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
|
3921 break; |
2967 | 3922 |
1168 | 3923 if(index >= h->ref_count[list]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3924 av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n"); |
1168 | 3925 return -1; |
3926 } | |
2967 | 3927 |
1168 | 3928 if(reordering_of_pic_nums_idc<3){ |
3929 if(reordering_of_pic_nums_idc<2){ | |
3930 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1; | |
3931 | |
3932 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
|
3933 av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n"); |
1168 | 3934 return -1; |
3935 } | |
3936 | |
3937 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num; | |
3938 else pred+= abs_diff_pic_num; | |
3939 pred &= h->max_pic_num - 1; | |
2967 | 3940 |
2683 | 3941 for(i= h->short_ref_count-1; i>=0; i--){ |
3942 ref = h->short_ref[i]; | |
3943 assert(ref->reference == 3); | |
3944 assert(!ref->long_ref); | |
3945 if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer | |
1168 | 3946 break; |
3947 } | |
2683 | 3948 if(i>=0) |
3949 ref->pic_id= ref->frame_num; | |
1168 | 3950 }else{ |
3951 pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx | |
2683 | 3952 ref = h->long_ref[pic_id]; |
3953 ref->pic_id= pic_id; | |
3954 assert(ref->reference == 3); | |
3955 assert(ref->long_ref); | |
3956 i=0; | |
1168 | 3957 } |
3958 | |
2485
2844b8cf4e11
H.264 multiplce instance in reference list patch by (Loic <lll+ffmpeg m4x org )
michael
parents:
2484
diff
changeset
|
3959 if (i < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3960 av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n"); |
1168 | 3961 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME |
2683 | 3962 } else { |
3963 for(i=index; i+1<h->ref_count[list]; i++){ | |
3964 if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id) | |
3965 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
|
3966 } |
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
|
3967 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
|
3968 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
|
3969 } |
2683 | 3970 h->ref_list[list][index]= *ref; |
1168 | 3971 } |
2284
6d26e105f68f
h.264 ref list reordering bugfix patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2272
diff
changeset
|
3972 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
3973 av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n"); |
1168 | 3974 return -1; |
3975 } | |
3976 } | |
3977 } | |
3978 | |
3979 if(h->slice_type!=B_TYPE) break; | |
3980 } | |
2680
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3981 for(list=0; list<2; list++){ |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3982 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
|
3983 if(!h->ref_list[list][index].data[0]) |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3984 h->ref_list[list][index]= s->current_picture; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3985 } |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3986 if(h->slice_type!=B_TYPE) break; |
1a6192e0b1f9
fill missing reference pictures with something to avoid assertion failure
michael
parents:
2675
diff
changeset
|
3987 } |
2967 | 3988 |
2396 | 3989 if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred) |
3990 direct_dist_scale_factor(h); | |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
3991 direct_ref_list_init(h); |
2967 | 3992 return 0; |
1168 | 3993 } |
3994 | |
3379
69901769c811
fill_mbaff_ref_list is missing a return statement, its return value
mru
parents:
3341
diff
changeset
|
3995 static void fill_mbaff_ref_list(H264Context *h){ |
3316 | 3996 int list, i, j; |
3997 for(list=0; list<2; list++){ | |
3998 for(i=0; i<h->ref_count[list]; i++){ | |
3999 Picture *frame = &h->ref_list[list][i]; | |
4000 Picture *field = &h->ref_list[list][16+2*i]; | |
4001 field[0] = *frame; | |
4002 for(j=0; j<3; j++) | |
4003 field[0].linesize[j] <<= 1; | |
4004 field[1] = field[0]; | |
4005 for(j=0; j<3; j++) | |
4006 field[1].data[j] += frame->linesize[j]; | |
4007 | |
4008 h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i]; | |
4009 h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i]; | |
4010 for(j=0; j<2; j++){ | |
4011 h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j]; | |
4012 h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j]; | |
4013 } | |
4014 } | |
4015 } | |
4016 for(j=0; j<h->ref_count[1]; j++){ | |
4017 for(i=0; i<h->ref_count[0]; i++) | |
4018 h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i]; | |
4019 memcpy(h->implicit_weight[16+2*j], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4020 memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight)); | |
4021 } | |
4022 } | |
4023 | |
1168 | 4024 static int pred_weight_table(H264Context *h){ |
4025 MpegEncContext * const s = &h->s; | |
4026 int list, i; | |
2415 | 4027 int luma_def, chroma_def; |
2967 | 4028 |
2415 | 4029 h->use_weight= 0; |
4030 h->use_weight_chroma= 0; | |
1168 | 4031 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); |
4032 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); | |
2415 | 4033 luma_def = 1<<h->luma_log2_weight_denom; |
4034 chroma_def = 1<<h->chroma_log2_weight_denom; | |
1168 | 4035 |
4036 for(list=0; list<2; list++){ | |
4037 for(i=0; i<h->ref_count[list]; i++){ | |
4038 int luma_weight_flag, chroma_weight_flag; | |
2967 | 4039 |
1168 | 4040 luma_weight_flag= get_bits1(&s->gb); |
4041 if(luma_weight_flag){ | |
4042 h->luma_weight[list][i]= get_se_golomb(&s->gb); | |
4043 h->luma_offset[list][i]= get_se_golomb(&s->gb); | |
2415 | 4044 if( h->luma_weight[list][i] != luma_def |
4045 || h->luma_offset[list][i] != 0) | |
4046 h->use_weight= 1; | |
4047 }else{ | |
4048 h->luma_weight[list][i]= luma_def; | |
4049 h->luma_offset[list][i]= 0; | |
1168 | 4050 } |
4051 | |
4052 chroma_weight_flag= get_bits1(&s->gb); | |
4053 if(chroma_weight_flag){ | |
4054 int j; | |
4055 for(j=0; j<2; j++){ | |
4056 h->chroma_weight[list][i][j]= get_se_golomb(&s->gb); | |
4057 h->chroma_offset[list][i][j]= get_se_golomb(&s->gb); | |
2415 | 4058 if( h->chroma_weight[list][i][j] != chroma_def |
4059 || h->chroma_offset[list][i][j] != 0) | |
4060 h->use_weight_chroma= 1; | |
4061 } | |
4062 }else{ | |
4063 int j; | |
4064 for(j=0; j<2; j++){ | |
4065 h->chroma_weight[list][i][j]= chroma_def; | |
4066 h->chroma_offset[list][i][j]= 0; | |
1168 | 4067 } |
4068 } | |
4069 } | |
4070 if(h->slice_type != B_TYPE) break; | |
4071 } | |
2415 | 4072 h->use_weight= h->use_weight || h->use_weight_chroma; |
1168 | 4073 return 0; |
4074 } | |
4075 | |
2415 | 4076 static void implicit_weight_table(H264Context *h){ |
4077 MpegEncContext * const s = &h->s; | |
4078 int ref0, ref1; | |
4079 int cur_poc = s->current_picture_ptr->poc; | |
4080 | |
4081 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 | |
4082 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ | |
4083 h->use_weight= 0; | |
4084 h->use_weight_chroma= 0; | |
4085 return; | |
4086 } | |
4087 | |
4088 h->use_weight= 2; | |
4089 h->use_weight_chroma= 2; | |
4090 h->luma_log2_weight_denom= 5; | |
4091 h->chroma_log2_weight_denom= 5; | |
4092 | |
4093 for(ref0=0; ref0 < h->ref_count[0]; ref0++){ | |
4094 int poc0 = h->ref_list[0][ref0].poc; | |
4095 for(ref1=0; ref1 < h->ref_count[1]; ref1++){ | |
2519 | 4096 int poc1 = h->ref_list[1][ref1].poc; |
2415 | 4097 int td = clip(poc1 - poc0, -128, 127); |
4098 if(td){ | |
4099 int tb = clip(cur_poc - poc0, -128, 127); | |
4001 | 4100 int tx = (16384 + (FFABS(td) >> 1)) / td; |
2415 | 4101 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2; |
4102 if(dist_scale_factor < -64 || dist_scale_factor > 128) | |
4103 h->implicit_weight[ref0][ref1] = 32; | |
4104 else | |
4105 h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor; | |
4106 }else | |
4107 h->implicit_weight[ref0][ref1] = 32; | |
4108 } | |
4109 } | |
4110 } | |
4111 | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4112 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
|
4113 int i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4114 pic->reference=0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4115 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
|
4116 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4117 else{ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4118 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
|
4119 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
|
4120 pic->reference=1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4121 break; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4122 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4123 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4124 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4125 |
1168 | 4126 /** |
2392 | 4127 * instantaneous decoder refresh. |
1168 | 4128 */ |
4129 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
|
4130 int i; |
1168 | 4131 |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4132 for(i=0; i<16; i++){ |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4133 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
|
4134 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
|
4135 h->long_ref[i]= NULL; |
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4136 } |
1168 | 4137 } |
4138 h->long_ref_count=0; | |
4139 | |
4140 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
|
4141 unreference_pic(h, h->short_ref[i]); |
1168 | 4142 h->short_ref[i]= NULL; |
4143 } | |
4144 h->short_ref_count=0; | |
4145 } | |
4146 | |
2640 | 4147 /* forget old pics after a seek */ |
4148 static void flush_dpb(AVCodecContext *avctx){ | |
4149 H264Context *h= avctx->priv_data; | |
4150 int i; | |
3144 | 4151 for(i=0; i<16; i++) { |
4152 if(h->delayed_pic[i]) | |
4153 h->delayed_pic[i]->reference= 0; | |
2640 | 4154 h->delayed_pic[i]= NULL; |
3144 | 4155 } |
4156 if(h->delayed_output_pic) | |
4157 h->delayed_output_pic->reference= 0; | |
2640 | 4158 h->delayed_output_pic= NULL; |
4159 idr(h); | |
2751
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4160 if(h->s.current_picture_ptr) |
3247049dfc7a
fix segfault if flush is called before the first frame
mru
parents:
2748
diff
changeset
|
4161 h->s.current_picture_ptr->reference= 0; |
2640 | 4162 } |
4163 | |
1168 | 4164 /** |
4165 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4166 * @return the removed picture or NULL if an error occurs |
1168 | 4167 */ |
4168 static Picture * remove_short(H264Context *h, int frame_num){ | |
1169 | 4169 MpegEncContext * const s = &h->s; |
1168 | 4170 int i; |
2967 | 4171 |
1169 | 4172 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
|
4173 av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); |
2967 | 4174 |
1168 | 4175 for(i=0; i<h->short_ref_count; i++){ |
4176 Picture *pic= h->short_ref[i]; | |
1169 | 4177 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
|
4178 av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); |
1168 | 4179 if(pic->frame_num == frame_num){ |
4180 h->short_ref[i]= NULL; | |
4181 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*)); | |
4182 h->short_ref_count--; | |
4183 return pic; | |
4184 } | |
4185 } | |
4186 return NULL; | |
4187 } | |
4188 | |
4189 /** | |
4190 * | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4191 * @return the removed picture or NULL if an error occurs |
1168 | 4192 */ |
4193 static Picture * remove_long(H264Context *h, int i){ | |
4194 Picture *pic; | |
4195 | |
4196 pic= h->long_ref[i]; | |
4197 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
|
4198 if(pic) h->long_ref_count--; |
1168 | 4199 |
4200 return pic; | |
4201 } | |
4202 | |
4203 /** | |
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
|
4204 * 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
|
4205 */ |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4206 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
|
4207 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
|
4208 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
|
4209 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
|
4210 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
|
4211 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
|
4212 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
|
4213 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4214 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4215 } |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4216 |
358813ec4ca2
H.264 b ref pic list order and long term pictures patch by (Loic Le Loarer <loic.le-loarer polytechnique org>)
michael
parents:
2440
diff
changeset
|
4217 /** |
358813ec4ca2
H.264 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 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
|
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_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
|
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, "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
|
4224 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
|
4225 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
|
4226 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
|
4227 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
|
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 |
358813ec4ca2
H.264 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 /** |
1168 | 4234 * Executes the reference picture marking (memory management control operations). |
4235 */ | |
4236 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){ | |
4237 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
|
4238 int i, j; |
1168 | 4239 int current_is_long=0; |
4240 Picture *pic; | |
2967 | 4241 |
1168 | 4242 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
|
4243 av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n"); |
2967 | 4244 |
1168 | 4245 for(i=0; i<mmco_count; i++){ |
4246 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
|
4247 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 | 4248 |
4249 switch(mmco[i].opcode){ | |
4250 case MMCO_SHORT2UNUSED: | |
4251 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
|
4252 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4253 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4254 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
|
4255 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n"); |
1168 | 4256 break; |
4257 case MMCO_SHORT2LONG: | |
4258 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
|
4259 if(pic) unreference_pic(h, pic); |
2967 | 4260 |
1168 | 4261 h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num); |
4262 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
2484
a3188eb4266c
correct long term picture management patch by (Loic <lll+ffmpeg m4x org>)
michael
parents:
2471
diff
changeset
|
4263 h->long_ref_count++; |
1168 | 4264 break; |
4265 case MMCO_LONG2UNUSED: | |
4266 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
|
4267 if(pic) |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4268 unreference_pic(h, pic); |
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4269 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
|
4270 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n"); |
1168 | 4271 break; |
4272 case MMCO_LONG: | |
4273 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
|
4274 if(pic) unreference_pic(h, pic); |
2967 | 4275 |
1168 | 4276 h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr; |
4277 h->long_ref[ mmco[i].long_index ]->long_ref=1; | |
4278 h->long_ref_count++; | |
2967 | 4279 |
1168 | 4280 current_is_long=1; |
4281 break; | |
4282 case MMCO_SET_MAX_LONG: | |
4283 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
|
4284 // 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
|
4285 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
|
4286 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
|
4287 if (pic) unreference_pic(h, pic); |
1168 | 4288 } |
4289 break; | |
4290 case MMCO_RESET: | |
4291 while(h->short_ref_count){ | |
4292 pic= remove_short(h, h->short_ref[0]->frame_num); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4293 unreference_pic(h, pic); |
1168 | 4294 } |
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
|
4295 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
|
4296 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
|
4297 if(pic) unreference_pic(h, pic); |
1168 | 4298 } |
4299 break; | |
4300 default: assert(0); | |
4301 } | |
4302 } | |
2967 | 4303 |
1168 | 4304 if(!current_is_long){ |
4305 pic= remove_short(h, s->current_picture_ptr->frame_num); | |
4306 if(pic){ | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
4307 unreference_pic(h, pic); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4308 av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); |
1168 | 4309 } |
2967 | 4310 |
1168 | 4311 if(h->short_ref_count) |
1169 | 4312 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*)); |
4313 | |
4314 h->short_ref[0]= s->current_picture_ptr; | |
1168 | 4315 h->short_ref[0]->long_ref=0; |
4316 h->short_ref_count++; | |
4317 } | |
2967 | 4318 |
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
|
4319 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
|
4320 print_long_term(h); |
2967 | 4321 return 0; |
1168 | 4322 } |
4323 | |
4324 static int decode_ref_pic_marking(H264Context *h){ | |
4325 MpegEncContext * const s = &h->s; | |
4326 int i; | |
2967 | 4327 |
1168 | 4328 if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields |
4329 s->broken_link= get_bits1(&s->gb) -1; | |
4330 h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx | |
4331 if(h->mmco[0].long_index == -1) | |
4332 h->mmco_index= 0; | |
4333 else{ | |
4334 h->mmco[0].opcode= MMCO_LONG; | |
4335 h->mmco_index= 1; | |
2967 | 4336 } |
1168 | 4337 }else{ |
4338 if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag | |
2967 | 4339 for(i= 0; i<MAX_MMCO_COUNT; i++) { |
1168 | 4340 MMCOOpcode opcode= get_ue_golomb(&s->gb);; |
4341 | |
4342 h->mmco[i].opcode= opcode; | |
4343 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){ | |
4344 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 | |
4345 /* 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
|
4346 av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco); |
1168 | 4347 return -1; |
4348 }*/ | |
4349 } | |
4350 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){ | |
4351 h->mmco[i].long_index= get_ue_golomb(&s->gb); | |
4352 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4353 av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode); |
1168 | 4354 return -1; |
4355 } | |
4356 } | |
2967 | 4357 |
1168 | 4358 if(opcode > MMCO_LONG){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4359 av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode); |
1168 | 4360 return -1; |
4361 } | |
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
|
4362 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
|
4363 break; |
1168 | 4364 } |
4365 h->mmco_index= i; | |
4366 }else{ | |
4367 assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count); | |
4368 | |
4369 if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields | |
4370 h->mmco[0].opcode= MMCO_SHORT2UNUSED; | |
4371 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num; | |
4372 h->mmco_index= 1; | |
4373 }else | |
4374 h->mmco_index= 0; | |
4375 } | |
4376 } | |
2967 | 4377 |
4378 return 0; | |
1168 | 4379 } |
4380 | |
4381 static int init_poc(H264Context *h){ | |
4382 MpegEncContext * const s = &h->s; | |
4383 const int max_frame_num= 1<<h->sps.log2_max_frame_num; | |
4384 int field_poc[2]; | |
4385 | |
4386 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4387 h->frame_num_offset= 0; | |
4388 }else{ | |
4389 if(h->frame_num < h->prev_frame_num) | |
4390 h->frame_num_offset= h->prev_frame_num_offset + max_frame_num; | |
4391 else | |
4392 h->frame_num_offset= h->prev_frame_num_offset; | |
4393 } | |
4394 | |
4395 if(h->sps.poc_type==0){ | |
4396 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; | |
4397 | |
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
|
4398 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
|
4399 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
|
4400 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
|
4401 } |
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
|
4402 |
1168 | 4403 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) |
4404 h->poc_msb = h->prev_poc_msb + max_poc_lsb; | |
4405 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) | |
4406 h->poc_msb = h->prev_poc_msb - max_poc_lsb; | |
4407 else | |
4408 h->poc_msb = h->prev_poc_msb; | |
4409 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); | |
2967 | 4410 field_poc[0] = |
1168 | 4411 field_poc[1] = h->poc_msb + h->poc_lsb; |
2967 | 4412 if(s->picture_structure == PICT_FRAME) |
1168 | 4413 field_poc[1] += h->delta_poc_bottom; |
4414 }else if(h->sps.poc_type==1){ | |
4415 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; | |
4416 int i; | |
4417 | |
4418 if(h->sps.poc_cycle_length != 0) | |
4419 abs_frame_num = h->frame_num_offset + h->frame_num; | |
4420 else | |
4421 abs_frame_num = 0; | |
4422 | |
4423 if(h->nal_ref_idc==0 && abs_frame_num > 0) | |
4424 abs_frame_num--; | |
2967 | 4425 |
1168 | 4426 expected_delta_per_poc_cycle = 0; |
4427 for(i=0; i < h->sps.poc_cycle_length; i++) | |
4428 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse | |
4429 | |
4430 if(abs_frame_num > 0){ | |
4431 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; | |
4432 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; | |
4433 | |
4434 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; | |
4435 for(i = 0; i <= frame_num_in_poc_cycle; i++) | |
4436 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; | |
4437 } else | |
4438 expectedpoc = 0; | |
4439 | |
2967 | 4440 if(h->nal_ref_idc == 0) |
1168 | 4441 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; |
2967 | 4442 |
1168 | 4443 field_poc[0] = expectedpoc + h->delta_poc[0]; |
4444 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; | |
4445 | |
4446 if(s->picture_structure == PICT_FRAME) | |
4447 field_poc[1] += h->delta_poc[1]; | |
4448 }else{ | |
4449 int poc; | |
4450 if(h->nal_unit_type == NAL_IDR_SLICE){ | |
4451 poc= 0; | |
4452 }else{ | |
4453 if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num); | |
4454 else poc= 2*(h->frame_num_offset + h->frame_num) - 1; | |
4455 } | |
4456 field_poc[0]= poc; | |
4457 field_poc[1]= poc; | |
4458 } | |
2967 | 4459 |
1168 | 4460 if(s->picture_structure != PICT_BOTTOM_FIELD) |
4461 s->current_picture_ptr->field_poc[0]= field_poc[0]; | |
4462 if(s->picture_structure != PICT_TOP_FIELD) | |
4463 s->current_picture_ptr->field_poc[1]= field_poc[1]; | |
4464 if(s->picture_structure == PICT_FRAME) // FIXME field pix? | |
4465 s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]); | |
4466 | |
4467 return 0; | |
4468 } | |
4469 | |
4470 /** | |
4471 * decodes a slice header. | |
4472 * this will allso call MPV_common_init() and frame_start() as needed | |
4473 */ | |
4474 static int decode_slice_header(H264Context *h){ | |
4475 MpegEncContext * const s = &h->s; | |
4476 int first_mb_in_slice, pps_id; | |
4477 int num_ref_idx_active_override_flag; | |
4478 static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE}; | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4479 int slice_type; |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4480 int default_ref_list_done = 0; |
1168 | 4481 |
4482 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
|
4483 s->dropable= h->nal_ref_idc == 0; |
1168 | 4484 |
4485 first_mb_in_slice= get_ue_golomb(&s->gb); | |
4486 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4487 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
|
4488 if(slice_type > 9){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4489 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 | 4490 return -1; |
1168 | 4491 } |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4492 if(slice_type > 4){ |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4493 slice_type -= 5; |
1168 | 4494 h->slice_type_fixed=1; |
4495 }else | |
4496 h->slice_type_fixed=0; | |
2967 | 4497 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4498 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
|
4499 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
|
4500 || (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
|
4501 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
|
4502 } |
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4503 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
|
4504 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
4505 s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though |
2967 | 4506 |
1168 | 4507 pps_id= get_ue_golomb(&s->gb); |
4508 if(pps_id>255){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4509 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
1168 | 4510 return -1; |
4511 } | |
4512 h->pps= h->pps_buffer[pps_id]; | |
1174 | 4513 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
|
4514 av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n"); |
1174 | 4515 return -1; |
4516 } | |
4517 | |
1168 | 4518 h->sps= h->sps_buffer[ h->pps.sps_id ]; |
1174 | 4519 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
|
4520 av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n"); |
1174 | 4521 return -1; |
4522 } | |
2919 | 4523 |
4524 if(h->dequant_coeff_pps != pps_id){ | |
4525 h->dequant_coeff_pps = pps_id; | |
4526 init_dequant_tables(h); | |
4527 } | |
2967 | 4528 |
1168 | 4529 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
|
4530 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); |
2967 | 4531 |
3178 | 4532 h->b_stride= s->mb_width*4; |
4533 h->b8_stride= s->mb_width*2; | |
1168 | 4534 |
1371 | 4535 s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right ); |
1168 | 4536 if(h->sps.frame_mbs_only_flag) |
1371 | 4537 s->height= 16*s->mb_height - 2*(h->sps.crop_top + h->sps.crop_bottom); |
1168 | 4538 else |
1371 | 4539 s->height= 16*s->mb_height - 4*(h->sps.crop_top + h->sps.crop_bottom); //FIXME recheck |
2967 | 4540 |
4541 if (s->context_initialized | |
1548 | 4542 && ( s->width != s->avctx->width || s->height != s->avctx->height)) { |
1168 | 4543 free_tables(h); |
4544 MPV_common_end(s); | |
4545 } | |
4546 if (!s->context_initialized) { | |
4547 if (MPV_common_init(s) < 0) | |
4548 return -1; | |
2967 | 4549 |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4550 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
|
4551 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
|
4552 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
|
4553 }else{ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4554 int i; |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4555 for(i=0; i<16; i++){ |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4556 #define T(x) (x>>2) | ((x<<2) & 0xF) |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4557 h->zigzag_scan[i] = T(zigzag_scan[i]); |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4558 h-> field_scan[i] = T( field_scan[i]); |
3174 | 4559 #undef T |
4560 } | |
4561 } | |
4562 if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){ | |
3316 | 4563 memcpy(h->zigzag_scan8x8, zigzag_scan8x8, 64*sizeof(uint8_t)); |
3174 | 4564 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); |
3316 | 4565 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); |
4566 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); | |
3174 | 4567 }else{ |
4568 int i; | |
4569 for(i=0; i<64; i++){ | |
4570 #define T(x) (x>>3) | ((x&7)<<3) | |
3316 | 4571 h->zigzag_scan8x8[i] = T(zigzag_scan8x8[i]); |
3174 | 4572 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); |
3316 | 4573 h->field_scan8x8[i] = T(field_scan8x8[i]); |
4574 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); | |
3174 | 4575 #undef T |
2758
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4576 } |
a7925aaeea1e
10l (dont read variables before they have been set)
michael
parents:
2757
diff
changeset
|
4577 } |
2763 | 4578 if(h->sps.transform_bypass){ //FIXME same ugly |
3316 | 4579 h->zigzag_scan_q0 = zigzag_scan; |
4580 h->zigzag_scan8x8_q0 = zigzag_scan8x8; | |
3174 | 4581 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; |
3316 | 4582 h->field_scan_q0 = field_scan; |
4583 h->field_scan8x8_q0 = field_scan8x8; | |
4584 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; | |
2763 | 4585 }else{ |
3316 | 4586 h->zigzag_scan_q0 = h->zigzag_scan; |
4587 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; | |
3174 | 4588 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; |
3316 | 4589 h->field_scan_q0 = h->field_scan; |
4590 h->field_scan8x8_q0 = h->field_scan8x8; | |
4591 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; | |
2763 | 4592 } |
1168 | 4593 |
4594 alloc_tables(h); | |
4595 | |
4596 s->avctx->width = s->width; | |
4597 s->avctx->height = s->height; | |
1548 | 4598 s->avctx->sample_aspect_ratio= h->sps.sar; |
2440 | 4599 if(!s->avctx->sample_aspect_ratio.den) |
4600 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
|
4601 |
2648 | 4602 if(h->sps.timing_info_present_flag){ |
3052 | 4603 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
|
4604 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
|
4605 s->avctx->time_base.den *= 2; |
f02d0b59279c
Remove all stray tabs and trailing whitespace, this time for good.
diego
parents:
3052
diff
changeset
|
4606 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
|
4607 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
|
4608 } |
1168 | 4609 } |
4610 | |
2392 | 4611 if(h->slice_num == 0){ |
2935 | 4612 if(frame_start(h) < 0) |
4613 return -1; | |
1168 | 4614 } |
4615 | |
1169 | 4616 s->current_picture_ptr->frame_num= //FIXME frame_num cleanup |
1168 | 4617 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); |
4618 | |
3316 | 4619 h->mb_mbaff = 0; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4620 h->mb_aff_frame = 0; |
1168 | 4621 if(h->sps.frame_mbs_only_flag){ |
4622 s->picture_structure= PICT_FRAME; | |
4623 }else{ | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4624 if(get_bits1(&s->gb)) { //field_pic_flag |
1168 | 4625 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag |
3316 | 4626 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
|
4627 } else { |
1168 | 4628 s->picture_structure= PICT_FRAME; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4629 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
|
4630 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4631 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4632 |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4633 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; |
3316 | 4634 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << h->mb_aff_frame; |
2772 | 4635 if(s->mb_y >= s->mb_height){ |
4636 return -1; | |
4637 } | |
2967 | 4638 |
1168 | 4639 if(s->picture_structure==PICT_FRAME){ |
4640 h->curr_pic_num= h->frame_num; | |
4641 h->max_pic_num= 1<< h->sps.log2_max_frame_num; | |
4642 }else{ | |
4643 h->curr_pic_num= 2*h->frame_num; | |
4644 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); | |
4645 } | |
2967 | 4646 |
1168 | 4647 if(h->nal_unit_type == NAL_IDR_SLICE){ |
1453 | 4648 get_ue_golomb(&s->gb); /* idr_pic_id */ |
1168 | 4649 } |
2967 | 4650 |
1168 | 4651 if(h->sps.poc_type==0){ |
4652 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); | |
2967 | 4653 |
1168 | 4654 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ |
4655 h->delta_poc_bottom= get_se_golomb(&s->gb); | |
4656 } | |
4657 } | |
2967 | 4658 |
1168 | 4659 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ |
4660 h->delta_poc[0]= get_se_golomb(&s->gb); | |
2967 | 4661 |
1168 | 4662 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) |
4663 h->delta_poc[1]= get_se_golomb(&s->gb); | |
4664 } | |
2967 | 4665 |
1168 | 4666 init_poc(h); |
2967 | 4667 |
1168 | 4668 if(h->pps.redundant_pic_cnt_present){ |
4669 h->redundant_pic_count= get_ue_golomb(&s->gb); | |
4670 } | |
4671 | |
4672 //set defaults, might be overriden a few line later | |
4673 h->ref_count[0]= h->pps.ref_count[0]; | |
4674 h->ref_count[1]= h->pps.ref_count[1]; | |
4675 | |
4676 if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){ | |
4677 if(h->slice_type == B_TYPE){ | |
4678 h->direct_spatial_mv_pred= get_bits1(&s->gb); | |
3316 | 4679 if(h->sps.mb_aff && h->direct_spatial_mv_pred) |
4680 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + spatial direct mode is not implemented\n"); | |
1168 | 4681 } |
4682 num_ref_idx_active_override_flag= get_bits1(&s->gb); | |
2967 | 4683 |
1168 | 4684 if(num_ref_idx_active_override_flag){ |
4685 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
4686 if(h->slice_type==B_TYPE) | |
4687 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
4688 | |
4689 if(h->ref_count[0] > 32 || h->ref_count[1] > 32){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4690 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); |
1168 | 4691 return -1; |
4692 } | |
4693 } | |
4694 } | |
4695 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
4696 if(!default_ref_list_done){ |
1168 | 4697 fill_default_ref_list(h); |
4698 } | |
4699 | |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
4700 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
|
4701 return -1; |
1168 | 4702 |
2967 | 4703 if( (h->pps.weighted_pred && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE )) |
1168 | 4704 || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) ) |
4705 pred_weight_table(h); | |
2415 | 4706 else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE) |
4707 implicit_weight_table(h); | |
4708 else | |
4709 h->use_weight = 0; | |
2967 | 4710 |
2580
b4f6f89ec2f6
The cvs version 1.103 of h264.c brokes 13 conformance streams, this
michael
parents:
2561
diff
changeset
|
4711 if(s->current_picture.reference) |
1168 | 4712 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
|
4713 |
3316 | 4714 if(FRAME_MBAFF) |
4715 fill_mbaff_ref_list(h); | |
4716 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4717 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && 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
|
4718 h->cabac_init_idc = get_ue_golomb(&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
|
4719 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
4720 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
|
4721 s->qscale = h->pps.init_qp + get_se_golomb(&s->gb); |
1898 | 4722 if(s->qscale<0 || s->qscale>51){ |
4723 av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale); | |
4724 return -1; | |
4725 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
4726 h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 4727 //FIXME qscale / qp ... stuff |
4728 if(h->slice_type == SP_TYPE){ | |
1453 | 4729 get_bits1(&s->gb); /* sp_for_switch_flag */ |
1168 | 4730 } |
4731 if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){ | |
1453 | 4732 get_se_golomb(&s->gb); /* slice_qs_delta */ |
1168 | 4733 } |
4734 | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4735 h->deblocking_filter = 1; |
1898 | 4736 h->slice_alpha_c0_offset = 0; |
4737 h->slice_beta_offset = 0; | |
1168 | 4738 if( h->pps.deblocking_filter_parameters_present ) { |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4739 h->deblocking_filter= get_ue_golomb(&s->gb); |
2967 | 4740 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
|
4741 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
|
4742 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
4743 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
|
4744 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
|
4745 h->slice_beta_offset = get_se_golomb(&s->gb) << 1; |
1168 | 4746 } |
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
|
4747 } |
2792 | 4748 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL |
4749 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE) | |
4750 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type == B_TYPE) | |
4751 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) | |
4752 h->deblocking_filter= 0; | |
1168 | 4753 |
4754 #if 0 //FMO | |
4755 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) | |
4756 slice_group_change_cycle= get_bits(&s->gb, ?); | |
4757 #endif | |
4758 | |
2392 | 4759 h->slice_num++; |
4760 | |
3316 | 4761 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; |
4762 h->emu_edge_height= FRAME_MBAFF ? 0 : h->emu_edge_width; | |
4763 | |
1168 | 4764 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 4765 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%d 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
|
4766 h->slice_num, |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
4767 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), |
2967 | 4768 first_mb_in_slice, |
1264 | 4769 av_get_pict_type_char(h->slice_type), |
1168 | 4770 pps_id, h->frame_num, |
4771 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], | |
4772 h->ref_count[0], h->ref_count[1], | |
4773 s->qscale, | |
2583 | 4774 h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2, |
2415 | 4775 h->use_weight, |
4776 h->use_weight==1 && h->use_weight_chroma ? "c" : "" | |
1168 | 4777 ); |
4778 } | |
4779 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4780 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
|
4781 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
|
4782 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
|
4783 }else{ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4784 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
|
4785 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
|
4786 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3776
diff
changeset
|
4787 |
1168 | 4788 return 0; |
4789 } | |
4790 | |
4791 /** | |
4792 * | |
4793 */ | |
4794 static inline int get_level_prefix(GetBitContext *gb){ | |
4795 unsigned int buf; | |
4796 int log; | |
2967 | 4797 |
1168 | 4798 OPEN_READER(re, gb); |
4799 UPDATE_CACHE(re, gb); | |
4800 buf=GET_CACHE(re, gb); | |
2967 | 4801 |
1168 | 4802 log= 32 - av_log2(buf); |
4803 #ifdef TRACE | |
4804 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
|
4805 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 | 4806 #endif |
4807 | |
4808 LAST_SKIP_BITS(re, gb, log); | |
4809 CLOSE_READER(re, gb); | |
4810 | |
4811 return log-1; | |
4812 } | |
4813 | |
2755 | 4814 static inline int get_dct8x8_allowed(H264Context *h){ |
4815 int i; | |
4816 for(i=0; i<4; i++){ | |
4817 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
|
4818 || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i]))) |
2755 | 4819 return 0; |
4820 } | |
4821 return 1; | |
4822 } | |
4823 | |
1168 | 4824 /** |
4825 * decodes a residual block. | |
4826 * @param n block index | |
4827 * @param scantable scantable | |
4828 * @param max_coeff number of coefficients in the block | |
4829 * @return <0 if an error occured | |
4830 */ | |
2919 | 4831 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ |
1168 | 4832 MpegEncContext * const s = &h->s; |
4833 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 | 4834 int level[16]; |
4835 int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; | |
1168 | 4836 |
4837 //FIXME put trailing_onex into the context | |
4838 | |
4839 if(n == CHROMA_DC_BLOCK_INDEX){ | |
4840 coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1); | |
4841 total_coeff= coeff_token>>2; | |
2967 | 4842 }else{ |
1168 | 4843 if(n == LUMA_DC_BLOCK_INDEX){ |
4844 total_coeff= pred_non_zero_count(h, 0); | |
4845 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4846 total_coeff= coeff_token>>2; | |
4847 }else{ | |
4848 total_coeff= pred_non_zero_count(h, n); | |
4849 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2); | |
4850 total_coeff= coeff_token>>2; | |
4851 h->non_zero_count_cache[ scan8[n] ]= total_coeff; | |
4852 } | |
4853 } | |
4854 | |
4855 //FIXME set last_non_zero? | |
4856 | |
4857 if(total_coeff==0) | |
4858 return 0; | |
4270 | 4859 if(total_coeff<0) { |
4860 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff<0)\n", s->mb_x, s->mb_y); | |
4861 return -1; | |
4862 } | |
2967 | 4863 |
1168 | 4864 trailing_ones= coeff_token&3; |
1170 | 4865 tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff); |
1168 | 4866 assert(total_coeff<=16); |
2967 | 4867 |
1168 | 4868 for(i=0; i<trailing_ones; i++){ |
4869 level[i]= 1 - 2*get_bits1(gb); | |
4870 } | |
4871 | |
2897 | 4872 if(i<total_coeff) { |
1168 | 4873 int level_code, mask; |
2897 | 4874 int suffix_length = total_coeff > 10 && trailing_ones < 3; |
4875 int prefix= get_level_prefix(gb); | |
4876 | |
4877 //first coefficient has suffix_length equal to 0 or 1 | |
1168 | 4878 if(prefix<14){ //FIXME try to build a large unified VLC table for all this |
4879 if(suffix_length) | |
4880 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4881 else | |
4882 level_code= (prefix<<suffix_length); //part | |
4883 }else if(prefix==14){ | |
4884 if(suffix_length) | |
4885 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part | |
4886 else | |
4887 level_code= prefix + get_bits(gb, 4); //part | |
4888 }else if(prefix==15){ | |
4889 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
|
4890 if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense |
1168 | 4891 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4892 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4893 return -1; |
4894 } | |
4895 | |
2897 | 4896 if(trailing_ones < 3) level_code += 2; |
4897 | |
4898 suffix_length = 1; | |
4899 if(level_code > 5) | |
4900 suffix_length++; | |
1168 | 4901 mask= -(level_code&1); |
4902 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
2897 | 4903 i++; |
4904 | |
4905 //remaining coefficients have suffix_length > 0 | |
4906 for(;i<total_coeff;i++) { | |
4907 static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX }; | |
4908 prefix = get_level_prefix(gb); | |
4909 if(prefix<15){ | |
4910 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length); | |
4911 }else if(prefix==15){ | |
4912 level_code = (prefix<<suffix_length) + get_bits(gb, 12); | |
4913 }else{ | |
4914 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y); | |
4915 return -1; | |
4916 } | |
4917 mask= -(level_code&1); | |
4918 level[i]= (((2+level_code)>>1) ^ mask) - mask; | |
4919 if(level_code > suffix_limit[suffix_length]) | |
4920 suffix_length++; | |
4921 } | |
1168 | 4922 } |
4923 | |
4924 if(total_coeff == max_coeff) | |
4925 zeros_left=0; | |
4926 else{ | |
4927 if(n == CHROMA_DC_BLOCK_INDEX) | |
4928 zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1); | |
4929 else | |
4930 zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1); | |
4931 } | |
2897 | 4932 |
4933 coeff_num = zeros_left + total_coeff - 1; | |
4934 j = scantable[coeff_num]; | |
4935 if(n > 24){ | |
4936 block[j] = level[0]; | |
4937 for(i=1;i<total_coeff;i++) { | |
4938 if(zeros_left <= 0) | |
4939 run_before = 0; | |
4940 else if(zeros_left < 7){ | |
4941 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4942 }else{ | |
4943 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4944 } | |
4945 zeros_left -= run_before; | |
4946 coeff_num -= 1 + run_before; | |
4947 j= scantable[ coeff_num ]; | |
4948 | |
4949 block[j]= level[i]; | |
4950 } | |
4951 }else{ | |
2919 | 4952 block[j] = (level[0] * qmul[j] + 32)>>6; |
2897 | 4953 for(i=1;i<total_coeff;i++) { |
4954 if(zeros_left <= 0) | |
4955 run_before = 0; | |
4956 else if(zeros_left < 7){ | |
4957 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1); | |
4958 }else{ | |
4959 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); | |
4960 } | |
4961 zeros_left -= run_before; | |
4962 coeff_num -= 1 + run_before; | |
4963 j= scantable[ coeff_num ]; | |
4964 | |
2919 | 4965 block[j]= (level[i] * qmul[j] + 32)>>6; |
2897 | 4966 } |
1168 | 4967 } |
4968 | |
4969 if(zeros_left<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
4970 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); |
1168 | 4971 return -1; |
4972 } | |
2897 | 4973 |
1168 | 4974 return 0; |
4975 } | |
4976 | |
3316 | 4977 static void predict_field_decoding_flag(H264Context *h){ |
4978 MpegEncContext * const s = &h->s; | |
4979 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; | |
4980 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) | |
4981 ? s->current_picture.mb_type[mb_xy-1] | |
4982 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) | |
4983 ? s->current_picture.mb_type[mb_xy-s->mb_stride] | |
4984 : 0; | |
4985 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; | |
4986 } | |
4987 | |
1168 | 4988 /** |
2396 | 4989 * decodes a P_SKIP or B_SKIP macroblock |
4990 */ | |
4991 static void decode_mb_skip(H264Context *h){ | |
4992 MpegEncContext * const s = &h->s; | |
4993 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
|
4994 int mb_type=0; |
2967 | 4995 |
2396 | 4996 memset(h->non_zero_count[mb_xy], 0, 16); |
4997 memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui | |
4998 | |
3316 | 4999 if(MB_FIELD) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5000 mb_type|= MB_TYPE_INTERLACED; |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5001 |
2396 | 5002 if( h->slice_type == B_TYPE ) |
5003 { | |
5004 // 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
|
5005 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP; |
2396 | 5006 |
2449 | 5007 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5008 pred_direct_motion(h, &mb_type); |
3927 | 5009 mb_type|= MB_TYPE_SKIP; |
2396 | 5010 } |
5011 else | |
5012 { | |
5013 int mx, my; | |
2674
58fb8e1efcae
10l (mb_type uninitalized and then changed and overwritten)
michael
parents:
2673
diff
changeset
|
5014 mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP; |
2396 | 5015 |
2449 | 5016 fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ... |
2396 | 5017 pred_pskip_motion(h, &mx, &my); |
5018 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1); | |
5019 fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4); | |
5020 } | |
5021 | |
5022 write_back_motion(h, mb_type); | |
3927 | 5023 s->current_picture.mb_type[mb_xy]= mb_type; |
2396 | 5024 s->current_picture.qscale_table[mb_xy]= s->qscale; |
5025 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
|
5026 h->prev_mb_skipped= 1; |
2396 | 5027 } |
5028 | |
5029 /** | |
1168 | 5030 * decodes a macroblock |
5031 * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
5032 */ | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5033 static int decode_mb_cavlc(H264Context *h){ |
1168 | 5034 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
|
5035 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1169 | 5036 int mb_type, partition_count, cbp; |
2755 | 5037 int dct8x8_allowed= h->pps.transform_8x8_mode; |
1168 | 5038 |
2967 | 5039 s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong? |
1168 | 5040 |
1170 | 5041 tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); |
1453 | 5042 cbp = 0; /* avoid warning. FIXME: find a solution without slowing |
5043 down the code */ | |
1168 | 5044 if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){ |
5045 if(s->mb_skip_run==-1) | |
5046 s->mb_skip_run= get_ue_golomb(&s->gb); | |
2967 | 5047 |
1168 | 5048 if (s->mb_skip_run--) { |
3316 | 5049 if(FRAME_MBAFF && (s->mb_y&1) == 0){ |
5050 if(s->mb_skip_run==0) | |
5051 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
5052 else | |
5053 predict_field_decoding_flag(h); | |
5054 } | |
2396 | 5055 decode_mb_skip(h); |
1168 | 5056 return 0; |
5057 } | |
5058 } | |
3316 | 5059 if(FRAME_MBAFF){ |
5060 if( (s->mb_y&1) == 0 ) | |
5061 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); | |
1168 | 5062 }else |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
5063 h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME); |
2967 | 5064 |
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= 0; |
2967 | 5066 |
1168 | 5067 mb_type= get_ue_golomb(&s->gb); |
5068 if(h->slice_type == B_TYPE){ | |
5069 if(mb_type < 23){ | |
5070 partition_count= b_mb_type_info[mb_type].partition_count; | |
5071 mb_type= b_mb_type_info[mb_type].type; | |
5072 }else{ | |
5073 mb_type -= 23; | |
5074 goto decode_intra_mb; | |
5075 } | |
5076 }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){ | |
5077 if(mb_type < 5){ | |
5078 partition_count= p_mb_type_info[mb_type].partition_count; | |
5079 mb_type= p_mb_type_info[mb_type].type; | |
5080 }else{ | |
5081 mb_type -= 5; | |
5082 goto decode_intra_mb; | |
5083 } | |
5084 }else{ | |
5085 assert(h->slice_type == I_TYPE); | |
5086 decode_intra_mb: | |
5087 if(mb_type > 25){ | |
3954 | 5088 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 | 5089 return -1; |
5090 } | |
5091 partition_count=0; | |
5092 cbp= i_mb_type_info[mb_type].cbp; | |
5093 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
5094 mb_type= i_mb_type_info[mb_type].type; | |
5095 } | |
5096 | |
3316 | 5097 if(MB_FIELD) |
1168 | 5098 mb_type |= MB_TYPE_INTERLACED; |
5099 | |
5100 h->slice_table[ mb_xy ]= h->slice_num; | |
2967 | 5101 |
1168 | 5102 if(IS_INTRA_PCM(mb_type)){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5103 unsigned int x, y; |
2967 | 5104 |
1168 | 5105 // we assume these blocks are very rare so we dont optimize it |
5106 align_get_bits(&s->gb); | |
2967 | 5107 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5108 // The pixels are stored in the same order as levels in h->mb array. |
1168 | 5109 for(y=0; y<16; y++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5110 const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3); |
1168 | 5111 for(x=0; x<16; x++){ |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5112 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
|
5113 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8); |
1168 | 5114 } |
5115 } | |
5116 for(y=0; y<8; y++){ | |
5117 const int index= 256 + 4*(y&3) + 32*(y>>2); | |
5118 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5119 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
|
5120 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5121 } |
5122 } | |
5123 for(y=0; y<8; y++){ | |
5124 const int index= 256 + 64 + 4*(y&3) + 32*(y>>2); | |
5125 for(x=0; x<8; x++){ | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5126 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
|
5127 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8); |
1168 | 5128 } |
5129 } | |
2967 | 5130 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
5131 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
5132 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
|
5133 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
|
5134 // 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
|
5135 memset(h->non_zero_count[mb_xy], 16, 16); |
2967 | 5136 |
2755 | 5137 s->current_picture.mb_type[mb_xy]= mb_type; |
1168 | 5138 return 0; |
5139 } | |
2967 | 5140 |
3316 | 5141 if(MB_MBAFF){ |
5142 h->ref_count[0] <<= 1; | |
5143 h->ref_count[1] <<= 1; | |
5144 } | |
5145 | |
2449 | 5146 fill_caches(h, mb_type, 0); |
1168 | 5147 |
5148 //mb_pred | |
5149 if(IS_INTRA(mb_type)){ | |
5150 // init_top_left_availability(h); | |
5151 if(IS_INTRA4x4(mb_type)){ | |
5152 int i; | |
2755 | 5153 int di = 1; |
5154 if(dct8x8_allowed && get_bits1(&s->gb)){ | |
5155 mb_type |= MB_TYPE_8x8DCT; | |
5156 di = 4; | |
5157 } | |
1168 | 5158 |
5159 // fill_intra4x4_pred_table(h); | |
2755 | 5160 for(i=0; i<16; i+=di){ |
3409 | 5161 int mode= pred_intra_mode(h, i); |
5162 | |
5163 if(!get_bits1(&s->gb)){ | |
1168 | 5164 const int rem_mode= get_bits(&s->gb, 3); |
3409 | 5165 mode = rem_mode + (rem_mode >= mode); |
1168 | 5166 } |
2967 | 5167 |
2755 | 5168 if(di==4) |
5169 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
5170 else | |
5171 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; | |
1168 | 5172 } |
5173 write_back_intra_pred_mode(h); | |
5174 if( check_intra4x4_pred_mode(h) < 0) | |
5175 return -1; | |
5176 }else{ | |
5177 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode); | |
5178 if(h->intra16x16_pred_mode < 0) | |
5179 return -1; | |
5180 } | |
5181 h->chroma_pred_mode= get_ue_golomb(&s->gb); | |
5182 | |
5183 h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode); | |
5184 if(h->chroma_pred_mode < 0) | |
5185 return -1; | |
5186 }else if(partition_count==4){ | |
5187 int i, j, sub_partition_count[4], list, ref[2][4]; | |
2967 | 5188 |
1168 | 5189 if(h->slice_type == B_TYPE){ |
5190 for(i=0; i<4; i++){ | |
5191 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5192 if(h->sub_mb_type[i] >=13){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5193 av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5194 return -1; |
5195 } | |
5196 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5197 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5198 } | |
2396 | 5199 if( IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1]) |
3003 | 5200 || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) { |
2396 | 5201 pred_direct_motion(h, &mb_type); |
3003 | 5202 h->ref_cache[0][scan8[4]] = |
5203 h->ref_cache[1][scan8[4]] = | |
5204 h->ref_cache[0][scan8[12]] = | |
5205 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
5206 } | |
1168 | 5207 }else{ |
5208 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ? | |
5209 for(i=0; i<4; i++){ | |
5210 h->sub_mb_type[i]= get_ue_golomb(&s->gb); | |
5211 if(h->sub_mb_type[i] >=4){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5212 av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y); |
1168 | 5213 return -1; |
5214 } | |
5215 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
5216 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
5217 } | |
5218 } | |
2967 | 5219 |
1168 | 5220 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
|
5221 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; |
1168 | 5222 if(ref_count == 0) continue; |
5223 for(i=0; i<4; i++){ | |
2396 | 5224 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
5225 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1168 | 5226 ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip? |
5227 }else{ | |
5228 //FIXME | |
5229 ref[list][i] = -1; | |
5230 } | |
5231 } | |
5232 } | |
2967 | 5233 |
2755 | 5234 if(dct8x8_allowed) |
5235 dct8x8_allowed = get_dct8x8_allowed(h); | |
2967 | 5236 |
1168 | 5237 for(list=0; list<2; list++){ |
5238 const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; | |
5239 if(ref_count == 0) continue; | |
5240 | |
5241 for(i=0; i<4; i++){ | |
3003 | 5242 if(IS_DIRECT(h->sub_mb_type[i])) { |
5243 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; | |
5244 continue; | |
5245 } | |
1168 | 5246 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= |
5247 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
5248 | |
2396 | 5249 if(IS_DIR(h->sub_mb_type[i], 0, list)){ |
1168 | 5250 const int sub_mb_type= h->sub_mb_type[i]; |
5251 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
5252 for(j=0; j<sub_partition_count[i]; j++){ | |
5253 int mx, my; | |
5254 const int index= 4*i + block_width*j; | |
5255 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
5256 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); | |
5257 mx += get_se_golomb(&s->gb); | |
5258 my += get_se_golomb(&s->gb); | |
1170 | 5259 tprintf("final mv:%d %d\n", mx, my); |
5260 | |
1168 | 5261 if(IS_SUB_8X8(sub_mb_type)){ |
2967 | 5262 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
1168 | 5263 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
2967 | 5264 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
1168 | 5265 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; |
5266 }else if(IS_SUB_8X4(sub_mb_type)){ | |
5267 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; | |
5268 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; | |
5269 }else if(IS_SUB_4X8(sub_mb_type)){ | |
5270 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; | |
5271 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; | |
5272 }else{ | |
5273 assert(IS_SUB_4X4(sub_mb_type)); | |
5274 mv_cache[ 0 ][0]= mx; | |
5275 mv_cache[ 0 ][1]= my; | |
5276 } | |
5277 } | |
5278 }else{ | |
5279 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
5280 p[0] = p[1]= | |
5281 p[8] = p[9]= 0; | |
5282 } | |
5283 } | |
5284 } | |
2396 | 5285 }else if(IS_DIRECT(mb_type)){ |
5286 pred_direct_motion(h, &mb_type); | |
2755 | 5287 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 5288 }else{ |
1168 | 5289 int list, mx, my, i; |
5290 //FIXME we should set ref_idx_l? to 0 if we use that later ... | |
5291 if(IS_16X16(mb_type)){ | |
5292 for(list=0; list<2; list++){ | |
2392 | 5293 if(h->ref_count[list]>0){ |
1168 | 5294 if(IS_DIR(mb_type, 0, list)){ |
5295 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5296 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); | |
2523 | 5297 }else |
5298 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1168 | 5299 } |
5300 } | |
5301 for(list=0; list<2; list++){ | |
5302 if(IS_DIR(mb_type, 0, list)){ | |
5303 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
5304 mx += get_se_golomb(&s->gb); | |
5305 my += get_se_golomb(&s->gb); | |
1170 | 5306 tprintf("final mv:%d %d\n", mx, my); |
5307 | |
1269 | 5308 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 5309 }else |
5310 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1168 | 5311 } |
5312 } | |
5313 else if(IS_16X8(mb_type)){ | |
5314 for(list=0; list<2; list++){ | |
5315 if(h->ref_count[list]>0){ | |
5316 for(i=0; i<2; i++){ | |
5317 if(IS_DIR(mb_type, i, list)){ | |
5318 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5319 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); | |
2523 | 5320 }else |
2396 | 5321 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5322 } |
5323 } | |
5324 } | |
5325 for(list=0; list<2; list++){ | |
5326 for(i=0; i<2; i++){ | |
5327 if(IS_DIR(mb_type, i, list)){ | |
5328 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
5329 mx += get_se_golomb(&s->gb); | |
5330 my += get_se_golomb(&s->gb); | |
1170 | 5331 tprintf("final mv:%d %d\n", mx, my); |
5332 | |
1269 | 5333 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2396 | 5334 }else |
5335 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1168 | 5336 } |
5337 } | |
5338 }else{ | |
5339 assert(IS_8X16(mb_type)); | |
5340 for(list=0; list<2; list++){ | |
5341 if(h->ref_count[list]>0){ | |
5342 for(i=0; i<2; i++){ | |
5343 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
5344 const int val= get_te0_golomb(&s->gb, h->ref_count[list]); | |
5345 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); | |
2523 | 5346 }else |
2396 | 5347 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); |
1168 | 5348 } |
5349 } | |
5350 } | |
5351 for(list=0; list<2; list++){ | |
5352 for(i=0; i<2; i++){ | |
5353 if(IS_DIR(mb_type, i, list)){ | |
5354 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
5355 mx += get_se_golomb(&s->gb); | |
5356 my += get_se_golomb(&s->gb); | |
1170 | 5357 tprintf("final mv:%d %d\n", mx, my); |
5358 | |
1269 | 5359 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2396 | 5360 }else |
5361 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1168 | 5362 } |
5363 } | |
5364 } | |
5365 } | |
2967 | 5366 |
1168 | 5367 if(IS_INTER(mb_type)) |
5368 write_back_motion(h, mb_type); | |
2967 | 5369 |
1168 | 5370 if(!IS_INTRA16x16(mb_type)){ |
5371 cbp= get_ue_golomb(&s->gb); | |
5372 if(cbp > 47){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5373 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y); |
1168 | 5374 return -1; |
5375 } | |
2967 | 5376 |
1168 | 5377 if(IS_INTRA4x4(mb_type)) |
5378 cbp= golomb_to_intra4x4_cbp[cbp]; | |
5379 else | |
5380 cbp= golomb_to_inter_cbp[cbp]; | |
5381 } | |
3651 | 5382 h->cbp = cbp; |
1168 | 5383 |
2755 | 5384 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ |
5385 if(get_bits1(&s->gb)) | |
5386 mb_type |= MB_TYPE_8x8DCT; | |
5387 } | |
5388 s->current_picture.mb_type[mb_xy]= mb_type; | |
5389 | |
1168 | 5390 if(cbp || IS_INTRA16x16(mb_type)){ |
5391 int i8x8, i4x4, chroma_idx; | |
5392 int chroma_qp, dquant; | |
5393 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; | |
3174 | 5394 const uint8_t *scan, *scan8x8, *dc_scan; |
2967 | 5395 |
1168 | 5396 // fill_non_zero_count_cache(h); |
5397 | |
5398 if(IS_INTERLACED(mb_type)){ | |
3316 | 5399 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; |
2763 | 5400 scan= s->qscale ? h->field_scan : h->field_scan_q0; |
1168 | 5401 dc_scan= luma_dc_field_scan; |
5402 }else{ | |
3316 | 5403 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; |
2763 | 5404 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; |
1168 | 5405 dc_scan= luma_dc_zigzag_scan; |
5406 } | |
5407 | |
5408 dquant= get_se_golomb(&s->gb); | |
5409 | |
5410 if( dquant > 25 || dquant < -26 ){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
5411 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 | 5412 return -1; |
5413 } | |
2967 | 5414 |
1168 | 5415 s->qscale += dquant; |
5416 if(((unsigned)s->qscale) > 51){ | |
5417 if(s->qscale<0) s->qscale+= 52; | |
5418 else s->qscale-= 52; | |
5419 } | |
2967 | 5420 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
5421 h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale); |
1168 | 5422 if(IS_INTRA16x16(mb_type)){ |
2919 | 5423 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
|
5424 return -1; //FIXME continue if partitioned and other return -1 too |
1168 | 5425 } |
5426 | |
5427 assert((cbp&15) == 0 || (cbp&15) == 15); | |
5428 | |
5429 if(cbp&15){ | |
5430 for(i8x8=0; i8x8<4; i8x8++){ | |
5431 for(i4x4=0; i4x4<4; i4x4++){ | |
5432 const int index= i4x4 + 4*i8x8; | |
2919 | 5433 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ |
1168 | 5434 return -1; |
5435 } | |
5436 } | |
5437 } | |
5438 }else{ | |
1636 | 5439 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); |
1168 | 5440 } |
5441 }else{ | |
5442 for(i8x8=0; i8x8<4; i8x8++){ | |
5443 if(cbp & (1<<i8x8)){ | |
2755 | 5444 if(IS_8x8DCT(mb_type)){ |
5445 DCTELEM *buf = &h->mb[64*i8x8]; | |
2757 | 5446 uint8_t *nnz; |
2755 | 5447 for(i4x4=0; i4x4<4; i4x4++){ |
3174 | 5448 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, |
2919 | 5449 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) |
2755 | 5450 return -1; |
5451 } | |
2757 | 5452 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
|
5453 nnz[0] += nnz[1] + nnz[8] + nnz[9]; |
2755 | 5454 }else{ |
5455 for(i4x4=0; i4x4<4; i4x4++){ | |
5456 const int index= i4x4 + 4*i8x8; | |
2967 | 5457 |
2919 | 5458 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 | 5459 return -1; |
5460 } | |
1168 | 5461 } |
5462 } | |
5463 }else{ | |
5464 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
5465 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
5466 } | |
5467 } | |
5468 } | |
2967 | 5469 |
1168 | 5470 if(cbp&0x30){ |
5471 for(chroma_idx=0; chroma_idx<2; chroma_idx++) | |
2919 | 5472 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ |
1168 | 5473 return -1; |
5474 } | |
5475 } | |
5476 | |
5477 if(cbp&0x20){ | |
5478 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ | |
5479 for(i4x4=0; i4x4<4; i4x4++){ | |
5480 const int index= 16 + 4*chroma_idx + i4x4; | |
2919 | 5481 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 | 5482 return -1; |
5483 } | |
5484 } | |
5485 } | |
5486 }else{ | |
5487 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
5488 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
5489 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
5490 } | |
5491 }else{ | |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
5492 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
|
5493 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
|
5494 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
|
5495 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; |
1168 | 5496 } |
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
|
5497 s->current_picture.qscale_table[mb_xy]= s->qscale; |
1168 | 5498 write_back_non_zero_count(h); |
5499 | |
3316 | 5500 if(MB_MBAFF){ |
5501 h->ref_count[0] >>= 1; | |
5502 h->ref_count[1] >>= 1; | |
5503 } | |
5504 | |
1168 | 5505 return 0; |
5506 } | |
5507 | |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5508 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
|
5509 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
|
5510 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
|
5511 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
|
5512 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
|
5513 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
|
5514 |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5515 unsigned int ctx = 0; |
2967 | 5516 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5517 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
|
5518 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5519 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5520 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
|
5521 ctx += 1; |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5522 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5523 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5524 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
|
5525 } |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5526 |
2312 | 5527 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { |
5528 uint8_t *state= &h->cabac_state[ctx_base]; | |
5529 int mb_type; | |
2967 | 5530 |
2312 | 5531 if(intra_slice){ |
5532 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
|
5533 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
|
5534 const int mbb_xy = h->top_mb_xy; |
2312 | 5535 int ctx=0; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5536 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
|
5537 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5538 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
|
5539 ctx++; |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5540 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) |
2312 | 5541 return 0; /* I4x4 */ |
5542 state += 2; | |
5543 }else{ | |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5544 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
|
5545 return 0; /* I4x4 */ |
2312 | 5546 } |
5547 | |
5548 if( get_cabac_terminate( &h->cabac ) ) | |
5549 return 25; /* PCM */ | |
5550 | |
5551 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
|
5552 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
|
5553 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
|
5554 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
|
5555 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
|
5556 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); |
2312 | 5557 return mb_type; |
5558 } | |
5559 | |
5560 static int decode_cabac_mb_type( H264Context *h ) { | |
5561 MpegEncContext * const s = &h->s; | |
5562 | |
5563 if( h->slice_type == I_TYPE ) { | |
5564 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
|
5565 } 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
|
5566 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
|
5567 /* 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
|
5568 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { |
3138 | 5569 /* 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
|
5570 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
|
5571 } else { |
3138 | 5572 /* 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
|
5573 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
|
5574 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5575 } else { |
2312 | 5576 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
|
5577 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5578 } 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
|
5579 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
|
5580 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
|
5581 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
|
5582 int bits; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5583 |
3138 | 5584 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
|
5585 ctx++; |
3138 | 5586 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
|
5587 ctx++; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5588 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5589 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
|
5590 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
|
5591 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5592 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
|
5593 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
|
5594 } |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5595 |
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5596 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
|
5597 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
|
5598 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
|
5599 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
|
5600 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
|
5601 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
|
5602 else if( bits == 13 ) { |
2312 | 5603 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
|
5604 } 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
|
5605 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
|
5606 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
|
5607 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
|
5608 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5609 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
|
5610 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
|
5611 } else { |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5612 /* 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
|
5613 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
|
5614 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5615 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5616 |
3316 | 5617 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
|
5618 MpegEncContext * const s = &h->s; |
3316 | 5619 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
|
5620 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
|
5621 |
3316 | 5622 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? |
5623 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
5624 mba_xy = mb_xy - 1; | |
5625 if( (mb_y&1) | |
5626 && h->slice_table[mba_xy] == h->slice_num | |
5627 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
5628 mba_xy += s->mb_stride; | |
5629 if( MB_FIELD ){ | |
5630 mbb_xy = mb_xy - s->mb_stride; | |
5631 if( !(mb_y&1) | |
5632 && h->slice_table[mbb_xy] == h->slice_num | |
5633 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
5634 mbb_xy -= s->mb_stride; | |
5635 }else | |
5636 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
5637 }else{ | |
5638 int mb_xy = mb_x + mb_y*s->mb_stride; | |
5639 mba_xy = mb_xy - 1; | |
5640 mbb_xy = mb_xy - s->mb_stride; | |
5641 } | |
5642 | |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5643 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
|
5644 ctx++; |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5645 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
|
5646 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5647 |
3138 | 5648 if( h->slice_type == B_TYPE ) |
5649 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
|
5650 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
|
5651 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5652 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5653 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
|
5654 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
|
5655 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5656 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
|
5657 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
|
5658 |
2928 | 5659 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); |
5660 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5661 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
5662 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5663 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
|
5664 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
|
5665 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5666 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
|
5667 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5668 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5669 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
|
5670 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
|
5671 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
|
5672 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5673 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
|
5674 |
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
|
5675 /* 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
|
5676 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
|
5677 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
|
5678 |
2498
4d6d056a00c6
H.264 multiple slice support in CABAC patch by (Loic (lll+ffmpeg m4x org)
michael
parents:
2485
diff
changeset
|
5679 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
|
5680 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5681 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5682 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
|
5683 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
|
5684 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5685 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
|
5686 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
|
5687 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
|
5688 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
|
5689 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5690 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
|
5691 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5692 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5693 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
|
5694 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
|
5695 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5696 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
|
5697 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
|
5698 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5699 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
|
5700 { 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
|
5701 { 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
|
5702 { 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
|
5703 { 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
|
5704 }; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5705 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5706 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
|
5707 int cbp = 0; |
3138 | 5708 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
|
5709 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
|
5710 |
3138 | 5711 if( h->slice_table[h->top_mb_xy] == h->slice_num ) { |
5712 cbp_b = h->top_cbp; | |
5713 tprintf("cbp_b = top_cbp = %x\n", cbp_b); | |
5714 } | |
5715 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5716 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
|
5717 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
|
5718 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
|
5719 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
|
5720 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5721 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
|
5722 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
|
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 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
|
5725 cbp_a = cbp; |
3138 | 5726 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
|
5727 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
|
5728 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
|
5729 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5730 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5731 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
|
5732 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
|
5733 |
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 /* 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
|
5735 /* 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
|
5736 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
|
5737 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
|
5738 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
|
5739 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5740 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5741 |
2594
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
5742 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
|
5743 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
|
5744 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
|
5745 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
|
5746 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5747 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5748 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
|
5749 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
|
5750 } |
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 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
|
5753 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5754 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
|
5755 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
|
5756 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
|
5757 |
2314 | 5758 cbp_a = (h->left_cbp>>4)&0x03; |
5759 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
|
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 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
|
5762 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
|
5763 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
|
5764 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
|
5765 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
|
5766 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5767 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
|
5768 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
|
5769 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
|
5770 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
|
5771 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5772 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
|
5773 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
|
5774 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
|
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 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
|
5777 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5778 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
|
5779 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
|
5780 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5781 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
|
5782 |
3316 | 5783 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
|
5784 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5785 |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
5786 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
|
5787 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
|
5788 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
|
5789 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5790 ctx = 3; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5791 val++; |
3128 | 5792 if(val > 102) //prevent infinite loop |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
5793 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
|
5794 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5795 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5796 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
|
5797 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
|
5798 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5799 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
|
5800 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5801 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
|
5802 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
|
5803 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
|
5804 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
|
5805 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
|
5806 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
|
5807 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
|
5808 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
|
5809 } |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5810 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
|
5811 int type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5812 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
|
5813 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
|
5814 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
|
5815 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
|
5816 type = 3; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5817 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
|
5818 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
|
5819 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
|
5820 type += 4; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5821 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5822 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
|
5823 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
|
5824 return type; |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
5825 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5826 |
2755 | 5827 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
|
5828 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
2755 | 5829 } |
5830 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5831 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
|
5832 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
|
5833 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
|
5834 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
|
5835 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
|
5836 |
2396 | 5837 if( h->slice_type == B_TYPE) { |
5838 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
5839 ctx++; | |
5840 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
5841 ctx += 2; | |
5842 } else { | |
5843 if( refa > 0 ) | |
5844 ctx++; | |
5845 if( refb > 0 ) | |
5846 ctx += 2; | |
5847 } | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5848 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5849 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
|
5850 ref++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5851 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
|
5852 ctx = 4; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5853 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5854 ctx = 5; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5855 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5856 return ref; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5857 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5858 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5859 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
|
5860 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
|
5861 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
|
5862 int ctxbase = (l == 0) ? 40 : 47; |
2317 | 5863 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
|
5864 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5865 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
|
5866 ctx = 0; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5867 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
|
5868 ctx = 2; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5869 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5870 ctx = 1; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5871 |
2317 | 5872 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) |
5873 return 0; | |
5874 | |
5875 mvd= 1; | |
5876 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
|
5877 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
|
5878 mvd++; |
2317 | 5879 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
|
5880 ctx++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5881 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5882 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5883 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
|
5884 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
|
5885 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
|
5886 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
|
5887 k++; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5888 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5889 while( k-- ) { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5890 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
|
5891 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
|
5892 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5893 } |
4042 | 5894 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
|
5895 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
5896 |
2316 | 5897 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) { |
2314 | 5898 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
|
5899 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
|
5900 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5901 if( cat == 0 ) { |
2314 | 5902 nza = h->left_cbp&0x100; |
5903 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
|
5904 } else if( cat == 1 || cat == 2 ) { |
2314 | 5905 nza = h->non_zero_count_cache[scan8[idx] - 1]; |
5906 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
|
5907 } else if( cat == 3 ) { |
2314 | 5908 nza = (h->left_cbp>>(6+idx))&0x01; |
5909 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
5910 } else { | |
5911 assert(cat == 4); | |
5912 nza = h->non_zero_count_cache[scan8[16+idx] - 1]; | |
5913 nzb = h->non_zero_count_cache[scan8[16+idx] - 8]; | |
5914 } | |
5915 | |
5916 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
|
5917 ctx++; |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5918 |
2314 | 5919 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
|
5920 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
|
5921 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5922 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
|
5923 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5924 |
4051 | 5925 static const __attribute((used)) uint8_t last_coeff_flag_offset_8x8[63] = { |
5926 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
5927 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
5928 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
5929 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
5930 }; | |
5931 | |
3028 | 5932 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
|
5933 const int mb_xy = h->s.mb_x + h->s.mb_y*h->s.mb_stride; |
3316 | 5934 static const int significant_coeff_flag_offset[2][6] = { |
5935 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
5936 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
5937 }; | |
5938 static const int last_coeff_flag_offset[2][6] = { | |
5939 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
5940 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
5941 }; | |
5942 static const int coeff_abs_level_m1_offset[6] = { | |
5943 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
5944 }; | |
4007 | 5945 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { |
3316 | 5946 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
2755 | 5947 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, |
5948 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
3316 | 5949 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, |
5950 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
5951 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
5952 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
5953 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
2755 | 5954 }; |
5955 | |
5956 int index[64]; | |
2313 | 5957 |
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
|
5958 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
|
5959 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
|
5960 |
2316 | 5961 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
|
5962 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
|
5963 |
2898 | 5964 uint8_t *significant_coeff_ctx_base; |
5965 uint8_t *last_coeff_ctx_base; | |
5966 uint8_t *abs_level_m1_ctx_base; | |
2755 | 5967 |
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
|
5968 #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
|
5969 #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
|
5970 #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
|
5971 #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
|
5972 #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
|
5973 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
|
5974 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
|
5975 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
|
5976 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
|
5977 #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
|
5978 #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
|
5979 #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
|
5980 |
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
|
5981 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5982 /* 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
|
5983 * 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
|
5984 * 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
|
5985 * 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
|
5986 * 4-> AC Chroma n = 4 * iCbCr + chroma4x4idx |
2755 | 5987 * 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
|
5988 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5989 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
5990 /* read coded block flag */ |
2898 | 5991 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
|
5992 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) { |
2755 | 5993 if( cat == 1 || cat == 2 ) |
5994 h->non_zero_count_cache[scan8[n]] = 0; | |
5995 else if( cat == 4 ) | |
5996 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
|
5997 #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
|
5998 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
|
5999 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
|
6000 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
|
6001 #endif |
2755 | 6002 return 0; |
6003 } | |
2898 | 6004 } |
6005 | |
6006 significant_coeff_ctx_base = h->cabac_state | |
3316 | 6007 + significant_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6008 last_coeff_ctx_base = h->cabac_state |
3316 | 6009 + last_coeff_flag_offset[MB_FIELD][cat]; |
2898 | 6010 abs_level_m1_ctx_base = h->cabac_state |
6011 + coeff_abs_level_m1_offset[cat]; | |
6012 | |
6013 if( cat == 5 ) { | |
6014 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
6015 for(last= 0; last < coefs; last++) { \ | |
6016 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
|
6017 if( get_cabac( CC, sig_ctx )) { \ |
2898 | 6018 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ |
6019 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
|
6020 if( get_cabac( CC, last_ctx ) ) { \ |
2898 | 6021 last= max_coeff; \ |
6022 break; \ | |
6023 } \ | |
6024 } \ | |
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
|
6025 }\ |
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
|
6026 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
|
6027 index[coeff_count++] = last;\ |
2898 | 6028 } |
4009 | 6029 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
|
6030 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__)) |
4051 | 6031 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); |
6032 } else { | |
6033 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
6034 #else | |
3316 | 6035 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); |
2898 | 6036 } else { |
6037 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
|
6038 #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
|
6039 } |
2316 | 6040 assert(coeff_count > 0); |
6041 | |
6042 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
|
6043 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
|
6044 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
|
6045 h->non_zero_count_cache[scan8[n]] = coeff_count; |
2316 | 6046 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
|
6047 h->cbp_table[mb_xy] |= 0x40 << n; |
2755 | 6048 else if( cat == 4 ) |
6049 h->non_zero_count_cache[scan8[16+n]] = coeff_count; | |
2316 | 6050 else { |
2755 | 6051 assert( cat == 5 ); |
3105
2d35fb3cb940
h264: special case dc-only idct. ~1% faster overall
lorenm
parents:
3101
diff
changeset
|
6052 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); |
2316 | 6053 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6054 |
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
|
6055 for( coeff_count--; coeff_count >= 0; coeff_count-- ) { |
2898 | 6056 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
|
6057 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
|
6058 |
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
|
6059 if( get_cabac( CC, ctx ) == 0 ) { |
2898 | 6060 if( !qmul ) { |
4040 | 6061 block[j] = get_cabac_bypass_sign( CC, -1); |
2316 | 6062 }else{ |
4040 | 6063 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;; |
2316 | 6064 } |
2967 | 6065 |
2313 | 6066 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
|
6067 } else { |
2313 | 6068 int coeff_abs = 2; |
2898 | 6069 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
|
6070 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { |
2313 | 6071 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
|
6072 } |
2313 | 6073 |
6074 if( coeff_abs >= 15 ) { | |
6075 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
|
6076 while( get_cabac_bypass( CC ) ) { |
2313 | 6077 j++; |
6078 } | |
2967 | 6079 |
4016 | 6080 coeff_abs=1; |
2313 | 6081 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
|
6082 coeff_abs += coeff_abs + get_cabac_bypass( CC ); |
2313 | 6083 } |
4016 | 6084 coeff_abs+= 14; |
2313 | 6085 } |
6086 | |
2898 | 6087 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
|
6088 if( get_cabac_bypass( CC ) ) block[j] = -coeff_abs; |
2316 | 6089 else block[j] = coeff_abs; |
6090 }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
|
6091 if( get_cabac_bypass( CC ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6; |
2919 | 6092 else block[j] = ( coeff_abs * qmul[j] + 32) >> 6; |
2316 | 6093 } |
2967 | 6094 |
2313 | 6095 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
|
6096 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6097 } |
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
|
6098 #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
|
6099 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
|
6100 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
|
6101 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
|
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 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
|
6104 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6105 |
3077 | 6106 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
|
6107 { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6108 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
|
6109 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
|
6110 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
|
6111 h->left_mb_xy[0] = mb_xy - 1; |
3316 | 6112 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
|
6113 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
|
6114 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
|
6115 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
|
6116 const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); |
3316 | 6117 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
|
6118 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
|
6119 if (bottom |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6120 ? !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
|
6121 : (!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
|
6122 ) { |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6123 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
|
6124 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6125 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
|
6126 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
|
6127 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6128 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6129 return; |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6130 } |
b5b09255f7c3
CABAC support for MBAFF I frames patch by (Loc Le Loarer < lll+ffmpeg m4x org)
michael
parents:
2594
diff
changeset
|
6131 |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6132 /** |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6133 * 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
|
6134 * @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
|
6135 */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6136 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
|
6137 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
|
6138 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
|
6139 int mb_type, partition_count, cbp = 0; |
2755 | 6140 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
|
6141 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6142 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
|
6143 |
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
|
6144 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
|
6145 if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) { |
3316 | 6146 int skip; |
6147 /* a skipped mb needs the aff flag from the following mb */ | |
6148 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
6149 predict_field_decoding_flag(h); | |
6150 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
6151 skip = h->next_mb_skipped; | |
6152 else | |
6153 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
|
6154 /* read skip flags */ |
3316 | 6155 if( skip ) { |
6156 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
6157 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
6158 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
6159 if(h->next_mb_skipped) | |
6160 predict_field_decoding_flag(h); | |
6161 else | |
6162 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
6163 } | |
6164 | |
2396 | 6165 decode_mb_skip(h); |
6166 | |
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 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
|
6168 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
|
6169 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
|
6170 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6171 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
|
6172 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6173 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6174 } |
3316 | 6175 if(FRAME_MBAFF){ |
6176 if( (s->mb_y&1) == 0 ) | |
6177 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
|
6178 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
|
6179 }else |
5357b214eda0
CABAC support for MBAFF I frames patch by (Loc Le Loarer | lll+ffmpeg m4x org)
michael
parents:
2583
diff
changeset
|
6180 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
|
6181 |
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
|
6182 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
|
6183 |
3077 | 6184 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
|
6185 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
|
6186 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
|
6187 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
|
6188 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6189 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6190 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
|
6191 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
|
6192 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
|
6193 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
|
6194 }else{ |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6195 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
|
6196 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
|
6197 } |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6198 } 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
|
6199 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
|
6200 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
|
6201 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
|
6202 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6203 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
|
6204 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
|
6205 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6206 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6207 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
|
6208 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
|
6209 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
|
6210 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
|
6211 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
|
6212 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
|
6213 } |
3316 | 6214 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
|
6215 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
|
6216 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6217 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
|
6218 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6219 if(IS_INTRA_PCM(mb_type)) { |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6220 const uint8_t *ptr; |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6221 unsigned int x, y; |
2967 | 6222 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6223 // 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
|
6224 // 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
|
6225 // 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
|
6226 ptr= h->cabac.bytestream; |
4344 | 6227 if(h->cabac.low&0x1) ptr--; |
6228 if(CABAC_BITS==16){ | |
6229 if(h->cabac.low&0x1FF) ptr--; | |
6230 } | |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6231 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6232 // 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
|
6233 for(y=0; y<16; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6234 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
|
6235 for(x=0; x<16; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6236 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr); |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6237 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
|
6238 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6239 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6240 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6241 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
|
6242 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6243 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
|
6244 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
|
6245 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6246 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6247 for(y=0; y<8; y++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6248 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
|
6249 for(x=0; x<8; x++){ |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6250 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
|
6251 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
|
6252 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6253 } |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6254 |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6255 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
|
6256 |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
6257 // All blocks are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6258 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
|
6259 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
|
6260 // In deblocking, the quantizer is 0 |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6261 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
|
6262 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
|
6263 // All coeffs are present |
2504
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
6264 memset(h->non_zero_count[mb_xy], 16, 16); |
2755 | 6265 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
|
6266 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
|
6267 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6268 |
3316 | 6269 if(MB_MBAFF){ |
6270 h->ref_count[0] <<= 1; | |
6271 h->ref_count[1] <<= 1; | |
6272 } | |
6273 | |
2449 | 6274 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
|
6275 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6276 if( IS_INTRA( mb_type ) ) { |
2755 | 6277 int 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
|
6278 if( IS_INTRA4x4( mb_type ) ) { |
2755 | 6279 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { |
6280 mb_type |= MB_TYPE_8x8DCT; | |
6281 for( i = 0; i < 16; i+=4 ) { | |
6282 int pred = pred_intra_mode( h, i ); | |
6283 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
6284 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
6285 } | |
6286 } else { | |
6287 for( i = 0; i < 16; i++ ) { | |
6288 int pred = pred_intra_mode( h, i ); | |
6289 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
|
6290 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6291 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); |
2755 | 6292 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6293 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6294 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
|
6295 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
|
6296 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6297 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
|
6298 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
|
6299 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6300 h->chroma_pred_mode_table[mb_xy] = |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6301 h->chroma_pred_mode = decode_cabac_mb_chroma_pre_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
|
6302 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6303 h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_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
|
6304 if( h->chroma_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
|
6305 } 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
|
6306 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
|
6307 |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6308 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
|
6309 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
|
6310 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
|
6311 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
|
6312 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
|
6313 } |
3482 | 6314 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | |
6315 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
2396 | 6316 pred_direct_motion(h, &mb_type); |
6317 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
6318 for( i = 0; i < 4; i++ ) | |
6319 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
6320 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
6321 } | |
6322 } | |
2310
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6323 } else { |
c5cd8a064c34
H.264 CABAC + B-frames patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2284
diff
changeset
|
6324 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
|
6325 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
|
6326 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
|
6327 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
|
6328 } |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6329 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6330 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6331 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
|
6332 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
|
6333 for( i = 0; i < 4; i++ ) { |
2396 | 6334 if(IS_DIRECT(h->sub_mb_type[i])) continue; |
6335 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
|
6336 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
|
6337 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
|
6338 else |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6339 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
|
6340 } else { |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6341 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
|
6342 } |
2110 | 6343 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
|
6344 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
|
6345 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6346 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6347 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6348 |
2755 | 6349 if(dct8x8_allowed) |
6350 dct8x8_allowed = get_dct8x8_allowed(h); | |
6351 | |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6352 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
|
6353 for(i=0; i<4; i++){ |
2396 | 6354 if(IS_DIRECT(h->sub_mb_type[i])){ |
6355 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
6356 continue; | |
6357 } | |
2110 | 6358 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
|
6359 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6360 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
|
6361 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
|
6362 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
|
6363 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
|
6364 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
|
6365 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
|
6366 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
|
6367 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
|
6368 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
|
6369 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
|
6370 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6371 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
|
6372 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
|
6373 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
|
6374 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6375 if(IS_SUB_8X8(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6376 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6377 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6378 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6379 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
|
6380 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6381 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6382 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6383 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6384 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
|
6385 }else if(IS_SUB_8X4(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6386 mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6387 mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6388 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6389 mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6390 mvd_cache[ 0 ][1]= mvd_cache[ 1 ][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
|
6391 }else if(IS_SUB_4X8(sub_mb_type)){ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6392 mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6393 mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my; |
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 mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6396 mvd_cache[ 0 ][1]= mvd_cache[ 8 ][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
|
6397 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6398 assert(IS_SUB_4X4(sub_mb_type)); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6399 mv_cache[ 0 ][0]= mx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6400 mv_cache[ 0 ][1]= my; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6401 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6402 mvd_cache[ 0 ][0]= mx - mpx; |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6403 mvd_cache[ 0 ][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
|
6404 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6405 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6406 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6407 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
|
6408 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
|
6409 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
|
6410 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
|
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 } |
2396 | 6414 } else if( IS_DIRECT(mb_type) ) { |
6415 pred_direct_motion(h, &mb_type); | |
6416 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
6417 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
2755 | 6418 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
2396 | 6419 } else { |
1935
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6420 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
|
6421 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
|
6422 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
|
6423 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
|
6424 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
|
6425 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
|
6426 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
|
6427 } |
2523 | 6428 }else |
6429 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
|
6430 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6431 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
|
6432 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
|
6433 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
|
6434 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6435 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
|
6436 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
|
6437 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
|
6438 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6439 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
|
6440 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
2523 | 6441 }else |
6442 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
|
6443 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6444 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6445 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
|
6446 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
|
6447 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
|
6448 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
|
6449 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
|
6450 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
|
6451 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); |
2396 | 6452 }else |
6453 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
|
6454 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6455 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6456 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6457 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
|
6458 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
|
6459 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
|
6460 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
|
6461 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
|
6462 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
|
6463 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
|
6464 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6465 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
|
6466 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
2523 | 6467 }else{ |
2396 | 6468 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
6469 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
|
6470 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6471 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6472 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6473 }else{ |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6474 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
|
6475 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
|
6476 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
|
6477 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
|
6478 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
|
6479 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
|
6480 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); |
2396 | 6481 }else |
6482 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
|
6483 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6484 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6485 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6486 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
|
6487 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
|
6488 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
|
6489 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
|
6490 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
|
6491 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
|
6492 |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6493 tprintf("final mv:%d %d\n", mx, my); |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6494 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
|
6495 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
2523 | 6496 }else{ |
2396 | 6497 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
6498 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
|
6499 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6500 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6501 } |
e935af90767b
progressive P frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1909
diff
changeset
|
6502 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6503 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6504 |
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
|
6505 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
|
6506 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
|
6507 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
|
6508 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6509 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6510 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
|
6511 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
|
6512 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
|
6513 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6514 |
3651 | 6515 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
|
6516 |
2755 | 6517 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { |
6518 if( decode_cabac_mb_transform_size( h ) ) | |
6519 mb_type |= MB_TYPE_8x8DCT; | |
6520 } | |
6521 s->current_picture.mb_type[mb_xy]= mb_type; | |
6522 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6523 if( cbp || IS_INTRA16x16( mb_type ) ) { |
3174 | 6524 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
|
6525 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
|
6526 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6527 if(IS_INTERLACED(mb_type)){ |
3316 | 6528 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; |
2763 | 6529 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
|
6530 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
|
6531 }else{ |
3316 | 6532 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; |
2763 | 6533 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
|
6534 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
|
6535 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6536 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6537 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
|
6538 if( dqp == INT_MIN ){ |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6539 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
|
6540 return -1; |
a95e55679dfa
check return value of decode_cabac_mb_dqp, it is INT_MIN on error.
reimar
parents:
2867
diff
changeset
|
6541 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6542 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
|
6543 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
|
6544 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
|
6545 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
|
6546 } |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6547 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
|
6548 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6549 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
|
6550 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
|
6551 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); |
2898 | 6552 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
|
6553 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
|
6554 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
|
6555 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
|
6556 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); |
2919 | 6557 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
|
6558 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
|
6559 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6560 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6561 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
|
6562 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6563 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6564 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
|
6565 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
|
6566 if( cbp & (1<<i8x8) ) { |
2755 | 6567 if( IS_8x8DCT(mb_type) ) { |
6568 if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
3174 | 6569 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 ) |
2755 | 6570 return -1; |
6571 } 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
|
6572 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
|
6573 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
|
6574 //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
|
6575 //START_TIMER |
2919 | 6576 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
|
6577 return -1; |
3972
f5f1c9af095d
move outcommented START/STOP_TIMER to a hopefully better place for benchmarking ...
michael
parents:
3955
diff
changeset
|
6578 //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
|
6579 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6580 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6581 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
|
6582 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
|
6583 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6584 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6585 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6586 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6587 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
|
6588 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
|
6589 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
|
6590 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); |
2898 | 6591 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
|
6592 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
|
6593 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6594 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6595 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6596 if( 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
|
6597 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
|
6598 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
|
6599 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
|
6600 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
|
6601 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); |
2919 | 6602 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
|
6603 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
|
6604 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6605 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6606 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6607 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
|
6608 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
|
6609 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
|
6610 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6611 } else { |
2315 | 6612 uint8_t * const nnz= &h->non_zero_count_cache[0]; |
6613 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
6614 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
6615 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
3316 | 6616 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
|
6617 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6618 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6619 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
|
6620 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
|
6621 |
3316 | 6622 if(MB_MBAFF){ |
6623 h->ref_count[0] >>= 1; | |
6624 h->ref_count[1] >>= 1; | |
6625 } | |
6626 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6627 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
|
6628 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6629 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
6630 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6631 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
|
6632 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
|
6633 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
|
6634 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
|
6635 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
|
6636 |
2633 | 6637 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
|
6638 int8_t tc[4]; |
2633 | 6639 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
|
6640 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6641 h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc); |
6642 } else { | |
6643 /* 16px edge length, because bS=4 is triggered by being at | |
6644 * the edge of an intra MB, so all 4 bS are the same */ | |
6645 for( d = 0; d < 16; d++ ) { | |
1898 | 6646 const int p0 = pix[-1]; |
6647 const int p1 = pix[-2]; | |
6648 const int p2 = pix[-3]; | |
6649 | |
6650 const int q0 = pix[0]; | |
6651 const int q1 = pix[1]; | |
6652 const int q2 = pix[2]; | |
6653 | |
4001 | 6654 if( FFABS( p0 - q0 ) < alpha && |
6655 FFABS( p1 - p0 ) < beta && | |
6656 FFABS( q1 - q0 ) < beta ) { | |
6657 | |
6658 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6659 if( FFABS( p2 - p0 ) < beta) | |
1898 | 6660 { |
6661 const int p3 = pix[-4]; | |
6662 /* p0', p1', p2' */ | |
6663 pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6664 pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6665 pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6666 } else { | |
6667 /* p0' */ | |
6668 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6669 } | |
4001 | 6670 if( FFABS( q2 - q0 ) < beta) |
1898 | 6671 { |
6672 const int q3 = pix[3]; | |
6673 /* q0', q1', q2' */ | |
6674 pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6675 pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6676 pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6677 } else { | |
6678 /* q0' */ | |
6679 pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6680 } | |
6681 }else{ | |
6682 /* p0', q0' */ | |
6683 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6684 pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6685 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6686 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
|
6687 } |
1898 | 6688 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
|
6689 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6690 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6691 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6692 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6693 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6694 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
|
6695 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
|
6696 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
|
6697 |
2633 | 6698 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
|
6699 int8_t tc[4]; |
2633 | 6700 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
|
6701 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6702 h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6703 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6704 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
|
6705 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6706 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6707 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6708 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
|
6709 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6710 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
|
6711 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6712 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6713 int beta; |
2967 | 6714 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6715 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6716 int bS_index = (i >> 1); |
3316 | 6717 if (!MB_FIELD) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6718 bS_index &= ~1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6719 bS_index |= (i & 1); |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6720 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6721 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6722 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6723 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6724 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6725 |
3316 | 6726 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
|
6727 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
|
6728 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
|
6729 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
|
6730 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6731 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
|
6732 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
|
6733 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6734 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6735 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6736 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6737 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6738 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6739 |
4001 | 6740 if( FFABS( p0 - q0 ) < alpha && |
6741 FFABS( p1 - p0 ) < beta && | |
6742 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6743 int tc = tc0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6744 int i_delta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6745 |
4001 | 6746 if( FFABS( p2 - p0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6747 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
|
6748 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6749 } |
4001 | 6750 if( FFABS( q2 - q0 ) < beta ) { |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6751 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
|
6752 tc++; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6753 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6754 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6755 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
|
6756 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
|
6757 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
|
6758 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
|
6759 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6760 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6761 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6762 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6763 const int p2 = pix[-3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6764 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6765 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6766 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6767 const int q2 = pix[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6768 |
4001 | 6769 if( FFABS( p0 - q0 ) < alpha && |
6770 FFABS( p1 - p0 ) < beta && | |
6771 FFABS( q1 - q0 ) < beta ) { | |
6772 | |
6773 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ | |
6774 if( FFABS( p2 - p0 ) < beta) | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6775 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6776 const int p3 = pix[-4]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6777 /* p0', p1', p2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6778 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
|
6779 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
|
6780 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
|
6781 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6782 /* p0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6783 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
|
6784 } |
4001 | 6785 if( FFABS( q2 - q0 ) < beta) |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6786 { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6787 const int q3 = pix[3]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6788 /* q0', q1', q2' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6789 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
|
6790 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
|
6791 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
|
6792 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6793 /* q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6794 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
|
6795 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6796 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6797 /* p0', q0' */ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6798 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
|
6799 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
|
6800 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6801 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
|
6802 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6803 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6804 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6805 } |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6806 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
|
6807 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6808 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
|
6809 int index_a; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6810 int alpha; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6811 int beta; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6812 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6813 int qp_index; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6814 int bS_index = i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6815 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6816 if( bS[bS_index] == 0 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6817 continue; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6818 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6819 |
3316 | 6820 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
|
6821 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
|
6822 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
|
6823 beta = (beta_table+52)[qp[qp_index] + h->slice_beta_offset]; |
3316 | 6824 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6825 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
|
6826 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
|
6827 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6828 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6829 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6830 const int q1 = pix[1]; |
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 ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6835 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
|
6836 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6837 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
|
6838 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
|
6839 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
|
6840 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6841 }else{ |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6842 const int p0 = pix[-1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6843 const int p1 = pix[-2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6844 const int q0 = pix[0]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6845 const int q1 = pix[1]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6846 |
4001 | 6847 if( FFABS( p0 - q0 ) < alpha && |
6848 FFABS( p1 - p0 ) < beta && | |
6849 FFABS( q1 - q0 ) < beta ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6850 |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6851 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
|
6852 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
|
6853 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
|
6854 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6855 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6856 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6857 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6858 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6859 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
|
6860 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
|
6861 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
|
6862 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
|
6863 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
|
6864 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
|
6865 |
2633 | 6866 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
|
6867 int8_t tc[4]; |
2633 | 6868 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
|
6869 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1; |
2633 | 6870 h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc); |
6871 } else { | |
6872 /* 16px edge length, see filter_mb_edgev */ | |
6873 for( d = 0; d < 16; d++ ) { | |
1898 | 6874 const int p0 = pix[-1*pix_next]; |
6875 const int p1 = pix[-2*pix_next]; | |
6876 const int p2 = pix[-3*pix_next]; | |
6877 const int q0 = pix[0]; | |
6878 const int q1 = pix[1*pix_next]; | |
6879 const int q2 = pix[2*pix_next]; | |
6880 | |
4001 | 6881 if( FFABS( p0 - q0 ) < alpha && |
6882 FFABS( p1 - p0 ) < beta && | |
6883 FFABS( q1 - q0 ) < beta ) { | |
1898 | 6884 |
6885 const int p3 = pix[-4*pix_next]; | |
6886 const int q3 = pix[ 3*pix_next]; | |
6887 | |
4001 | 6888 if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){ |
6889 if( FFABS( p2 - p0 ) < beta) { | |
1898 | 6890 /* p0', p1', p2' */ |
6891 pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3; | |
6892 pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2; | |
6893 pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3; | |
6894 } else { | |
6895 /* p0' */ | |
6896 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6897 } | |
4001 | 6898 if( FFABS( q2 - q0 ) < beta) { |
1898 | 6899 /* q0', q1', q2' */ |
6900 pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3; | |
6901 pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2; | |
6902 pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3; | |
6903 } else { | |
6904 /* q0' */ | |
6905 pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6906 } | |
6907 }else{ | |
6908 /* p0', q0' */ | |
6909 pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2; | |
6910 pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2; | |
6911 } | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
6912 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
|
6913 } |
1898 | 6914 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
|
6915 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6916 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6917 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6918 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6919 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { |
2834 | 6920 int i; |
4118
a1786732cd62
merge clip() into the alpha/beta/tc0 tables (10% faster filter_mb_fast() on P3)
michael
parents:
4113
diff
changeset
|
6921 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
|
6922 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
|
6923 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
|
6924 |
2633 | 6925 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
|
6926 int8_t tc[4]; |
2633 | 6927 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
|
6928 tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0; |
2633 | 6929 h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc); |
6930 } else { | |
2707
360024d31dab
H.264 deblocking optimizations (mmx for chroma_bS4 case, convert existing cases to 8-bit math)
lorenm
parents:
2683
diff
changeset
|
6931 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
|
6932 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6933 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
6934 |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6935 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
|
6936 MpegEncContext * const s = &h->s; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6937 int mb_xy, mb_type; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6938 int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6939 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6940 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
|
6941 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
|
6942 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6943 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6944 assert(!FRAME_MBAFF); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6945 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6946 mb_xy = mb_x + mb_y*s->mb_stride; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6947 mb_type = s->current_picture.mb_type[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6948 qp = s->current_picture.qscale_table[mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6949 qp0 = s->current_picture.qscale_table[mb_xy-1]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6950 qp1 = s->current_picture.qscale_table[h->top_mb_xy]; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6951 qpc = get_chroma_qp( h->pps.chroma_qp_index_offset, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6952 qpc0 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6953 qpc1 = get_chroma_qp( h->pps.chroma_qp_index_offset, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6954 qp0 = (qp + qp0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6955 qp1 = (qp + qp1 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6956 qpc0 = (qpc + qpc0 + 1) >> 1; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6957 qpc1 = (qpc + qpc1 + 1) >> 1; |
3651 | 6958 qp_thresh = 15 - h->slice_alpha_c0_offset; |
6959 if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh && | |
6960 qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh) | |
6961 return; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6962 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6963 if( IS_INTRA(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6964 int16_t bS4[4] = {4,4,4,4}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6965 int16_t bS3[4] = {3,3,3,3}; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6966 if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6967 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6968 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6969 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6970 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6971 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6972 filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6973 filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6974 filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6975 filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6976 filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bS4, qp1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6977 filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6978 filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6979 filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6980 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6981 filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6982 filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6983 filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6984 filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6985 filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6986 filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6987 filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bS4, qpc1 ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6988 filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc ); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6989 return; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6990 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6991 DECLARE_ALIGNED_8(int16_t, bS[2][4][4]); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
6992 uint64_t (*bSv)[4] = (uint64_t(*)[4])bS; |
3651 | 6993 int edges; |
6994 if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) { | |
6995 edges = 4; | |
6996 bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL; | |
6997 } else { | |
6998 int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 : | |
6999 (mb_type & MB_TYPE_16x8) ? 1 : 0; | |
7000 int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7001 && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16)) | |
7002 ? 3 : 0; | |
7003 int step = IS_8x8DCT(mb_type) ? 2 : 1; | |
7004 edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4; | |
7005 s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache, | |
7006 (h->slice_type == B_TYPE), edges, step, mask_edge0, mask_edge1 ); | |
7007 } | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7008 if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7009 bSv[0][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7010 if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) ) |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7011 bSv[1][0] = 0x0004000400040004ULL; |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7012 |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7013 #define FILTER(hv,dir,edge)\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7014 if(bSv[dir][edge]) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7015 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
|
7016 if(!(edge&1)) {\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7017 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
|
7018 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
|
7019 }\ |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7020 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7021 if( edges == 1 ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7022 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7023 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7024 } else if( IS_8x8DCT(mb_type) ) { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7025 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7026 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7027 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7028 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7029 } else { |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7030 FILTER(v,0,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7031 FILTER(v,0,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7032 FILTER(v,0,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7033 FILTER(v,0,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7034 FILTER(h,1,0); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7035 FILTER(h,1,1); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7036 FILTER(h,1,2); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7037 FILTER(h,1,3); |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7038 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7039 #undef FILTER |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7040 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7041 } |
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7042 |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7043 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
|
7044 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
|
7045 const int mb_xy= mb_x + mb_y*s->mb_stride; |
3316 | 7046 const int mb_type = s->current_picture.mb_type[mb_xy]; |
7047 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
|
7048 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
|
7049 int dir; |
2629
202cd69d8d2e
fix ref comparison in B-frame deblocker ('unused' and 'unavailable' were treated as different)
lorenm
parents:
2628
diff
changeset
|
7050 /* 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
|
7051 * 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
|
7052 * frame numbers, not indices. */ |
3316 | 7053 static const int ref2frm[34] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, |
7054 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
|
7055 |
3101 | 7056 //for sufficiently low qp, filtering wouldn't do anything |
7057 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp | |
3316 | 7058 if(!FRAME_MBAFF){ |
3101 | 7059 int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX(0, h->pps.chroma_qp_index_offset); |
7060 int qp = s->current_picture.qscale_table[mb_xy]; | |
7061 if(qp <= qp_thresh | |
7062 && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh) | |
7063 && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){ | |
7064 return; | |
7065 } | |
7066 } | |
7067 | |
3316 | 7068 if (FRAME_MBAFF |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7069 // left mb is in picture |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7070 && 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
|
7071 // and current and left pair do not have the same interlaced type |
3316 | 7072 && (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
|
7073 // 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
|
7074 && (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
|
7075 /* 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
|
7076 * 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
|
7077 */ |
3316 | 7078 const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride; |
7079 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
|
7080 int16_t bS[8]; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7081 int qp[2]; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7082 int chroma_qp[2]; |
3316 | 7083 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
|
7084 int i; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7085 first_vertical_edge_done = 1; |
3316 | 7086 |
7087 if( IS_INTRA(mb_type) ) | |
7088 bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4; | |
7089 else { | |
7090 for( i = 0; i < 8; i++ ) { | |
7091 int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1]; | |
7092 | |
7093 if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) | |
7094 bS[i] = 4; | |
7095 else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 || | |
7096 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */ | |
7097 h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2] ) | |
7098 bS[i] = 2; | |
7099 else | |
7100 bS[i] = 1; | |
7101 } | |
7102 } | |
7103 | |
7104 mb_qp = s->current_picture.qscale_table[mb_xy]; | |
7105 mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]]; | |
7106 mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]]; | |
7107 qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; | |
7108 chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7109 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn0_qp ) + 1 ) >> 1; | |
7110 qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1; | |
7111 chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, mb_qp ) + | |
7112 get_chroma_qp( h->pps.chroma_qp_index_offset, mbn1_qp ) + 1 ) >> 1; | |
7113 | |
7114 /* Filter edge */ | |
7115 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); | |
7116 { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7117 filter_mb_mbaff_edgev ( h, &img_y [0], linesize, bS, qp ); | |
7118 filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp ); | |
7119 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
|
7120 } |
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
|
7121 /* 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
|
7122 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
|
7123 { |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7124 int edge; |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7125 const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; |
2924 | 7126 const int mbm_type = s->current_picture.mb_type[mbm_xy]; |
2454 | 7127 int start = h->slice_table[mbm_xy] == 255 ? 1 : 0; |
7128 | |
3101 | 7129 const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP)) |
7130 == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4; | |
2926 | 7131 // how often to recheck mv-based bS when iterating between edges |
7132 const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 : | |
7133 (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0; | |
7134 // how often to recheck mv-based bS when iterating along each edge | |
7135 const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)); | |
7136 | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7137 if (first_vertical_edge_done) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7138 start = 1; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7139 first_vertical_edge_done = 0; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7140 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7141 |
2454 | 7142 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
|
7143 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
|
7144 |
3316 | 7145 if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0 |
7146 && !IS_INTERLACED(mb_type) | |
7147 && IS_INTERLACED(mbm_type) | |
7148 ) { | |
7149 // This is a special case in the norm where the filtering must | |
7150 // be done twice (one each of the field) even if we are in a | |
7151 // frame macroblock. | |
7152 // | |
7153 static const int nnz_idx[4] = {4,5,6,3}; | |
7154 unsigned int tmp_linesize = 2 * linesize; | |
7155 unsigned int tmp_uvlinesize = 2 * uvlinesize; | |
7156 int mbn_xy = mb_xy - 2 * s->mb_stride; | |
7157 int qp, chroma_qp; | |
7158 int i, j; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7159 int16_t bS[4]; |
3316 | 7160 |
7161 for(j=0; j<2; j++, mbn_xy += s->mb_stride){ | |
7162 if( IS_INTRA(mb_type) || | |
7163 IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) { | |
7164 bS[0] = bS[1] = bS[2] = bS[3] = 3; | |
7165 } else { | |
7166 const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy]; | |
7167 for( i = 0; i < 4; i++ ) { | |
7168 if( h->non_zero_count_cache[scan8[0]+i] != 0 || | |
7169 mbn_nnz[nnz_idx[i]] != 0 ) | |
7170 bS[i] = 2; | |
7171 else | |
7172 bS[i] = 1; | |
7173 } | |
7174 } | |
7175 // Do not use s->qscale as luma quantizer because it has not the same | |
7176 // value in IPCM macroblocks. | |
7177 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1; | |
7178 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); | |
7179 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); } | |
7180 filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp ); | |
7181 chroma_qp = ( h->chroma_qp + | |
7182 get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1; | |
7183 filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7184 filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS, chroma_qp ); | |
7185 } | |
7186 | |
7187 start = 1; | |
7188 } | |
7189 | |
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
|
7190 /* Calculate bS */ |
2924 | 7191 for( edge = start; edge < edges; edge++ ) { |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7192 /* mbn_xy: neighbor macroblock */ |
2924 | 7193 const int mbn_xy = edge > 0 ? mb_xy : mbm_xy; |
7194 const int mbn_type = s->current_picture.mb_type[mbn_xy]; | |
3645
47821be55b6c
mmx implementation of deblocking strength decision.
lorenm
parents:
3519
diff
changeset
|
7195 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
|
7196 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
|
7197 |
2924 | 7198 if( (edge&1) && IS_8x8DCT(mb_type) ) |
2755 | 7199 continue; |
7200 | |
2924 | 7201 if( IS_INTRA(mb_type) || |
7202 IS_INTRA(mbn_type) ) { | |
2581
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7203 int value; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7204 if (edge == 0) { |
2924 | 7205 if ( (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type)) |
3316 | 7206 || ((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
|
7207 ) { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7208 value = 4; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7209 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7210 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7211 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7212 } else { |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7213 value = 3; |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7214 } |
ae72796e722f
This is the second patch for MBAFF support, this adds the deblocking
michael
parents:
2580
diff
changeset
|
7215 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
|
7216 } else { |
2924 | 7217 int i, l; |
7218 int mv_done; | |
7219 | |
7220 if( edge & mask_edge ) { | |
7221 bS[0] = bS[1] = bS[2] = bS[3] = 0; | |
7222 mv_done = 1; | |
7223 } | |
3316 | 7224 else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) { |
7225 bS[0] = bS[1] = bS[2] = bS[3] = 1; | |
7226 mv_done = 1; | |
7227 } | |
2924 | 7228 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) { |
7229 int b_idx= 8 + 4 + edge * (dir ? 8:1); | |
7230 int bn_idx= b_idx - (dir ? 8:1); | |
7231 int v = 0; | |
7232 for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) { | |
7233 v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || | |
4001 | 7234 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7235 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit; | |
2924 | 7236 } |
7237 bS[0] = bS[1] = bS[2] = bS[3] = v; | |
7238 mv_done = 1; | |
7239 } | |
7240 else | |
7241 mv_done = 0; | |
7242 | |
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
|
7243 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
|
7244 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
|
7245 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
|
7246 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
|
7247 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
|
7248 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7249 if( h->non_zero_count_cache[b_idx] != 0 || |
2449 | 7250 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
|
7251 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
|
7252 } |
2924 | 7253 else if(!mv_done) |
2523 | 7254 { |
7255 bS[i] = 0; | |
7256 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
|
7257 if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] || |
4001 | 7258 FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 || |
7259 FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) { | |
2523 | 7260 bS[i] = 1; |
7261 break; | |
7262 } | |
7263 } | |
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
|
7264 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7265 } |
1899
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7266 |
379a18a7131f
do loop filter immediatly after each macroblock is decoded instead of after a frame is decoded
michael
parents:
1898
diff
changeset
|
7267 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
|
7268 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
|
7269 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7270 |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7271 /* Filter edge */ |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
7272 // 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
|
7273 // value in IPCM macroblocks. |
f12657081093
INTRA PCM macroblocks support patch by (Loic )lll+ffmpeg m4x org)
michael
parents:
2498
diff
changeset
|
7274 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
|
7275 //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
|
7276 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
|
7277 { 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
|
7278 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
|
7279 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp ); |
1898 | 7280 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
|
7281 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
|
7282 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
|
7283 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
|
7284 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
|
7285 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7286 } 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
|
7287 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp ); |
1898 | 7288 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
|
7289 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
|
7290 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
|
7291 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
|
7292 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
|
7293 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7294 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7295 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7296 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7297 } |
4e8ed93524f6
h264 loop filter for progressive I&P frames by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1892
diff
changeset
|
7298 |
1168 | 7299 static int decode_slice(H264Context *h){ |
7300 MpegEncContext * const s = &h->s; | |
7301 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; | |
7302 | |
7303 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
|
7304 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7305 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
|
7306 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
|
7307 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7308 /* realign */ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7309 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
|
7310 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7311 /* 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
|
7312 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
|
7313 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
|
7314 s->gb.buffer + get_bits_count(&s->gb)/8, |
2116 | 7315 ( 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
|
7316 /* calculate pre-state */ |
2755 | 7317 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
|
7318 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
|
7319 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
|
7320 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
|
7321 else |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7322 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
|
7323 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7324 if( pre <= 63 ) |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7325 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
|
7326 else |
3976
27e90123b346
reverse remainder of the failed attempt to optimize *state=c->mps_state[s]
michael
parents:
3972
diff
changeset
|
7327 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; |
1168 | 7328 } |
7329 | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7330 for(;;){ |
4008
b636f3d59283
prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents:
4007
diff
changeset
|
7331 //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
|
7332 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
|
7333 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
|
7334 //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
|
7335 |
2163 | 7336 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
|
7337 |
3316 | 7338 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
|
7339 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
|
7340 |
2163 | 7341 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
|
7342 |
2844
5f20ab245501
prevent assert failures and infinite loops with broken streams
michael
parents:
2834
diff
changeset
|
7343 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
|
7344 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
|
7345 } |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7346 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
|
7347 |
3948
3edbf131ee44
refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents:
3947
diff
changeset
|
7348 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
|
7349 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
|
7350 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
|
7351 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
|
7352 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7353 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7354 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
|
7355 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
|
7356 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
2392 | 7357 ++s->mb_y; |
3316 | 7358 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7359 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7360 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7361 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7362 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7363 if( eos || s->mb_y >= s->mb_height ) { |
2392 | 7364 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
|
7365 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
|
7366 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
|
7367 } |
1168 | 7368 } |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7369 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7370 } else { |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7371 for(;;){ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7372 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
|
7373 |
2163 | 7374 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
|
7375 |
3316 | 7376 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
|
7377 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
|
7378 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
|
7379 |
2163 | 7380 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
|
7381 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
|
7382 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7383 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7384 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
|
7385 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
|
7386 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
|
7387 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7388 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
|
7389 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7390 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7391 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
|
7392 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
|
7393 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
|
7394 ++s->mb_y; |
3316 | 7395 if(FRAME_MBAFF) { |
2551
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7396 ++s->mb_y; |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7397 } |
615995277bc5
MBAFF I slice no deblocking patch by (Loic >>lll+ffmpeg m4x org<<)
michael
parents:
2548
diff
changeset
|
7398 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
|
7399 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
|
7400 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7401 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
|
7402 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
|
7403 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7404 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
|
7405 }else{ |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7406 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
|
7407 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7408 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
|
7409 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7410 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7411 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7412 |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7413 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ |
2392 | 7414 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
|
7415 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ |
1168 | 7416 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); |
7417 | |
7418 return 0; | |
7419 }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
|
7420 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 | 7421 |
7422 return -1; | |
7423 } | |
7424 } | |
7425 } | |
1908
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7426 } |
e20fd60b215c
h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents:
1899
diff
changeset
|
7427 |
1168 | 7428 #if 0 |
7429 for(;s->mb_y < s->mb_height; s->mb_y++){ | |
7430 for(;s->mb_x < s->mb_width; s->mb_x++){ | |
7431 int ret= decode_mb(h); | |
2967 | 7432 |
1168 | 7433 hl_decode_mb(h); |
7434 | |
7435 if(ret<0){ | |
3177 | 7436 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
1168 | 7437 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); |
7438 | |
7439 return -1; | |
7440 } | |
2967 | 7441 |
1168 | 7442 if(++s->mb_x >= s->mb_width){ |
7443 s->mb_x=0; | |
7444 if(++s->mb_y >= s->mb_height){ | |
7445 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7446 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); | |
7447 | |
7448 return 0; | |
7449 }else{ | |
7450 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); | |
7451 | |
7452 return -1; | |
7453 } | |
7454 } | |
7455 } | |
2967 | 7456 |
1168 | 7457 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ |
7458 if(get_bits_count(s->gb) == s->gb.size_in_bits){ | |
7459 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); | |
7460 | |
7461 return 0; | |
7462 }else{ | |
7463 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); | |
7464 | |
7465 return -1; | |
7466 } | |
7467 } | |
7468 } | |
7469 s->mb_x=0; | |
7470 ff_draw_horiz_band(s, 16*s->mb_y, 16); | |
7471 } | |
7472 #endif | |
7473 return -1; //not reached | |
7474 } | |
7475 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7476 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
|
7477 MpegEncContext * const s = &h->s; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7478 uint8_t user_data[16+256]; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7479 int e, build, i; |
2967 | 7480 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7481 if(size<16) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7482 return -1; |
2967 | 7483 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7484 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
|
7485 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
|
7486 } |
2967 | 7487 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7488 user_data[i]= 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7489 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
|
7490 if(e==1 && build>=0) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7491 h->x264_build= build; |
2967 | 7492 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7493 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
|
7494 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
|
7495 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7496 for(; i<size; i++) |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7497 skip_bits(&s->gb, 8); |
2967 | 7498 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7499 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7500 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7501 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7502 static int decode_sei(H264Context *h){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7503 MpegEncContext * const s = &h->s; |
2967 | 7504 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7505 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
|
7506 int size, type; |
2967 | 7507 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7508 type=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7509 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7510 type+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7511 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7512 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7513 size=0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7514 do{ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7515 size+= show_bits(&s->gb, 8); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7516 }while(get_bits(&s->gb, 8) == 255); |
2967 | 7517 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7518 switch(type){ |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7519 case 5: |
3318 | 7520 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
|
7521 return -1; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7522 break; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7523 default: |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7524 skip_bits(&s->gb, 8*size); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7525 } |
2967 | 7526 |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7527 //FIXME check bits here |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7528 align_get_bits(&s->gb); |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7529 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7530 |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7531 return 0; |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7532 } |
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
7533 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7534 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
|
7535 MpegEncContext * const s = &h->s; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7536 int cpb_count, i; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7537 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
|
7538 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
|
7539 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
|
7540 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
|
7541 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
|
7542 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
|
7543 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
|
7544 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7545 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
|
7546 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
|
7547 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
|
7548 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
|
7549 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7550 |
1168 | 7551 static inline int decode_vui_parameters(H264Context *h, SPS *sps){ |
7552 MpegEncContext * const s = &h->s; | |
7553 int aspect_ratio_info_present_flag, aspect_ratio_idc; | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7554 int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag; |
1168 | 7555 |
7556 aspect_ratio_info_present_flag= get_bits1(&s->gb); | |
2967 | 7557 |
1168 | 7558 if( aspect_ratio_info_present_flag ) { |
7559 aspect_ratio_idc= get_bits(&s->gb, 8); | |
7560 if( aspect_ratio_idc == EXTENDED_SAR ) { | |
1548 | 7561 sps->sar.num= get_bits(&s->gb, 16); |
7562 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
|
7563 }else if(aspect_ratio_idc < 14){ |
1548 | 7564 sps->sar= pixel_aspect[aspect_ratio_idc]; |
1168 | 7565 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7566 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n"); |
1168 | 7567 return -1; |
7568 } | |
7569 }else{ | |
2967 | 7570 sps->sar.num= |
1548 | 7571 sps->sar.den= 0; |
1168 | 7572 } |
7573 // 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
|
7574 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7575 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
|
7576 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
|
7577 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7578 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7579 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
|
7580 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
|
7581 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
|
7582 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
|
7583 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
|
7584 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
|
7585 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
|
7586 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7587 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7588 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7589 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
|
7590 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
|
7591 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
|
7592 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7593 |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7594 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
|
7595 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
|
7596 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
|
7597 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
|
7598 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
|
7599 } |
6d614374d907
Get H.264 frame rate from SPS/VUI patch by (Mns Rullgrd <mru at kth dot se>)
michael
parents:
2163
diff
changeset
|
7600 |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7601 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
|
7602 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
|
7603 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7604 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
|
7605 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
|
7606 decode_hrd_parameters(h, sps); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7607 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
|
7608 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
|
7609 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
|
7610 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7611 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
|
7612 if(sps->bitstream_restriction_flag){ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7613 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
|
7614 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
|
7615 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
|
7616 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
|
7617 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7618 sps->num_reorder_frames = get_ue_golomb(&s->gb); |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7619 get_ue_golomb(&s->gb); /* max_dec_frame_buffering */ |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7620 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
7621 |
1168 | 7622 return 0; |
7623 } | |
7624 | |
3004 | 7625 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, |
7626 const uint8_t *jvt_list, const uint8_t *fallback_list){ | |
2919 | 7627 MpegEncContext * const s = &h->s; |
7628 int i, last = 8, next = 8; | |
7629 const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8; | |
3004 | 7630 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */ |
7631 memcpy(factors, fallback_list, size*sizeof(uint8_t)); | |
2919 | 7632 else |
7633 for(i=0;i<size;i++){ | |
7634 if(next) | |
7635 next = (last + get_se_golomb(&s->gb)) & 0xff; | |
3004 | 7636 if(!i && !next){ /* matrix not written, we use the preset one */ |
7637 memcpy(factors, jvt_list, size*sizeof(uint8_t)); | |
2919 | 7638 break; |
7639 } | |
7640 last = factors[scan[i]] = next ? next : last; | |
7641 } | |
7642 } | |
7643 | |
7644 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, | |
7645 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){ | |
7646 MpegEncContext * const s = &h->s; | |
7647 int fallback_sps = !is_sps && sps->scaling_matrix_present; | |
7648 const uint8_t *fallback[4] = { | |
7649 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0], | |
7650 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1], | |
7651 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0], | |
7652 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1] | |
7653 }; | |
7654 if(get_bits1(&s->gb)){ | |
7655 sps->scaling_matrix_present |= is_sps; | |
3004 | 7656 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y |
7657 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr | |
7658 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb | |
7659 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y | |
7660 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr | |
7661 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb | |
2919 | 7662 if(is_sps || pps->transform_8x8_mode){ |
3004 | 7663 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y |
7664 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y | |
2919 | 7665 } |
7666 } else if(fallback_sps) { | |
7667 memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t)); | |
7668 memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t)); | |
7669 } | |
7670 } | |
7671 | |
1168 | 7672 static inline int decode_seq_parameter_set(H264Context *h){ |
7673 MpegEncContext * const s = &h->s; | |
1371 | 7674 int profile_idc, level_idc; |
1168 | 7675 int sps_id, i; |
7676 SPS *sps; | |
2967 | 7677 |
1168 | 7678 profile_idc= get_bits(&s->gb, 8); |
1371 | 7679 get_bits1(&s->gb); //constraint_set0_flag |
7680 get_bits1(&s->gb); //constraint_set1_flag | |
7681 get_bits1(&s->gb); //constraint_set2_flag | |
2312 | 7682 get_bits1(&s->gb); //constraint_set3_flag |
7683 get_bits(&s->gb, 4); // reserved | |
1168 | 7684 level_idc= get_bits(&s->gb, 8); |
7685 sps_id= get_ue_golomb(&s->gb); | |
2967 | 7686 |
1168 | 7687 sps= &h->sps_buffer[ sps_id ]; |
7688 sps->profile_idc= profile_idc; | |
7689 sps->level_idc= level_idc; | |
2312 | 7690 |
2755 | 7691 if(sps->profile_idc >= 100){ //high profile |
7692 if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc | |
7693 get_bits1(&s->gb); //residual_color_transform_flag | |
7694 get_ue_golomb(&s->gb); //bit_depth_luma_minus8 | |
7695 get_ue_golomb(&s->gb); //bit_depth_chroma_minus8 | |
2763 | 7696 sps->transform_bypass = get_bits1(&s->gb); |
2919 | 7697 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8); |
7698 }else | |
7699 sps->scaling_matrix_present = 0; | |
2755 | 7700 |
1168 | 7701 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4; |
7702 sps->poc_type= get_ue_golomb(&s->gb); | |
2967 | 7703 |
1168 | 7704 if(sps->poc_type == 0){ //FIXME #define |
7705 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4; | |
7706 } else if(sps->poc_type == 1){//FIXME #define | |
7707 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb); | |
7708 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb); | |
7709 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb); | |
7710 sps->poc_cycle_length= get_ue_golomb(&s->gb); | |
2967 | 7711 |
1168 | 7712 for(i=0; i<sps->poc_cycle_length; i++) |
7713 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb); | |
7714 } | |
7715 if(sps->poc_type > 2){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7716 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type); |
1168 | 7717 return -1; |
7718 } | |
7719 | |
7720 sps->ref_frame_count= get_ue_golomb(&s->gb); | |
2254
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
7721 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){ |
0dfe4e32b19c
H.264 max reference pictures fix by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents:
2227
diff
changeset
|
7722 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
|
7723 } |
1371 | 7724 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb); |
1168 | 7725 sps->mb_width= get_ue_golomb(&s->gb) + 1; |
7726 sps->mb_height= get_ue_golomb(&s->gb) + 1; | |
2967 | 7727 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 || |
2422 | 7728 avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)) |
7729 return -1; | |
7730 | |
1168 | 7731 sps->frame_mbs_only_flag= get_bits1(&s->gb); |
7732 if(!sps->frame_mbs_only_flag) | |
7733 sps->mb_aff= get_bits1(&s->gb); | |
7734 else | |
7735 sps->mb_aff= 0; | |
7736 | |
7737 sps->direct_8x8_inference_flag= get_bits1(&s->gb); | |
7738 | |
3316 | 7739 #ifndef ALLOW_INTERLACE |
7740 if(sps->mb_aff) | |
3954 | 7741 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n"); |
3316 | 7742 #endif |
7743 if(!sps->direct_8x8_inference_flag && sps->mb_aff) | |
7744 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF + !direct_8x8_inference is not implemented\n"); | |
7745 | |
1371 | 7746 sps->crop= get_bits1(&s->gb); |
7747 if(sps->crop){ | |
7748 sps->crop_left = get_ue_golomb(&s->gb); | |
7749 sps->crop_right = get_ue_golomb(&s->gb); | |
7750 sps->crop_top = get_ue_golomb(&s->gb); | |
7751 sps->crop_bottom= get_ue_golomb(&s->gb); | |
7752 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
|
7753 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n"); |
1371 | 7754 } |
7755 }else{ | |
2967 | 7756 sps->crop_left = |
7757 sps->crop_right = | |
7758 sps->crop_top = | |
1371 | 7759 sps->crop_bottom= 0; |
7760 } | |
7761 | |
1168 | 7762 sps->vui_parameters_present_flag= get_bits1(&s->gb); |
7763 if( sps->vui_parameters_present_flag ) | |
7764 decode_vui_parameters(h, sps); | |
2967 | 7765 |
1168 | 7766 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 7767 av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n", |
1168 | 7768 sps_id, sps->profile_idc, sps->level_idc, |
7769 sps->poc_type, | |
7770 sps->ref_frame_count, | |
7771 sps->mb_width, sps->mb_height, | |
7772 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"), | |
7773 sps->direct_8x8_inference_flag ? "8B8" : "", | |
2967 | 7774 sps->crop_left, sps->crop_right, |
7775 sps->crop_top, sps->crop_bottom, | |
1168 | 7776 sps->vui_parameters_present_flag ? "VUI" : "" |
7777 ); | |
7778 } | |
7779 return 0; | |
7780 } | |
7781 | |
2755 | 7782 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){ |
1168 | 7783 MpegEncContext * const s = &h->s; |
7784 int pps_id= get_ue_golomb(&s->gb); | |
7785 PPS *pps= &h->pps_buffer[pps_id]; | |
2967 | 7786 |
1168 | 7787 pps->sps_id= get_ue_golomb(&s->gb); |
7788 pps->cabac= get_bits1(&s->gb); | |
7789 pps->pic_order_present= get_bits1(&s->gb); | |
7790 pps->slice_group_count= get_ue_golomb(&s->gb) + 1; | |
7791 if(pps->slice_group_count > 1 ){ | |
7792 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
|
7793 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n"); |
1168 | 7794 switch(pps->mb_slice_group_map_type){ |
7795 case 0: | |
7796 #if 0 | |
7797 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | | | |
7798 | run_length[ i ] |1 |ue(v) | | |
7799 #endif | |
7800 break; | |
7801 case 2: | |
7802 #if 0 | |
7803 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | | | |
7804 |{ | | | | |
7805 | top_left_mb[ i ] |1 |ue(v) | | |
7806 | bottom_right_mb[ i ] |1 |ue(v) | | |
7807 | } | | | | |
7808 #endif | |
7809 break; | |
7810 case 3: | |
7811 case 4: | |
7812 case 5: | |
7813 #if 0 | |
7814 | slice_group_change_direction_flag |1 |u(1) | | |
7815 | slice_group_change_rate_minus1 |1 |ue(v) | | |
7816 #endif | |
7817 break; | |
7818 case 6: | |
7819 #if 0 | |
7820 | slice_group_id_cnt_minus1 |1 |ue(v) | | |
7821 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | | | |
7822 |) | | | | |
7823 | slice_group_id[ i ] |1 |u(v) | | |
7824 #endif | |
1214 | 7825 break; |
1168 | 7826 } |
7827 } | |
7828 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1; | |
7829 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1; | |
7830 if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
7831 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n"); |
1168 | 7832 return -1; |
7833 } | |
2967 | 7834 |
1168 | 7835 pps->weighted_pred= get_bits1(&s->gb); |
7836 pps->weighted_bipred_idc= get_bits(&s->gb, 2); | |
7837 pps->init_qp= get_se_golomb(&s->gb) + 26; | |
7838 pps->init_qs= get_se_golomb(&s->gb) + 26; | |
7839 pps->chroma_qp_index_offset= get_se_golomb(&s->gb); | |
7840 pps->deblocking_filter_parameters_present= get_bits1(&s->gb); | |
7841 pps->constrained_intra_pred= get_bits1(&s->gb); | |
7842 pps->redundant_pic_cnt_present = get_bits1(&s->gb); | |
2967 | 7843 |
3291
454de57e45cf
reinit quant matrices if pps is overwritten by another of the same pps_id.
lorenm
parents:
3285
diff
changeset
|
7844 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
|
7845 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit |
2919 | 7846 memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t)); |
7847 memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t)); | |
2755 | 7848 |
7849 if(get_bits_count(&s->gb) < bit_length){ | |
7850 pps->transform_8x8_mode= get_bits1(&s->gb); | |
2919 | 7851 decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8); |
2755 | 7852 get_se_golomb(&s->gb); //second_chroma_qp_index_offset |
7853 } | |
2967 | 7854 |
1168 | 7855 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
2967 | 7856 av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n", |
1168 | 7857 pps_id, pps->sps_id, |
7858 pps->cabac ? "CABAC" : "CAVLC", | |
7859 pps->slice_group_count, | |
7860 pps->ref_count[0], pps->ref_count[1], | |
7861 pps->weighted_pred ? "weighted" : "", | |
7862 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset, | |
7863 pps->deblocking_filter_parameters_present ? "LPAR" : "", | |
7864 pps->constrained_intra_pred ? "CONSTR" : "", | |
2755 | 7865 pps->redundant_pic_cnt_present ? "REDU" : "", |
7866 pps->transform_8x8_mode ? "8x8DCT" : "" | |
1168 | 7867 ); |
7868 } | |
2967 | 7869 |
1168 | 7870 return 0; |
7871 } | |
7872 | |
7873 /** | |
7874 * finds the end of the current frame in the bitstream. | |
7875 * @return the position of the first byte of the next frame, or -1 | |
7876 */ | |
2392 | 7877 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){ |
1187 | 7878 int i; |
1168 | 7879 uint32_t state; |
2392 | 7880 ParseContext *pc = &(h->s.parse_context); |
1168 | 7881 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]); |
7882 // mb_addr= pc->mb_addr - 1; | |
7883 state= pc->state; | |
2392 | 7884 for(i=0; i<=buf_size; i++){ |
1168 | 7885 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ |
2392 | 7886 tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i); |
1168 | 7887 if(pc->frame_start_found){ |
2392 | 7888 // If there isn't one more byte in the buffer |
7889 // the test on first_mb_in_slice cannot be done yet | |
7890 // do it at next call. | |
7891 if (i >= buf_size) break; | |
7892 if (buf[i] & 0x80) { | |
7893 // first_mb_in_slice is 0, probably the first nal of a new | |
7894 // slice | |
7895 tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i); | |
2967 | 7896 pc->state=-1; |
2392 | 7897 pc->frame_start_found= 0; |
7898 return i-4; | |
7899 } | |
1168 | 7900 } |
2392 | 7901 pc->frame_start_found = 1; |
1168 | 7902 } |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7903 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
|
7904 if(pc->frame_start_found){ |
2967 | 7905 pc->state=-1; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7906 pc->frame_start_found= 0; |
2967 | 7907 return i-4; |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7908 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7909 } |
2392 | 7910 if (i<buf_size) |
7911 state= (state<<8) | buf[i]; | |
1168 | 7912 } |
2967 | 7913 |
1168 | 7914 pc->state= state; |
1219 | 7915 return END_NOT_FOUND; |
1168 | 7916 } |
7917 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
7918 #ifdef CONFIG_H264_PARSER |
1988 | 7919 static int h264_parse(AVCodecParserContext *s, |
7920 AVCodecContext *avctx, | |
2967 | 7921 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 7922 const uint8_t *buf, int buf_size) |
7923 { | |
2392 | 7924 H264Context *h = s->priv_data; |
7925 ParseContext *pc = &h->s.parse_context; | |
1988 | 7926 int next; |
2967 | 7927 |
2392 | 7928 next= find_frame_end(h, buf, buf_size); |
1988 | 7929 |
7930 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
7931 *poutbuf = NULL; | |
7932 *poutbuf_size = 0; | |
7933 return buf_size; | |
7934 } | |
7935 | |
7936 *poutbuf = (uint8_t *)buf; | |
7937 *poutbuf_size = buf_size; | |
7938 return next; | |
7939 } | |
7940 | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7941 static int h264_split(AVCodecContext *avctx, |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7942 const uint8_t *buf, int buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7943 { |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7944 int i; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7945 uint32_t state = -1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7946 int has_sps= 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7947 |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7948 for(i=0; i<=buf_size; i++){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7949 if((state&0xFFFFFF1F) == 0x107) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7950 has_sps=1; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7951 /* 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
|
7952 }*/ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7953 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
|
7954 if(has_sps){ |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7955 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
|
7956 return i-4; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7957 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7958 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7959 if (i<buf_size) |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7960 state= (state<<8) | buf[i]; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7961 } |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7962 return 0; |
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7963 } |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
7964 #endif /* CONFIG_H264_PARSER */ |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
7965 |
1168 | 7966 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){ |
7967 MpegEncContext * const s = &h->s; | |
7968 AVCodecContext * const avctx= s->avctx; | |
7969 int buf_index=0; | |
1322 | 7970 #if 0 |
1168 | 7971 int i; |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7972 for(i=0; i<50; i++){ |
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
7973 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); |
1168 | 7974 } |
7975 #endif | |
2392 | 7976 h->slice_num = 0; |
2766
0609f405e000
make decoder a little bit more tolerant to missing NAL units
michael
parents:
2763
diff
changeset
|
7977 s->current_picture_ptr= NULL; |
1168 | 7978 for(;;){ |
7979 int consumed; | |
7980 int dst_length; | |
7981 int bit_length; | |
7982 uint8_t *ptr; | |
2227 | 7983 int i, nalsize = 0; |
2967 | 7984 |
2227 | 7985 if(h->is_avc) { |
7986 if(buf_index >= buf_size) break; | |
7987 nalsize = 0; | |
7988 for(i = 0; i < h->nal_length_size; i++) | |
7989 nalsize = (nalsize << 8) | buf[buf_index++]; | |
3126 | 7990 if(nalsize <= 1){ |
7991 if(nalsize == 1){ | |
7992 buf_index++; | |
7993 continue; | |
7994 }else{ | |
7995 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); | |
7996 break; | |
7997 } | |
7998 } | |
2227 | 7999 } else { |
1168 | 8000 // start code prefix search |
8001 for(; buf_index + 3 < buf_size; buf_index++){ | |
8002 // this should allways succeed in the first iteration | |
8003 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) | |
8004 break; | |
8005 } | |
2967 | 8006 |
1168 | 8007 if(buf_index+3 >= buf_size) break; |
2967 | 8008 |
1168 | 8009 buf_index+=3; |
2967 | 8010 } |
8011 | |
2401
46898a9fd6dc
Fix avc1 if there is nore than one nal per mov frame
rtognimp
parents:
2396
diff
changeset
|
8012 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index); |
3341 | 8013 while(ptr[dst_length - 1] == 0 && dst_length > 1) |
8014 dst_length--; | |
1168 | 8015 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1); |
8016 | |
8017 if(s->avctx->debug&FF_DEBUG_STARTCODE){ | |
2402
f9d4e1eddbc5
- correct several errors on the deblocking accross slice boundaries.
michael
parents:
2401
diff
changeset
|
8018 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 | 8019 } |
2967 | 8020 |
2227 | 8021 if (h->is_avc && (nalsize != consumed)) |
8022 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); | |
8023 | |
1168 | 8024 buf_index += consumed; |
8025 | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8026 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME dont discard SEI id |
2792 | 8027 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) |
1168 | 8028 continue; |
2967 | 8029 |
1168 | 8030 switch(h->nal_unit_type){ |
8031 case NAL_IDR_SLICE: | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8032 idr(h); //FIXME ensure we don't loose some frames if there is reordering |
1168 | 8033 case NAL_SLICE: |
8034 init_get_bits(&s->gb, ptr, bit_length); | |
8035 h->intra_gb_ptr= | |
8036 h->inter_gb_ptr= &s->gb; | |
8037 s->data_partitioning = 0; | |
2967 | 8038 |
2771 | 8039 if(decode_slice_header(h) < 0){ |
8040 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8041 break; | |
8042 } | |
3161
e3e94632c6e9
keyframe flag was wrong if SEIs followed the keyframe
lorenm
parents:
3145
diff
changeset
|
8043 s->current_picture_ptr->key_frame= (h->nal_unit_type == NAL_IDR_SLICE); |
2967 | 8044 if(h->redundant_pic_count==0 && s->hurry_up < 5 |
2793 | 8045 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) |
8046 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8047 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8048 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8049 decode_slice(h); |
8050 break; | |
8051 case NAL_DPA: | |
8052 init_get_bits(&s->gb, ptr, bit_length); | |
8053 h->intra_gb_ptr= | |
8054 h->inter_gb_ptr= NULL; | |
8055 s->data_partitioning = 1; | |
2967 | 8056 |
2771 | 8057 if(decode_slice_header(h) < 0){ |
8058 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
8059 } | |
1168 | 8060 break; |
8061 case NAL_DPB: | |
8062 init_get_bits(&h->intra_gb, ptr, bit_length); | |
8063 h->intra_gb_ptr= &h->intra_gb; | |
8064 break; | |
8065 case NAL_DPC: | |
8066 init_get_bits(&h->inter_gb, ptr, bit_length); | |
8067 h->inter_gb_ptr= &h->inter_gb; | |
1174 | 8068 |
2967 | 8069 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
|
8070 && s->context_initialized |
2793 | 8071 && s->hurry_up < 5 |
8072 && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc) | |
8073 && (avctx->skip_frame < AVDISCARD_BIDIR || h->slice_type!=B_TYPE) | |
8074 && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE) | |
8075 && avctx->skip_frame < AVDISCARD_ALL) | |
1168 | 8076 decode_slice(h); |
8077 break; | |
8078 case NAL_SEI: | |
2815
636133fccbdc
workaround 'colocated mv if colocated block is L1 predicted' bug in x264
michael
parents:
2809
diff
changeset
|
8079 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
|
8080 decode_sei(h); |
1168 | 8081 break; |
8082 case NAL_SPS: | |
8083 init_get_bits(&s->gb, ptr, bit_length); | |
8084 decode_seq_parameter_set(h); | |
2967 | 8085 |
1168 | 8086 if(s->flags& CODEC_FLAG_LOW_DELAY) |
8087 s->low_delay=1; | |
2967 | 8088 |
2538 | 8089 if(avctx->has_b_frames < 2) |
8090 avctx->has_b_frames= !s->low_delay; | |
1168 | 8091 break; |
8092 case NAL_PPS: | |
8093 init_get_bits(&s->gb, ptr, bit_length); | |
2967 | 8094 |
2755 | 8095 decode_picture_parameter_set(h, bit_length); |
1168 | 8096 |
8097 break; | |
2960 | 8098 case NAL_AUD: |
8099 case NAL_END_SEQUENCE: | |
8100 case NAL_END_STREAM: | |
8101 case NAL_FILLER_DATA: | |
8102 case NAL_SPS_EXT: | |
8103 case NAL_AUXILIARY_SLICE: | |
1168 | 8104 break; |
2979 | 8105 default: |
8106 av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type); | |
2967 | 8107 } |
8108 } | |
8109 | |
1174 | 8110 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
|
8111 |
2971 | 8112 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
|
8113 s->current_picture_ptr->pict_type= s->pict_type; |
2967 | 8114 |
1168 | 8115 h->prev_frame_num_offset= h->frame_num_offset; |
8116 h->prev_frame_num= h->frame_num; | |
8117 if(s->current_picture_ptr->reference){ | |
8118 h->prev_poc_msb= h->poc_msb; | |
8119 h->prev_poc_lsb= h->poc_lsb; | |
8120 } | |
8121 if(s->current_picture_ptr->reference) | |
8122 execute_ref_pic_marking(h, h->mmco, h->mmco_index); | |
8123 | |
8124 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
|
8125 |
1168 | 8126 MPV_frame_end(s); |
8127 | |
8128 return buf_index; | |
8129 } | |
8130 | |
8131 /** | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8132 * returns the number of bytes consumed for building the current frame |
1168 | 8133 */ |
8134 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ | |
8135 if(s->flags&CODEC_FLAG_TRUNCATED){ | |
8136 pos -= s->parse_context.last_index; | |
2645
42528c1f0246
More spelling errors patch by (Kevin Baragona (kevinmb500 gawab com>)
michael
parents:
2641
diff
changeset
|
8137 if(pos<0) pos=0; // FIXME remove (unneeded?) |
2967 | 8138 |
1168 | 8139 return pos; |
8140 }else{ | |
8141 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
8142 if(pos+10>buf_size) pos=buf_size; // oops ;) | |
8143 | |
8144 return pos; | |
8145 } | |
8146 } | |
8147 | |
2967 | 8148 static int decode_frame(AVCodecContext *avctx, |
1168 | 8149 void *data, int *data_size, |
8150 uint8_t *buf, int buf_size) | |
8151 { | |
8152 H264Context *h = avctx->priv_data; | |
8153 MpegEncContext *s = &h->s; | |
2967 | 8154 AVFrame *pict = data; |
1168 | 8155 int buf_index; |
2967 | 8156 |
1168 | 8157 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1706
diff
changeset
|
8158 s->flags2= avctx->flags2; |
1168 | 8159 |
8160 /* no supplementary picture */ | |
8161 if (buf_size == 0) { | |
8162 return 0; | |
8163 } | |
2967 | 8164 |
1168 | 8165 if(s->flags&CODEC_FLAG_TRUNCATED){ |
2392 | 8166 int next= find_frame_end(h, buf, buf_size); |
2967 | 8167 |
1988 | 8168 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
1168 | 8169 return buf_size; |
8170 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index); | |
8171 } | |
8172 | |
2227 | 8173 if(h->is_avc && !h->got_avcC) { |
8174 int i, cnt, nalsize; | |
8175 unsigned char *p = avctx->extradata; | |
8176 if(avctx->extradata_size < 7) { | |
8177 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); | |
8178 return -1; | |
8179 } | |
8180 if(*p != 1) { | |
8181 av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p); | |
8182 return -1; | |
8183 } | |
8184 /* sps and pps in the avcC always have length coded with 2 bytes, | |
8185 so put a fake nal_length_size = 2 while parsing them */ | |
8186 h->nal_length_size = 2; | |
8187 // Decode sps from avcC | |
8188 cnt = *(p+5) & 0x1f; // Number of sps | |
8189 p += 6; | |
8190 for (i = 0; i < cnt; i++) { | |
8191 nalsize = BE_16(p) + 2; | |
2867
7c7edddaa835
dont be so picky with .mp4 ... fixes Mr&MrsSmith.mp4
michael
parents:
2861
diff
changeset
|
8192 if(decode_nal_units(h, p, nalsize) < 0) { |
2227 | 8193 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); |
8194 return -1; | |
8195 } | |
8196 p += nalsize; | |
2967 | 8197 } |
2227 | 8198 // Decode pps from avcC |
8199 cnt = *(p++); // Number of pps | |
8200 for (i = 0; i < cnt; i++) { | |
8201 nalsize = BE_16(p) + 2; | |
8202 if(decode_nal_units(h, p, nalsize) != nalsize) { | |
8203 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); | |
8204 return -1; | |
8205 } | |
8206 p += nalsize; | |
2967 | 8207 } |
2227 | 8208 // Now store right nal length size, that will be use to parse all other nals |
8209 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; | |
8210 // Do not reparse avcC | |
8211 h->got_avcC = 1; | |
8212 } | |
8213 | |
8214 if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){ | |
2967 | 8215 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) |
1168 | 8216 return -1; |
8217 } | |
8218 | |
8219 buf_index=decode_nal_units(h, buf, buf_size); | |
2967 | 8220 if(buf_index < 0) |
1168 | 8221 return -1; |
8222 | |
2967 | 8223 //FIXME do something with unavailable reference frames |
8224 | |
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
|
8225 // if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size); |
1174 | 8226 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1548
diff
changeset
|
8227 av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n"); |
1174 | 8228 return -1; |
8229 } | |
8230 | |
2409 | 8231 { |
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
|
8232 Picture *out = s->current_picture_ptr; |
2561 | 8233 #if 0 //decode order |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8234 *data_size = sizeof(AVFrame); |
2561 | 8235 #else |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8236 /* Sort B-frames into display order */ |
2409 | 8237 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
|
8238 Picture *prev = h->delayed_output_pic; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8239 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
|
8240 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8241 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
|
8242 && 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
|
8243 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
|
8244 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8245 } |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8246 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8247 pics = 0; |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8248 while(h->delayed_pic[pics]) pics++; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8249 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
|
8250 if(cur->reference == 0) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8251 cur->reference = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8252 |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8253 cross_idr = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8254 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
|
8255 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
|
8256 cross_idr = 1; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8257 |
2537
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8258 out = h->delayed_pic[0]; |
3298
9637da0a9c1b
cosmetics (initalize variables where they are used)
michael
parents:
3297
diff
changeset
|
8259 out_idx = 0; |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8260 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
|
8261 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
|
8262 out = h->delayed_pic[i]; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8263 out_idx = i; |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8264 } |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8265 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8266 out_of_order = !cross_idr && prev && out->poc < prev->poc; |
3125 | 8267 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) |
8268 { } | |
8269 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
|
8270 out = prev; |
2923 | 8271 else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15) |
2967 | 8272 || (s->low_delay && |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8273 ((!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
|
8274 || cur->pict_type == B_TYPE))) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8275 { |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8276 s->low_delay = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8277 s->avctx->has_b_frames++; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8278 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8279 } |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8280 else if(out_of_order) |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8281 out = prev; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8282 |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8283 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
|
8284 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
|
8285 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
|
8286 } |
14fef0f3f532
H.264: decode arbitrary frame orders and allow B-frames as references.
lorenm
parents:
2536
diff
changeset
|
8287 |
3297
9ae9653d706c
decoders should (IMHO) not duplicate frames, the application can do this if it wants
michael
parents:
3291
diff
changeset
|
8288 if(prev == out) |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8289 *data_size = 0; |
2561 | 8290 else |
8291 *data_size = sizeof(AVFrame); | |
2560
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8292 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
|
8293 prev->reference = 0; |
bfba825ee300
Set keyframe flag only on IDR-frames (needed for reordering across I-frames).
lorenm
parents:
2553
diff
changeset
|
8294 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
|
8295 #endif |
2409 | 8296 |
2937 | 8297 if(out) |
8298 *pict= *(AVFrame*)out; | |
8299 else | |
8300 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); | |
8301 } | |
8302 | |
8303 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
|
8304 ff_print_debug_info(s, pict); |
1168 | 8305 //printf("out %d\n", (int)pict->data[0]); |
8306 #if 0 //? | |
8307 | |
8308 /* Return the Picture timestamp as the frame number */ | |
8309 /* we substract 1 because it is added on utils.c */ | |
8310 avctx->frame_number = s->picture_number - 1; | |
8311 #endif | |
8312 return get_consumed_bytes(s, buf_index, buf_size); | |
8313 } | |
8314 #if 0 | |
8315 static inline void fill_mb_avail(H264Context *h){ | |
8316 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
|
8317 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; |
1168 | 8318 |
8319 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
|
8320 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
|
8321 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
|
8322 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; |
1168 | 8323 }else{ |
8324 h->mb_avail[0]= | |
8325 h->mb_avail[1]= | |
8326 h->mb_avail[2]= 0; | |
8327 } | |
8328 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; | |
8329 h->mb_avail[4]= 1; //FIXME move out | |
8330 h->mb_avail[5]= 0; //FIXME move out | |
8331 } | |
8332 #endif | |
8333 | |
8334 #if 0 //selftest | |
8335 #define COUNT 8000 | |
8336 #define SIZE (COUNT*40) | |
8337 int main(){ | |
8338 int i; | |
8339 uint8_t temp[SIZE]; | |
8340 PutBitContext pb; | |
8341 GetBitContext gb; | |
8342 // int int_temp[10000]; | |
8343 DSPContext dsp; | |
8344 AVCodecContext avctx; | |
2967 | 8345 |
1168 | 8346 dsputil_init(&dsp, &avctx); |
8347 | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1453
diff
changeset
|
8348 init_put_bits(&pb, temp, SIZE); |
1168 | 8349 printf("testing unsigned exp golomb\n"); |
8350 for(i=0; i<COUNT; i++){ | |
8351 START_TIMER | |
8352 set_ue_golomb(&pb, i); | |
8353 STOP_TIMER("set_ue_golomb"); | |
8354 } | |
8355 flush_put_bits(&pb); | |
2967 | 8356 |
1168 | 8357 init_get_bits(&gb, temp, 8*SIZE); |
8358 for(i=0; i<COUNT; i++){ | |
8359 int j, s; | |
2967 | 8360 |
1168 | 8361 s= show_bits(&gb, 24); |
2967 | 8362 |
1168 | 8363 START_TIMER |
8364 j= get_ue_golomb(&gb); | |
8365 if(j != i){ | |
8366 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8367 // return -1; | |
8368 } | |
8369 STOP_TIMER("get_ue_golomb"); | |
8370 } | |
2967 | 8371 |
8372 | |
1524 | 8373 init_put_bits(&pb, temp, SIZE); |
1168 | 8374 printf("testing signed exp golomb\n"); |
8375 for(i=0; i<COUNT; i++){ | |
8376 START_TIMER | |
8377 set_se_golomb(&pb, i - COUNT/2); | |
8378 STOP_TIMER("set_se_golomb"); | |
8379 } | |
8380 flush_put_bits(&pb); | |
2967 | 8381 |
1168 | 8382 init_get_bits(&gb, temp, 8*SIZE); |
8383 for(i=0; i<COUNT; i++){ | |
8384 int j, s; | |
2967 | 8385 |
1168 | 8386 s= show_bits(&gb, 24); |
2967 | 8387 |
1168 | 8388 START_TIMER |
8389 j= get_se_golomb(&gb); | |
8390 if(j != i - COUNT/2){ | |
8391 printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); | |
8392 // return -1; | |
8393 } | |
8394 STOP_TIMER("get_se_golomb"); | |
8395 } | |
8396 | |
8397 printf("testing 4x4 (I)DCT\n"); | |
2967 | 8398 |
1168 | 8399 DCTELEM block[16]; |
8400 uint8_t src[16], ref[16]; | |
8401 uint64_t error= 0, max_error=0; | |
8402 | |
8403 for(i=0; i<COUNT; i++){ | |
8404 int j; | |
8405 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); | |
8406 for(j=0; j<16; j++){ | |
8407 ref[j]= random()%255; | |
8408 src[j]= random()%255; | |
8409 } | |
8410 | |
8411 h264_diff_dct_c(block, src, ref, 4); | |
2967 | 8412 |
1168 | 8413 //normalize |
8414 for(j=0; j<16; j++){ | |
8415 // printf("%d ", block[j]); | |
8416 block[j]= block[j]*4; | |
8417 if(j&1) block[j]= (block[j]*4 + 2)/5; | |
8418 if(j&4) block[j]= (block[j]*4 + 2)/5; | |
8419 } | |
8420 // printf("\n"); | |
2967 | 8421 |
2272
cd43603c46f9
move h264 idct to its own file and call via function pointer in DspContext
michael
parents:
2255
diff
changeset
|
8422 s->dsp.h264_idct_add(ref, block, 4); |
1168 | 8423 /* for(j=0; j<16; j++){ |
8424 printf("%d ", ref[j]); | |
8425 } | |
8426 printf("\n");*/ | |
2967 | 8427 |
1168 | 8428 for(j=0; j<16; j++){ |
4001 | 8429 int diff= FFABS(src[j] - ref[j]); |
2967 | 8430 |
1168 | 8431 error+= diff*diff; |
8432 max_error= FFMAX(max_error, diff); | |
8433 } | |
8434 } | |
8435 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); | |
8436 #if 0 | |
8437 printf("testing quantizer\n"); | |
8438 for(qp=0; qp<52; qp++){ | |
8439 for(i=0; i<16; i++) | |
8440 src1_block[i]= src2_block[i]= random()%255; | |
2967 | 8441 |
1168 | 8442 } |
8443 #endif | |
8444 printf("Testing NAL layer\n"); | |
2967 | 8445 |
1168 | 8446 uint8_t bitstream[COUNT]; |
8447 uint8_t nal[COUNT*2]; | |
8448 H264Context h; | |
8449 memset(&h, 0, sizeof(H264Context)); | |
2967 | 8450 |
1168 | 8451 for(i=0; i<COUNT; i++){ |
8452 int zeros= i; | |
8453 int nal_length; | |
8454 int consumed; | |
8455 int out_length; | |
8456 uint8_t *out; | |
8457 int j; | |
2967 | 8458 |
1168 | 8459 for(j=0; j<COUNT; j++){ |
8460 bitstream[j]= (random() % 255) + 1; | |
8461 } | |
2967 | 8462 |
1168 | 8463 for(j=0; j<zeros; j++){ |
8464 int pos= random() % COUNT; | |
8465 while(bitstream[pos] == 0){ | |
8466 pos++; | |
8467 pos %= COUNT; | |
8468 } | |
8469 bitstream[pos]=0; | |
8470 } | |
2967 | 8471 |
1168 | 8472 START_TIMER |
2967 | 8473 |
1168 | 8474 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); |
8475 if(nal_length<0){ | |
8476 printf("encoding failed\n"); | |
8477 return -1; | |
8478 } | |
2967 | 8479 |
1168 | 8480 out= decode_nal(&h, nal, &out_length, &consumed, nal_length); |
8481 | |
8482 STOP_TIMER("NAL") | |
2967 | 8483 |
1168 | 8484 if(out_length != COUNT){ |
8485 printf("incorrect length %d %d\n", out_length, COUNT); | |
8486 return -1; | |
8487 } | |
2967 | 8488 |
1168 | 8489 if(consumed != nal_length){ |
8490 printf("incorrect consumed length %d %d\n", nal_length, consumed); | |
8491 return -1; | |
8492 } | |
2967 | 8493 |
1168 | 8494 if(memcmp(bitstream, out, COUNT)){ |
8495 printf("missmatch\n"); | |
8496 return -1; | |
8497 } | |
8498 } | |
2967 | 8499 |
1168 | 8500 printf("Testing RBSP\n"); |
2967 | 8501 |
8502 | |
1168 | 8503 return 0; |
8504 } | |
8505 #endif | |
8506 | |
8507 | |
8508 static int decode_end(AVCodecContext *avctx) | |
8509 { | |
8510 H264Context *h = avctx->priv_data; | |
8511 MpegEncContext *s = &h->s; | |
2967 | 8512 |
2891
4c6eb826e9cb
Just noticed there is a memory leak in h264.c with the usage of rbsp_buffer.
michael
parents:
2883
diff
changeset
|
8513 av_freep(&h->rbsp_buffer); |
1168 | 8514 free_tables(h); //FIXME cleanup init stuff perhaps |
8515 MPV_common_end(s); | |
8516 | |
8517 // memset(h, 0, sizeof(H264Context)); | |
2967 | 8518 |
1168 | 8519 return 0; |
8520 } | |
8521 | |
8522 | |
8523 AVCodec h264_decoder = { | |
8524 "h264", | |
8525 CODEC_TYPE_VIDEO, | |
8526 CODEC_ID_H264, | |
8527 sizeof(H264Context), | |
8528 decode_init, | |
8529 NULL, | |
8530 decode_end, | |
8531 decode_frame, | |
2453 | 8532 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
2640 | 8533 .flush= flush_dpb, |
1168 | 8534 }; |
8535 | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8536 #ifdef CONFIG_H264_PARSER |
1988 | 8537 AVCodecParser h264_parser = { |
8538 { CODEC_ID_H264 }, | |
2392 | 8539 sizeof(H264Context), |
1988 | 8540 NULL, |
8541 h264_parse, | |
8542 ff_parse_close, | |
2774
3eddfe241bb9
support extracting sps/pps from bitstream and putting it in extradata
michael
parents:
2773
diff
changeset
|
8543 h264_split, |
1988 | 8544 }; |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3409
diff
changeset
|
8545 #endif |
1988 | 8546 |
1234 | 8547 #include "svq3.c" |